isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-29 11:30:45 -05:00
Code Issues Packages Projects Releases Wiki Activity
7654c7cffc
mutter/cogl/cogl-internal.h

132 lines
4.4 KiB
C
Raw Normal View History

Unifies 90% of the code in {gl,gles}/cogl.c in common/cogl.c This code keeps on diverging and we get bugs and fixes in one version but not the other. This should make things a bit more maintainable.
2009-03-30 12:07:31 -04:00
/*
* Cogl
*
[cogl] Updates all file headers and removes lots of trailing white space Adds missing notices, and ensures all the notices are consistent. The Cogl blurb also now reads: * Cogl * * An object oriented GL/GLES Abstraction/Utility Layer
2009-04-27 10:48:12 -04:00
* An object oriented GL/GLES Abstraction/Utility Layer
Unifies 90% of the code in {gl,gles}/cogl.c in common/cogl.c This code keeps on diverging and we get bugs and fixes in one version but not the other. This should make things a bit more maintainable.
2009-03-30 12:07:31 -04:00
*
cogl: improves header and coding style consistency We've had complaints that our Cogl code/headers are a bit "special" so this is a first pass at tidying things up by giving them some consistency. These changes are all consistent with how new code in Cogl is being written, but the style isn't consistently applied across all code yet. There are two parts to this patch; but since each one required a large amount of effort to maintain tidy indenting it made sense to combine the changes to reduce the time spent re indenting the same lines. The first change is to use a consistent style for declaring function prototypes in headers. Cogl headers now consistently use this style for prototypes: return_type cogl_function_name (CoglType arg0, CoglType arg1); Not everyone likes this style, but it seems that most of the currently active Cogl developers agree on it. The second change is to constrain the use of redundant glib data types in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all been replaced with int, unsigned int, float, long, unsigned long and char respectively. When talking about pixel data; use of guchar has been replaced with guint8, otherwise unsigned char can be used. The glib types that we continue to use for portability are gboolean, gint{8,16,32,64}, guint{8,16,32,64} and gsize. The general intention is that Cogl should look palatable to the widest range of C programmers including those outside the Gnome community so - especially for the public API - we want to minimize the number of foreign looking typedefs.
2010-02-09 20:57:32 -05:00
* Copyright (C) 2007,2008,2009,2010 Intel Corporation.
Unifies 90% of the code in {gl,gles}/cogl.c in common/cogl.c This code keeps on diverging and we get bugs and fixes in one version but not the other. This should make things a bit more maintainable.
2009-03-30 12:07:31 -04:00
*
* 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
Remove mentions of the FSF address Since using addresses that might change is something that finally the FSF acknowledge as a plausible scenario (after changing address twice), the license blurb in the source files should use the URI for getting the license in case the library did not come with it. Not that URIs cannot possibly change, but at least it's easier to set up a redirection at the same place. As a side note: this commit closes the oldes bug in Clutter's bug report tool. http://bugzilla.openedhand.com/show_bug.cgi?id=521
2010-03-01 07:56:10 -05:00
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*
Unifies 90% of the code in {gl,gles}/cogl.c in common/cogl.c This code keeps on diverging and we get bugs and fixes in one version but not the other. This should make things a bit more maintainable.
2009-03-30 12:07:31 -04:00
*/
#ifndef __COGL_INTERNAL_H
#define __COGL_INTERNAL_H
cogl: Use a CoglBitmask to store the list of used texcoord arrays Instead of directly using a guint32 to store a bitmask for each used texcoord array, it now stores them in a CoglBitmask. This removes the limitation of 32 layers (although there are still other places in Cogl that imply this restriction). To disable texcoord arrays code should call _cogl_disable_other_texcoord_arrays which takes a bitmask of texcoord arrays that should not be disabled. There are two extra bitmasks stored in the CoglContext which are used temporarily for this function to avoid allocating a new bitmask each time. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-24 07:40:11 -04:00
#include "cogl-bitmask.h"
Don't include any GL header from the public GL headers This splits the GL header inclusion from cogl-defines.h into a separate headear called cogl-gl-header.h which we will only include internally. That way we don't leak GL declarations out of our public headers. The texture functions that were using GLenum and GLuint in the public header have now changed to just use unsigned int. Note however that if an EGL winsys is enabled then it will still publicly include an EGL header. This is a bit more awkward to fix because we have public API which returns an EGLDisplay and we can't determine what type that is. There is also a conformance test which just verifies that no GL header has been included while compiling. The test isn't added to test-conform-main because it doesn't actually test anything at runtime. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ef5680d3fda5df929dbd0b420c8f598ded58dfee)
2012-03-23 14:05:46 -04:00
#include "cogl-gl-header.h"
[cogl] Removes the cogl-current-matrix abstraction The indirection through this API isn't necessary since we no longer arbitrate between the OpenGL matrix API and Cogl's client side API. Also it doesn't help to maintain an OpenGL style matrix mode API for internal use since it's awkward to keep restoring the MODELVIEW mode and easy enough to directly work with the matrix stacks of interest. This replaces use of the _cogl_current_matrix API with direct use of the _cogl_matrix_stack API. All the unused cogl_current_matrix API is removed and the matrix utility code left in cogl-current-matrix.c was moved to cogl.c.
2009-10-13 18:09:42 -04:00
Stubs out _cogl_xlib_handle_event This stubs out an xlib event handling mechanism for Cogl. The intention is for Clutter to use this to forward all x11 events to Cogl. As we move winsys functionality down into Cogl, Cogl will become responsible for handling a number of X events: ConfigureNotify events for onscreen framebuffers, swap events and Damage events for cogl_x11_texture_pixmap.
2009-10-13 10:27:06 -04:00
#ifdef COGL_HAS_XLIB_SUPPORT
Moves all GLX code down from Clutter to Cogl This migrates all the GLX window system code down from the Clutter backend code into a Cogl winsys. Moving OpenGL window system binding code down from Clutter into Cogl is the biggest blocker to having Cogl become a standalone 3D graphics library, so this is an important step in that direction.
2010-11-05 08:28:33 -04:00
#include <X11/Xutil.h>
Stubs out _cogl_xlib_handle_event This stubs out an xlib event handling mechanism for Cogl. The intention is for Clutter to use this to forward all x11 events to Cogl. As we move winsys functionality down into Cogl, Cogl will become responsible for handling a number of X events: ConfigureNotify events for onscreen framebuffers, swap events and Damage events for cogl_x11_texture_pixmap.
2009-10-13 10:27:06 -04:00
#endif
[cogl] Move debugging to a configure-time switch Currently, COGL depends on defining debug symbols by manually modifying the source code. When it's done, it will forcefully print stuff to the console. Since COGL has also a pretty, runtime selectable debugging API we might as well switch everything to it. In order for this to happen, configure needs a new: --enable-cogl-debug command line switch; this will enable COGL debugging, the CoglHandle debugging and will also turn on the error checking for each GL operation. The default setting for the COGL debug defines is off, since it slows down the GL operations; enabling it for a particular debug build is trivial, though.
2009-05-19 11:00:18 -04:00
#ifdef COGL_GL_DEBUG
Unifies 90% of the code in {gl,gles}/cogl.c in common/cogl.c This code keeps on diverging and we get bugs and fixes in one version but not the other. This should make things a bit more maintainable.
2009-03-30 12:07:31 -04:00
cogl: improves header and coding style consistency We've had complaints that our Cogl code/headers are a bit "special" so this is a first pass at tidying things up by giving them some consistency. These changes are all consistent with how new code in Cogl is being written, but the style isn't consistently applied across all code yet. There are two parts to this patch; but since each one required a large amount of effort to maintain tidy indenting it made sense to combine the changes to reduce the time spent re indenting the same lines. The first change is to use a consistent style for declaring function prototypes in headers. Cogl headers now consistently use this style for prototypes: return_type cogl_function_name (CoglType arg0, CoglType arg1); Not everyone likes this style, but it seems that most of the currently active Cogl developers agree on it. The second change is to constrain the use of redundant glib data types in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all been replaced with int, unsigned int, float, long, unsigned long and char respectively. When talking about pixel data; use of guchar has been replaced with guint8, otherwise unsigned char can be used. The glib types that we continue to use for portability are gboolean, gint{8,16,32,64}, guint{8,16,32,64} and gsize. The general intention is that Cogl should look palatable to the widest range of C programmers including those outside the Gnome community so - especially for the public API - we want to minimize the number of foreign looking typedefs.
2010-02-09 20:57:32 -05:00
const char *
Don't export cogl_gl_error_to_string This is only used internally when debugging is enabled to give a human-readable name to a GL error so we shouldn't be exporting it outside of the library. This just adds an underscore to the symbol name. This shouldn't end up removing any public symbols from the 1.9.8 release because by default a non-git build disables debug so it wasn't exported anyway. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-09 11:40:42 -05:00
_cogl_gl_error_to_string (GLenum error_code);
[cogl] Rework the GL-error-to-string conversion The code for the conversion of the GL error enumeration code into a string is not following the code style and conventions we follow in Clutter and COGL. The GE() macro is also using fprintf(stderr) directly instead of using g_warning() -- which is redirectable to an alternative logging system using the g_log* API.
2009-05-18 14:38:03 -04:00
Use all core GL functions through indirect pointers cogl-ext-functions.h now contains definitions for all of the core GL and GLES functions that we would normally link to directly. All of the code has changed to access them through the cogl context pointer. The GE macro now takes an extra parameter to specify the context because the macro itself needs to make GL calls but various points in the Cogl source use different names for the context variable.
2011-07-06 16:51:00 -04:00
#define GE(ctx, x) G_STMT_START { \
[cogl] Rework the debug messages COGL has a debug message system like Clutter's own. In parallel, it also uses a coupld of #defines. Spread around there are also calls to printf() instead to the more correct g_log* wrappers. This commit tries to unify and clean up the macros and the debug message handling inside COGL to be more consistent.
2009-05-19 09:44:29 -04:00
GLenum __err; \
Use all core GL functions through indirect pointers cogl-ext-functions.h now contains definitions for all of the core GL and GLES functions that we would normally link to directly. All of the code has changed to access them through the cogl context pointer. The GE macro now takes an extra parameter to specify the context because the macro itself needs to make GL calls but various points in the Cogl source use different names for the context variable.
2011-07-06 16:51:00 -04:00
(ctx)->x; \
while ((__err = (ctx)->glGetError ()) != GL_NO_ERROR) \
[cogl] Rework the debug messages COGL has a debug message system like Clutter's own. In parallel, it also uses a coupld of #defines. Spread around there are also calls to printf() instead to the more correct g_log* wrappers. This commit tries to unify and clean up the macros and the debug message handling inside COGL to be more consistent.
2009-05-19 09:44:29 -04:00
{ \
g_warning ("%s: GL error (%d): %s\n", \
G_STRLOC, \
[build] The cogl GE macro wasn't passing an int according to the format string This patch simply updates the arguments passed to g_warning inline with the given format string.
2009-05-21 10:04:38 -04:00
__err, \
Don't export cogl_gl_error_to_string This is only used internally when debugging is enabled to give a human-readable name to a GL error so we shouldn't be exporting it outside of the library. This just adds an underscore to the symbol name. This shouldn't end up removing any public symbols from the 1.9.8 release because by default a non-git build disables debug so it wasn't exported anyway. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-09 11:40:42 -05:00
_cogl_gl_error_to_string (__err)); \
[cogl] Rework the debug messages COGL has a debug message system like Clutter's own. In parallel, it also uses a coupld of #defines. Spread around there are also calls to printf() instead to the more correct g_log* wrappers. This commit tries to unify and clean up the macros and the debug message handling inside COGL to be more consistent.
2009-05-19 09:44:29 -04:00
} } G_STMT_END
Unifies 90% of the code in {gl,gles}/cogl.c in common/cogl.c This code keeps on diverging and we get bugs and fixes in one version but not the other. This should make things a bit more maintainable.
2009-03-30 12:07:31 -04:00
Use all core GL functions through indirect pointers cogl-ext-functions.h now contains definitions for all of the core GL and GLES functions that we would normally link to directly. All of the code has changed to access them through the cogl context pointer. The GE macro now takes an extra parameter to specify the context because the macro itself needs to make GL calls but various points in the Cogl source use different names for the context variable.
2011-07-06 16:51:00 -04:00
#define GE_RET(ret, ctx, x) G_STMT_START { \
cogl: Introduce the GE_RET() debug macro Some GL functions have a return value that the GE() macro is not able to handle. Let's define a new Ge_RET() macro which will be able to handle functions such as glMapBuffer(). While at it, removed the unused variadic dots to the GE() macro.
2010-01-10 19:15:25 -05:00
GLenum __err; \
Use all core GL functions through indirect pointers cogl-ext-functions.h now contains definitions for all of the core GL and GLES functions that we would normally link to directly. All of the code has changed to access them through the cogl context pointer. The GE macro now takes an extra parameter to specify the context because the macro itself needs to make GL calls but various points in the Cogl source use different names for the context variable.
2011-07-06 16:51:00 -04:00
ret = (ctx)->x; \
while ((__err = (ctx)->glGetError ()) != GL_NO_ERROR) \
cogl: Introduce the GE_RET() debug macro Some GL functions have a return value that the GE() macro is not able to handle. Let's define a new Ge_RET() macro which will be able to handle functions such as glMapBuffer(). While at it, removed the unused variadic dots to the GE() macro.
2010-01-10 19:15:25 -05:00
{ \
g_warning ("%s: GL error (%d): %s\n", \
G_STRLOC, \
__err, \
Don't export cogl_gl_error_to_string This is only used internally when debugging is enabled to give a human-readable name to a GL error so we shouldn't be exporting it outside of the library. This just adds an underscore to the symbol name. This shouldn't end up removing any public symbols from the 1.9.8 release because by default a non-git build disables debug so it wasn't exported anyway. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-09 11:40:42 -05:00
_cogl_gl_error_to_string (__err)); \
cogl: Introduce the GE_RET() debug macro Some GL functions have a return value that the GE() macro is not able to handle. Let's define a new Ge_RET() macro which will be able to handle functions such as glMapBuffer(). While at it, removed the unused variadic dots to the GE() macro.
2010-01-10 19:15:25 -05:00
} } G_STMT_END
[cogl] Rework the debug messages COGL has a debug message system like Clutter's own. In parallel, it also uses a coupld of #defines. Spread around there are also calls to printf() instead to the more correct g_log* wrappers. This commit tries to unify and clean up the macros and the debug message handling inside COGL to be more consistent.
2009-05-19 09:44:29 -04:00
#else /* !COGL_GL_DEBUG */
Unifies 90% of the code in {gl,gles}/cogl.c in common/cogl.c This code keeps on diverging and we get bugs and fixes in one version but not the other. This should make things a bit more maintainable.
2009-03-30 12:07:31 -04:00
Use all core GL functions through indirect pointers cogl-ext-functions.h now contains definitions for all of the core GL and GLES functions that we would normally link to directly. All of the code has changed to access them through the cogl context pointer. The GE macro now takes an extra parameter to specify the context because the macro itself needs to make GL calls but various points in the Cogl source use different names for the context variable.
2011-07-06 16:51:00 -04:00
#define GE(ctx, x) ((ctx)->x)
#define GE_RET(ret, ctx, x) (ret = ((ctx)->x))
Unifies 90% of the code in {gl,gles}/cogl.c in common/cogl.c This code keeps on diverging and we get bugs and fixes in one version but not the other. This should make things a bit more maintainable.
2009-03-30 12:07:31 -04:00
[cogl] Rework the debug messages COGL has a debug message system like Clutter's own. In parallel, it also uses a coupld of #defines. Spread around there are also calls to printf() instead to the more correct g_log* wrappers. This commit tries to unify and clean up the macros and the debug message handling inside COGL to be more consistent.
2009-05-19 09:44:29 -04:00
#endif /* COGL_GL_DEBUG */
Unifies 90% of the code in {gl,gles}/cogl.c in common/cogl.c This code keeps on diverging and we get bugs and fixes in one version but not the other. This should make things a bit more maintainable.
2009-03-30 12:07:31 -04:00
CoglMaterial: Implements sparse materials design This is a complete overhaul of the data structures used to manage CoglMaterial state. We have these requirements that were aiming to meet: (Note: the references to "renderlists" correspond to the effort to support scenegraph level shuffling of Clutter actor primitives so we can minimize GPU state changes) Sparse State: We wanted a design that allows sparse descriptions of state so it scales well as we make CoglMaterial responsible for more and more state. It needs to scale well in terms of memory usage and the cost of operations we need to apply to materials such as comparing, copying and flushing their state. I.e. we would rather have these things scale by the number of real changes a material represents not by how much overall state CoglMaterial becomes responsible for. Cheap Copies: As we add support for renderlists in Clutter we will need to be able to get an immutable handle for a given material's current state so that we can retain a record of a primitive with its associated material without worrying that changes to the original material will invalidate that record. No more flush override options: We want to get rid of the flush overrides mechanism we currently use to deal with texture fallbacks, wrap mode changes and to handle the use of highlevel CoglTextures that need to be resolved into lowlevel textures before flushing the material state. The flush options structure has been expanding in size and the structure is logged with every journal entry so it is not an approach that scales well at all. It also makes flushing material state that much more complex. Weak Materials: Again for renderlists we need a way to create materials derived from other materials but without the strict requirement that modifications to the original material wont affect the derived ("weak") material. The only requirement is that its possible to later check if the original material has been changed. A summary of the new design: A CoglMaterial now basically represents a diff against its parent. Each material has a single parent and a mask of state that it changes. Each group of state (such as the blending state) has an "authority" which is found by walking up from a given material through its ancestors checking the difference mask until a match for that group is found. There is only one root node to the graph of all materials, which is the default material first created when Cogl is being initialized. All the groups of state are divided into two types, such that infrequently changed state belongs in a separate "BigState" structure that is only allocated and attached to a material when necessary. CoglMaterialLayers are another sparse structure. Like CoglMaterials they represent a diff against their parent and all the layers are part of another graph with the "default_layer_0" layer being the root node that Cogl creates during initialization. Copying a material is now basically just a case of slice allocating a CoglMaterial, setting the parent to be the source being copied and zeroing the mask of changes. Flush overrides should now be handled by simply relying on the cheapness of copying a material and making changes to it. (This will be done in a follow on commit) Weak material support will be added in a follow on commit.
2010-04-08 07:21:04 -04:00
#define COGL_ENABLE_ALPHA_TEST (1<<1)
#define COGL_ENABLE_VERTEX_ARRAY (1<<2)
#define COGL_ENABLE_COLOR_ARRAY (1<<3)
Unifies 90% of the code in {gl,gles}/cogl.c in common/cogl.c This code keeps on diverging and we get bugs and fixes in one version but not the other. This should make things a bit more maintainable.
2009-03-30 12:07:31 -04:00
cogl: improves header and coding style consistency We've had complaints that our Cogl code/headers are a bit "special" so this is a first pass at tidying things up by giving them some consistency. These changes are all consistent with how new code in Cogl is being written, but the style isn't consistently applied across all code yet. There are two parts to this patch; but since each one required a large amount of effort to maintain tidy indenting it made sense to combine the changes to reduce the time spent re indenting the same lines. The first change is to use a consistent style for declaring function prototypes in headers. Cogl headers now consistently use this style for prototypes: return_type cogl_function_name (CoglType arg0, CoglType arg1); Not everyone likes this style, but it seems that most of the currently active Cogl developers agree on it. The second change is to constrain the use of redundant glib data types in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all been replaced with int, unsigned int, float, long, unsigned long and char respectively. When talking about pixel data; use of guchar has been replaced with guint8, otherwise unsigned char can be used. The glib types that we continue to use for portability are gboolean, gint{8,16,32,64}, guint{8,16,32,64} and gsize. The general intention is that Cogl should look palatable to the widest range of C programmers including those outside the Gnome community so - especially for the public API - we want to minimize the number of foreign looking typedefs.
2010-02-09 20:57:32 -05:00
void
cogl: rename cogl_enable to _cogl_enable Every now and then someone sees the cogl_enable API and gets confused, thinking its public API so this renames the symbol to be clear that it's is an internal only API.
2010-03-19 05:16:08 -04:00
_cogl_enable (unsigned long flags);
Unifies 90% of the code in {gl,gles}/cogl.c in common/cogl.c This code keeps on diverging and we get bugs and fixes in one version but not the other. This should make things a bit more maintainable.
2009-03-30 12:07:31 -04:00
cogl: improves header and coding style consistency We've had complaints that our Cogl code/headers are a bit "special" so this is a first pass at tidying things up by giving them some consistency. These changes are all consistent with how new code in Cogl is being written, but the style isn't consistently applied across all code yet. There are two parts to this patch; but since each one required a large amount of effort to maintain tidy indenting it made sense to combine the changes to reduce the time spent re indenting the same lines. The first change is to use a consistent style for declaring function prototypes in headers. Cogl headers now consistently use this style for prototypes: return_type cogl_function_name (CoglType arg0, CoglType arg1); Not everyone likes this style, but it seems that most of the currently active Cogl developers agree on it. The second change is to constrain the use of redundant glib data types in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all been replaced with int, unsigned int, float, long, unsigned long and char respectively. When talking about pixel data; use of guchar has been replaced with guint8, otherwise unsigned char can be used. The glib types that we continue to use for portability are gboolean, gint{8,16,32,64}, guint{8,16,32,64} and gsize. The general intention is that Cogl should look palatable to the widest range of C programmers including those outside the Gnome community so - especially for the public API - we want to minimize the number of foreign looking typedefs.
2010-02-09 20:57:32 -05:00
unsigned long
cogl: rename cogl_enable to _cogl_enable Every now and then someone sees the cogl_enable API and gets confused, thinking its public API so this renames the symbol to be clear that it's is an internal only API.
2010-03-19 05:16:08 -04:00
_cogl_get_enable (void);
Unifies 90% of the code in {gl,gles}/cogl.c in common/cogl.c This code keeps on diverging and we get bugs and fixes in one version but not the other. This should make things a bit more maintainable.
2009-03-30 12:07:31 -04:00
cogl-clip-state: Export transform_point internally to Cogl The transform_point function takes a modelview matrix, projection matrix and a viewport and performs all three transformations on a point to give a Cogl window coordinate. This is useful in a number of places in Cogl so this patch moves it to cogl.c and adds it to cogl-internal.h
2010-04-22 08:48:49 -04:00
void
_cogl_transform_point (const CoglMatrix *matrix_mv,
const CoglMatrix *matrix_p,
const float *viewport,
float *x,
float *y);
Moves all GLX code down from Clutter to Cogl This migrates all the GLX window system code down from the Clutter backend code into a Cogl winsys. Moving OpenGL window system binding code down from Clutter into Cogl is the biggest blocker to having Cogl become a standalone 3D graphics library, so this is an important step in that direction.
2010-11-05 08:28:33 -04:00
#define COGL_DRIVER_ERROR (_cogl_driver_error_quark ())
Pass all Xlib events through Cogl The Clutter X11 backend now passes all events through _cogl_xlib_handle_event. This function can now internally be hooked with _cogl_xlib_add_filter. These are added to a list of callbacks which are all called in turn by _cogl_xlib_handle_event. This is intended to be used internally in Cogl by any parts that need to see Xlib events. Cogl now also has an internally exposed function to set a pointer to the Xlib display. This is stored in a global variable. The Clutter X11 backend sets this. _cogl_xlib_handle_event and _cogl_xlib_set_display can be removed once Cogl gains a proper window system abstraction.
2010-05-19 11:13:07 -04:00
Moves all GLX code down from Clutter to Cogl This migrates all the GLX window system code down from the Clutter backend code into a Cogl winsys. Moving OpenGL window system binding code down from Clutter into Cogl is the biggest blocker to having Cogl become a standalone 3D graphics library, so this is an important step in that direction.
2010-11-05 08:28:33 -04:00
typedef enum { /*< prefix=COGL_DRIVER_ERROR >*/
COGL_DRIVER_ERROR_UNKNOWN_VERSION,
Dynamically load the GL or GLES library The GL or GLES library is now dynamically loaded by the CoglRenderer so that it can choose between GL, GLES1 and GLES2 at runtime. The library is loaded by the renderer because it needs to be done before calling eglInitialize. There is a new environment variable called COGL_DRIVER to choose between gl, gles1 or gles2. The #ifdefs for HAVE_COGL_GL, HAVE_COGL_GLES and HAVE_COGL_GLES2 have been changed so that they don't assume the ifdefs are mutually exclusive. They haven't been removed entirely so that it's possible to compile the GLES backends without the the enums from the GL headers. When using GLX the winsys additionally dynamically loads libGL because that also contains the GLX API. It can't be linked in directly because that would probably conflict with the GLES API if the EGL is selected. When compiling with EGL support the library links directly to libEGL because it doesn't contain any GL API so it shouldn't have any conflicts. When building for WGL or OSX Cogl still directly links against the GL API so there is a #define in config.h so that Cogl won't try to dlopen the library. Cogl-pango previously had a #ifdef to detect when the GL backend is used so that it can sneakily pass GL_QUADS to cogl_vertex_buffer_draw. This is now changed so that it queries the CoglContext for the backend. However to get this to work Cogl now needs to export the _cogl_context_get_default symbol and cogl-pango needs some extra -I flags to so that it can include cogl-context-private.h
2011-07-07 15:44:56 -04:00
COGL_DRIVER_ERROR_INVALID_VERSION,
COGL_DRIVER_ERROR_NO_SUITABLE_DRIVER_FOUND,
COGL_DRIVER_ERROR_FAILED_TO_LOAD_LIBRARY
Moves all GLX code down from Clutter to Cogl This migrates all the GLX window system code down from the Clutter backend code into a Cogl winsys. Moving OpenGL window system binding code down from Clutter into Cogl is the biggest blocker to having Cogl become a standalone 3D graphics library, so this is an important step in that direction.
2010-11-05 08:28:33 -04:00
} CoglDriverError;
cogl: Introduce private feature flags and check for ARB_fp The Cogl context has now a feature_flags_private enum that will allow us to query and use OpenGL features without exposing them in the public API. The ARB_fragment_program extension is the first user of those flags. Looking for this extension only happens in the gl driver as the gles drivers will not expose them. One can use _cogl_features_available_private() to check for the availability of such private features. While at it, reindent cogl-internal.h as described in CODING_STYLE.
2009-11-14 09:59:59 -05: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 17:34:10 -04:00
typedef enum
{
cogl-internal: remove COGL_PRIVATE_FEATURE_EGL flags This removes the unused COGL_PRIVATE_FEATURE_EGL flags since check_egl_extensions doesn't refer to these flags it uses the COGL_EGL_WINSYS_FEATURE flags. Signed-off-by: Neil Roberts <neil@linux.intel.com>
2011-07-05 09:13:12 -04:00
COGL_PRIVATE_FEATURE_TEXTURE_2D_FROM_EGL_IMAGE = 1L<<0,
make COGL_FEATURE_STENCIL_BUFFER private Although we have to leave the COGL_FEATURE_STENCIL_BUFFER enum as part of the public api we no longer ever set this feature flag. Cogl doesn't currently expose the concept of a stencil buffer in the public api (we only indirectly expose it via the clip stack api) so it doesn't make much sense to have a stencil buffer feature flag. We now have a COGL_PRIVATE_FEATURE_STENCIL_BUFFER flag instead which we can check when we need to use the buffer for clipping. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-12 17:37:29 -04:00
COGL_PRIVATE_FEATURE_MESA_PACK_INVERT = 1L<<1,
make COGL_FEATURE_OFFSCREEN_BLIT a private feature Cogl doesn't expose public api for blitting between framebuffers so it doesn't make much sense to have this feature as part of the public api currently. We can't break the api by removing the enum but at least we no longer ever set the feature flag. We now have a replacement private feature flag COGL_PRIVATE_FEATURE_OFFSCREEN_BLIT which cogl now checks for internally. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-12 17:47:42 -04:00
COGL_PRIVATE_FEATURE_STENCIL_BUFFER = 1L<<2,
make COGL_FEATURE_FOUR_CLIP_PLANES a private feature Cogl doesn't currently expose public api for clip planes so it doesn't make much sense to have this feature as part of the public api. We can't break the api by removing the enum but at least we no longer ever set the feature flag. We now have a replacement private feature flag COGL_PRIVATE_FEATURE_FOUR_CLIP_PLANES which cogl now checks for internally. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 04:24:58 -04:00
COGL_PRIVATE_FEATURE_OFFSCREEN_BLIT = 1L<<3,
make COGL_FEATURE_PBOS a private feature Cogl provides a consistent public interface regardless of whether the underlying GL driver supports PBOs so it doesn't make much sense to have this feature as part of the public api. We can't break the api by removing the enum but at least we no longer ever set the feature flag. We now have a replacement private feature flag COGL_PRIVATE_FEATURE_PBOS which cogl now checks for internally. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 04:30:33 -04:00
COGL_PRIVATE_FEATURE_FOUR_CLIP_PLANES = 1L<<4,
make COGL_FEATURE_VBOS a private feature Cogl provides a consistent public interface regardless of whether the underlying GL driver supports VBOs so it doesn't make much sense to have this feature as part of the public api. We can't break the api by removing the enum but at least we no longer ever set the feature flag. We now have a replacement private feature flag COGL_PRIVATE_FEATURE_VBOS which cogl now checks for internally. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 04:36:46 -04:00
COGL_PRIVATE_FEATURE_PBOS = 1L<<5,
Check for GL_EXT_packed_depth_stencil The GL_DEPTH_STENCIL format for renderbuffers is defined in a separate extension from GL_EXT_framebuffer_object so we probably shouldn't being trying to use it unless that extension is advertised. This just replaces the check for whether the driver is GL for a check for a private feature flag before trying GL_DEPTH_STENCIL. The private feature flag is set if the extension is available on GL. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-22 11:55:34 -05:00
COGL_PRIVATE_FEATURE_VBOS = 1L<<6,
Use GL_OES_packed_depth_stencil on GLES2 If the GL_OES_packed_depth_stencil extension is available then we can try creating a combined depth-stencil buffer with the GL_DEPTH24_STENCIL8 format. This adds a private flag for the feature. https://bugzilla.gnome.org/show_bug.cgi?id=666184 Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-22 12:02:28 -05:00
COGL_PRIVATE_FEATURE_EXT_PACKED_DEPTH_STENCIL = 1L<<7,
gles: Support the GL_EXT_texture_format_BGRA8888 extension This extension allows an application to upload data in BGRA format. We can use this to avoid a conversion in Cogl whenever it is given BGRA data. This is quite useful when uploading data generated by Cairo because at least on little-endian architectures that ends up as BGRA. The patch just makes the pixel_format_to_gl implementation return GL_BGRA_EXT for the data format and internal format whenever COGL_PIXEL_FORMAT_BGRA_8888{,_PRE} is used. A small caveat with this patch is that once a texture is created as GL_BGRA, when later using glTexSubImage2D to update the texture it must always be given data as GL_BGRA. Currently this just works out because we store the internal format of a texture as a CoglPixelFormat and we already swizzle the data if it does not match exactly on GLES. However if we later switch to using a different enum for internal formats then we might lose the ability to store the component ordering so we'll have to think of another way to do this.
2012-03-21 12:06:59 -04:00
COGL_PRIVATE_FEATURE_OES_PACKED_DEPTH_STENCIL = 1L<<8,
gles2: Support the GL_EXT_unpack_subimage extension This extension lets you upload texture data from a subregion of a buffer by passing GL_UNPACK_ROW_LENGTH, GL_UNPACK_SKIP_PIXELS and GL_UNPACK_SKIP_ROWS to glPixelStore. When this extension is available the GLES texture driver will now avoid making a copy of the bitmap when a subregion is used. Note that Mesa doesn't currently advertise this extension but I've made a patch to propose it: http://lists.freedesktop.org/archives/mesa-dev/2012-March/020191.html
2012-03-21 13:51:51 -04:00
COGL_PRIVATE_FEATURE_TEXTURE_FORMAT_BGRA8888 = 1L<<9,
Use GL_ARB_sampler_objects GL_ARB_sampler_objects provides a GL object which overrides the sampler state part of a texture object with different values. The sampler state that Cogl currently exposes is the wrap modes and filters. Cogl exposes the state as part of the pipeline layer state but without this extension GL only exposes it as part of the texture object state. This means that it won't work to use a single texture multiple times in one primitive with different sampler states. It also makes switching between different sampler states with a single texture not terribly efficient because it has to change the texture object state every time. This patch adds a cache for sampler states in a shared hash table attached to the CoglContext. The entire set of parameters for the sampler state is used as the key for the hash table. When a unique state is encountered the sampler cache will create a new entry, otherwise it will return a const pointer to an existing entry. That means we can have a single pointer to represent any combination of sampler state. Pipeline layers now just store this single pointer rather than storing all of the sampler state. The two separate state flags for wrap modes and filters have now been combined into one. It should be faster to compare the sampler state now because instead of comparing each value it can just compare the pointers to the cached sampler entries. The hash table of cached sampler states should only need to perform its more expensive hash on the state when a property is changed on a pipeline, not every time it is flushed. When the sampler objects extension is available each cached sampler state will also get a sampler object to represent it. The common code to flush the GL state will now simply bind this object to a unit instead of flushing the state though the CoglTexture when possible. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-04-04 17:20:04 -04:00
COGL_PRIVATE_FEATURE_UNPACK_SUBIMAGE = 1L<<10,
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 15:32:36 -04:00
COGL_PRIVATE_FEATURE_SAMPLER_OBJECTS = 1L<<11,
COGL_PRIVATE_FEATURE_FIXED_FUNCTION = 1L<<12,
COGL_PRIVATE_FEATURE_READ_PIXELS_ANY_FORMAT = 1L<<13,
COGL_PRIVATE_FEATURE_ANY_GL = 1L<<14,
COGL_PRIVATE_FEATURE_ALPHA_TEST = 1L<<15,
COGL_PRIVATE_FEATURE_FORMAT_CONVERSION = 1L<<16,
COGL_PRIVATE_FEATURE_QUADS = 1L<<17,
COGL_PRIVATE_FEATURE_BLEND_CONSTANT = 1L<<18,
COGL_PRIVATE_FEATURE_QUERY_FRAMEBUFFER_BITS = 1L<<19,
COGL_PRIVATE_FEATURE_BUILTIN_POINT_SIZE_UNIFORM = 1L<<20,
COGL_PRIVATE_FEATURE_QUERY_TEXTURE_PARAMETERS = 1L<<21
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 17:34:10 -04:00
} CoglPrivateFeatureFlags;
pipeline: Split more code out from cogl-pipeline.c This splits out the core CoglPipelineLayer support code from cogl-pipeline.c into cogl-pipeline-layer.c; it splits out the debugging code for dumping a pipeline to a .dot file into cogl-pipeline-debug.c and it splits the CoglPipelineNode support which is shared between CoglPipeline and CoglPipelineLayer into cogl-node.c. Note: cogl-pipeline-layer.c only contains the layer code directly relating to CoglPipelineLayer objects; it does not contain any _cogl_pipeline API relating to how CoglPipeline tracks and manipulates layers.
2011-09-08 19:40:06 -04:00
/* Sometimes when evaluating pipelines, either during comparisons or
* if calculating a hash value we need to tweak the evaluation
* semantics */
typedef enum _CoglPipelineEvalFlags
{
COGL_PIPELINE_EVAL_FLAG_NONE = 0
} CoglPipelineEvalFlags;
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 14:28:27 -04:00
uint32_t
Moves all GLX code down from Clutter to Cogl This migrates all the GLX window system code down from the Clutter backend code into a Cogl winsys. Moving OpenGL window system binding code down from Clutter into Cogl is the biggest blocker to having Cogl become a standalone 3D graphics library, so this is an important step in that direction.
2010-11-05 08:28:33 -04:00
_cogl_driver_error_quark (void);
cogl: Introduce private feature flags and check for ARB_fp The Cogl context has now a feature_flags_private enum that will allow us to query and use OpenGL features without exposing them in the public API. The ARB_fragment_program extension is the first user of those flags. Looking for this extension only happens in the gl driver as the gles drivers will not expose them. One can use _cogl_features_available_private() to check for the availability of such private features. While at it, reindent cogl-internal.h as described in CODING_STYLE.
2009-11-14 09:59:59 -05:00
Unifies 90% of the code in {gl,gles}/cogl.c in common/cogl.c This code keeps on diverging and we get bugs and fixes in one version but not the other. This should make things a bit more maintainable.
2009-03-30 12:07:31 -04:00
#endif /* __COGL_INTERNAL_H */
Reference in New Issue Copy Permalink