sungmg/mutter-performance-source
1
0
Fork 0
Code Activity
mutter-performance-source/cogl/winsys/cogl-winsys-egl-private.h

175 lines
4.6 KiB
C
Raw Normal View History

Add _cogl_egl_texture_2d_new_from_image API This adds an internal texture_2d constructor that can wrap an EGLImage as a CoglTexture2D. The plan is to utilize this for texture-from-pixmap support with EGL as well as creating textures from wayland buffers.
2011-05-24 21:34:10 +00:00
/*
* Cogl
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
* Copyright (C) 2011 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*
*/
#ifndef __COGL_WINSYS_EGL_PRIVATE_H
#define __COGL_WINSYS_EGL_PRIVATE_H
#include "cogl-defines.h"
#include "cogl-winsys-private.h"
#include "cogl-context.h"
build: Add missing include in cogl-winsys-egl-private.h We were missing APIENTRY.
2011-12-06 16:53:53 +00:00
#include "cogl-context-private.h"
Move the EGL GDL winsys out of cogl-winsys-egl This moves all of the code specific to the gdl winsys out of cogl-winsys-egl. It is completely untested apart from that it compiles. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-13 11:42:42 +00:00
#include "cogl-framebuffer-private.h"
kms: move Cogl*EGL typedefs to cogl-winsys-egl-private.h So that the various internal Cogl*EGL typedefs can be available to cogl-winsys-kms.c this moves them into cogl-winsys-egl-private.h Reviewed-by: Rob Bradford <rob@linux.intel.com>
2011-11-28 16:02:35 +00:00
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
typedef struct _CoglWinsysEGLVtable
{
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
CoglBool
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
(* display_setup) (CoglDisplay *display,
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 18:28:27 +00:00
CoglError **error);
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
void
(* display_destroy) (CoglDisplay *display);
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
CoglBool
winsys: Move X11/Xlib-specific code out of the EGL winsys All of the X11/Xlib-specific code now lives in the EGL_X11 winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 15:59:35 +00:00
(* context_created) (CoglDisplay *display,
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 18:28:27 +00:00
CoglError **error);
winsys: Move X11/Xlib-specific code out of the EGL winsys All of the X11/Xlib-specific code now lives in the EGL_X11 winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 15:59:35 +00:00
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
void
(* cleanup_context) (CoglDisplay *display);
winsys: Move X11/Xlib-specific code out of the EGL winsys All of the X11/Xlib-specific code now lives in the EGL_X11 winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 15:59:35 +00:00
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
CoglBool
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 18:28:27 +00:00
(* context_init) (CoglContext *context, CoglError **error);
winsys: Move X11/Xlib-specific code out of the EGL winsys All of the X11/Xlib-specific code now lives in the EGL_X11 winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 15:59:35 +00:00
void
(* context_deinit) (CoglContext *context);
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
CoglBool
winsys: Move X11/Xlib-specific code out of the EGL winsys All of the X11/Xlib-specific code now lives in the EGL_X11 winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 15:59:35 +00:00
(* onscreen_init) (CoglOnscreen *onscreen,
EGLConfig config,
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 18:28:27 +00:00
CoglError **error);
winsys: Move X11/Xlib-specific code out of the EGL winsys All of the X11/Xlib-specific code now lives in the EGL_X11 winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 15:59:35 +00:00
void
(* onscreen_deinit) (CoglOnscreen *onscreen);
Move the EGL GDL winsys out of cogl-winsys-egl This moves all of the code specific to the gdl winsys out of cogl-winsys-egl. It is completely untested apart from that it compiles. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-13 11:42:42 +00:00
int
(* add_config_attributes) (CoglDisplay *display,
CoglFramebufferConfig *config,
EGLint *attributes);
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
} CoglWinsysEGLVtable;
kms: move Cogl*EGL typedefs to cogl-winsys-egl-private.h So that the various internal Cogl*EGL typedefs can be available to cogl-winsys-kms.c this moves them into cogl-winsys-egl-private.h Reviewed-by: Rob Bradford <rob@linux.intel.com>
2011-11-28 16:02:35 +00:00
typedef enum _CoglEGLWinsysFeature
{
COGL_EGL_WINSYS_FEATURE_SWAP_REGION =1L<<0,
COGL_EGL_WINSYS_FEATURE_EGL_IMAGE_FROM_X11_PIXMAP =1L<<1,
Add a GL 3 driver This adds a new CoglDriver for GL 3 called COGL_DRIVER_GL3. When requested, the GLX, EGL and SDL2 winsyss will set the necessary attributes to request a forward-compatible core profile 3.1 context. That means it will have no deprecated features. To simplify the explosion of checks for specific combinations of context->driver, many of these conditionals have now been replaced with private feature flags that are checked instead. The GL and GLES drivers now initialise these private feature flags depending on which driver is used. The fixed function backends now explicitly check whether the fixed function private feature is available which means the GL3 driver will fall back to always using the GLSL progend. Since Rob's latest patches the GLSL progend no longer uses any fixed function API anyway so it should just work. The driver is currently lower priority than COGL_DRIVER_GL so it will not be used unless it is specificly requested. We may want to change this priority at some point because apparently Mesa can make some memory savings if a core profile context is used. In GL 3, getting the combined extensions string with glGetString is deprecated so this patch changes it to use glGetStringi to build up an array of extensions instead. _cogl_context_get_gl_extensions now returns this array instead of trying to return a const string. The caller is expected to free the array. Some issues with this patch: • GL 3 does not support GL_ALPHA format textures. We should probably make this a feature flag or something. Cogl uses this to render text which currently just throws a GL error and breaks so it's pretty important to do something about this before considering the GL3 driver to be stable. • GL 3 doesn't support client side vertex buffers. This probably doesn't matter because CoglBuffer won't normally use malloc'd buffers if VBOs are available, but it might but worth making malloc'd buffers a private feature and forcing it not to use them. • GL 3 doesn't support the default vertex array object. This patch just makes it create and bind a single non-default vertex array object which gets used just like the normal default object. Ideally it would be good to use vertex array objects properly and attach them to a CoglPrimitive to cache the state. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 66c9db993595b3a22e63f4c201ea468bc9b88cb6)
2012-09-26 19:32:36 +00:00
COGL_EGL_WINSYS_FEATURE_EGL_IMAGE_FROM_WAYLAND_BUFFER =1L<<2,
egl: support EGL_EXT_buffer_age This adds support for the EGL_EXT_buffer_age extension which is a counterpart to the GLX_EXT_buffer_age extension. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 92d869764c03d0bac6b51dac833510c22669ac4a)
2013-01-22 21:21:33 +00:00
COGL_EGL_WINSYS_FEATURE_CREATE_CONTEXT =1L<<3,
Add fence API cogl_framebuffer_add_fence creates a synchronisation fence, which will invoke a user-specified callback when the GPU has finished executing all commands provided to it up to that point in time. Support is currently provided for GL 3.x's GL_ARB_sync extension, and EGL's EGL_KHR_fence_sync (when used with OpenGL ES). Signed-off-by: Daniel Stone <daniel@fooishbar.org> Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> https://bugzilla.gnome.org/show_bug.cgi?id=691752 (cherry picked from commit e6d37470da9294adc1554c0a8c91aa2af560ed9f)
2013-01-11 01:13:34 +00:00
COGL_EGL_WINSYS_FEATURE_BUFFER_AGE =1L<<4,
COGL_EGL_WINSYS_FEATURE_FENCE_SYNC =1L<<5
kms: move Cogl*EGL typedefs to cogl-winsys-egl-private.h So that the various internal Cogl*EGL typedefs can be available to cogl-winsys-kms.c this moves them into cogl-winsys-egl-private.h Reviewed-by: Rob Bradford <rob@linux.intel.com>
2011-11-28 16:02:35 +00:00
} CoglEGLWinsysFeature;
typedef struct _CoglRendererEGL
{
CoglEGLWinsysFeature private_features;
EGLDisplay edpy;
EGLint egl_version_major;
EGLint egl_version_minor;
Add api for queuing idle callback internally This adds a _cogl_poll_renderer_add_idle api that can be used internally for queuing an idle callback without needing to make any assumption about the system mainloop that is being used. This is now used to avoid having the _cogl_poll_renderer_dispatch() directly check for all kinds of events to dispatch, and to avoid having the winsys dispatch vfuncs need to directly know about CoglContext. This means we can now avoid having a back reference from CoglRenderer to the CoglContext. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit a1e169f18f4257caec58760adccfe4ec09b9805d)
2013-04-18 13:19:43 +00:00
CoglClosure *resize_notify_idle;
Move event polling into CoglRenderer This updates the cogl_poll_ apis to allow dispatching events before we have a CoglContext and to also enables pollfd state to be changed in a more add-hoc way by different Cogl components by replacing the winsys->get_poll_info with _cogl_poll_renderer_add/remove_fd functions and a winsys->get_dispatch_timeout vfunc. One of the intentions here is that applications should be able to run their mainloop before creating a CoglContext to potentially get events relating to CoglOutputs. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 667e58c9cb2662aef5f44e580a9eda42dc8d0176)
2013-04-16 22:46:03 +00:00
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
/* Data specific to the EGL platform */
void *platform;
/* vtable for platform specific parts */
const CoglWinsysEGLVtable *platform_vtable;
kms: move Cogl*EGL typedefs to cogl-winsys-egl-private.h So that the various internal Cogl*EGL typedefs can be available to cogl-winsys-kms.c this moves them into cogl-winsys-egl-private.h Reviewed-by: Rob Bradford <rob@linux.intel.com>
2011-11-28 16:02:35 +00:00
winsys: Move X11/Xlib-specific code out of the EGL winsys All of the X11/Xlib-specific code now lives in the EGL_X11 winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 15:59:35 +00:00
/* Function pointers for EGL specific extensions */
kms: move Cogl*EGL typedefs to cogl-winsys-egl-private.h So that the various internal Cogl*EGL typedefs can be available to cogl-winsys-kms.c this moves them into cogl-winsys-egl-private.h Reviewed-by: Rob Bradford <rob@linux.intel.com>
2011-11-28 16:02:35 +00:00
#define COGL_WINSYS_FEATURE_BEGIN(a, b, c, d)
#define COGL_WINSYS_FEATURE_FUNCTION(ret, name, args) \
ret (APIENTRY * pf_ ## name) args;
#define COGL_WINSYS_FEATURE_END()
#include "cogl-winsys-egl-feature-functions.h"
#undef COGL_WINSYS_FEATURE_BEGIN
#undef COGL_WINSYS_FEATURE_FUNCTION
#undef COGL_WINSYS_FEATURE_END
} CoglRendererEGL;
typedef struct _CoglDisplayEGL
{
EGLContext egl_context;
EGLSurface dummy_surface;
egl: Allow multiple EGL platforms The #ifdefs in cogl-winsys-egl have been changed so that they additionally check renderer->winsys_vtable->id for the corresponding winsys ID so that multiple EGL platforms can be enabled. The is a stop-gap solution until we can move all of the EGL platforms into their own winsys files with overrides of the EGL vtable. However with this approach we can move one platform at a time which will make it easier. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-08 17:38:19 +00:00
EGLSurface egl_surface;
kms: move Cogl*EGL typedefs to cogl-winsys-egl-private.h So that the various internal Cogl*EGL typedefs can be available to cogl-winsys-kms.c this moves them into cogl-winsys-egl-private.h Reviewed-by: Rob Bradford <rob@linux.intel.com>
2011-11-28 16:02:35 +00:00
EGLConfig egl_config;
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
CoglBool found_egl_config;
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
Adds initial GLES2 integration support This makes it possible to integrate existing GLES2 code with applications using Cogl as the rendering api. Currently all GLES2 usage is handled with separate GLES2 contexts to ensure that GLES2 api usage doesn't interfere with Cogl's own use of OpenGL[ES]. The api has been designed though so we can provide tighter integration later. The api would allow us to support GLES2 virtualized on top of an OpenGL/GLX driver as well as GLES2 virtualized on the core rendering api of Cogl itself. Virtualizing the GLES2 support on Cogl will allow us to take advantage of Cogl debugging facilities as well as let us optimize the cost of allocating multiple GLES2 contexts and switching between them which can both be very expensive with many drivers. As as a side effect of this patch Cogl can also now be used as a portable window system binding API for GLES2 as an alternative to EGL. Parts of this patch are based on work done by Tomeu Vizoso <tomeu.vizoso@collabora.com> who did the first iteration of adding GLES2 API support to Cogl so that WebGL support could be added to webkit-clutter. This patch adds a very minimal cogl-gles2-context example that shows how to create a gles2 context, clear the screen to a random color and also draw a triangle with the cogl api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 4bb6eff3dbd50d8fef7d6bdbed55c5aaa70036a8)
2012-03-06 03:21:30 +00:00
EGLSurface current_read_surface;
EGLSurface current_draw_surface;
EGLContext current_context;
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
/* Platform specific display data */
void *platform;
kms: move Cogl*EGL typedefs to cogl-winsys-egl-private.h So that the various internal Cogl*EGL typedefs can be available to cogl-winsys-kms.c this moves them into cogl-winsys-egl-private.h Reviewed-by: Rob Bradford <rob@linux.intel.com>
2011-11-28 16:02:35 +00:00
} CoglDisplayEGL;
typedef struct _CoglContextEGL
{
Adds initial GLES2 integration support This makes it possible to integrate existing GLES2 code with applications using Cogl as the rendering api. Currently all GLES2 usage is handled with separate GLES2 contexts to ensure that GLES2 api usage doesn't interfere with Cogl's own use of OpenGL[ES]. The api has been designed though so we can provide tighter integration later. The api would allow us to support GLES2 virtualized on top of an OpenGL/GLX driver as well as GLES2 virtualized on the core rendering api of Cogl itself. Virtualizing the GLES2 support on Cogl will allow us to take advantage of Cogl debugging facilities as well as let us optimize the cost of allocating multiple GLES2 contexts and switching between them which can both be very expensive with many drivers. As as a side effect of this patch Cogl can also now be used as a portable window system binding API for GLES2 as an alternative to EGL. Parts of this patch are based on work done by Tomeu Vizoso <tomeu.vizoso@collabora.com> who did the first iteration of adding GLES2 API support to Cogl so that WebGL support could be added to webkit-clutter. This patch adds a very minimal cogl-gles2-context example that shows how to create a gles2 context, clear the screen to a random color and also draw a triangle with the cogl api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 4bb6eff3dbd50d8fef7d6bdbed55c5aaa70036a8)
2012-03-06 03:21:30 +00:00
EGLSurface saved_draw_surface;
EGLSurface saved_read_surface;
kms: move Cogl*EGL typedefs to cogl-winsys-egl-private.h So that the various internal Cogl*EGL typedefs can be available to cogl-winsys-kms.c this moves them into cogl-winsys-egl-private.h Reviewed-by: Rob Bradford <rob@linux.intel.com>
2011-11-28 16:02:35 +00:00
} CoglContextEGL;
Add _cogl_egl_texture_2d_new_from_image API This adds an internal texture_2d constructor that can wrap an EGLImage as a CoglTexture2D. The plan is to utilize this for texture-from-pixmap support with EGL as well as creating textures from wayland buffers.
2011-05-24 21:34:10 +00:00
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
typedef struct _CoglOnscreenEGL
{
EGLSurface egl_surface;
onscreen: Adds support for resizable windows This adds api to be able to request that the window system allows a given onscreen framebuffer to be resizable, and api to add and remove resize handlers to be called whenever the framebuffer does actually change size. The new functions are: cogl_onscreen_{get,set}_resizable() cogl_onscreen_{add,remove}_resize_handler() The examples cogl-hello and cogl-x11-foreign have been updated to use the new api. To smoke test how Cogl updates the viewport automatically in response to window resizes the cogl-hello test doesn't explicitly respond to resize events by setting the viewport and cogl-x11-foreign responds by setting a viewport that is offset by a quarter of the window's width/height and half the width and height of the window. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit a1a8cc00bfa2cecaf1007aec5f3dd95dc07b1786)
2012-06-20 15:22:36 +00:00
CoglBool pending_resize_notify;
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
/* Platform specific data */
void *platform;
} CoglOnscreenEGL;
Add _cogl_egl_texture_2d_new_from_image API This adds an internal texture_2d constructor that can wrap an EGLImage as a CoglTexture2D. The plan is to utilize this for texture-from-pixmap support with EGL as well as creating textures from wayland buffers.
2011-05-24 21:34:10 +00:00
const CoglWinsysVtable *
_cogl_winsys_egl_get_vtable (void);
Adds initial GLES2 integration support This makes it possible to integrate existing GLES2 code with applications using Cogl as the rendering api. Currently all GLES2 usage is handled with separate GLES2 contexts to ensure that GLES2 api usage doesn't interfere with Cogl's own use of OpenGL[ES]. The api has been designed though so we can provide tighter integration later. The api would allow us to support GLES2 virtualized on top of an OpenGL/GLX driver as well as GLES2 virtualized on the core rendering api of Cogl itself. Virtualizing the GLES2 support on Cogl will allow us to take advantage of Cogl debugging facilities as well as let us optimize the cost of allocating multiple GLES2 contexts and switching between them which can both be very expensive with many drivers. As as a side effect of this patch Cogl can also now be used as a portable window system binding API for GLES2 as an alternative to EGL. Parts of this patch are based on work done by Tomeu Vizoso <tomeu.vizoso@collabora.com> who did the first iteration of adding GLES2 API support to Cogl so that WebGL support could be added to webkit-clutter. This patch adds a very minimal cogl-gles2-context example that shows how to create a gles2 context, clear the screen to a random color and also draw a triangle with the cogl api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 4bb6eff3dbd50d8fef7d6bdbed55c5aaa70036a8)
2012-03-06 03:21:30 +00:00
EGLBoolean
_cogl_winsys_egl_make_current (CoglDisplay *display,
EGLSurface draw,
EGLSurface read,
EGLContext context);
Add _cogl_egl_texture_2d_new_from_image API This adds an internal texture_2d constructor that can wrap an EGLImage as a CoglTexture2D. The plan is to utilize this for texture-from-pixmap support with EGL as well as creating textures from wayland buffers.
2011-05-24 21:34:10 +00:00
#ifdef EGL_KHR_image_base
EGLImageKHR
_cogl_egl_create_image (CoglContext *ctx,
EGLenum target,
EGLClientBuffer buffer,
const EGLint *attribs);
void
_cogl_egl_destroy_image (CoglContext *ctx,
EGLImageKHR image);
#endif
check the wayland buffer format when creating texture The implementation of cogl_wayland_texture_2d_new_from_buffer now uses eglQueryWaylandBuffer to query the format of the buffer before trying to create a texture from the buffer. This makes sure we don't try and create a texture from YUV buffers for instance that may actually require multiple textures. We now also report an error when we don't understand the buffer type or format. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 79252d4e419e2462c5bc89ea4614b40bddc932c5)
2013-04-30 13:09:11 +00:00
#ifdef EGL_WL_bind_wayland_display
CoglBool
_cogl_egl_query_wayland_buffer (CoglContext *ctx,
struct wl_buffer *buffer,
int attribute,
int *value);
#endif
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
CoglBool
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
_cogl_winsys_egl_renderer_connect_common (CoglRenderer *renderer,
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 18:28:27 +00:00
CoglError **error);
egl: Split out the KMS winsys as overrides of the EGL winsys Instead of having #ifdefs to hook into the normal EGL winsys, the KMS winsys now overrides any winsys functions that it wants. Where the winsys wants to hook into a point within a function provided by the EGL winsys there is a EGL-platform vtable which gets set on the EGL renderer data during renderer_connect. The KMS-specific data on all of the structures is now allocated separately by the KMS winsys and is pointed to by a new 'platform' pointer in the EGL data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-09 16:10:01 +00:00
Add _cogl_egl_texture_2d_new_from_image API This adds an internal texture_2d constructor that can wrap an EGLImage as a CoglTexture2D. The plan is to utilize this for texture-from-pixmap support with EGL as well as creating textures from wayland buffers.
2011-05-24 21:34:10 +00:00
#endif /* __COGL_WINSYS_EGL_PRIVATE_H */
Copy permalink