brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
9401cb044e
mutter/cogl/cogl-context.c

746 lines
25 KiB
C
Raw Normal View History

Merged clutter-ivan branch into trunk. svn merge \ https://svn.o-hand.com/repos/clutter/trunk/clutter@2509 \ https://svn.o-hand.com/repos/clutter/branches/clutter-ivan@HEAD
2008-04-25 13:37:36 +00:00
/*
[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 14:48:12 +00:00
* Cogl
Merged clutter-ivan branch into trunk. svn merge \ https://svn.o-hand.com/repos/clutter/trunk/clutter@2509 \ https://svn.o-hand.com/repos/clutter/branches/clutter-ivan@HEAD
2008-04-25 13:37:36 +00:00
*
[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 14:48:12 +00:00
* An object oriented GL/GLES Abstraction/Utility Layer
Merged clutter-ivan branch into trunk. svn merge \ https://svn.o-hand.com/repos/clutter/trunk/clutter@2509 \ https://svn.o-hand.com/repos/clutter/branches/clutter-ivan@HEAD
2008-04-25 13:37:36 +00:00
*
[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 14:48:12 +00:00
* Copyright (C) 2007,2008,2009 Intel Corporation.
Merged clutter-ivan branch into trunk. svn merge \ https://svn.o-hand.com/repos/clutter/trunk/clutter@2509 \ https://svn.o-hand.com/repos/clutter/branches/clutter-ivan@HEAD
2008-04-25 13:37:36 +00: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 12:56:10 +00:00
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*
Merged clutter-ivan branch into trunk. svn merge \ https://svn.o-hand.com/repos/clutter/trunk/clutter@2509 \ https://svn.o-hand.com/repos/clutter/branches/clutter-ivan@HEAD
2008-04-25 13:37:36 +00:00
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
#include "cogl-object.h"
Merged clutter-ivan branch into trunk. svn merge \ https://svn.o-hand.com/repos/clutter/trunk/clutter@2509 \ https://svn.o-hand.com/repos/clutter/branches/clutter-ivan@HEAD
2008-04-25 13:37:36 +00:00
#include "cogl-internal.h"
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 12:28:33 +00:00
#include "cogl-private.h"
#include "cogl-winsys-private.h"
Fixes for make distcheck
2011-06-13 11:42:25 +00:00
#include "winsys/cogl-winsys-stub-private.h"
Initialize the cogl uprof state in cogl_create_context This avoids the use of of gcc constructor and destructor attributes to initialize the cogl uprof context and optionally print a cogl uprof report at app exit. We now initialize the uprof context in cogl_context_create instead.
2010-08-16 20:11:42 +00:00
#include "cogl-profile.h"
Merged clutter-ivan branch into trunk. svn merge \ https://svn.o-hand.com/repos/clutter/trunk/clutter@2509 \ https://svn.o-hand.com/repos/clutter/branches/clutter-ivan@HEAD
2008-04-25 13:37:36 +00:00
#include "cogl-util.h"
cogl: rename cogl-context.h cogl-context-private.h Since we plan to add public cogl_context_* API we need to rename the current cogl-context.h which contains private member details.
2010-11-04 22:25:52 +00:00
#include "cogl-context-private.h"
Add a vtable of indirection to the winsys code So that we can dynamically select what winsys backend to use at runtime we need to have some indirection to how code accesses the winsys instead of simply calling _cogl_winsys* functions that would collide if we wanted to compile more than one backend into Cogl.
2011-02-25 11:29:08 +00:00
#include "cogl-display-private.h"
#include "cogl-renderer-private.h"
[cogl-primitives] Split the journal out from cogl-primitives.c The Journal can be considered a standalone component, so even though it's currently only used to log quads, it seems better to split it out into its own file.
2009-09-16 13:01:57 +00:00
#include "cogl-journal-private.h"
Updates GLES1 support for CoglMaterial This updates cogl/gles in line with the integration of CoglMaterial throughout Cogl that has been done for cogl/gl. Note: This is still buggy, but at least it builds again and test-actors works. Some GLES2 specific changes were made, but these haven't been tested yet.
2009-01-26 11:07:35 +00:00
#include "cogl-texture-private.h"
cogl-pipeline-layer: Use CoglTextureType instead of GL target enum Instead of storing the GLenum for the target of the last used texture for a layer it now stores the CoglTextureType instead. The state name has been renamed to 'texture type' instead of 'texture target'. Previously the default pipeline layer would store 0 here to represent that there is no texture. This has been changed to store COGL_TEXTURE_TYPE_2D instead which means that all pipeline layers always have a valid value for the texture type. Any places that were previously fetching the texture from a layer to determine the target (for example when generating shaders or when enabling a particular texture target) now use the texture type instead. This means they will work even for layers that don't have a texture. This also changes it so that when binding a fallback texture instead of always using a 2D texture it will now use the default texture corresponding to the texture type of the layer. That way when the generated shader tries to do a texture lookup for that type of texture it will get a valid texture object. To make this work the patch adds a default texture for 3D textures to the context and also makes the default rectangle texture actually be a rectangle texture instead of using a 2D texture. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-09 12:52:45 +00:00
#include "cogl-texture-2d-private.h"
#include "cogl-texture-3d-private.h"
#include "cogl-texture-rectangle-private.h"
cogl: rename CoglMaterial -> CoglPipeline This applies an API naming change that's been deliberated over for a while now which is to rename CoglMaterial to CoglPipeline. For now the new pipeline API is marked as experimental and public headers continue to talk about materials not pipelines. The CoglMaterial API is now maintained in terms of the cogl_pipeline API internally. Currently this API is targeting Cogl 2.0 so we will have time to integrate it properly with other upcoming Cogl 2.0 work. The basic reasons for the rename are: - That the term "material" implies to many people that they are constrained to fragment processing; perhaps as some kind of high-level texture abstraction. - In Clutter they get exposed by ClutterTexture actors which may be re-inforcing this misconception. - When comparing how other frameworks use the term material, a material sometimes describes a multi-pass fragment processing technique which isn't the case in Cogl. - In code, "CoglPipeline" will hopefully be a much more self documenting summary of what these objects represent; a full GPU pipeline configuration including, for example, vertex processing, fragment processing and blending. - When considering the API documentation story, at some point we need a document introducing developers to how the "GPU pipeline" works so it should become intuitive that CoglPipeline maps back to that description of the GPU pipeline. - This is consistent in terminology and concept to OpenGL 4's new pipeline object which is a container for program objects. Note: The cogl-material.[ch] files have been renamed to cogl-material-compat.[ch] because otherwise git doesn't seem to treat the change as a moving the old cogl-material.c->cogl-pipeline.c and so we loose all our git-blame history.
2010-10-27 17:54:57 +00:00
#include "cogl-pipeline-private.h"
#include "cogl-pipeline-opengl-private.h"
cogl: deprecate cogl_draw_buffer API and replace with a cogl_framebuffer API cogl_push_draw_buffer, cogl_set_draw_buffer and cogl_pop_draw_buffer are now deprecated and new code should use the new cogl_framebuffer_* API instead. Code that previously did: cogl_push_draw_buffer (); cogl_set_draw_buffer (COGL_OFFSCREEN_BUFFER, buffer); /* draw */ cogl_pop_draw_buffer (); should now be re-written as: cogl_push_framebuffer (buffer); /* draw */ cogl_pop_framebuffer (); As can be seen from the example above the rename has been used as an opportunity to remove the redundant target argument from cogl_set_draw_buffer; it now only takes one call to redirect to an offscreen buffer, and finally the term framebuffer may be a bit more familiar to anyone coming from an OpenGL background.
2009-11-26 19:06:35 +00:00
#include "cogl-framebuffer-private.h"
framebuffer: split out CoglOnscreen code This factors out the CoglOnscreen code from cogl-framebuffer.c so we now have cogl-onscreen.c, cogl-onscreen.h and cogl-onscreen-private.h. Notably some of the functions pulled out are currently namespaced as cogl_framebuffer but we know we are planning on renaming them to be in the cogl_onscreen namespace; such as cogl_framebuffer_swap_buffers(). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 20:31:04 +00:00
#include "cogl-onscreen-private.h"
path 2.0: update path API for experimental 2.0 API When COGL_ENABLE_EXPERIMENTAL_2_0_API is defined cogl.h will now include cogl2-path.h which changes cogl_path_new() so it can directly return a CoglPath pointer; it no longer exposes a prototype for cogl_{get,set}_path and all the remaining cogl_path_ functions now take an explicit path as their first argument. The idea is that we want to encourage developers to retain path objects for as long as possible so they can take advantage of us uploading the path geometry to the GPU. Currently although it is possible to start a new path and query the current path, it is not convenient. The other thing is that we want to get Cogl to the point where nothing depends on a global, current context variable. This will allow us to one day define a sensible threading model if/when that is ever desired.
2010-11-04 00:27:47 +00:00
#include "cogl2-path.h"
rework enabling of attributes, removing _cogl_enable() This removes the limited caching of enabled attributes done by _cogl_enable() and replaces it with a more generalized set of bitmasks associated with the context that allow us to efficiently compare the set of attribute locations that are currently enabled vs the new locations that need enabling so we only have to inform OpenGL of the changes in which locations are enabled/disabled. This also adds a per-context hash table for mapping attribute names to global name-state structs which includes a unique name-index for any name as well as pre-validated information about builtin "cogl_" attribute names including whether the attribute is normalized and what texture unit a texture attribute corresponds too. The name-state hash table means that cogl_attribute_new() now only needs to validate names the first time they are seen. CoglAttributes now reference a name-state structure instead of just the attribute name, so now we can efficiently get the name-index for any attribute and we can use that to index into a per-glsl-program cache that maps name indices to real GL attribute locations so when we get asked to draw a set of attributes we can very quickly determine what GL attributes need to be setup and enabled. If we don't have a cached location though we can still quickly access the string name so we can query OpenGL. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-11-24 18:09:53 +00:00
#include "cogl-attribute-private.h"
Move all types/prototypes from cogl.h -> cogl[1]-context.h So we can get to the point where cogl.h is merely an aggregation of header includes for the 1.x api this moves all the function prototypes and type definitions into a cogl-context.h and a new cogl1-context.h. Ideally no code internally should ever need to include cogl.h as it just represents the public facing header for accessing the 1.x api which should only be used by Clutter. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-17 21:46:39 +00:00
#include "cogl1-context.h"
Add a mechanism for determining GPU driver details This adds a CoglGpuInfo struct to the CoglContext which contains some enums describing the GL driver in use. This currently includes the driver package (ie, is it Mesa) the version number of the package and the vendor of the GPU (ie, is it by Intel). There is also a bitmask which will contain the workarounds that we should do for that particular driver configuration. The struct is initialised on context creation by using a series of string comparisons on the strings returned from glGetString. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-27 13:43:04 +00:00
#include "cogl-gpu-info-private.h"
Add conf vars to trick Cogl to think extensions are disabled This adds two new configuration environment variables: COGL_DISABLE_GL_EXTENSIONS and COGL_OVERRIDE_GL_VERSION The variables can also be set in the cogl.conf file using the same names. The first one is a list of GL extension names separated by commas. When set Cogl will assume any extension listed here is not available by removing it from the string returned from glGetString(GL_EXTENSIONS). If the string is set in both the config file and the environment variable then the union of the two lists will be used. The second overrides the value returned from glGetString(GL_VERSION). If the string is set in both places the version from the environment variable will take priority. These are sometimes useful for debugging Cogl to test the various combinations of extensions. It could also be useful to work around driver bugs where an extension is badly supported and it would be better not to use it. The variables in cogl-config that just set a global char * variable have been put together in an array instead of having a separate blob of code for each one in order to make it simpler to add new variables. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ec69c2dc576c78664e0b73879365cb7414ecf441)
2012-07-31 15:30:33 +00:00
#include "cogl-config-private.h"
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
#include "cogl-error-private.h"
Merged clutter-ivan branch into trunk. svn merge \ https://svn.o-hand.com/repos/clutter/trunk/clutter@2509 \ https://svn.o-hand.com/repos/clutter/branches/clutter-ivan@HEAD
2008-04-25 13:37:36 +00:00
Updates GLES1 support for CoglMaterial This updates cogl/gles in line with the integration of CoglMaterial throughout Cogl that has been done for cogl/gl. Note: This is still buggy, but at least it builds again and test-actors works. Some GLES2 specific changes were made, but these haven't been tested yet.
2009-01-26 11:07:35 +00:00
#include <string.h>
clip-stack: workaround intel gen6 viewport clip bug The Intel Mesa gen6 driver doesn't currently handle scissoring offset viewports correctly, so this implements a workaround to intersect the current viewport bounds with the scissor rectangle. (cherry picked from commit afc5daab85e5faca99d6d6866658cb82c3954830)
2012-10-02 10:44:00 +00:00
#include <stdlib.h>
Updates GLES1 support for CoglMaterial This updates cogl/gles in line with the integration of CoglMaterial throughout Cogl that has been done for cogl/gl. Note: This is still buggy, but at least it builds again and test-actors works. Some GLES2 specific changes were made, but these haven't been tested yet.
2009-01-26 11:07:35 +00:00
cogl-context: Use the function pointer for glActiveUnit Under WGL, any functions that were defined after GL 1.1 are not directly exported in the DLL so we need to reference them via the function pointers. A new call to glActiveUnit was missed in cogl-context.c
2010-06-18 14:25:51 +00:00
#ifdef HAVE_COGL_GL
Rename CoglPipelineBackend to CoglPipelineFragend The current Cogl pipeline backends are entirely concerned with the fragment processing state. We also want to eventually have separate backends to generate shaders for the vertex processing state so we need to rename the fragment backends. 'Fragend' is a somewhat weird name but we wanted to avoid ending up with illegible symbols like CoglPipelineFragmentBackendGlslPrivate.
2010-11-29 16:56:41 +00:00
#include "cogl-pipeline-fragend-arbfp-private.h"
cogl-context: Use the function pointer for glActiveUnit Under WGL, any functions that were defined after GL 1.1 are not directly exported in the DLL so we need to reference them via the function pointers. A new call to glActiveUnit was missed in cogl-context.c
2010-06-18 14:25:51 +00:00
#endif
cogl-material: Add support for point sprites This adds a new API call to enable point sprite coordinate generation for a material layer: void cogl_material_set_layer_point_sprite_coords_enabled (CoglHandle material, int layer_index, gboolean enable); There is also a corresponding get function. Enabling point sprite coords simply sets the GL_COORD_REPLACE of the GL_POINT_SPRITE glTexEnv when flusing the material. There is no separate application control for glEnable(GL_POINT_SPRITE). Instead it is left permanently enabled under the assumption that it has no affect unless GL_COORD_REPLACE is enabled for a texture unit. http://bugzilla.openedhand.com/show_bug.cgi?id=2047
2010-03-22 13:33:55 +00:00
/* This isn't defined in the GLES headers */
#ifndef GL_POINT_SPRITE
#define GL_POINT_SPRITE 0x8861
#endif
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
static void _cogl_context_free (CoglContext *context);
COGL_OBJECT_DEFINE (Context, context);
Make the CoglContext structure a bit more maintainable This moves most of cogl-context.{c.h} to cogl/common with some driver specific members now living in a CoglContextDriver struct. Driver specific context initialization and typedefs now live in cogl/{gl,gles}/cogl-context-driver.{c,h} Driver specific members can be found under ctx->drv.stuff
2009-07-28 00:34:33 +00:00
extern void
_cogl_create_context_driver (CoglContext *context);
Avoid referencing file scope context in _context_new() cogl_context_new() had a mixture of references to the file scope context variable (_context) and the local (context) variable. This renames the file scope variable to _cogl_context to catch unnecessary references to the old name and fixes the code accordingly to reference the local variable instead. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 33a9397ee1ae1729200be2e5084cf43cebb64289)
2012-09-10 09:42:03 +00:00
static CoglContext *_cogl_context = NULL;
Merged clutter-ivan branch into trunk. svn merge \ https://svn.o-hand.com/repos/clutter/trunk/clutter@2509 \ https://svn.o-hand.com/repos/clutter/branches/clutter-ivan@HEAD
2008-04-25 13:37:36 +00:00
cogl-context: Get rid of the features_cached member The features_cached member of CoglContext is intended to mark when we've calculated the features so that we know if they are ready in cogl_get_features. However we always intialize the features while creating the context so features_cached will never be FALSE so it's not useful. We also had the odd behaviour that the COGL_DEBUG feature overrides were only applied in the first call to cogl_get_features. However there are other functions that use the feature flags such as cogl_features_available that don't use this function so in some cases the feature flags will be interpreted before the overrides are applied. This patch makes it always initialize the features and apply the overrides immediately while creating the context. This fixes a problem with COGL_DEBUG=disable-arbfp where the first material flushed is done before any call to cogl_get_features so it may still use ARBfp.
2010-11-24 18:37:47 +00:00
static void
_cogl_init_feature_overrides (CoglContext *ctx)
{
cogl-debug: Split the flags to support more than 32 The CoglDebugFlags are now stored in an array of unsigned ints rather than a single variable. The flags are accessed using macros instead of directly peeking at the cogl_debug_flags variable. The index values are stored in the enum rather than the actual mask values so that the enum doesn't need to be more than 32 bits wide. The hope is that the code to determine the index into the array can be optimized out by the compiler so it should have exactly the same performance as the old code.
2011-01-24 14:28:00 +00:00
if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_DISABLE_VBOS)))
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 08:36:46 +00:00
ctx->private_feature_flags &= ~COGL_PRIVATE_FEATURE_VBOS;
cogl-context: Get rid of the features_cached member The features_cached member of CoglContext is intended to mark when we've calculated the features so that we know if they are ready in cogl_get_features. However we always intialize the features while creating the context so features_cached will never be FALSE so it's not useful. We also had the odd behaviour that the COGL_DEBUG feature overrides were only applied in the first call to cogl_get_features. However there are other functions that use the feature flags such as cogl_features_available that don't use this function so in some cases the feature flags will be interpreted before the overrides are applied. This patch makes it always initialize the features and apply the overrides immediately while creating the context. This fixes a problem with COGL_DEBUG=disable-arbfp where the first material flushed is done before any call to cogl_get_features so it may still use ARBfp.
2010-11-24 18:37:47 +00:00
cogl-debug: Split the flags to support more than 32 The CoglDebugFlags are now stored in an array of unsigned ints rather than a single variable. The flags are accessed using macros instead of directly peeking at the cogl_debug_flags variable. The index values are stored in the enum rather than the actual mask values so that the enum doesn't need to be more than 32 bits wide. The hope is that the code to determine the index into the array can be optimized out by the compiler so it should have exactly the same performance as the old code.
2011-01-24 14:28:00 +00:00
if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_DISABLE_PBOS)))
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 08:30:33 +00:00
ctx->private_feature_flags &= ~COGL_PRIVATE_FEATURE_PBOS;
cogl-context: Get rid of the features_cached member The features_cached member of CoglContext is intended to mark when we've calculated the features so that we know if they are ready in cogl_get_features. However we always intialize the features while creating the context so features_cached will never be FALSE so it's not useful. We also had the odd behaviour that the COGL_DEBUG feature overrides were only applied in the first call to cogl_get_features. However there are other functions that use the feature flags such as cogl_features_available that don't use this function so in some cases the feature flags will be interpreted before the overrides are applied. This patch makes it always initialize the features and apply the overrides immediately while creating the context. This fixes a problem with COGL_DEBUG=disable-arbfp where the first material flushed is done before any call to cogl_get_features so it may still use ARBfp.
2010-11-24 18:37:47 +00:00
cogl-debug: Split the flags to support more than 32 The CoglDebugFlags are now stored in an array of unsigned ints rather than a single variable. The flags are accessed using macros instead of directly peeking at the cogl_debug_flags variable. The index values are stored in the enum rather than the actual mask values so that the enum doesn't need to be more than 32 bits wide. The hope is that the code to determine the index into the array can be optimized out by the compiler so it should have exactly the same performance as the old code.
2011-01-24 14:28:00 +00:00
if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_DISABLE_ARBFP)))
features: Support more than 32 features! Currently features are represented as bits in a 32bit mask so we obviously can't have more than 32 features with that approach. The new approach is to use the COGL_FLAGS_ macros which lets us handle bitmasks without a size limit and we change the public api to accept individual feature enums instead of a mask. This way there is no limit on the number of features we can add to Cogl. Instead of using cogl_features_available() there is a new cogl_has_feature() function and for checking multiple features there is cogl_has_features() which takes a zero terminated vararg list of features. In addition to being able to check for individual features this also adds a way to query all the features currently available via cogl_foreach_feature() which will call a callback for each feature. Since the new functions take an explicit context pointer there is also no longer any ambiguity over when users can first start to query features. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-12 21:31:12 +00:00
{
ctx->feature_flags &= ~COGL_FEATURE_SHADERS_ARBFP;
COGL_FLAGS_SET (ctx->features, COGL_FEATURE_ID_ARBFP, FALSE);
}
cogl-context: Get rid of the features_cached member The features_cached member of CoglContext is intended to mark when we've calculated the features so that we know if they are ready in cogl_get_features. However we always intialize the features while creating the context so features_cached will never be FALSE so it's not useful. We also had the odd behaviour that the COGL_DEBUG feature overrides were only applied in the first call to cogl_get_features. However there are other functions that use the feature flags such as cogl_features_available that don't use this function so in some cases the feature flags will be interpreted before the overrides are applied. This patch makes it always initialize the features and apply the overrides immediately while creating the context. This fixes a problem with COGL_DEBUG=disable-arbfp where the first material flushed is done before any call to cogl_get_features so it may still use ARBfp.
2010-11-24 18:37:47 +00:00
cogl-debug: Split the flags to support more than 32 The CoglDebugFlags are now stored in an array of unsigned ints rather than a single variable. The flags are accessed using macros instead of directly peeking at the cogl_debug_flags variable. The index values are stored in the enum rather than the actual mask values so that the enum doesn't need to be more than 32 bits wide. The hope is that the code to determine the index into the array can be optimized out by the compiler so it should have exactly the same performance as the old code.
2011-01-24 14:28:00 +00:00
if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_DISABLE_GLSL)))
features: Support more than 32 features! Currently features are represented as bits in a 32bit mask so we obviously can't have more than 32 features with that approach. The new approach is to use the COGL_FLAGS_ macros which lets us handle bitmasks without a size limit and we change the public api to accept individual feature enums instead of a mask. This way there is no limit on the number of features we can add to Cogl. Instead of using cogl_features_available() there is a new cogl_has_feature() function and for checking multiple features there is cogl_has_features() which takes a zero terminated vararg list of features. In addition to being able to check for individual features this also adds a way to query all the features currently available via cogl_foreach_feature() which will call a callback for each feature. Since the new functions take an explicit context pointer there is also no longer any ambiguity over when users can first start to query features. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-12 21:31:12 +00:00
{
ctx->feature_flags &= ~COGL_FEATURE_SHADERS_GLSL;
COGL_FLAGS_SET (ctx->features, COGL_FEATURE_ID_GLSL, FALSE);
}
cogl-context: Get rid of the features_cached member The features_cached member of CoglContext is intended to mark when we've calculated the features so that we know if they are ready in cogl_get_features. However we always intialize the features while creating the context so features_cached will never be FALSE so it's not useful. We also had the odd behaviour that the COGL_DEBUG feature overrides were only applied in the first call to cogl_get_features. However there are other functions that use the feature flags such as cogl_features_available that don't use this function so in some cases the feature flags will be interpreted before the overrides are applied. This patch makes it always initialize the features and apply the overrides immediately while creating the context. This fixes a problem with COGL_DEBUG=disable-arbfp where the first material flushed is done before any call to cogl_get_features so it may still use ARBfp.
2010-11-24 18:37:47 +00:00
cogl-debug: Split the flags to support more than 32 The CoglDebugFlags are now stored in an array of unsigned ints rather than a single variable. The flags are accessed using macros instead of directly peeking at the cogl_debug_flags variable. The index values are stored in the enum rather than the actual mask values so that the enum doesn't need to be more than 32 bits wide. The hope is that the code to determine the index into the array can be optimized out by the compiler so it should have exactly the same performance as the old code.
2011-01-24 14:28:00 +00:00
if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_DISABLE_NPOT_TEXTURES)))
features: Support more than 32 features! Currently features are represented as bits in a 32bit mask so we obviously can't have more than 32 features with that approach. The new approach is to use the COGL_FLAGS_ macros which lets us handle bitmasks without a size limit and we change the public api to accept individual feature enums instead of a mask. This way there is no limit on the number of features we can add to Cogl. Instead of using cogl_features_available() there is a new cogl_has_feature() function and for checking multiple features there is cogl_has_features() which takes a zero terminated vararg list of features. In addition to being able to check for individual features this also adds a way to query all the features currently available via cogl_foreach_feature() which will call a callback for each feature. Since the new functions take an explicit context pointer there is also no longer any ambiguity over when users can first start to query features. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-12 21:31:12 +00:00
{
ctx->feature_flags &= ~(COGL_FEATURE_TEXTURE_NPOT |
COGL_FEATURE_TEXTURE_NPOT_BASIC |
COGL_FEATURE_TEXTURE_NPOT_MIPMAP |
COGL_FEATURE_TEXTURE_NPOT_REPEAT);
COGL_FLAGS_SET (ctx->features, COGL_FEATURE_ID_TEXTURE_NPOT, FALSE);
COGL_FLAGS_SET (ctx->features,
COGL_FEATURE_ID_TEXTURE_NPOT_BASIC, FALSE);
COGL_FLAGS_SET (ctx->features,
COGL_FEATURE_ID_TEXTURE_NPOT_MIPMAP, FALSE);
COGL_FLAGS_SET (ctx->features,
COGL_FEATURE_ID_TEXTURE_NPOT_REPEAT, FALSE);
}
cogl-context: Get rid of the features_cached member The features_cached member of CoglContext is intended to mark when we've calculated the features so that we know if they are ready in cogl_get_features. However we always intialize the features while creating the context so features_cached will never be FALSE so it's not useful. We also had the odd behaviour that the COGL_DEBUG feature overrides were only applied in the first call to cogl_get_features. However there are other functions that use the feature flags such as cogl_features_available that don't use this function so in some cases the feature flags will be interpreted before the overrides are applied. This patch makes it always initialize the features and apply the overrides immediately while creating the context. This fixes a problem with COGL_DEBUG=disable-arbfp where the first material flushed is done before any call to cogl_get_features so it may still use ARBfp.
2010-11-24 18:37:47 +00:00
}
Add a vtable of indirection to the winsys code So that we can dynamically select what winsys backend to use at runtime we need to have some indirection to how code accesses the winsys instead of simply calling _cogl_winsys* functions that would collide if we wanted to compile more than one backend into Cogl.
2011-02-25 11:29:08 +00:00
const CoglWinsysVtable *
_cogl_context_get_winsys (CoglContext *context)
{
return context->display->renderer->winsys_vtable;
}
Adds renderer,display,onscreen-template and swap-chain stubs As part of the process of splitting Cogl out as a standalone graphics API we need to introduce some API concepts that will allow us to initialize a new CoglContext when Clutter isn't there to handle that for us... The new objects roughly in the order that they are (optionally) involved in constructing a context are: CoglRenderer, CoglOnscreenTemplate, CoglSwapChain and CoglDisplay. Conceptually a CoglRenderer represents a means for rendering. Cogl supports rendering via OpenGL or OpenGL ES 1/2.0 and those APIs are accessed through a number of different windowing APIs such as GLX, EGL, SDL or WGL and more. Potentially in the future Cogl could render using D3D or even by using libdrm and directly banging the hardware. All these choices are wrapped up in the configuration of a CoglRenderer. Conceptually a CoglDisplay represents a display pipeline for a renderer. Although Cogl doesn't aim to provide a detailed abstraction of display hardware, on some platforms we can give control over multiple display planes (On TV platforms for instance video content may be on one plane and 3D would be on another so a CoglDisplay lets you select the plane up-front.) Another aspect of CoglDisplay is that it lets us negotiate a display pipeline that best supports the type of CoglOnscreen framebuffers we are planning to create. For instance if you want transparent CoglOnscreen framebuffers then we have to be sure the display pipeline wont discard the alpha component of your framebuffers. Or if you want to use double/tripple buffering that requires support from the display pipeline. CoglOnscreenTemplate and CoglSwapChain are how we describe our default CoglOnscreen framebuffer configuration which can affect the configuration of the display pipeline. The default/simple way we expect most CoglContexts to be constructed will be via something like: if (!cogl_context_new (NULL, &error)) g_error ("Failed to construct a CoglContext: %s", error->message); Where that NULL is for an optional "display" parameter and NULL says to Cogl "please just try to do something sensible". If you want some more control though you can manually construct a CoglDisplay something like: display = cogl_display_new (NULL, NULL); cogl_gdl_display_set_plane (display, plane); if (!cogl_display_setup (display, &error)) g_error ("Failed to setup a CoglDisplay: %s", error->message); And in a similar fashion to cogl_context_new() you can optionally pass a NULL "renderer" and/or a NULL "onscreen template" so Cogl will try to just do something sensible. If you need to change the CoglOnscreen defaults you can provide a template something like: chain = cogl_swap_chain_new (); cogl_swap_chain_set_has_alpha (chain, TRUE); cogl_swap_chain_set_length (chain, 3); onscreen_template = cogl_onscreen_template_new (chain); cogl_onscreen_template_set_pixel_format (onscreen_template, COGL_PIXEL_FORMAT_RGB565); display = cogl_display_new (NULL, onscreen_template); if (!cogl_display_setup (display, &error)) g_error ("Failed to setup a CoglDisplay: %s", error->message);
2011-02-25 17:06:50 +00:00
/* For reference: There was some deliberation over whether to have a
* constructor that could throw an exception but looking at standard
* practices with several high level OO languages including python, C++,
* C# Java and Ruby they all support exceptions in constructors and the
* general consensus appears to be that throwing an exception is neater
* than successfully constructing with an internal error status that
* would then have to be explicitly checked via some form of ::is_ok()
* method.
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
*/
CoglContext *
Adds renderer,display,onscreen-template and swap-chain stubs As part of the process of splitting Cogl out as a standalone graphics API we need to introduce some API concepts that will allow us to initialize a new CoglContext when Clutter isn't there to handle that for us... The new objects roughly in the order that they are (optionally) involved in constructing a context are: CoglRenderer, CoglOnscreenTemplate, CoglSwapChain and CoglDisplay. Conceptually a CoglRenderer represents a means for rendering. Cogl supports rendering via OpenGL or OpenGL ES 1/2.0 and those APIs are accessed through a number of different windowing APIs such as GLX, EGL, SDL or WGL and more. Potentially in the future Cogl could render using D3D or even by using libdrm and directly banging the hardware. All these choices are wrapped up in the configuration of a CoglRenderer. Conceptually a CoglDisplay represents a display pipeline for a renderer. Although Cogl doesn't aim to provide a detailed abstraction of display hardware, on some platforms we can give control over multiple display planes (On TV platforms for instance video content may be on one plane and 3D would be on another so a CoglDisplay lets you select the plane up-front.) Another aspect of CoglDisplay is that it lets us negotiate a display pipeline that best supports the type of CoglOnscreen framebuffers we are planning to create. For instance if you want transparent CoglOnscreen framebuffers then we have to be sure the display pipeline wont discard the alpha component of your framebuffers. Or if you want to use double/tripple buffering that requires support from the display pipeline. CoglOnscreenTemplate and CoglSwapChain are how we describe our default CoglOnscreen framebuffer configuration which can affect the configuration of the display pipeline. The default/simple way we expect most CoglContexts to be constructed will be via something like: if (!cogl_context_new (NULL, &error)) g_error ("Failed to construct a CoglContext: %s", error->message); Where that NULL is for an optional "display" parameter and NULL says to Cogl "please just try to do something sensible". If you want some more control though you can manually construct a CoglDisplay something like: display = cogl_display_new (NULL, NULL); cogl_gdl_display_set_plane (display, plane); if (!cogl_display_setup (display, &error)) g_error ("Failed to setup a CoglDisplay: %s", error->message); And in a similar fashion to cogl_context_new() you can optionally pass a NULL "renderer" and/or a NULL "onscreen template" so Cogl will try to just do something sensible. If you need to change the CoglOnscreen defaults you can provide a template something like: chain = cogl_swap_chain_new (); cogl_swap_chain_set_has_alpha (chain, TRUE); cogl_swap_chain_set_length (chain, 3); onscreen_template = cogl_onscreen_template_new (chain); cogl_onscreen_template_set_pixel_format (onscreen_template, COGL_PIXEL_FORMAT_RGB565); display = cogl_display_new (NULL, onscreen_template); if (!cogl_display_setup (display, &error)) g_error ("Failed to setup a CoglDisplay: %s", error->message);
2011-02-25 17:06:50 +00:00
cogl_context_new (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)
Merged clutter-ivan branch into trunk. svn merge \ https://svn.o-hand.com/repos/clutter/trunk/clutter@2509 \ https://svn.o-hand.com/repos/clutter/branches/clutter-ivan@HEAD
2008-04-25 13:37:36 +00:00
{
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
CoglContext *context;
Updates GLES1 support for CoglMaterial This updates cogl/gles in line with the integration of CoglMaterial throughout Cogl that has been done for cogl/gl. Note: This is still buggy, but at least it builds again and test-actors works. Some GLES2 specific changes were made, but these haven't been tested yet.
2009-01-26 11:07:35 +00:00
GLubyte default_texture_data[] = { 0xff, 0xff, 0xff, 0x0 };
cogl-pipeline-layer: Use CoglTextureType instead of GL target enum Instead of storing the GLenum for the target of the last used texture for a layer it now stores the CoglTextureType instead. The state name has been renamed to 'texture type' instead of 'texture target'. Previously the default pipeline layer would store 0 here to represent that there is no texture. This has been changed to store COGL_TEXTURE_TYPE_2D instead which means that all pipeline layers always have a valid value for the texture type. Any places that were previously fetching the texture from a layer to determine the target (for example when generating shaders or when enabling a particular texture target) now use the texture type instead. This means they will work even for layers that don't have a texture. This also changes it so that when binding a fallback texture instead of always using a 2D texture it will now use the default texture corresponding to the texture type of the layer. That way when the generated shader tries to do a texture lookup for that type of texture it will get a valid texture object. To make this work the patch adds a default texture for 3D textures to the context and also makes the default rectangle texture actually be a rectangle texture instead of using a 2D texture. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-09 12:52:45 +00:00
CoglBitmap *default_texture_bitmap;
Add a vtable of indirection to the winsys code So that we can dynamically select what winsys backend to use at runtime we need to have some indirection to how code accesses the winsys instead of simply calling _cogl_winsys* functions that would collide if we wanted to compile more than one backend into Cogl.
2011-02-25 11:29:08 +00:00
const CoglWinsysVtable *winsys;
cogl-buffer: Track the last used bind target in CoglBuffer This makes CoglBuffer track the last used bind target as a private property. This is later used when binding a buffer to map instead of always using the PIXEL_UNPACK target. This also adds some additional sanity checks that code doesn't try to nest binds to the same target or bind a buffer to multiple targets at the same time.
2010-07-05 22:24:34 +00:00
int i;
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 *internal_error = NULL;
Updates GLES1 support for CoglMaterial This updates cogl/gles in line with the integration of CoglMaterial throughout Cogl that has been done for cogl/gl. Note: This is still buggy, but at least it builds again and test-actors works. Some GLES2 specific changes were made, but these haven't been tested yet.
2009-01-26 11:07:35 +00:00
Add internal _cogl_init() function This adds a _cogl_init function for Cogl that we expect to be the first thing called before anything else is done with Cogl. It's not a public API so it's expected that all entry points for Cogl that might be the first function used should call _cogl_init(). We currently call _cogl_init() in these functions: cogl_renderer_new cogl_display_new cogl_context_new cogl_android_set_native_window _cogl_init() can be called multiple times, and only the first call has any affect. For example _cogl_init() gives us a place check and parse the COGL_DEBUG environment variable. Since we don't have any need to parse command line arguments (we can always get user configuration options from the environment) our init function doesn't require argc/argv pointers. By saying up front that we aren't interested in command line arguments that means we can avoid the mess that is GOption based library initialization which is extremely fragile due to its lack of dependency tracking between modules. Signed-off-by: Neil Roberts <neil@linux.intel.com>
2011-06-14 21:33:44 +00:00
_cogl_init ();
profile: Adds a --enable-profile option This adds a --enable-profile option which enables uprof based profiling. It was also necessary to fixup a CLUTTER_ENABLE_PROFILING #ifdef in cogl-context.c to renamed COGL_ENABLE_PROFILING instead. By default Cogl doesn't output uprof reports directly, instead it assumes a higher level toolkit will output a report. If you want a report from Cogl you can export COGL_PROFILE_OUTPUT_REPORT=1 before running your app. The latest version of uprof can be fetched from: git://github.com/rib/UProf.git
2011-06-13 09:30:49 +00:00
#ifdef COGL_ENABLE_PROFILE
Initialize the cogl uprof state in cogl_create_context This avoids the use of of gcc constructor and destructor attributes to initialize the cogl uprof context and optionally print a cogl uprof report at app exit. We now initialize the uprof context in cogl_context_create instead.
2010-08-16 20:11:42 +00:00
/* We need to be absolutely sure that uprof has been initialized
* before calling _cogl_uprof_init. uprof_init (NULL, NULL)
* will be a NOP if it has been initialized but it will also
* mean subsequent parsing of the UProf GOptionGroup will have no
* affect.
*
* Sadly GOptionGroup based library initialization is extremely
* fragile by design because GOptionGroups have no notion of
* dependencies and so the order things are initialized isn't
* currently under tight control.
*/
uprof_init (NULL, NULL);
_cogl_uprof_init ();
#endif
Merged clutter-ivan branch into trunk. svn merge \ https://svn.o-hand.com/repos/clutter/trunk/clutter@2509 \ https://svn.o-hand.com/repos/clutter/branches/clutter-ivan@HEAD
2008-04-25 13:37:36 +00:00
/* Allocate context memory */
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
context = g_malloc0 (sizeof (CoglContext));
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
Add a public cogl_bitmap_new_for_data This creates a CoglBitmap which points into an existing buffer in system memory. That way it can be used to create a texture or to read pixel data into. The function replaces the existing internal function _cogl_bitmap_new_from_data but removes the destroy notify call back. If the application wants notification of destruction it can just use the cogl_object_set_user_data function as normal. Internally there is now a convenience function to create a bitmap for system memory and automatically free the buffer using that mechanism. The name of the function is inspired by cairo_image_surface_create_for_data which has similar semantics. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-13 14:46:18 +00:00
/* Convert the context into an object immediately in case any of the
code below wants to verify that the context pointer is a valid
object */
_cogl_context_object_new (context);
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
/* XXX: Gross hack!
* Currently everything in Cogl just assumes there is a default
* context which it can access via _COGL_GET_CONTEXT() including
* code used to construct a CoglContext. Until all of that code
* has been updated to take an explicit context argument we have
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 12:28:33 +00:00
* to immediately make our pointer the default context.
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
*/
Avoid referencing file scope context in _context_new() cogl_context_new() had a mixture of references to the file scope context variable (_context) and the local (context) variable. This renames the file scope variable to _cogl_context to catch unnecessary references to the old name and fixes the code accordingly to reference the local variable instead. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 33a9397ee1ae1729200be2e5084cf43cebb64289)
2012-09-10 09:42:03 +00:00
_cogl_context = context;
Updates GLES1 support for CoglMaterial This updates cogl/gles in line with the integration of CoglMaterial throughout Cogl that has been done for cogl/gl. Note: This is still buggy, but at least it builds again and test-actors works. Some GLES2 specific changes were made, but these haven't been tested yet.
2009-01-26 11:07:35 +00:00
Merged clutter-ivan branch into trunk. svn merge \ https://svn.o-hand.com/repos/clutter/trunk/clutter@2509 \ https://svn.o-hand.com/repos/clutter/branches/clutter-ivan@HEAD
2008-04-25 13:37:36 +00:00
/* Init default values */
features: Support more than 32 features! Currently features are represented as bits in a 32bit mask so we obviously can't have more than 32 features with that approach. The new approach is to use the COGL_FLAGS_ macros which lets us handle bitmasks without a size limit and we change the public api to accept individual feature enums instead of a mask. This way there is no limit on the number of features we can add to Cogl. Instead of using cogl_features_available() there is a new cogl_has_feature() function and for checking multiple features there is cogl_has_features() which takes a zero terminated vararg list of features. In addition to being able to check for individual features this also adds a way to query all the features currently available via cogl_foreach_feature() which will call a callback for each feature. Since the new functions take an explicit context pointer there is also no longer any ambiguity over when users can first start to query features. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-12 21:31:12 +00:00
memset (context->features, 0, sizeof (context->features));
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 12:28:33 +00:00
context->feature_flags = 0;
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
context->private_feature_flags = 0;
Updates GLES1 support for CoglMaterial This updates cogl/gles in line with the integration of CoglMaterial throughout Cogl that has been done for cogl/gl. Note: This is still buggy, but at least it builds again and test-actors works. Some GLES2 specific changes were made, but these haven't been tested yet.
2009-01-26 11:07:35 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
context->texture_types = NULL;
context->buffer_types = NULL;
cogl-texture: List texture subclass types rather than hardcoding them Instead of having a hardcoded series of if-statements in cogl_is_texture to determine which types should appear as texture subclasses, they are now stored in a GSList attached to the Cogl context. The list is amended to using a new cogl_texture_register_type function. There is a convenience macro called COGL_TEXTURE_DEFINE which uses COGL_HANDLE_DEFINE_WITH_CODE to register the texture type when the _get_type() function is first called.
2010-06-11 12:50:36 +00: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 12:28:33 +00:00
context->rectangle_state = COGL_WINSYS_RECTANGLE_STATE_UNKNOWN;
cogl-context: Store winsys features in an array of unsigned ints Previously the mask of available winsys features was stored in a CoglBitmask. That isn't the ideal type to use for this because it is intended for a growable array of bits so it can allocate extra memory if there are more than 31 flags set. For the winsys feature flags the highest used bit is known at compile time so it makes sense to allocate a fixed array instead. This is conceptually similar to the CoglDebugFlags which are stored in an array of integers with macros to test a bit in the array. This moves the macros used for CoglDebugFlags to cogl-flags.h and makes them more generic so they can be shared with CoglContext.
2011-04-15 14:39:14 +00:00
memset (context->winsys_features, 0, sizeof (context->winsys_features));
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 12:28:33 +00:00
if (!display)
fix cogl_context_new crash if fail to connect renderer If a NULL display is passed to cogl_context_new() then it has to implicitly create a CoglRenderer and CoglDisplay and propagate any resulting errors back to the user. Previously the implementation relied on passing a NULL renderer to cogl_display_new() as the means for implicitly connecting to a renderer. The problem with this though is that cogl_display_new() isn't designed to ever return NULL but if it failed to connect to a renderer automatically it would do and then cogl_context_new would pass NULL to cogl_display_setup() leading to a crash. This patch changes the implementation of cogl_context_new() to now explicitly create a CoglRenderer and connect to it if a NULL display is given. This way we can easily propagate any errors. In addition cogl_display_new has been changed to abort if it fails to implicitly connect to a renderer due to a NULL renderer argument. An application needing to gracefully handle problems connecting to a renderer at runtime should manually instantiate and connect a renderer passing a GError argument to cogl_renderer_connect. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-04-10 18:21:55 +00:00
{
CoglRenderer *renderer = cogl_renderer_new ();
if (!cogl_renderer_connect (renderer, error))
{
g_free (context);
return NULL;
}
display = cogl_display_new (renderer, NULL);
}
Adds renderer,display,onscreen-template and swap-chain stubs As part of the process of splitting Cogl out as a standalone graphics API we need to introduce some API concepts that will allow us to initialize a new CoglContext when Clutter isn't there to handle that for us... The new objects roughly in the order that they are (optionally) involved in constructing a context are: CoglRenderer, CoglOnscreenTemplate, CoglSwapChain and CoglDisplay. Conceptually a CoglRenderer represents a means for rendering. Cogl supports rendering via OpenGL or OpenGL ES 1/2.0 and those APIs are accessed through a number of different windowing APIs such as GLX, EGL, SDL or WGL and more. Potentially in the future Cogl could render using D3D or even by using libdrm and directly banging the hardware. All these choices are wrapped up in the configuration of a CoglRenderer. Conceptually a CoglDisplay represents a display pipeline for a renderer. Although Cogl doesn't aim to provide a detailed abstraction of display hardware, on some platforms we can give control over multiple display planes (On TV platforms for instance video content may be on one plane and 3D would be on another so a CoglDisplay lets you select the plane up-front.) Another aspect of CoglDisplay is that it lets us negotiate a display pipeline that best supports the type of CoglOnscreen framebuffers we are planning to create. For instance if you want transparent CoglOnscreen framebuffers then we have to be sure the display pipeline wont discard the alpha component of your framebuffers. Or if you want to use double/tripple buffering that requires support from the display pipeline. CoglOnscreenTemplate and CoglSwapChain are how we describe our default CoglOnscreen framebuffer configuration which can affect the configuration of the display pipeline. The default/simple way we expect most CoglContexts to be constructed will be via something like: if (!cogl_context_new (NULL, &error)) g_error ("Failed to construct a CoglContext: %s", error->message); Where that NULL is for an optional "display" parameter and NULL says to Cogl "please just try to do something sensible". If you want some more control though you can manually construct a CoglDisplay something like: display = cogl_display_new (NULL, NULL); cogl_gdl_display_set_plane (display, plane); if (!cogl_display_setup (display, &error)) g_error ("Failed to setup a CoglDisplay: %s", error->message); And in a similar fashion to cogl_context_new() you can optionally pass a NULL "renderer" and/or a NULL "onscreen template" so Cogl will try to just do something sensible. If you need to change the CoglOnscreen defaults you can provide a template something like: chain = cogl_swap_chain_new (); cogl_swap_chain_set_has_alpha (chain, TRUE); cogl_swap_chain_set_length (chain, 3); onscreen_template = cogl_onscreen_template_new (chain); cogl_onscreen_template_set_pixel_format (onscreen_template, COGL_PIXEL_FORMAT_RGB565); display = cogl_display_new (NULL, onscreen_template); if (!cogl_display_setup (display, &error)) g_error ("Failed to setup a CoglDisplay: %s", error->message);
2011-02-25 17:06:50 +00:00
else
cogl_object_ref (display);
if (!cogl_display_setup (display, error))
{
cogl_object_unref (display);
g_free (context);
return NULL;
}
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 12:28:33 +00:00
context->display = display;
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 19:44:56 +00:00
/* This is duplicated data, but it's much more convenient to have
the driver attached to the context and the value is accessed a
lot throughout Cogl */
context->driver = display->renderer->driver;
framebuffer: split GL code out from cogl-framebuffer.c This splits out most of the OpenGL specific code from cogl-framebuffer.c into cogl-framebuffer-gl.c and extends the CoglDriverVtable interface for cogl-framebuffer.c to use. There are hopes to support several different backends for Cogl eventually to hopefully get us closer to the metal so this makes some progress in organizing which parts of Cogl are OpenGL specific so these parts can potentially be switched out later. The only remaining use of OpenGL still in cogl-framebuffer.c is to handle cogl_framebuffer_read_pixels.
2012-08-31 23:04:00 +00:00
/* Again this is duplicated data, but it convenient to be able
* access these from the context. */
context->driver_vtable = display->renderer->driver_vtable;
context->texture_driver = display->renderer->texture_driver;
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 19:44:56 +00:00
Add a vtable for the driver Cogl already had a vtable for the texture driver. This ended up being used for some things that are not strictly related to texturing such as converting between pixel formats and GL enums. Some other functions that are driver dependent such as updating the features were not indirected through a vtable but instead switched directly by looking at the ctx->driver enum value. This patch normalises to the two uses by adding a separate vtable for driver functions not related to texturing and moves the pixel format conversion functions to it from the texture driver vtable. It also adds a context parameter to all of the functions in the new driver vtable so that they won't have to rely on the global context.
2012-03-22 16:32:56 +00:00
winsys = _cogl_context_get_winsys (context);
if (!winsys->context_init (context, error))
{
cogl_object_unref (display);
g_free (context);
return NULL;
}
rework enabling of attributes, removing _cogl_enable() This removes the limited caching of enabled attributes done by _cogl_enable() and replaces it with a more generalized set of bitmasks associated with the context that allow us to efficiently compare the set of attribute locations that are currently enabled vs the new locations that need enabling so we only have to inform OpenGL of the changes in which locations are enabled/disabled. This also adds a per-context hash table for mapping attribute names to global name-state structs which includes a unique name-index for any name as well as pre-validated information about builtin "cogl_" attribute names including whether the attribute is normalized and what texture unit a texture attribute corresponds too. The name-state hash table means that cogl_attribute_new() now only needs to validate names the first time they are seen. CoglAttributes now reference a name-state structure instead of just the attribute name, so now we can efficiently get the name-index for any attribute and we can use that to index into a per-glsl-program cache that maps name indices to real GL attribute locations so when we get asked to draw a set of attributes we can very quickly determine what GL attributes need to be setup and enabled. If we don't have a cached location though we can still quickly access the string name so we can query OpenGL. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-11-24 18:09:53 +00:00
context->attribute_name_states_hash =
g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
context->attribute_name_index_map = NULL;
context->n_attribute_names = 0;
/* The "cogl_color_in" attribute needs a deterministic name_index
* so we make sure it's the first attribute name we register */
_cogl_attribute_register_attribute_name (context, "cogl_color_in");
cogl-pipeline: Use a hash table for faster uniform name lookup The uniform names are now stored in a GPtrArray instead of a linked list. There is also a hash table to speed up converting names to locations. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-04 18:26:17 +00:00
context->uniform_names =
g_ptr_array_new_with_free_func ((GDestroyNotify) g_free);
context->uniform_name_hash = g_hash_table_new (g_str_hash, g_str_equal);
cogl-pipeline: Add support for setting uniform values This adds the following new public experimental functions to set uniform values on a CoglPipeline: void cogl_pipeline_set_uniform_1f (CoglPipeline *pipeline, int uniform_location, float value); void cogl_pipeline_set_uniform_1i (CoglPipeline *pipeline, int uniform_location, int value); void cogl_pipeline_set_uniform_float (CoglPipeline *pipeline, int uniform_location, int n_components, int count, const float *value); void cogl_pipeline_set_uniform_int (CoglPipeline *pipeline, int uniform_location, int n_components, int count, const int *value); void cogl_pipeline_set_uniform_matrix (CoglPipeline *pipeline, int uniform_location, int dimensions, int count, gboolean transpose, const float *value); These are similar to the old functions used to set uniforms on a CoglProgram. To get a value to pass in as the uniform_location there is also: int cogl_pipeline_get_uniform_location (CoglPipeline *pipeline, const char *uniform_name); Conceptually the uniform locations are tied to the pipeline so that whenever setting a value for a new pipeline the application is expected to call this function. However in practice the uniform locations are global to the CoglContext. The names are stored in a linked list where the position in the list is the uniform location. The global indices are used so that each pipeline can store a mask of which uniforms it overrides. That way it is quicker to detect which uniforms are different from the last pipeline that used the same CoglProgramState so it can avoid flushing uniforms that haven't changed. Currently the values are not actually compared which means that it will only avoid flushing a uniform if there is a common ancestor that sets the value (or if the same pipeline is being flushed again - in which case the pipeline and its common ancestor are the same thing). The uniform values are stored in the big state of the pipeline as a sparse linked list. A bitmask stores which values have been overridden and only overridden values are stored in the linked list. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-03 17:20:43 +00:00
context->n_uniform_names = 0;
[cogl] Ensure features are initialized first in cogl_create_context Previously some context initializing was being done without valid feature flags.
2009-10-22 11:35:33 +00:00
/* Initialise the driver specific state */
cogl: consolidate _create_context_driver + _features_init This moves the functionality of _cogl_create_context_driver from driver/{gl,gles}/cogl-context-driver-{gl,gles}.c into driver/{gl,gles}/cogl-{gl,gles}.c as a static function called initialize_context_driver. cogl-context-driver-{gl,gles}.[ch] have now been removed.
2010-11-05 00:34:37 +00:00
_cogl_init_feature_overrides (context);
[cogl] Ensure features are initialized first in cogl_create_context Previously some context initializing was being done without valid feature flags.
2009-10-22 11:35:33 +00:00
clip-stack: workaround intel gen6 viewport clip bug The Intel Mesa gen6 driver doesn't currently handle scissoring offset viewports correctly, so this implements a workaround to intersect the current viewport bounds with the scissor rectangle. (cherry picked from commit afc5daab85e5faca99d6d6866658cb82c3954830)
2012-10-02 10:44:00 +00:00
/* XXX: ONGOING BUG: Intel viewport scissor
*
* Intel gen6 drivers don't currently correctly handle offset
* viewports, since primitives aren't clipped within the bounds of
* the viewport. To workaround this we push our own clip for the
* viewport that will use scissoring to ensure we clip as expected.
*
* TODO: file a bug upstream!
*/
if (context->gpu.driver_package == COGL_GPU_INFO_DRIVER_PACKAGE_MESA &&
context->gpu.architecture == COGL_GPU_INFO_ARCHITECTURE_SANDYBRIDGE &&
!getenv ("COGL_DISABLE_INTEL_VIEWPORT_SCISSORT_WORKAROUND"))
context->needs_viewport_scissor_workaround = TRUE;
else
context->needs_viewport_scissor_workaround = FALSE;
Avoid referencing file scope context in _context_new() cogl_context_new() had a mixture of references to the file scope context variable (_context) and the local (context) variable. This renames the file scope variable to _cogl_context to catch unnecessary references to the old name and fixes the code accordingly to reference the local variable instead. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 33a9397ee1ae1729200be2e5084cf43cebb64289)
2012-09-10 09:42:03 +00:00
context->sampler_cache = _cogl_sampler_cache_new (context);
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 21:20:04 +00:00
cogl: rename CoglMaterial -> CoglPipeline This applies an API naming change that's been deliberated over for a while now which is to rename CoglMaterial to CoglPipeline. For now the new pipeline API is marked as experimental and public headers continue to talk about materials not pipelines. The CoglMaterial API is now maintained in terms of the cogl_pipeline API internally. Currently this API is targeting Cogl 2.0 so we will have time to integrate it properly with other upcoming Cogl 2.0 work. The basic reasons for the rename are: - That the term "material" implies to many people that they are constrained to fragment processing; perhaps as some kind of high-level texture abstraction. - In Clutter they get exposed by ClutterTexture actors which may be re-inforcing this misconception. - When comparing how other frameworks use the term material, a material sometimes describes a multi-pass fragment processing technique which isn't the case in Cogl. - In code, "CoglPipeline" will hopefully be a much more self documenting summary of what these objects represent; a full GPU pipeline configuration including, for example, vertex processing, fragment processing and blending. - When considering the API documentation story, at some point we need a document introducing developers to how the "GPU pipeline" works so it should become intuitive that CoglPipeline maps back to that description of the GPU pipeline. - This is consistent in terminology and concept to OpenGL 4's new pipeline object which is a container for program objects. Note: The cogl-material.[ch] files have been renamed to cogl-material-compat.[ch] because otherwise git doesn't seem to treat the change as a moving the old cogl-material.c->cogl-pipeline.c and so we loose all our git-blame history.
2010-10-27 17:54:57 +00:00
_cogl_pipeline_init_default_pipeline ();
_cogl_pipeline_init_default_layers ();
pipeline: Implements _cogl_pipeline_hash function This allows us to get a hash for a set of state groups for a given pipeline. This can be used for example to get a hash of the fragment processing state of a pipeline so we can implement a cache for compiled arbfp/glsl programs.
2010-11-04 13:57:36 +00:00
_cogl_pipeline_init_state_hash_functions ();
_cogl_pipeline_init_layer_state_hash_functions ();
[cogl-material] Adds cogl_material_copy() API cogl_material_copy can be used to create a new CoglHandle referencing a copy of some given material. From now on we will advise that developers always aim to use this function instead of cogl_material_new() when creating a material that is in any way derived from another. By using cogl_material_copy, Cogl can maintain an ancestry for each material and keep track of "similar" materials. The plan is that Cogl will use this information to minimize the cost of GPU state transitions.
2009-11-11 12:50:48 +00:00
Fixed uninitialized data (current_clip_stack_valid) in context creation Reviewed-By: Robert Bragg <robert@linux.intel.com>
2011-07-12 04:37:09 +00:00
context->current_clip_stack_valid = FALSE;
context->current_clip_stack = NULL;
Updates GLES1 support for CoglMaterial This updates cogl/gles in line with the integration of CoglMaterial throughout Cogl that has been done for cogl/gl. Note: This is still buggy, but at least it builds again and test-actors works. Some GLES2 specific changes were made, but these haven't been tested yet.
2009-01-26 11:07:35 +00:00
Make backface culling be part of the legacy state This adds an internal function to set the backface culling state on a pipeline. This includes properties to set the culling mode (front, back or both) and also to set which face is considered the front (COGL_WINDING_CLOCKWISE or COGL_WINDING_COUNTER_CLOCKWISE). The actual front face flushed to GL depends on whether we are rendering to an offscreen buffer or not. This means that when changing between on- and off- screen framebuffers it now checks whether the last flushed pipeline has backface culling enabled and forces a reflush of the cull face state if so. The backface culling is now set on a pipeline as part of the legacy state. This is important because some code in Cogl assumes it can flush a temporary pipeline to revert to a known state, but previously this wouldn't disable backface culling so things such as flushing the clip stack could get confused. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-09-15 10:25:39 +00:00
context->legacy_backface_culling_enabled = FALSE;
[cogl] Initialize boolean flag in CoglContext The private CoglContext is created using g_malloc() and not zeroed; this means we have to initialize the values we are going to check, to avoid hitting garbage. Thanks to Tommi Komulainen.
2009-03-10 17:53:51 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
cogl_matrix_init_identity (&context->identity_matrix);
cogl_matrix_init_identity (&context->y_flip_matrix);
cogl_matrix_scale (&context->y_flip_matrix, 1, -1, 1);
[cogl] Make sure we draw upside down to offscreen draw buffers First a few notes about Cogl coordinate systems: - Cogl defines the window origin, viewport origin and texture coordinates origin to be top left unlike OpenGL which defines them as bottom left. - Cogl defines the modelview and projection identity matrices in exactly the same way as OpenGL. - I.e. we believe that for 2D centric constructs: windows/framebuffers, viewports and textures developers are more used to dealing with a top left origin, but when modeling objects in 3D; an origin at the center with y going up is quite natural. The way Cogl handles textures is by uploading data upside down in OpenGL terms so that bottom left becomes top left. (Note: This also has the benefit that we don't need to flip the data we get from image decoding libraries since they typically also consider top left to be the image origin.) The viewport and window coords are mostly handled with various y = height - y tweaks before we pass y coordinates to OpenGL. Generally speaking though the handling of coordinate spaces in Cogl is a bit fragile. I guess partly because none of it was design to be, it just evolved from how Clutter defines its coordinates without much consideration or testing. I hope to improve this over a number of commits; starting here. This commit deals with the fact that offscreen draw buffers may be bound to textures but we don't "upload" the texture data upside down, and so if you texture from an offscreen draw buffer you need to manually flip the texture coordinates to get it the right way around. We now force offscreen rendering to be flipped upside down by tweaking the projection matrix right before we submit it to OpenGL to scale y by -1. The tweak is entirely hidden from the user such that if you call cogl_get_projection you will not see this scale.
2009-10-22 15:13:01 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
context->flushed_matrix_mode = COGL_MATRIX_MODELVIEW;
material: Adds backend abstraction for fragment processing As part of an effort to improve the architecture of CoglMaterial internally this overhauls how we flush layer state to OpenGL by adding a formal backend abstraction for fragment processing and further formalizing the CoglTextureUnit abstraction. There are three backends: "glsl", "arbfp" and "fixed". The fixed backend uses the OpenGL fixed function APIs to setup the fragment processing, the arbfp backend uses code generation to handle fragment processing using an ARBfp program, and the GLSL backend is currently only there as a formality to handle user programs associated with a material. (i.e. the glsl backend doesn't yet support code generation) The GLSL backend has highest precedence, then arbfp and finally the fixed. If a backend can't support some particular CoglMaterial feature then it will fallback to the next backend. This adds three new COGL_DEBUG options: * "disable-texturing" as expected should disable all texturing * "disable-arbfp" always make the arbfp backend fallback * "disable-glsl" always make the glsl backend fallback * "show-source" show code generated by the arbfp/glsl backends
2010-04-26 09:01:43 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
context->texture_units =
material: Adds backend abstraction for fragment processing As part of an effort to improve the architecture of CoglMaterial internally this overhauls how we flush layer state to OpenGL by adding a formal backend abstraction for fragment processing and further formalizing the CoglTextureUnit abstraction. There are three backends: "glsl", "arbfp" and "fixed". The fixed backend uses the OpenGL fixed function APIs to setup the fragment processing, the arbfp backend uses code generation to handle fragment processing using an ARBfp program, and the GLSL backend is currently only there as a formality to handle user programs associated with a material. (i.e. the glsl backend doesn't yet support code generation) The GLSL backend has highest precedence, then arbfp and finally the fixed. If a backend can't support some particular CoglMaterial feature then it will fallback to the next backend. This adds three new COGL_DEBUG options: * "disable-texturing" as expected should disable all texturing * "disable-arbfp" always make the arbfp backend fallback * "disable-glsl" always make the glsl backend fallback * "show-source" show code generated by the arbfp/glsl backends
2010-04-26 09:01:43 +00:00
g_array_new (FALSE, FALSE, sizeof (CoglTextureUnit));
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
if ((context->private_feature_flags & COGL_PRIVATE_FEATURE_ANY_GL))
Adds a NOP driver This adds a new "nop" driver that does nothing. This can be selected at runtime either with the COGL_DRIVER=nop environment variable or by passing COGL_DRIVER_NOP to cogl_renderer_set_driver() Adding the nop driver gives us a way to test workloads without any driver and hardware overheads which can help us understand how Cogl's state tracking performs in isolation. Having a nop driver can also serve as an shell/outline for creating other drivers later. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 90587418233b6438290741d80aedf193ae660cad)
2012-09-12 21:39:46 +00:00
{
/* See cogl-pipeline.c for more details about why we leave texture unit 1
* active by default... */
context->active_texture_unit = 1;
GE (context, glActiveTexture (GL_TEXTURE1));
}
[current-matrix] Adds texture matrix stacks + removes GL matrix API usage This relates back to an earlier commitment to stop using the OpenGL matrix API which is considered deprecated. (ref 54159f5a1d029db) The new texture matrix stacks are hung from a list of (internal only) CoglTextureUnit structures which the CoglMaterial code internally references via _cogl_get_texure_unit (). So we would be left with only the cogl-matrix-stack code being responsible for glMatrixMode, glLoadMatrix and glLoadIdentity this commit updates the journal code so it now uses the matrix-stack API instead of GL directly.
2009-09-29 01:58:27 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
context->legacy_fog_state.enabled = FALSE;
material: route fogging state through CoglMaterial Previously cogl_set_fog would cause a flush of the Cogl journal and would directly bang the GL state machine to setup fogging. As part of the ongoing effort to track most state in CoglMaterial to support renderlists this now adds an indirection so that cogl_set_fog now just updates ctx->legacy_fog_state. The fogging state then gets enabled as a legacy override similar to how the old depth testing API is handled.
2010-07-06 19:18:26 +00:00
Adds a context arg to cogl_pipeline_new() As we move towards Cogl 2.0 we are aiming to remove the need for a default global CoglContext and so everything should be explicitly related to a context somehow. CoglPipelines are top level objects and so this patch adds a context argument to cogl_pipeline_new(). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-18 16:03:10 +00:00
context->opaque_color_pipeline = cogl_pipeline_new (context);
context->blended_color_pipeline = cogl_pipeline_new (context);
context->texture_pipeline = cogl_pipeline_new (context);
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
context->codegen_header_buffer = g_string_new ("");
context->codegen_source_buffer = g_string_new ("");
Adds back tex_coord array for CoglShader compatibility This adds back compatibility for CoglShaders that reference the cogl_tex_coord_in[] or cogl_tex_coord_out[] varyings. Unlike the previous way this was done this patch maintains the use of layer numbers for attributes and maintains forwards compatibility by letting shaders alternatively access the per-layer tex_coord varyings via cogl_tex_coord%i_in/out defines that index into the array.
2013-01-19 16:00:33 +00:00
context->codegen_boilerplate_buffer = g_string_new ("");
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
context->source_stack = NULL;
material: Adds backend abstraction for fragment processing As part of an effort to improve the architecture of CoglMaterial internally this overhauls how we flush layer state to OpenGL by adding a formal backend abstraction for fragment processing and further formalizing the CoglTextureUnit abstraction. There are three backends: "glsl", "arbfp" and "fixed". The fixed backend uses the OpenGL fixed function APIs to setup the fragment processing, the arbfp backend uses code generation to handle fragment processing using an ARBfp program, and the GLSL backend is currently only there as a formality to handle user programs associated with a material. (i.e. the glsl backend doesn't yet support code generation) The GLSL backend has highest precedence, then arbfp and finally the fixed. If a backend can't support some particular CoglMaterial feature then it will fallback to the next backend. This adds three new COGL_DEBUG options: * "disable-texturing" as expected should disable all texturing * "disable-arbfp" always make the arbfp backend fallback * "disable-glsl" always make the glsl backend fallback * "show-source" show code generated by the arbfp/glsl backends
2010-04-26 09:01:43 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
context->legacy_state_set = 0;
Bug 1172 - Disjoint paths and clip to path * clutter/cogl/cogl-path.h: * clutter/cogl/common/cogl-primitives.c: * clutter/cogl/common/cogl-primitives.h: * clutter/cogl/gl/cogl-primitives.c: * clutter/cogl/gles/cogl-primitives.c: Changed the semantics of cogl_path_move_to. Previously this always started a new path but now it instead starts a new disjoint sub path. The path isn't cleared until you call either cogl_path_stroke, cogl_path_fill or cogl_path_new. There are also cogl_path_stroke_preserve and cogl_path_fill_preserve functions. * clutter/cogl/gl/cogl-context.c: * clutter/cogl/gl/cogl-context.h: * clutter/cogl/gles/cogl-context.c: * clutter/cogl/gles/cogl-context.h: Convert the path nodes array to a GArray. * clutter/cogl/gl/cogl-texture.c: * clutter/cogl/gles/cogl-texture.c: Call cogl_clip_ensure * clutter/cogl/common/cogl-clip-stack.c: * clutter/cogl/common/cogl-clip-stack.h: Simplified the clip stack code quite a bit to make it more maintainable. Previously whenever you added a new clip it would go through a separate route to immediately intersect with the current clip and when you removed it again it would immediately rebuild the entire clip. Now when you add or remove a clip it doesn't do anything immediately but just sets a dirty flag instead. * clutter/cogl/gl/cogl.c: * clutter/cogl/gles/cogl.c: Taken away the code to intersect stencil clips when there is exactly one stencil bit. It won't work with path clips and I don't know of any platform that doesn't have eight or zero stencil bits. It needs at least three bits to intersect a path with an existing clip. cogl_features_init now just decides you don't have a stencil buffer at all if you have less than three bits. * clutter/cogl/cogl.h.in: New functions and documentation. * tests/interactive/test-clip.c: Replaced with a different test that lets you add and remove clips. The three different mouse buttons add clips in different shapes. This makes it easier to test multiple levels of clipping. * tests/interactive/test-cogl-primitives.c: Use cogl_path_stroke_preserve when using the same path again. * doc/reference/cogl/cogl-sections.txt: Document the new functions.
2008-12-04 13:45:09 +00:00
Add a strong CoglTexture type to replace CoglHandle As part of the on going, incremental effort to purge the non type safe CoglHandle type from the Cogl API this patch tackles most of the CoglHandle uses relating to textures. We'd postponed making this change for quite a while because we wanted to have a clearer understanding of how we wanted to evolve the texture APIs towards Cogl 2.0 before exposing type safety here which would be difficult to change later since it would imply breaking APIs. The basic idea that we are steering towards now is that CoglTexture can be considered to be the most primitive interface we have for any object representing a texture. The texture interface would provide roughly these methods: cogl_texture_get_width cogl_texture_get_height cogl_texture_can_repeat cogl_texture_can_mipmap cogl_texture_generate_mipmap; cogl_texture_get_format cogl_texture_set_region cogl_texture_get_region Besides the texture interface we will then start to expose types corresponding to specific texture types: CoglTexture2D, CoglTexture3D, CoglTexture2DSliced, CoglSubTexture, CoglAtlasTexture and CoglTexturePixmapX11. We will then also expose an interface for the high-level texture types we have (such as CoglTexture2DSlice, CoglSubTexture and CoglAtlasTexture) called CoglMetaTexture. CoglMetaTexture is an additional interface that lets you iterate a virtual region of a meta texture and get mappings of primitive textures to sub-regions of that virtual region. Internally we already have this kind of abstraction for dealing with sliced texture, sub-textures and atlas textures in a consistent way, so this will just make that abstraction public. The aim here is to clarify that there is a difference between primitive textures (CoglTexture2D/3D) and some of the other high-level textures, and also enable developers to implement primitives that can support meta textures since they can only be used with the cogl_rectangle API currently. The thing that's not so clean-cut with this are the texture constructors we have currently; such as cogl_texture_new_from_file which no longer make sense when CoglTexture is considered to be an interface. These will basically just become convenient factory functions and it's just a bit unusual that they are within the cogl_texture namespace. It's worth noting here that all the texture type APIs will also have their own type specific constructors so these functions will only be used for the convenience of being able to create a texture without really wanting to know the details of what type of texture you need. Longer term for 2.0 we may come up with replacement names for these factory functions or the other thing we are considering is designing some asynchronous factory functions instead since it's so often detrimental to application performance to be blocked waiting for a texture to be uploaded to the GPU. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-08-24 20:30:34 +00:00
context->default_gl_texture_2d_tex = NULL;
cogl-pipeline-layer: Use CoglTextureType instead of GL target enum Instead of storing the GLenum for the target of the last used texture for a layer it now stores the CoglTextureType instead. The state name has been renamed to 'texture type' instead of 'texture target'. Previously the default pipeline layer would store 0 here to represent that there is no texture. This has been changed to store COGL_TEXTURE_TYPE_2D instead which means that all pipeline layers always have a valid value for the texture type. Any places that were previously fetching the texture from a layer to determine the target (for example when generating shaders or when enabling a particular texture target) now use the texture type instead. This means they will work even for layers that don't have a texture. This also changes it so that when binding a fallback texture instead of always using a 2D texture it will now use the default texture corresponding to the texture type of the layer. That way when the generated shader tries to do a texture lookup for that type of texture it will get a valid texture object. To make this work the patch adds a default texture for 3D textures to the context and also makes the default rectangle texture actually be a rectangle texture instead of using a 2D texture. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-09 12:52:45 +00:00
context->default_gl_texture_3d_tex = NULL;
Add a strong CoglTexture type to replace CoglHandle As part of the on going, incremental effort to purge the non type safe CoglHandle type from the Cogl API this patch tackles most of the CoglHandle uses relating to textures. We'd postponed making this change for quite a while because we wanted to have a clearer understanding of how we wanted to evolve the texture APIs towards Cogl 2.0 before exposing type safety here which would be difficult to change later since it would imply breaking APIs. The basic idea that we are steering towards now is that CoglTexture can be considered to be the most primitive interface we have for any object representing a texture. The texture interface would provide roughly these methods: cogl_texture_get_width cogl_texture_get_height cogl_texture_can_repeat cogl_texture_can_mipmap cogl_texture_generate_mipmap; cogl_texture_get_format cogl_texture_set_region cogl_texture_get_region Besides the texture interface we will then start to expose types corresponding to specific texture types: CoglTexture2D, CoglTexture3D, CoglTexture2DSliced, CoglSubTexture, CoglAtlasTexture and CoglTexturePixmapX11. We will then also expose an interface for the high-level texture types we have (such as CoglTexture2DSlice, CoglSubTexture and CoglAtlasTexture) called CoglMetaTexture. CoglMetaTexture is an additional interface that lets you iterate a virtual region of a meta texture and get mappings of primitive textures to sub-regions of that virtual region. Internally we already have this kind of abstraction for dealing with sliced texture, sub-textures and atlas textures in a consistent way, so this will just make that abstraction public. The aim here is to clarify that there is a difference between primitive textures (CoglTexture2D/3D) and some of the other high-level textures, and also enable developers to implement primitives that can support meta textures since they can only be used with the cogl_rectangle API currently. The thing that's not so clean-cut with this are the texture constructors we have currently; such as cogl_texture_new_from_file which no longer make sense when CoglTexture is considered to be an interface. These will basically just become convenient factory functions and it's just a bit unusual that they are within the cogl_texture namespace. It's worth noting here that all the texture type APIs will also have their own type specific constructors so these functions will only be used for the convenience of being able to create a texture without really wanting to know the details of what type of texture you need. Longer term for 2.0 we may come up with replacement names for these factory functions or the other thing we are considering is designing some asynchronous factory functions instead since it's so often detrimental to application performance to be blocked waiting for a texture to be uploaded to the GPU. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-08-24 20:30:34 +00:00
context->default_gl_texture_rect_tex = NULL;
Updates GLES1 support for CoglMaterial This updates cogl/gles in line with the integration of CoglMaterial throughout Cogl that has been done for cogl/gl. Note: This is still buggy, but at least it builds again and test-actors works. Some GLES2 specific changes were made, but these haven't been tested yet.
2009-01-26 11:07:35 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
context->framebuffers = NULL;
framebuffer: Optimize _cogl_framebuffer_flush_state() Previously the cost of _cogl_framebuffer_state_flush() would always scale by the total amount of state tracked by CoglFramebuffer even in cases where we knew up-front that we only wanted to flush a subset of the state or in cases where we requested to flush the same framebuffer multiple times with no changes being made to the framebuffer. We now track a set of state changed flags with each framebuffer and track the current read/draw buffers as part of the CoglContext so that we can quickly bail out when asked to flush the same framebuffer multiple times with no changes. _cogl_framebuffer_flush_state() now takes a mask of the state that we want to flush and the implementation has been redesigned so that the cost of checking what needs to be flushed and flushing those changes now scales by how much state we actually plan to update. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-11-21 15:53:40 +00:00
context->current_draw_buffer = NULL;
context->current_read_buffer = NULL;
context->current_draw_buffer_state_flushed = 0;
context->current_draw_buffer_changes = COGL_FRAMEBUFFER_STATE_ALL;
cogl: make sure to init ctx->framebuffers This makes sure to initialize ctx->framebuffers to NULL otherwise we can get apps crashing when they create their first framebuffer.
2011-01-21 17:28:34 +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
g_queue_init (&context->gles2_context_stack);
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
context->journal_flush_attributes_array =
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
g_array_new (TRUE, FALSE, sizeof (CoglAttribute *));
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
context->journal_clip_bounds = NULL;
Support cogl_texture_multiple_rectangles in GL ES backend
2008-12-09 15:10:33 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
context->polygon_vertices = g_array_new (FALSE, FALSE, sizeof (float));
primitives: implements cogl_polygon on vertex_attributes This updates the implementation of cogl_polygon so it sits on the new CoglVertexArray and CoglVertexAttribute apis. This lets us minimize the number of different drawing paths we have to maintain in Cogl. Since the sliced texture support for cogl_polygon has been broken for a long time now and no one has complained this patch also greatly simplifies the code by not doing any special material validation so cogl_polygon will be restricted in the same way as cogl_draw_vertex_attributes. (i.e. sliced textures not supported).
2010-10-18 16:17:22 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
context->current_pipeline = NULL;
context->current_pipeline_changes_since_flush = 0;
context->current_pipeline_skip_gl_color = FALSE;
material: Adds backend abstraction for fragment processing As part of an effort to improve the architecture of CoglMaterial internally this overhauls how we flush layer state to OpenGL by adding a formal backend abstraction for fragment processing and further formalizing the CoglTextureUnit abstraction. There are three backends: "glsl", "arbfp" and "fixed". The fixed backend uses the OpenGL fixed function APIs to setup the fragment processing, the arbfp backend uses code generation to handle fragment processing using an ARBfp program, and the GLSL backend is currently only there as a formality to handle user programs associated with a material. (i.e. the glsl backend doesn't yet support code generation) The GLSL backend has highest precedence, then arbfp and finally the fixed. If a backend can't support some particular CoglMaterial feature then it will fallback to the next backend. This adds three new COGL_DEBUG options: * "disable-texturing" as expected should disable all texturing * "disable-arbfp" always make the arbfp backend fallback * "disable-glsl" always make the glsl backend fallback * "show-source" show code generated by the arbfp/glsl backends
2010-04-26 09:01:43 +00:00
rework enabling of attributes, removing _cogl_enable() This removes the limited caching of enabled attributes done by _cogl_enable() and replaces it with a more generalized set of bitmasks associated with the context that allow us to efficiently compare the set of attribute locations that are currently enabled vs the new locations that need enabling so we only have to inform OpenGL of the changes in which locations are enabled/disabled. This also adds a per-context hash table for mapping attribute names to global name-state structs which includes a unique name-index for any name as well as pre-validated information about builtin "cogl_" attribute names including whether the attribute is normalized and what texture unit a texture attribute corresponds too. The name-state hash table means that cogl_attribute_new() now only needs to validate names the first time they are seen. CoglAttributes now reference a name-state structure instead of just the attribute name, so now we can efficiently get the name-index for any attribute and we can use that to index into a per-glsl-program cache that maps name indices to real GL attribute locations so when we get asked to draw a set of attributes we can very quickly determine what GL attributes need to be setup and enabled. If we don't have a cached location though we can still quickly access the string name so we can query OpenGL. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-11-24 18:09:53 +00:00
_cogl_bitmask_init (&context->enabled_builtin_attributes);
_cogl_bitmask_init (&context->enable_builtin_attributes_tmp);
_cogl_bitmask_init (&context->enabled_texcoord_attributes);
_cogl_bitmask_init (&context->enable_texcoord_attributes_tmp);
_cogl_bitmask_init (&context->enabled_custom_attributes);
_cogl_bitmask_init (&context->enable_custom_attributes_tmp);
_cogl_bitmask_init (&context->changed_bits_tmp);
[multi-texturing] This adds a new cogl_multi_texture API for GL,GLES1 + GLES2 Multitexturing allows blending multiple layers of texture data when texturing some geometry. A common use is for pre-baked light maps which can give nice lighting effects relativly cheaply. Another is for dot-3 bump mapping, and another is applying alpha channel masks. The dot-3 bump mapping would be really nice one day, but currently cogl doesn't support lighting so that's not dealt with in this patch. notable limitations: - It can only texture rectangles a.t.m - and like cogl_texture_rectangle there is no support for rotated texturing. - Sliced textures are not supported. I think I've figured out how to handle layers with different slice sizes at least for rectangular geometry, but I'm not sure how complex it becomes once rotations are possible and texturing arbitrary cogl_polygons. - Except for this new API, cogl still doesn't know about more than one texture unit, and so has no way of caching any enables related to other units. So that things don't break it's currently necessary to disable anything to do with additional units as soon as we are done with them which isn't ideal. - No clutter API yet.
2008-12-11 15:33:38 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
context->max_texture_units = -1;
context->max_activateable_texture_units = -1;
material: Adds backend abstraction for fragment processing As part of an effort to improve the architecture of CoglMaterial internally this overhauls how we flush layer state to OpenGL by adding a formal backend abstraction for fragment processing and further formalizing the CoglTextureUnit abstraction. There are three backends: "glsl", "arbfp" and "fixed". The fixed backend uses the OpenGL fixed function APIs to setup the fragment processing, the arbfp backend uses code generation to handle fragment processing using an ARBfp program, and the GLSL backend is currently only there as a formality to handle user programs associated with a material. (i.e. the glsl backend doesn't yet support code generation) The GLSL backend has highest precedence, then arbfp and finally the fixed. If a backend can't support some particular CoglMaterial feature then it will fallback to the next backend. This adds three new COGL_DEBUG options: * "disable-texturing" as expected should disable all texturing * "disable-arbfp" always make the arbfp backend fallback * "disable-glsl" always make the glsl backend fallback * "show-source" show code generated by the arbfp/glsl backends
2010-04-26 09:01:43 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
context->current_fragment_program_type = COGL_PIPELINE_PROGRAM_TYPE_FIXED;
context->current_vertex_program_type = COGL_PIPELINE_PROGRAM_TYPE_FIXED;
context->current_gl_program = 0;
material: Adds backend abstraction for fragment processing As part of an effort to improve the architecture of CoglMaterial internally this overhauls how we flush layer state to OpenGL by adding a formal backend abstraction for fragment processing and further formalizing the CoglTextureUnit abstraction. There are three backends: "glsl", "arbfp" and "fixed". The fixed backend uses the OpenGL fixed function APIs to setup the fragment processing, the arbfp backend uses code generation to handle fragment processing using an ARBfp program, and the GLSL backend is currently only there as a formality to handle user programs associated with a material. (i.e. the glsl backend doesn't yet support code generation) The GLSL backend has highest precedence, then arbfp and finally the fixed. If a backend can't support some particular CoglMaterial feature then it will fallback to the next backend. This adds three new COGL_DEBUG options: * "disable-texturing" as expected should disable all texturing * "disable-arbfp" always make the arbfp backend fallback * "disable-glsl" always make the glsl backend fallback * "show-source" show code generated by the arbfp/glsl backends
2010-04-26 09:01:43 +00:00
framebuffer: Add dither_enabled getter/setters This adds a getter and setter for requesting dithering to be enabled. Dithering is a hardware dependent technique to increase the visible color resolution beyond what the underlying hardware supports by playing tricks with the colors placed into the framebuffer to give the illusion of other colors. (For example this can be compared to half-toning used by some news papers to show varying levels of grey even though their may only be black and white are available). The results of enabling dithering are platform dependent and may have no effect. Signed-off-by: Neil Roberts <neil@linux.intel.com>
2011-07-13 15:33:25 +00:00
context->current_gl_dither_enabled = TRUE;
Adds ColorMask support to Cogl This adds CoglPipeline and CoglFramebuffer support for setting a color mask which is a bit mask defining which color channels should be written to the current framebuffer. The final color mask is the intersection of the framebuffer color mask and the pipeline color mask. The framebuffer mask affects all rendering to the framebuffer while the pipeline masks can be used to affect individual primitives. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-07-11 01:27:54 +00:00
context->current_gl_color_mask = COGL_COLOR_MASK_ALL;
framebuffer: Add dither_enabled getter/setters This adds a getter and setter for requesting dithering to be enabled. Dithering is a hardware dependent technique to increase the visible color resolution beyond what the underlying hardware supports by playing tricks with the colors placed into the framebuffer to give the illusion of other colors. (For example this can be compared to half-toning used by some news papers to show varying levels of grey even though their may only be black and white are available). The results of enabling dithering are platform dependent and may have no effect. Signed-off-by: Neil Roberts <neil@linux.intel.com>
2011-07-13 15:33:25 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
context->gl_blend_enable_cache = FALSE;
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 11:21:04 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
context->depth_test_enabled_cache = FALSE;
context->depth_test_function_cache = COGL_DEPTH_TEST_FUNCTION_LESS;
context->depth_writing_enabled_cache = TRUE;
context->depth_range_near_cache = 0;
context->depth_range_far_cache = 1;
material: Make CoglMaterial responsible for depth state This redirects the legacy depth testing APIs through CoglMaterial and adds a new experimental cogl_material_ API for handling the depth testing state. This adds the following new functions: cogl_material_set_depth_test_enabled cogl_material_get_depth_test_enabled cogl_material_set_depth_writing_enabled cogl_material_get_depth_writing_enabled cogl_material_set_depth_test_function cogl_material_get_depth_test_function cogl_material_set_depth_range cogl_material_get_depth_range As with other experimental Cogl API you need to define COGL_ENABLE_EXPERIMENTAL_API to access them and their stability isn't yet guaranteed.
2010-05-26 10:33:32 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
context->legacy_depth_test_enabled = FALSE;
material: Make CoglMaterial responsible for depth state This redirects the legacy depth testing APIs through CoglMaterial and adds a new experimental cogl_material_ API for handling the depth testing state. This adds the following new functions: cogl_material_set_depth_test_enabled cogl_material_get_depth_test_enabled cogl_material_set_depth_writing_enabled cogl_material_get_depth_writing_enabled cogl_material_set_depth_test_function cogl_material_get_depth_test_function cogl_material_set_depth_range cogl_material_get_depth_range As with other experimental Cogl API you need to define COGL_ENABLE_EXPERIMENTAL_API to access them and their stability isn't yet guaranteed.
2010-05-26 10:33:32 +00:00
fragend-arbfp: Move the pipeline cache to a separate file The pipeline cache is now handled in CoglPipelineCache instead of directly in the ARBfp fragend. The flags needed to hash a pipeline should be exactly the same for the ARBfp and GLSL fragends so it's convenient to share the code. The hash table now stores the actual pipeline as the value instead of the private data so that the two fragends can attach their data to it. That way it's possible to use the same pipeline key with ancestors that are using different fragends. The hash table is created with g_hash_table_new_full to set a destructor for the key and value and there is a destructor for CoglPipelineCache that gets called when the CoglContext is destroyed. That way we no longer leak the pipelines and shader state when the context is desroyed.
2011-06-30 14:55:56 +00:00
context->pipeline_cache = cogl_pipeline_cache_new ();
arbfp: Adds an ARBfp program cache This adds a cache (A GHashTable) of ARBfp programs and before ever starting to code-generate a new program we will always first try and find an existing program in the cache. This uses _cogl_pipeline_hash and _cogl_pipeline_equal to hash and compare the keys for the cache. There is a new COGL_DEBUG=disable-program-caches option that can disable the cache for debugging purposes.
2010-12-03 12:01:18 +00:00
cogl-buffer: Track the last used bind target in CoglBuffer This makes CoglBuffer track the last used bind target as a private property. This is later used when binding a buffer to map instead of always using the PIXEL_UNPACK target. This also adds some additional sanity checks that code doesn't try to nest binds to the same target or bind a buffer to multiple targets at the same time.
2010-07-05 22:24:34 +00:00
for (i = 0; i < COGL_BUFFER_BIND_TARGET_COUNT; i++)
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
context->current_buffer[i] = NULL;
cogl-buffer: Track the last used bind target in CoglBuffer This makes CoglBuffer track the last used bind target as a private property. This is later used when binding a buffer to map instead of always using the PIXEL_UNPACK target. This also adds some additional sanity checks that code doesn't try to nest binds to the same target or bind a buffer to multiple targets at the same time.
2010-07-05 22:24:34 +00:00
cogl-framebuffer: Force flushing the color mask when changing fbs When changing between two framebuffers that have different color masks it now forces the pipeline to flush the mask by setting current_pipeline_changes_since_flush. For this to work there needs to be a common bit of code that gets called when the framebuffers are changed that has access to both the old framebuffer and the new framebuffer. _cogl_set_framebuffers_real can't be used for this because when it is called from cogl_pop_framebuffer the stack entries have already changed so it can't know the old framebuffer. This patch adds a new function called notify_buffers_changed which should get called whenever the buffers are changed and it explicitly gets passed pointers to the old and new buffers. cogl_pop_framebuffer now calls this instead of trying to use _cogl_set_framebuffers_real to force a flush. This patch also fixes the ctx->window_buffer pointer. Previously this was implemented by searching in the framebuffer stack for an onscreen framebuffer whenever the current buffers are changed. However it does this after the stack has already changed so it won't usually find the right buffer. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-09-16 10:41:21 +00:00
context->window_buffer = NULL;
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
context->framebuffer_stack = _cogl_create_framebuffer_stack ();
Implement accessors for the color bits in a framebuffer Instead of using cogl_get_bitmasks() to query the GL machinery for the size of the color bits, we should store the values inside the CoglFramebuffer object and query them the first time we set the framebuffer as the current one. Currently, cogl_get_bitmasks() is re-implemented in terms of cogl_framebuffer_get_*_bits(). As soon as we are able to expose the CoglOnscreen framebuffer object in the public API we'll be able to deprecate cogl_get_bitmasks() altogether. http://bugzilla.openedhand.com/show_bug.cgi?id=2094
2010-04-26 17:08:45 +00: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 12:28:33 +00:00
/* XXX: In this case the Clutter backend is still responsible for
* the OpenGL binding API and for creating onscreen framebuffers and
* so we have to add a dummy framebuffer to represent the backend
* owned window... */
Make stub winsys into a proper winsys backend Instead of the stub winsys being a special case set of #ifdef'd code used when COGL_HAS_FULL_WINSYS wasn't defined, the stub winsys now implements a CoglWinsysVtable like all other winsys backends (it's just that everything is a NOP). This way we can get rid of the COGL_HAS_FULL_WINSYS define and also the stub winsys can be runtime selected whereas before it was incompatible with all other winsys backends.
2011-05-17 14:00:38 +00:00
if (_cogl_context_get_winsys (context) == _cogl_winsys_stub_get_vtable ())
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 12:28:33 +00:00
{
CoglOnscreen *window = _cogl_onscreen_new ();
cogl_set_framebuffer (COGL_FRAMEBUFFER (window));
cogl_object_unref (COGL_FRAMEBUFFER (window));
}
CoglContext: correct initialization order http://bugzilla.clutter-project.org/show_bug.cgi?id=2401
2010-11-05 17:20:14 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
context->current_path = cogl2_path_new ();
Adds a context arg to cogl_pipeline_new() As we move towards Cogl 2.0 we are aiming to remove the need for a default global CoglContext and so everything should be explicitly related to a context somehow. CoglPipelines are top level objects and so this patch adds a context argument to cogl_pipeline_new(). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-18 16:03:10 +00:00
context->stencil_pipeline = cogl_pipeline_new (context);
GLES 2 backend * clutter/eglx/clutter-stage-egl.h: * clutter/eglx/clutter-egl-headers.h: * clutter/eglx/clutter-backend-egl.h: * clutter/eglx/Makefile.am: Include the GLES and EGL headers via clutter-egl-headers.h so that the right version can be used depending on whether the GLES 2 wrapper is being used. * configure.ac: Added an automake conditional for whether the GLES 2 wrapper should be used. * clutter/eglx/clutter-stage-egl.c (clutter_stage_egl_realize): Remove the call to glGetIntegerv to get the max texture size. It was being called before the GL context was bound so it didn't work anyway and it was causing trouble for the GLES 2 simulator. * clutter/cogl/gles/stringify.sh: Shell script to convert the shaders into a C string. * clutter/cogl/gles/cogl-gles2-wrapper.h: * clutter/cogl/gles/cogl-gles2-wrapper.c: Wrappers for most of the missing GL functions in GLES 2. * clutter/cogl/gles/cogl-fixed-fragment-shader.glsl: * clutter/cogl/gles/cogl-fixed-vertex-shader.glsl: New shaders for GLES 2 * clutter/cogl/gles/cogl-defines.h.in: Use the @CLUTTER_GL_HEADER@ macro instead of always using the GLES 1 header. * clutter/cogl/gles/cogl-context.h (CoglContext): Include a field for the state of the GLES 2 wrapper. * clutter/cogl/gles/cogl-texture.c: * clutter/cogl/gles/cogl-primitives.c: * clutter/cogl/gles/cogl.c: Use wrapped versions of the GL functions where neccessary. * clutter/cogl/gles/Makefile.am: Add sources for the GLES 2 wrapper and an extra build step to put the GLSL files into a C string whenever the files change.
2008-05-27 17:42:50 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
context->in_begin_gl_block = FALSE;
Make the CoglContext structure a bit more maintainable This moves most of cogl-context.{c.h} to cogl/common with some driver specific members now living in a CoglContextDriver struct. Driver specific context initialization and typedefs now live in cogl/{gl,gles}/cogl-context-driver.{c,h} Driver specific members can be found under ctx->drv.stuff
2009-07-28 00:34:33 +00:00
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 13:14:10 +00:00
context->quad_buffer_indices_byte = NULL;
context->quad_buffer_indices = NULL;
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
context->quad_buffer_indices_len = 0;
cogl: Adds experimental CoglIndices API CoglIndices define a range of indices inside a CoglIndexArray. I.e. a CoglIndexArray is simply a buffer of N bytes and you can then instantiate multiple CoglIndices collections that define a sub-region of a CoglIndexArray by specifying a start offset and an index data type.
2010-10-12 11:48:58 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
context->rectangle_byte_indices = NULL;
context->rectangle_short_indices = NULL;
context->rectangle_short_indices_len = 0;
cogl: Adds experimental CoglIndices API CoglIndices define a range of indices inside a CoglIndexArray. I.e. a CoglIndexArray is simply a buffer of N bytes and you can then instantiate multiple CoglIndices collections that define a sub-region of a CoglIndexArray by specifying a start offset and an index data type.
2010-10-12 11:48:58 +00:00
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 13:14:10 +00:00
context->texture_download_pipeline = NULL;
context->blit_texture_pipeline = NULL;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
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 19:44:56 +00:00
#if defined (HAVE_COGL_GL) || defined (HAVE_COGL_GLES)
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
if ((context->private_feature_flags & COGL_PRIVATE_FEATURE_ALPHA_TEST))
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 19:44:56 +00:00
/* The default for GL_ALPHA_TEST is to always pass which is equivalent to
* the test being disabled therefore we assume that for all drivers there
* will be no performance impact if we always leave the test enabled which
* makes things a bit simpler for us. Under GLES2 the alpha test is
* implemented in the fragment shader so there is no enable for it
*/
GE (context, glEnable (GL_ALPHA_TEST));
Remove the GLES2 wrapper The GLES2 wrapper is no longer needed because the shader generation is done within the GLSL fragend and vertend and any functions that are different for GLES2 are now guarded by #ifdefs.
2010-12-05 18:02:05 +00:00
#endif
[material] fix _set_alpha_test_function: missing a glEnable(GL_ALPHA_TEST) Since the default alpha test function of GL_ALWAYS is equivalent to GL_ALPHA_TEST being disabled we don't need to worry about Enabling/Disabling it when flushing material state, instead it's enough to leave it always enabled. We will assume that any driver worth its salt wont incur any additional cost for glEnable (GL_ALPHA_TEST) + GL_ALWAYS vs glDisable (GL_ALPHA_TEST). This patch simply calls glEnable (GL_ALPHA_TEST) in cogl_create_context
2009-09-25 18:04:13 +00:00
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
#if defined (HAVE_COGL_GL)
if ((context->driver == COGL_DRIVER_GL3))
{
GLuint vertex_array;
/* In a forward compatible context, GL 3 doesn't support rendering
* using the default vertex array object. Cogl doesn't use vertex
* array objects yet so for now we just create a dummy array
* object that we will use as our own default object. Eventually
* it could be good to attach the vertex array objects to
* CoglPrimitives */
context->glGenVertexArrays (1, &vertex_array);
context->glBindVertexArray (vertex_array);
}
#endif
Avoid referencing file scope context in _context_new() cogl_context_new() had a mixture of references to the file scope context variable (_context) and the local (context) variable. This renames the file scope variable to _cogl_context to catch unnecessary references to the old name and fixes the code accordingly to reference the local variable instead. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 33a9397ee1ae1729200be2e5084cf43cebb64289)
2012-09-10 09:42:03 +00:00
context->current_modelview_entry = NULL;
context->current_projection_entry = NULL;
_cogl_matrix_entry_identity_init (&context->identity_entry);
_cogl_matrix_entry_cache_init (&context->builtin_flushed_projection);
_cogl_matrix_entry_cache_init (&context->builtin_flushed_modelview);
cogl: upload matrices with uniforms on GLES2 Once the GLES2 wrapper is removed we won't be able to upload the matrices with the fixed function API any more. The fixed function API gives a global state for setting the matrix but if a custom shader uniform is used for the matrices then the state is per program. _cogl_matrix_stack_flush_to_gl is called in a few places and it is assumed the current pipeline doesn't need to be flushed before it is called. To allow these semantics to continue to work, on GLES2 the matrix flush now just stores a reference to the matrix stack in the CoglContext. A pre_paint virtual is added to the progend which is called whenever a pipeline is flushed, even if the same pipeline was flushed already. This gives the GLSL progend a chance to upload the matrices to the uniforms. The combined modelview/projection matrix is only calculated if it is used. The generated programs end up never using the modelview or projection matrix so it usually only has to upload the combined matrix. When a matrix stack is flushed a reference is taked to it by the pipeline progend and the age is stored so that if the same state is used with the same program again then we don't need to reupload the uniform.
2010-12-06 12:31:51 +00:00
cogl-pipeline-layer: Use CoglTextureType instead of GL target enum Instead of storing the GLenum for the target of the last used texture for a layer it now stores the CoglTextureType instead. The state name has been renamed to 'texture type' instead of 'texture target'. Previously the default pipeline layer would store 0 here to represent that there is no texture. This has been changed to store COGL_TEXTURE_TYPE_2D instead which means that all pipeline layers always have a valid value for the texture type. Any places that were previously fetching the texture from a layer to determine the target (for example when generating shaders or when enabling a particular texture target) now use the texture type instead. This means they will work even for layers that don't have a texture. This also changes it so that when binding a fallback texture instead of always using a 2D texture it will now use the default texture corresponding to the texture type of the layer. That way when the generated shader tries to do a texture lookup for that type of texture it will get a valid texture object. To make this work the patch adds a default texture for 3D textures to the context and also makes the default rectangle texture actually be a rectangle texture instead of using a 2D texture. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-09 12:52:45 +00:00
default_texture_bitmap =
Avoid referencing file scope context in _context_new() cogl_context_new() had a mixture of references to the file scope context variable (_context) and the local (context) variable. This renames the file scope variable to _cogl_context to catch unnecessary references to the old name and fixes the code accordingly to reference the local variable instead. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 33a9397ee1ae1729200be2e5084cf43cebb64289)
2012-09-10 09:42:03 +00:00
cogl_bitmap_new_for_data (context,
Add a public cogl_bitmap_new_for_data This creates a CoglBitmap which points into an existing buffer in system memory. That way it can be used to create a texture or to read pixel data into. The function replaces the existing internal function _cogl_bitmap_new_from_data but removes the destroy notify call back. If the application wants notification of destruction it can just use the cogl_object_set_user_data function as normal. Internally there is now a convenience function to create a bitmap for system memory and automatically free the buffer using that mechanism. The name of the function is inspired by cairo_image_surface_create_for_data which has similar semantics. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-13 14:46:18 +00:00
1, 1, /* width/height */
COGL_PIXEL_FORMAT_RGBA_8888_PRE,
4, /* rowstride */
default_texture_data);
cogl-pipeline-layer: Use CoglTextureType instead of GL target enum Instead of storing the GLenum for the target of the last used texture for a layer it now stores the CoglTextureType instead. The state name has been renamed to 'texture type' instead of 'texture target'. Previously the default pipeline layer would store 0 here to represent that there is no texture. This has been changed to store COGL_TEXTURE_TYPE_2D instead which means that all pipeline layers always have a valid value for the texture type. Any places that were previously fetching the texture from a layer to determine the target (for example when generating shaders or when enabling a particular texture target) now use the texture type instead. This means they will work even for layers that don't have a texture. This also changes it so that when binding a fallback texture instead of always using a 2D texture it will now use the default texture corresponding to the texture type of the layer. That way when the generated shader tries to do a texture lookup for that type of texture it will get a valid texture object. To make this work the patch adds a default texture for 3D textures to the context and also makes the default rectangle texture actually be a rectangle texture instead of using a 2D texture. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-09 12:52:45 +00:00
Updates GLES1 support for CoglMaterial This updates cogl/gles in line with the integration of CoglMaterial throughout Cogl that has been done for cogl/gl. Note: This is still buggy, but at least it builds again and test-actors works. Some GLES2 specific changes were made, but these haven't been tested yet.
2009-01-26 11:07:35 +00:00
/* Create default textures used for fall backs */
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
context->default_gl_texture_2d_tex =
Add constructors which take a CoglBitmap to all primitive textures This adds public constructors which take a CoglBitmap to all primitive texture types. This constructor should be considered the canonical constructor for initializing the texture with data because it should be possible to wrap any type of data in a CoglBitmap. Having at least this single constructor avoids the need to have an explosion of constructors such as new_from_data, new_from_pixel_buffer and new_from_file etc. The already available internal bitmap constructor for CoglTexture2D has had its flags parameter removed under the assumption that flags do not make sense for primitive textures. The meta constructor cogl_texture_new_from_bitmap now just explicitly calls set_auto_mipmap after constructing the texture depending on the value of the COGL_TEXTURE_NO_AUTO_MIPMAP flag. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-04-04 14:10:04 +00:00
cogl_texture_2d_new_from_bitmap (default_texture_bitmap,
/* internal format */
COGL_PIXEL_FORMAT_RGBA_8888_PRE,
NULL);
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
/* If 3D or rectangle textures aren't supported then these will
* return errors that we can simply ignore. */
internal_error = NULL;
cogl-pipeline-layer: Use CoglTextureType instead of GL target enum Instead of storing the GLenum for the target of the last used texture for a layer it now stores the CoglTextureType instead. The state name has been renamed to 'texture type' instead of 'texture target'. Previously the default pipeline layer would store 0 here to represent that there is no texture. This has been changed to store COGL_TEXTURE_TYPE_2D instead which means that all pipeline layers always have a valid value for the texture type. Any places that were previously fetching the texture from a layer to determine the target (for example when generating shaders or when enabling a particular texture target) now use the texture type instead. This means they will work even for layers that don't have a texture. This also changes it so that when binding a fallback texture instead of always using a 2D texture it will now use the default texture corresponding to the texture type of the layer. That way when the generated shader tries to do a texture lookup for that type of texture it will get a valid texture object. To make this work the patch adds a default texture for 3D textures to the context and also makes the default rectangle texture actually be a rectangle texture instead of using a 2D texture. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-09 12:52:45 +00:00
context->default_gl_texture_3d_tex =
Add constructors which take a CoglBitmap to all primitive textures This adds public constructors which take a CoglBitmap to all primitive texture types. This constructor should be considered the canonical constructor for initializing the texture with data because it should be possible to wrap any type of data in a CoglBitmap. Having at least this single constructor avoids the need to have an explosion of constructors such as new_from_data, new_from_pixel_buffer and new_from_file etc. The already available internal bitmap constructor for CoglTexture2D has had its flags parameter removed under the assumption that flags do not make sense for primitive textures. The meta constructor cogl_texture_new_from_bitmap now just explicitly calls set_auto_mipmap after constructing the texture depending on the value of the COGL_TEXTURE_NO_AUTO_MIPMAP flag. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-04-04 14:10:04 +00:00
cogl_texture_3d_new_from_bitmap (default_texture_bitmap,
1, /* height */
1, /* depth */
COGL_PIXEL_FORMAT_RGBA_8888_PRE,
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
&internal_error);
if (internal_error)
cogl_error_free (internal_error);
internal_error = NULL;
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
context->default_gl_texture_rect_tex =
Add constructors which take a CoglBitmap to all primitive textures This adds public constructors which take a CoglBitmap to all primitive texture types. This constructor should be considered the canonical constructor for initializing the texture with data because it should be possible to wrap any type of data in a CoglBitmap. Having at least this single constructor avoids the need to have an explosion of constructors such as new_from_data, new_from_pixel_buffer and new_from_file etc. The already available internal bitmap constructor for CoglTexture2D has had its flags parameter removed under the assumption that flags do not make sense for primitive textures. The meta constructor cogl_texture_new_from_bitmap now just explicitly calls set_auto_mipmap after constructing the texture depending on the value of the COGL_TEXTURE_NO_AUTO_MIPMAP flag. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-04-04 14:10:04 +00:00
cogl_texture_rectangle_new_from_bitmap (default_texture_bitmap,
COGL_PIXEL_FORMAT_RGBA_8888_PRE,
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
&internal_error);
if (internal_error)
cogl_error_free (internal_error);
cogl-pipeline-layer: Use CoglTextureType instead of GL target enum Instead of storing the GLenum for the target of the last used texture for a layer it now stores the CoglTextureType instead. The state name has been renamed to 'texture type' instead of 'texture target'. Previously the default pipeline layer would store 0 here to represent that there is no texture. This has been changed to store COGL_TEXTURE_TYPE_2D instead which means that all pipeline layers always have a valid value for the texture type. Any places that were previously fetching the texture from a layer to determine the target (for example when generating shaders or when enabling a particular texture target) now use the texture type instead. This means they will work even for layers that don't have a texture. This also changes it so that when binding a fallback texture instead of always using a 2D texture it will now use the default texture corresponding to the texture type of the layer. That way when the generated shader tries to do a texture lookup for that type of texture it will get a valid texture object. To make this work the patch adds a default texture for 3D textures to the context and also makes the default rectangle texture actually be a rectangle texture instead of using a 2D texture. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-09 12:52:45 +00:00
cogl_object_unref (default_texture_bitmap);
Updates GLES1 support for CoglMaterial This updates cogl/gles in line with the integration of CoglMaterial throughout Cogl that has been done for cogl/gl. Note: This is still buggy, but at least it builds again and test-actors works. Some GLES2 specific changes were made, but these haven't been tested yet.
2009-01-26 11:07:35 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
cogl_push_source (context->opaque_color_pipeline);
Updates GLES1 support for CoglMaterial This updates cogl/gles in line with the integration of CoglMaterial throughout Cogl that has been done for cogl/gl. Note: This is still buggy, but at least it builds again and test-actors works. Some GLES2 specific changes were made, but these haven't been tested yet.
2009-01-26 11:07:35 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
context->atlases = NULL;
cogl-atlas-texture: Add a callback for when any atlas reorganizes This adds cogl_atlas_texture_* functions to register a callback that will get invoked whenever any of the CoglAtlas's the textures use get reorganized. The callback is global and is not tied to any particular atlas texture.
2011-03-30 11:53:50 +00:00
g_hook_list_init (&context->atlas_reorganize_callbacks, sizeof (GHook));
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 13:06:32 +00:00
Avoid referencing file scope context in _context_new() cogl_context_new() had a mixture of references to the file scope context variable (_context) and the local (context) variable. This renames the file scope variable to _cogl_context to catch unnecessary references to the old name and fixes the code accordingly to reference the local variable instead. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 33a9397ee1ae1729200be2e5084cf43cebb64289)
2012-09-10 09:42:03 +00:00
context->buffer_map_fallback_array = g_byte_array_new ();
context->buffer_map_fallback_in_use = FALSE;
cogl: Fallback to set_data when mapping a buffer to fill it In the journal code and when generating the stroke path the vertices are generated on the fly and stored in a CoglBuffer using cogl_buffer_map. However cogl_buffer_map is allowed to fail but it wasn't checking for a NULL return value. In particular on GLES it will always fail because glMapBuffer is only provided by an extension. This adds a new pair of internal functions called _cogl_buffer_{un,}map_for_fill_or_fallback which wrap cogl_buffer_map. If the map fails then it will instead return a pointer into a GByteArray attached to the context. When the buffer is unmapped the array is copied into the buffer using cogl_buffer_set_data.
2011-01-13 15:35:30 +00:00
cogl-material: Add support for point sprites This adds a new API call to enable point sprite coordinate generation for a material layer: void cogl_material_set_layer_point_sprite_coords_enabled (CoglHandle material, int layer_index, gboolean enable); There is also a corresponding get function. Enabling point sprite coords simply sets the GL_COORD_REPLACE of the GL_POINT_SPRITE glTexEnv when flusing the material. There is no separate application control for glEnable(GL_POINT_SPRITE). Instead it is left permanently enabled under the assumption that it has no affect unless GL_COORD_REPLACE is enabled for a texture unit. http://bugzilla.openedhand.com/show_bug.cgi?id=2047
2010-03-22 13:33:55 +00:00
/* As far as I can tell, GL_POINT_SPRITE doesn't have any effect
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
unless GL_COORD_REPLACE is enabled for an individual layer.
Therefore it seems like it should be ok to just leave it enabled
all the time instead of having to have a set property on each
pipeline to track whether any layers have point sprite coords
enabled. We don't need to do this for GL3 or GLES2 because point
cogl-context: Don't enable point sprites on GLES2 On GLES2 there's no builtin mechanism to replace texture coordinates with point sprite coordinates so calling glEnable(GL_POINT_SPRITE) isn't valid. Instead the point sprite coords are implemented by using a special builtin varying variable in GLSL.
2011-01-13 14:12:10 +00:00
sprites are handled using a builtin varying in the shader. */
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
if ((context->private_feature_flags & COGL_PRIVATE_FEATURE_FIXED_FUNCTION) &&
features: Support more than 32 features! Currently features are represented as bits in a 32bit mask so we obviously can't have more than 32 features with that approach. The new approach is to use the COGL_FLAGS_ macros which lets us handle bitmasks without a size limit and we change the public api to accept individual feature enums instead of a mask. This way there is no limit on the number of features we can add to Cogl. Instead of using cogl_features_available() there is a new cogl_has_feature() function and for checking multiple features there is cogl_has_features() which takes a zero terminated vararg list of features. In addition to being able to check for individual features this also adds a way to query all the features currently available via cogl_foreach_feature() which will call a callback for each feature. Since the new functions take an explicit context pointer there is also no longer any ambiguity over when users can first start to query features. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-12 21:31:12 +00:00
cogl_has_feature (context, COGL_FEATURE_ID_POINT_SPRITE))
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 20:51:00 +00:00
GE (context, glEnable (GL_POINT_SPRITE));
cogl-material: Add support for point sprites This adds a new API call to enable point sprite coordinate generation for a material layer: void cogl_material_set_layer_point_sprite_coords_enabled (CoglHandle material, int layer_index, gboolean enable); There is also a corresponding get function. Enabling point sprite coords simply sets the GL_COORD_REPLACE of the GL_POINT_SPRITE glTexEnv when flusing the material. There is no separate application control for glEnable(GL_POINT_SPRITE). Instead it is left permanently enabled under the assumption that it has no affect unless GL_COORD_REPLACE is enabled for a texture unit. http://bugzilla.openedhand.com/show_bug.cgi?id=2047
2010-03-22 13:33:55 +00:00
Add a public cogl_bitmap_new_for_data This creates a CoglBitmap which points into an existing buffer in system memory. That way it can be used to create a texture or to read pixel data into. The function replaces the existing internal function _cogl_bitmap_new_from_data but removes the destroy notify call back. If the application wants notification of destruction it can just use the cogl_object_set_user_data function as normal. Internally there is now a convenience function to create a bitmap for system memory and automatically free the buffer using that mechanism. The name of the function is inspired by cairo_image_surface_create_for_data which has similar semantics. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-13 14:46:18 +00:00
return context;
Merged clutter-ivan branch into trunk. svn merge \ https://svn.o-hand.com/repos/clutter/trunk/clutter@2509 \ https://svn.o-hand.com/repos/clutter/branches/clutter-ivan@HEAD
2008-04-25 13:37:36 +00:00
}
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
static void
_cogl_context_free (CoglContext *context)
Merged clutter-ivan branch into trunk. svn merge \ https://svn.o-hand.com/repos/clutter/trunk/clutter@2509 \ https://svn.o-hand.com/repos/clutter/branches/clutter-ivan@HEAD
2008-04-25 13:37:36 +00:00
{
Add a vtable of indirection to the winsys code So that we can dynamically select what winsys backend to use at runtime we need to have some indirection to how code accesses the winsys instead of simply calling _cogl_winsys* functions that would collide if we wanted to compile more than one backend into Cogl.
2011-02-25 11:29:08 +00:00
const CoglWinsysVtable *winsys = _cogl_context_get_winsys (context);
winsys->context_deinit (context);
cogl: Add a struct for winsys-specific data to CoglContext This creates a separate struct to store the fields of the context that are specific to the winsys. This is all stored in one file but ideally this could work more like the CoglContextDriver struct and have a different header for each winsys.
2010-06-02 14:16:14 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
_cogl_free_framebuffer_stack (context->framebuffer_stack);
[draw-buffers] First pass at overhauling Cogl's framebuffer management Cogl's support for offscreen rendering was originally written just to support the clutter_texture_new_from_actor API and due to lack of documentation and several confusing - non orthogonal - side effects of using the API it wasn't really possible to use directly. This commit does a number of things: - It removes {gl,gles}/cogl-fbo.{c,h} and adds shared cogl-draw-buffer.{c,h} files instead which should be easier to maintain. - internally CoglFbo objects are now called CoglDrawBuffers. A CoglDrawBuffer is an abstract base class that is inherited from to implement CoglOnscreen and CoglOffscreen draw buffers. CoglOffscreen draw buffers will initially be used to support the cogl_offscreen_new_to_texture API, and CoglOnscreen draw buffers will start to be used internally to represent windows as we aim to migrate some of Clutter's backend code to Cogl. - It makes draw buffer objects the owners of the following state: - viewport - projection matrix stack - modelview matrix stack - clip state (This means when you switch between draw buffers you will automatically be switching to their associated viewport, matrix and clip state) Aside from hopefully making cogl_offscreen_new_to_texture be more useful short term by having simpler and well defined semantics for cogl_set_draw_buffer, as mentioned above this is the first step for a couple of other things: - Its a step toward moving ownership for windows down from Clutter backends into Cogl, by (internally at least) introducing the CoglOnscreen draw buffer. Note: the plan is that cogl_set_draw_buffer will accept on or offscreen draw buffer handles, and the "target" argument will become redundant since we will instead query the type of the given draw buffer handle. - Because we have a common type for on and offscreen framebuffers we can provide a unified API for framebuffer management. Things like: - blitting between buffers - managing ancillary buffers (e.g. attaching depth and stencil buffers) - size requisition - clearing
2009-09-25 13:34:34 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
if (context->current_path)
cogl_handle_unref (context->current_path);
Bug 1172 - Disjoint paths and clip to path * clutter/cogl/cogl-path.h: * clutter/cogl/common/cogl-primitives.c: * clutter/cogl/common/cogl-primitives.h: * clutter/cogl/gl/cogl-primitives.c: * clutter/cogl/gles/cogl-primitives.c: Changed the semantics of cogl_path_move_to. Previously this always started a new path but now it instead starts a new disjoint sub path. The path isn't cleared until you call either cogl_path_stroke, cogl_path_fill or cogl_path_new. There are also cogl_path_stroke_preserve and cogl_path_fill_preserve functions. * clutter/cogl/gl/cogl-context.c: * clutter/cogl/gl/cogl-context.h: * clutter/cogl/gles/cogl-context.c: * clutter/cogl/gles/cogl-context.h: Convert the path nodes array to a GArray. * clutter/cogl/gl/cogl-texture.c: * clutter/cogl/gles/cogl-texture.c: Call cogl_clip_ensure * clutter/cogl/common/cogl-clip-stack.c: * clutter/cogl/common/cogl-clip-stack.h: Simplified the clip stack code quite a bit to make it more maintainable. Previously whenever you added a new clip it would go through a separate route to immediately intersect with the current clip and when you removed it again it would immediately rebuild the entire clip. Now when you add or remove a clip it doesn't do anything immediately but just sets a dirty flag instead. * clutter/cogl/gl/cogl.c: * clutter/cogl/gles/cogl.c: Taken away the code to intersect stencil clips when there is exactly one stencil bit. It won't work with path clips and I don't know of any platform that doesn't have eight or zero stencil bits. It needs at least three bits to intersect a path with an existing clip. cogl_features_init now just decides you don't have a stencil buffer at all if you have less than three bits. * clutter/cogl/cogl.h.in: New functions and documentation. * tests/interactive/test-clip.c: Replaced with a different test that lets you add and remove clips. The three different mouse buttons add clips in different shapes. This makes it easier to test multiple levels of clipping. * tests/interactive/test-cogl-primitives.c: Use cogl_path_stroke_preserve when using the same path again. * doc/reference/cogl/cogl-sections.txt: Document the new functions.
2008-12-04 13:45:09 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
if (context->default_gl_texture_2d_tex)
Add a strong CoglTexture type to replace CoglHandle As part of the on going, incremental effort to purge the non type safe CoglHandle type from the Cogl API this patch tackles most of the CoglHandle uses relating to textures. We'd postponed making this change for quite a while because we wanted to have a clearer understanding of how we wanted to evolve the texture APIs towards Cogl 2.0 before exposing type safety here which would be difficult to change later since it would imply breaking APIs. The basic idea that we are steering towards now is that CoglTexture can be considered to be the most primitive interface we have for any object representing a texture. The texture interface would provide roughly these methods: cogl_texture_get_width cogl_texture_get_height cogl_texture_can_repeat cogl_texture_can_mipmap cogl_texture_generate_mipmap; cogl_texture_get_format cogl_texture_set_region cogl_texture_get_region Besides the texture interface we will then start to expose types corresponding to specific texture types: CoglTexture2D, CoglTexture3D, CoglTexture2DSliced, CoglSubTexture, CoglAtlasTexture and CoglTexturePixmapX11. We will then also expose an interface for the high-level texture types we have (such as CoglTexture2DSlice, CoglSubTexture and CoglAtlasTexture) called CoglMetaTexture. CoglMetaTexture is an additional interface that lets you iterate a virtual region of a meta texture and get mappings of primitive textures to sub-regions of that virtual region. Internally we already have this kind of abstraction for dealing with sliced texture, sub-textures and atlas textures in a consistent way, so this will just make that abstraction public. The aim here is to clarify that there is a difference between primitive textures (CoglTexture2D/3D) and some of the other high-level textures, and also enable developers to implement primitives that can support meta textures since they can only be used with the cogl_rectangle API currently. The thing that's not so clean-cut with this are the texture constructors we have currently; such as cogl_texture_new_from_file which no longer make sense when CoglTexture is considered to be an interface. These will basically just become convenient factory functions and it's just a bit unusual that they are within the cogl_texture namespace. It's worth noting here that all the texture type APIs will also have their own type specific constructors so these functions will only be used for the convenience of being able to create a texture without really wanting to know the details of what type of texture you need. Longer term for 2.0 we may come up with replacement names for these factory functions or the other thing we are considering is designing some asynchronous factory functions instead since it's so often detrimental to application performance to be blocked waiting for a texture to be uploaded to the GPU. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-08-24 20:30:34 +00:00
cogl_object_unref (context->default_gl_texture_2d_tex);
cogl-pipeline-layer: Use CoglTextureType instead of GL target enum Instead of storing the GLenum for the target of the last used texture for a layer it now stores the CoglTextureType instead. The state name has been renamed to 'texture type' instead of 'texture target'. Previously the default pipeline layer would store 0 here to represent that there is no texture. This has been changed to store COGL_TEXTURE_TYPE_2D instead which means that all pipeline layers always have a valid value for the texture type. Any places that were previously fetching the texture from a layer to determine the target (for example when generating shaders or when enabling a particular texture target) now use the texture type instead. This means they will work even for layers that don't have a texture. This also changes it so that when binding a fallback texture instead of always using a 2D texture it will now use the default texture corresponding to the texture type of the layer. That way when the generated shader tries to do a texture lookup for that type of texture it will get a valid texture object. To make this work the patch adds a default texture for 3D textures to the context and also makes the default rectangle texture actually be a rectangle texture instead of using a 2D texture. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-09 12:52:45 +00:00
if (context->default_gl_texture_3d_tex)
cogl_object_unref (context->default_gl_texture_3d_tex);
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
if (context->default_gl_texture_rect_tex)
Add a strong CoglTexture type to replace CoglHandle As part of the on going, incremental effort to purge the non type safe CoglHandle type from the Cogl API this patch tackles most of the CoglHandle uses relating to textures. We'd postponed making this change for quite a while because we wanted to have a clearer understanding of how we wanted to evolve the texture APIs towards Cogl 2.0 before exposing type safety here which would be difficult to change later since it would imply breaking APIs. The basic idea that we are steering towards now is that CoglTexture can be considered to be the most primitive interface we have for any object representing a texture. The texture interface would provide roughly these methods: cogl_texture_get_width cogl_texture_get_height cogl_texture_can_repeat cogl_texture_can_mipmap cogl_texture_generate_mipmap; cogl_texture_get_format cogl_texture_set_region cogl_texture_get_region Besides the texture interface we will then start to expose types corresponding to specific texture types: CoglTexture2D, CoglTexture3D, CoglTexture2DSliced, CoglSubTexture, CoglAtlasTexture and CoglTexturePixmapX11. We will then also expose an interface for the high-level texture types we have (such as CoglTexture2DSlice, CoglSubTexture and CoglAtlasTexture) called CoglMetaTexture. CoglMetaTexture is an additional interface that lets you iterate a virtual region of a meta texture and get mappings of primitive textures to sub-regions of that virtual region. Internally we already have this kind of abstraction for dealing with sliced texture, sub-textures and atlas textures in a consistent way, so this will just make that abstraction public. The aim here is to clarify that there is a difference between primitive textures (CoglTexture2D/3D) and some of the other high-level textures, and also enable developers to implement primitives that can support meta textures since they can only be used with the cogl_rectangle API currently. The thing that's not so clean-cut with this are the texture constructors we have currently; such as cogl_texture_new_from_file which no longer make sense when CoglTexture is considered to be an interface. These will basically just become convenient factory functions and it's just a bit unusual that they are within the cogl_texture namespace. It's worth noting here that all the texture type APIs will also have their own type specific constructors so these functions will only be used for the convenience of being able to create a texture without really wanting to know the details of what type of texture you need. Longer term for 2.0 we may come up with replacement names for these factory functions or the other thing we are considering is designing some asynchronous factory functions instead since it's so often detrimental to application performance to be blocked waiting for a texture to be uploaded to the GPU. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-08-24 20:30:34 +00:00
cogl_object_unref (context->default_gl_texture_rect_tex);
Updates GLES1 support for CoglMaterial This updates cogl/gles in line with the integration of CoglMaterial throughout Cogl that has been done for cogl/gl. Note: This is still buggy, but at least it builds again and test-actors works. Some GLES2 specific changes were made, but these haven't been tested yet.
2009-01-26 11:07:35 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
if (context->opaque_color_pipeline)
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 13:14:10 +00:00
cogl_object_unref (context->opaque_color_pipeline);
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
if (context->blended_color_pipeline)
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 13:14:10 +00:00
cogl_object_unref (context->blended_color_pipeline);
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
if (context->texture_pipeline)
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 13:14:10 +00:00
cogl_object_unref (context->texture_pipeline);
Updates GLES1 support for CoglMaterial This updates cogl/gles in line with the integration of CoglMaterial throughout Cogl that has been done for cogl/gl. Note: This is still buggy, but at least it builds again and test-actors works. Some GLES2 specific changes were made, but these haven't been tested yet.
2009-01-26 11:07:35 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
if (context->blit_texture_pipeline)
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 13:14:10 +00:00
cogl_object_unref (context->blit_texture_pipeline);
cogl-atlas: Try 4 different approaches for migrating textures Instead of directly banging GL to migrate textures the atlas now uses the CoglFramebuffer API. It will use one of four approaches; it can set up two FBOs and use _cogl_blit_framebuffer to copy between them; it can use a single target fbo and then render the source texture to the FBO using a Cogl draw call; it can use a single FBO and call glCopyTexSubImage2D; or it can fallback to reading all of the texture data back to system memory and uploading it again with a sub texture update. Previously GL calls were used directly because Cogl wasn't able to create a framebuffer without a stencil and depth buffer. However there is now an internal version of cogl_offscreen_new_to_texture which takes a set of flags to disable the two buffers. The code for blitting has now been moved into a separate file called cogl-blit.c because it has become quite long and it may be useful outside of the atlas at some point. The 4 different methods have a fixed order of preference which is: * Texture render between two FBOs * glBlitFramebuffer * glCopyTexSubImage2D * glGetTexImage + glTexSubImage2D Once a method is succesfully used it is tried first for all subsequent blits. The default default can be overridden by setting the environment variable COGL_ATLAS_DEFAULT_BLIT_MODE to one of the following values: * texture-render * framebuffer * copy-tex-sub-image * get-tex-data
2011-01-20 17:45:47 +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
g_warn_if_fail (context->gles2_context_stack.length == 0);
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
if (context->journal_flush_attributes_array)
g_array_free (context->journal_flush_attributes_array, TRUE);
if (context->journal_clip_bounds)
g_array_free (context->journal_clip_bounds, TRUE);
Updates GLES1 support for CoglMaterial This updates cogl/gles in line with the integration of CoglMaterial throughout Cogl that has been done for cogl/gl. Note: This is still buggy, but at least it builds again and test-actors works. Some GLES2 specific changes were made, but these haven't been tested yet.
2009-01-26 11:07:35 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
if (context->polygon_vertices)
g_array_free (context->polygon_vertices, TRUE);
primitives: implements cogl_polygon on vertex_attributes This updates the implementation of cogl_polygon so it sits on the new CoglVertexArray and CoglVertexAttribute apis. This lets us minimize the number of different drawing paths we have to maintain in Cogl. Since the sliced texture support for cogl_polygon has been broken for a long time now and no one has complained this patch also greatly simplifies the code by not doing any special material validation so cogl_polygon will be restricted in the same way as cogl_draw_vertex_attributes. (i.e. sliced textures not supported).
2010-10-18 16:17:22 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
if (context->quad_buffer_indices_byte)
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 13:14:10 +00:00
cogl_object_unref (context->quad_buffer_indices_byte);
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
if (context->quad_buffer_indices)
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 13:14:10 +00:00
cogl_object_unref (context->quad_buffer_indices);
cogl: Adds experimental CoglIndices API CoglIndices define a range of indices inside a CoglIndexArray. I.e. a CoglIndexArray is simply a buffer of N bytes and you can then instantiate multiple CoglIndices collections that define a sub-region of a CoglIndexArray by specifying a start offset and an index data type.
2010-10-12 11:48:58 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
if (context->rectangle_byte_indices)
cogl_object_unref (context->rectangle_byte_indices);
if (context->rectangle_short_indices)
cogl_object_unref (context->rectangle_short_indices);
cogl: Adds experimental CoglIndices API CoglIndices define a range of indices inside a CoglIndexArray. I.e. a CoglIndexArray is simply a buffer of N bytes and you can then instantiate multiple CoglIndices collections that define a sub-region of a CoglIndexArray by specifying a start offset and an index data type.
2010-10-12 11:48:58 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
if (context->default_pipeline)
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 13:14:10 +00:00
cogl_object_unref (context->default_pipeline);
[cogl-material] Adds cogl_material_copy() API cogl_material_copy can be used to create a new CoglHandle referencing a copy of some given material. From now on we will advise that developers always aim to use this function instead of cogl_material_new() when creating a material that is in any way derived from another. By using cogl_material_copy, Cogl can maintain an ancestry for each material and keep track of "similar" materials. The plan is that Cogl will use this information to minimize the cost of GPU state transitions.
2009-11-11 12:50:48 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
if (context->dummy_layer_dependant)
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 13:14:10 +00:00
cogl_object_unref (context->dummy_layer_dependant);
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
if (context->default_layer_n)
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 13:14:10 +00:00
cogl_object_unref (context->default_layer_n);
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
if (context->default_layer_0)
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 13:14:10 +00:00
cogl_object_unref (context->default_layer_0);
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 11:21:04 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
if (context->current_clip_stack_valid)
_cogl_clip_stack_unref (context->current_clip_stack);
cogl: Move the clip stack dirtiness to the context rather than the FB Previously we tracked whether the clip stack needs flushing as part of the CoglClipState which is part of the CoglFramebuffer state. This is a bit odd because most of the clipping state (such as the clip planes and the scissor) are part of the GL context's state rather than the framebuffer. We were marking the clip state on the framebuffer dirty every time we change the framebuffer anyway so it seems to make more sense to have the dirtiness be part of the global context. Instead of a just a single boolean to record whether the state needs flushing, the CoglContext now holds a reference to the clip stack that was flushed. That way we can flush arbitrary stack states and if it happens to be the same as the state already flushed then Cogl will do nothing. This will be useful if we log the clip stack in the journal because then we will need to flush unrelated clip stack states for each batch.
2010-11-02 14:28:12 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
g_slist_free (context->atlases);
cogl-atlas-texture: Add a callback for when any atlas reorganizes This adds cogl_atlas_texture_* functions to register a callback that will get invoked whenever any of the CoglAtlas's the textures use get reorganized. The callback is global and is not tied to any particular atlas texture.
2011-03-30 11:53:50 +00:00
g_hook_list_clear (&context->atlas_reorganize_callbacks);
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 13:06:32 +00:00
rework enabling of attributes, removing _cogl_enable() This removes the limited caching of enabled attributes done by _cogl_enable() and replaces it with a more generalized set of bitmasks associated with the context that allow us to efficiently compare the set of attribute locations that are currently enabled vs the new locations that need enabling so we only have to inform OpenGL of the changes in which locations are enabled/disabled. This also adds a per-context hash table for mapping attribute names to global name-state structs which includes a unique name-index for any name as well as pre-validated information about builtin "cogl_" attribute names including whether the attribute is normalized and what texture unit a texture attribute corresponds too. The name-state hash table means that cogl_attribute_new() now only needs to validate names the first time they are seen. CoglAttributes now reference a name-state structure instead of just the attribute name, so now we can efficiently get the name-index for any attribute and we can use that to index into a per-glsl-program cache that maps name indices to real GL attribute locations so when we get asked to draw a set of attributes we can very quickly determine what GL attributes need to be setup and enabled. If we don't have a cached location though we can still quickly access the string name so we can query OpenGL. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-11-24 18:09:53 +00:00
_cogl_bitmask_destroy (&context->enabled_builtin_attributes);
_cogl_bitmask_destroy (&context->enable_builtin_attributes_tmp);
_cogl_bitmask_destroy (&context->enabled_texcoord_attributes);
_cogl_bitmask_destroy (&context->enable_texcoord_attributes_tmp);
_cogl_bitmask_destroy (&context->enabled_custom_attributes);
_cogl_bitmask_destroy (&context->enable_custom_attributes_tmp);
_cogl_bitmask_destroy (&context->changed_bits_tmp);
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 11:40:11 +00:00
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
g_slist_free (context->texture_types);
g_slist_free (context->buffer_types);
cogl-texture: List texture subclass types rather than hardcoding them Instead of having a hardcoded series of if-statements in cogl_is_texture to determine which types should appear as texture subclasses, they are now stored in a GSList attached to the Cogl context. The list is amended to using a new cogl_texture_register_type function. There is a convenience macro called COGL_TEXTURE_DEFINE which uses COGL_HANDLE_DEFINE_WITH_CODE to register the texture type when the _get_type() function is first called.
2010-06-11 12:50:36 +00:00
Avoid referencing file scope context in _context_new() cogl_context_new() had a mixture of references to the file scope context variable (_context) and the local (context) variable. This renames the file scope variable to _cogl_context to catch unnecessary references to the old name and fixes the code accordingly to reference the local variable instead. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 33a9397ee1ae1729200be2e5084cf43cebb64289)
2012-09-10 09:42:03 +00:00
if (context->current_modelview_entry)
matrix-stack: make CoglMatrixStack public We have found several times now when writing code using Cogl that it would really help if Cogl's matrix stack api was public as a utility api. In Rig for example we want to avoid redundant arithmetic when deriving the matrices of entities used to render and we aren't able to simply use the framebuffer's matrix stack to achieve this. Also when implementing cairo-cogl we found that it would be really useful if we could have a matrix stack utility api. (cherry picked from commit d17a01fd935d88fab96fe6cc0b906c84026c0067)
2012-11-20 17:08:43 +00:00
cogl_matrix_entry_unref (context->current_modelview_entry);
Avoid referencing file scope context in _context_new() cogl_context_new() had a mixture of references to the file scope context variable (_context) and the local (context) variable. This renames the file scope variable to _cogl_context to catch unnecessary references to the old name and fixes the code accordingly to reference the local variable instead. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 33a9397ee1ae1729200be2e5084cf43cebb64289)
2012-09-10 09:42:03 +00:00
if (context->current_projection_entry)
matrix-stack: make CoglMatrixStack public We have found several times now when writing code using Cogl that it would really help if Cogl's matrix stack api was public as a utility api. In Rig for example we want to avoid redundant arithmetic when deriving the matrices of entities used to render and we aren't able to simply use the framebuffer's matrix stack to achieve this. Also when implementing cairo-cogl we found that it would be really useful if we could have a matrix stack utility api. (cherry picked from commit d17a01fd935d88fab96fe6cc0b906c84026c0067)
2012-11-20 17:08:43 +00:00
cogl_matrix_entry_unref (context->current_projection_entry);
Re-design the matrix stack using a graph of ops This re-designs the matrix stack so we now keep track of each separate operation such as rotating, scaling, translating and multiplying as immutable, ref-counted nodes in a graph. Being a "graph" here means that different transformations composed of a sequence of linked operation nodes may share nodes. The first node in a matrix-stack is always a LOAD_IDENTITY operation. As an example consider if an application where to draw three rectangles A, B and C something like this: cogl_framebuffer_scale (fb, 2, 2, 2); cogl_framebuffer_push_matrix(fb); cogl_framebuffer_translate (fb, 10, 0, 0); cogl_framebuffer_push_matrix(fb); cogl_framebuffer_rotate (fb, 45, 0, 0, 1); cogl_framebuffer_draw_rectangle (...); /* A */ cogl_framebuffer_pop_matrix(fb); cogl_framebuffer_draw_rectangle (...); /* B */ cogl_framebuffer_pop_matrix(fb); cogl_framebuffer_push_matrix(fb); cogl_framebuffer_set_modelview_matrix (fb, &mv); cogl_framebuffer_draw_rectangle (...); /* C */ cogl_framebuffer_pop_matrix(fb); That would result in a graph of nodes like this: LOAD_IDENTITY | SCALE / \ SAVE LOAD | | TRANSLATE RECTANGLE(C) | \ SAVE RECTANGLE(B) | ROTATE | RECTANGLE(A) Each push adds a SAVE operation which serves as a marker to rewind too when a corresponding pop is issued and also each SAVE node may also store a cached matrix representing the composition of all its ancestor nodes. This means if we repeatedly need to resolve a real CoglMatrix for a given node then we don't need to repeat the composition. Some advantages of this design are: - A single pointer to any node in the graph can now represent a complete, immutable transformation that can be logged for example into a journal. Previously we were storing a full CoglMatrix in each journal entry which is 16 floats for the matrix itself as well as space for flags and another 16 floats for possibly storing a cache of the inverse. This means that we significantly reduce the size of the journal when drawing lots of primitives and we also avoid copying over 128 bytes per entry. - It becomes much cheaper to check for equality. In cases where some (unlikely) false negatives are allowed simply comparing the pointers of two matrix stack graph entries is enough. Previously we would use memcmp() to compare matrices. - It becomes easier to do comparisons of transformations. By looking for the common ancestry between nodes we can determine the operations that differentiate the transforms and use those to gain a high level understanding of the differences. For example we use this in the journal to be able to efficiently determine when two rectangle transforms only differ by some translation so that we can perform software clipping. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit f75aee93f6b293ca7a7babbd8fcc326ee6bf7aef)
2012-02-20 15:59:48 +00:00
_cogl_matrix_entry_cache_destroy (&context->builtin_flushed_projection);
_cogl_matrix_entry_cache_destroy (&context->builtin_flushed_modelview);
cogl: upload matrices with uniforms on GLES2 Once the GLES2 wrapper is removed we won't be able to upload the matrices with the fixed function API any more. The fixed function API gives a global state for setting the matrix but if a custom shader uniform is used for the matrices then the state is per program. _cogl_matrix_stack_flush_to_gl is called in a few places and it is assumed the current pipeline doesn't need to be flushed before it is called. To allow these semantics to continue to work, on GLES2 the matrix flush now just stores a reference to the matrix stack in the CoglContext. A pre_paint virtual is added to the progend which is called whenever a pipeline is flushed, even if the same pipeline was flushed already. This gives the GLSL progend a chance to upload the matrices to the uniforms. The combined modelview/projection matrix is only calculated if it is used. The generated programs end up never using the modelview or projection matrix so it usually only has to upload the combined matrix. When a matrix stack is flushed a reference is taked to it by the pipeline progend and the age is stored so that if the same state is used with the same program again then we don't need to reupload the uniform.
2010-12-06 12:31:51 +00:00
fragend-arbfp: Move the pipeline cache to a separate file The pipeline cache is now handled in CoglPipelineCache instead of directly in the ARBfp fragend. The flags needed to hash a pipeline should be exactly the same for the ARBfp and GLSL fragends so it's convenient to share the code. The hash table now stores the actual pipeline as the value instead of the private data so that the two fragends can attach their data to it. That way it's possible to use the same pipeline key with ancestors that are using different fragends. The hash table is created with g_hash_table_new_full to set a destructor for the key and value and there is a destructor for CoglPipelineCache that gets called when the CoglContext is destroyed. That way we no longer leak the pipelines and shader state when the context is desroyed.
2011-06-30 14:55:56 +00:00
cogl_pipeline_cache_free (context->pipeline_cache);
arbfp: Adds an ARBfp program cache This adds a cache (A GHashTable) of ARBfp programs and before ever starting to code-generate a new program we will always first try and find an existing program in the cache. This uses _cogl_pipeline_hash and _cogl_pipeline_equal to hash and compare the keys for the cache. There is a new COGL_DEBUG=disable-program-caches option that can disable the cache for debugging purposes.
2010-12-03 12:01:18 +00:00
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 21:20:04 +00:00
_cogl_sampler_cache_free (context->sampler_cache);
cogl-pipeline: Add support for setting uniform values This adds the following new public experimental functions to set uniform values on a CoglPipeline: void cogl_pipeline_set_uniform_1f (CoglPipeline *pipeline, int uniform_location, float value); void cogl_pipeline_set_uniform_1i (CoglPipeline *pipeline, int uniform_location, int value); void cogl_pipeline_set_uniform_float (CoglPipeline *pipeline, int uniform_location, int n_components, int count, const float *value); void cogl_pipeline_set_uniform_int (CoglPipeline *pipeline, int uniform_location, int n_components, int count, const int *value); void cogl_pipeline_set_uniform_matrix (CoglPipeline *pipeline, int uniform_location, int dimensions, int count, gboolean transpose, const float *value); These are similar to the old functions used to set uniforms on a CoglProgram. To get a value to pass in as the uniform_location there is also: int cogl_pipeline_get_uniform_location (CoglPipeline *pipeline, const char *uniform_name); Conceptually the uniform locations are tied to the pipeline so that whenever setting a value for a new pipeline the application is expected to call this function. However in practice the uniform locations are global to the CoglContext. The names are stored in a linked list where the position in the list is the uniform location. The global indices are used so that each pipeline can store a mask of which uniforms it overrides. That way it is quicker to detect which uniforms are different from the last pipeline that used the same CoglProgramState so it can avoid flushing uniforms that haven't changed. Currently the values are not actually compared which means that it will only avoid flushing a uniform if there is a common ancestor that sets the value (or if the same pipeline is being flushed again - in which case the pipeline and its common ancestor are the same thing). The uniform values are stored in the big state of the pipeline as a sparse linked list. A bitmask stores which values have been overridden and only overridden values are stored in the linked list. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-03 17:20:43 +00:00
cogl-context: Destroy texture units later on This patch moves the call to _cogl_destroy_texture_units() from _cogl_context_free() to later on. When destroying a GL texture the texture units are checked. This would end up accessing invalid memory so we need to try to destroy the texture units only after everything that might be referencing a texture has been destroyed. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-04 12:53:25 +00:00
_cogl_destroy_texture_units ();
cogl-pipeline: Use a hash table for faster uniform name lookup The uniform names are now stored in a GPtrArray instead of a linked list. There is also a hash table to speed up converting names to locations. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-04 18:26:17 +00:00
g_ptr_array_free (context->uniform_names, TRUE);
g_hash_table_destroy (context->uniform_name_hash);
cogl-pipeline: Add support for setting uniform values This adds the following new public experimental functions to set uniform values on a CoglPipeline: void cogl_pipeline_set_uniform_1f (CoglPipeline *pipeline, int uniform_location, float value); void cogl_pipeline_set_uniform_1i (CoglPipeline *pipeline, int uniform_location, int value); void cogl_pipeline_set_uniform_float (CoglPipeline *pipeline, int uniform_location, int n_components, int count, const float *value); void cogl_pipeline_set_uniform_int (CoglPipeline *pipeline, int uniform_location, int n_components, int count, const int *value); void cogl_pipeline_set_uniform_matrix (CoglPipeline *pipeline, int uniform_location, int dimensions, int count, gboolean transpose, const float *value); These are similar to the old functions used to set uniforms on a CoglProgram. To get a value to pass in as the uniform_location there is also: int cogl_pipeline_get_uniform_location (CoglPipeline *pipeline, const char *uniform_name); Conceptually the uniform locations are tied to the pipeline so that whenever setting a value for a new pipeline the application is expected to call this function. However in practice the uniform locations are global to the CoglContext. The names are stored in a linked list where the position in the list is the uniform location. The global indices are used so that each pipeline can store a mask of which uniforms it overrides. That way it is quicker to detect which uniforms are different from the last pipeline that used the same CoglProgramState so it can avoid flushing uniforms that haven't changed. Currently the values are not actually compared which means that it will only avoid flushing a uniform if there is a common ancestor that sets the value (or if the same pipeline is being flushed again - in which case the pipeline and its common ancestor are the same thing). The uniform values are stored in the big state of the pipeline as a sparse linked list. A bitmask stores which values have been overridden and only overridden values are stored in the linked list. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-03 17:20:43 +00:00
rework enabling of attributes, removing _cogl_enable() This removes the limited caching of enabled attributes done by _cogl_enable() and replaces it with a more generalized set of bitmasks associated with the context that allow us to efficiently compare the set of attribute locations that are currently enabled vs the new locations that need enabling so we only have to inform OpenGL of the changes in which locations are enabled/disabled. This also adds a per-context hash table for mapping attribute names to global name-state structs which includes a unique name-index for any name as well as pre-validated information about builtin "cogl_" attribute names including whether the attribute is normalized and what texture unit a texture attribute corresponds too. The name-state hash table means that cogl_attribute_new() now only needs to validate names the first time they are seen. CoglAttributes now reference a name-state structure instead of just the attribute name, so now we can efficiently get the name-index for any attribute and we can use that to index into a per-glsl-program cache that maps name indices to real GL attribute locations so when we get asked to draw a set of attributes we can very quickly determine what GL attributes need to be setup and enabled. If we don't have a cached location though we can still quickly access the string name so we can query OpenGL. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-11-24 18:09:53 +00:00
g_hash_table_destroy (context->attribute_name_states_hash);
g_array_free (context->attribute_name_index_map, TRUE);
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
g_byte_array_free (context->buffer_map_fallback_array, TRUE);
cogl: Fallback to set_data when mapping a buffer to fill it In the journal code and when generating the stroke path the vertices are generated on the fly and stored in a CoglBuffer using cogl_buffer_map. However cogl_buffer_map is allowed to fail but it wasn't checking for a NULL return value. In particular on GLES it will always fail because glMapBuffer is only provided by an extension. This adds a new pair of internal functions called _cogl_buffer_{un,}map_for_fill_or_fallback which wrap cogl_buffer_map. If the map fails then it will instead return a pointer into a GByteArray attached to the context. When the buffer is unmapped the array is copied into the buffer using cogl_buffer_set_data.
2011-01-13 15:35:30 +00:00
Adds renderer,display,onscreen-template and swap-chain stubs As part of the process of splitting Cogl out as a standalone graphics API we need to introduce some API concepts that will allow us to initialize a new CoglContext when Clutter isn't there to handle that for us... The new objects roughly in the order that they are (optionally) involved in constructing a context are: CoglRenderer, CoglOnscreenTemplate, CoglSwapChain and CoglDisplay. Conceptually a CoglRenderer represents a means for rendering. Cogl supports rendering via OpenGL or OpenGL ES 1/2.0 and those APIs are accessed through a number of different windowing APIs such as GLX, EGL, SDL or WGL and more. Potentially in the future Cogl could render using D3D or even by using libdrm and directly banging the hardware. All these choices are wrapped up in the configuration of a CoglRenderer. Conceptually a CoglDisplay represents a display pipeline for a renderer. Although Cogl doesn't aim to provide a detailed abstraction of display hardware, on some platforms we can give control over multiple display planes (On TV platforms for instance video content may be on one plane and 3D would be on another so a CoglDisplay lets you select the plane up-front.) Another aspect of CoglDisplay is that it lets us negotiate a display pipeline that best supports the type of CoglOnscreen framebuffers we are planning to create. For instance if you want transparent CoglOnscreen framebuffers then we have to be sure the display pipeline wont discard the alpha component of your framebuffers. Or if you want to use double/tripple buffering that requires support from the display pipeline. CoglOnscreenTemplate and CoglSwapChain are how we describe our default CoglOnscreen framebuffer configuration which can affect the configuration of the display pipeline. The default/simple way we expect most CoglContexts to be constructed will be via something like: if (!cogl_context_new (NULL, &error)) g_error ("Failed to construct a CoglContext: %s", error->message); Where that NULL is for an optional "display" parameter and NULL says to Cogl "please just try to do something sensible". If you want some more control though you can manually construct a CoglDisplay something like: display = cogl_display_new (NULL, NULL); cogl_gdl_display_set_plane (display, plane); if (!cogl_display_setup (display, &error)) g_error ("Failed to setup a CoglDisplay: %s", error->message); And in a similar fashion to cogl_context_new() you can optionally pass a NULL "renderer" and/or a NULL "onscreen template" so Cogl will try to just do something sensible. If you need to change the CoglOnscreen defaults you can provide a template something like: chain = cogl_swap_chain_new (); cogl_swap_chain_set_has_alpha (chain, TRUE); cogl_swap_chain_set_length (chain, 3); onscreen_template = cogl_onscreen_template_new (chain); cogl_onscreen_template_set_pixel_format (onscreen_template, COGL_PIXEL_FORMAT_RGB565); display = cogl_display_new (NULL, onscreen_template); if (!cogl_display_setup (display, &error)) g_error ("Failed to setup a CoglDisplay: %s", error->message);
2011-02-25 17:06:50 +00:00
cogl_object_unref (context->display);
cogl: Adds experimental cogl_context_new() API This adds a new experimental function (you need to define COGL_ENABLE_EXPERIMENTAL_API to access it) which takes us towards being able to have a standalone Cogl API. This is really a minor aesthetic change for now since all the GL context creation code still lives in Clutter but it's a step forward none the less. Since our current designs introduce a CoglDisplay object as something that would be passed to the context constructor this provides a stub cogl-display.h with CoglDisplay typedef. _cogl_context_get_default() which Clutter uses to access the Cogl context has been modified to use cogl_context_new() to initialize the default context. There is one rather nasty hack used in this patch which is that the implementation of cogl_context_new() has to forcibly make the allocated context become the default context because currently all the code in Cogl assumes it can access the context using _COGL_GET_CONTEXT including code used to initialize the context.
2010-11-05 00:00:25 +00:00
g_free (context);
Merged clutter-ivan branch into trunk. svn merge \ https://svn.o-hand.com/repos/clutter/trunk/clutter@2509 \ https://svn.o-hand.com/repos/clutter/branches/clutter-ivan@HEAD
2008-04-25 13:37:36 +00:00
}
CoglContext *
analysis: Make all function declarations be protoypes It's valid C to declare a function omitting it prototype, but it seems to be a good practise to always declare a function with its corresponding prototype.
2010-05-27 11:18:29 +00:00
_cogl_context_get_default (void)
Merged clutter-ivan branch into trunk. svn merge \ https://svn.o-hand.com/repos/clutter/trunk/clutter@2509 \ https://svn.o-hand.com/repos/clutter/branches/clutter-ivan@HEAD
2008-04-25 13:37:36 +00:00
{
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 = NULL;
Updates GLES1 support for CoglMaterial This updates cogl/gles in line with the integration of CoglMaterial throughout Cogl that has been done for cogl/gl. Note: This is still buggy, but at least it builds again and test-actors works. Some GLES2 specific changes were made, but these haven't been tested yet.
2009-01-26 11:07:35 +00:00
/* Create if doesn't exist yet */
Avoid referencing file scope context in _context_new() cogl_context_new() had a mixture of references to the file scope context variable (_context) and the local (context) variable. This renames the file scope variable to _cogl_context to catch unnecessary references to the old name and fixes the code accordingly to reference the local variable instead. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 33a9397ee1ae1729200be2e5084cf43cebb64289)
2012-09-10 09:42:03 +00:00
if (_cogl_context == NULL)
Adds renderer,display,onscreen-template and swap-chain stubs As part of the process of splitting Cogl out as a standalone graphics API we need to introduce some API concepts that will allow us to initialize a new CoglContext when Clutter isn't there to handle that for us... The new objects roughly in the order that they are (optionally) involved in constructing a context are: CoglRenderer, CoglOnscreenTemplate, CoglSwapChain and CoglDisplay. Conceptually a CoglRenderer represents a means for rendering. Cogl supports rendering via OpenGL or OpenGL ES 1/2.0 and those APIs are accessed through a number of different windowing APIs such as GLX, EGL, SDL or WGL and more. Potentially in the future Cogl could render using D3D or even by using libdrm and directly banging the hardware. All these choices are wrapped up in the configuration of a CoglRenderer. Conceptually a CoglDisplay represents a display pipeline for a renderer. Although Cogl doesn't aim to provide a detailed abstraction of display hardware, on some platforms we can give control over multiple display planes (On TV platforms for instance video content may be on one plane and 3D would be on another so a CoglDisplay lets you select the plane up-front.) Another aspect of CoglDisplay is that it lets us negotiate a display pipeline that best supports the type of CoglOnscreen framebuffers we are planning to create. For instance if you want transparent CoglOnscreen framebuffers then we have to be sure the display pipeline wont discard the alpha component of your framebuffers. Or if you want to use double/tripple buffering that requires support from the display pipeline. CoglOnscreenTemplate and CoglSwapChain are how we describe our default CoglOnscreen framebuffer configuration which can affect the configuration of the display pipeline. The default/simple way we expect most CoglContexts to be constructed will be via something like: if (!cogl_context_new (NULL, &error)) g_error ("Failed to construct a CoglContext: %s", error->message); Where that NULL is for an optional "display" parameter and NULL says to Cogl "please just try to do something sensible". If you want some more control though you can manually construct a CoglDisplay something like: display = cogl_display_new (NULL, NULL); cogl_gdl_display_set_plane (display, plane); if (!cogl_display_setup (display, &error)) g_error ("Failed to setup a CoglDisplay: %s", error->message); And in a similar fashion to cogl_context_new() you can optionally pass a NULL "renderer" and/or a NULL "onscreen template" so Cogl will try to just do something sensible. If you need to change the CoglOnscreen defaults you can provide a template something like: chain = cogl_swap_chain_new (); cogl_swap_chain_set_has_alpha (chain, TRUE); cogl_swap_chain_set_length (chain, 3); onscreen_template = cogl_onscreen_template_new (chain); cogl_onscreen_template_set_pixel_format (onscreen_template, COGL_PIXEL_FORMAT_RGB565); display = cogl_display_new (NULL, onscreen_template); if (!cogl_display_setup (display, &error)) g_error ("Failed to setup a CoglDisplay: %s", error->message);
2011-02-25 17:06:50 +00:00
{
Avoid referencing file scope context in _context_new() cogl_context_new() had a mixture of references to the file scope context variable (_context) and the local (context) variable. This renames the file scope variable to _cogl_context to catch unnecessary references to the old name and fixes the code accordingly to reference the local variable instead. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 33a9397ee1ae1729200be2e5084cf43cebb64289)
2012-09-10 09:42:03 +00:00
_cogl_context = cogl_context_new (NULL, &error);
if (!_cogl_context)
Adds renderer,display,onscreen-template and swap-chain stubs As part of the process of splitting Cogl out as a standalone graphics API we need to introduce some API concepts that will allow us to initialize a new CoglContext when Clutter isn't there to handle that for us... The new objects roughly in the order that they are (optionally) involved in constructing a context are: CoglRenderer, CoglOnscreenTemplate, CoglSwapChain and CoglDisplay. Conceptually a CoglRenderer represents a means for rendering. Cogl supports rendering via OpenGL or OpenGL ES 1/2.0 and those APIs are accessed through a number of different windowing APIs such as GLX, EGL, SDL or WGL and more. Potentially in the future Cogl could render using D3D or even by using libdrm and directly banging the hardware. All these choices are wrapped up in the configuration of a CoglRenderer. Conceptually a CoglDisplay represents a display pipeline for a renderer. Although Cogl doesn't aim to provide a detailed abstraction of display hardware, on some platforms we can give control over multiple display planes (On TV platforms for instance video content may be on one plane and 3D would be on another so a CoglDisplay lets you select the plane up-front.) Another aspect of CoglDisplay is that it lets us negotiate a display pipeline that best supports the type of CoglOnscreen framebuffers we are planning to create. For instance if you want transparent CoglOnscreen framebuffers then we have to be sure the display pipeline wont discard the alpha component of your framebuffers. Or if you want to use double/tripple buffering that requires support from the display pipeline. CoglOnscreenTemplate and CoglSwapChain are how we describe our default CoglOnscreen framebuffer configuration which can affect the configuration of the display pipeline. The default/simple way we expect most CoglContexts to be constructed will be via something like: if (!cogl_context_new (NULL, &error)) g_error ("Failed to construct a CoglContext: %s", error->message); Where that NULL is for an optional "display" parameter and NULL says to Cogl "please just try to do something sensible". If you want some more control though you can manually construct a CoglDisplay something like: display = cogl_display_new (NULL, NULL); cogl_gdl_display_set_plane (display, plane); if (!cogl_display_setup (display, &error)) g_error ("Failed to setup a CoglDisplay: %s", error->message); And in a similar fashion to cogl_context_new() you can optionally pass a NULL "renderer" and/or a NULL "onscreen template" so Cogl will try to just do something sensible. If you need to change the CoglOnscreen defaults you can provide a template something like: chain = cogl_swap_chain_new (); cogl_swap_chain_set_has_alpha (chain, TRUE); cogl_swap_chain_set_length (chain, 3); onscreen_template = cogl_onscreen_template_new (chain); cogl_onscreen_template_set_pixel_format (onscreen_template, COGL_PIXEL_FORMAT_RGB565); display = cogl_display_new (NULL, onscreen_template); if (!cogl_display_setup (display, &error)) g_error ("Failed to setup a CoglDisplay: %s", error->message);
2011-02-25 17:06:50 +00:00
{
g_warning ("Failed to create default context: %s",
error->message);
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
cogl_error_free (error);
Adds renderer,display,onscreen-template and swap-chain stubs As part of the process of splitting Cogl out as a standalone graphics API we need to introduce some API concepts that will allow us to initialize a new CoglContext when Clutter isn't there to handle that for us... The new objects roughly in the order that they are (optionally) involved in constructing a context are: CoglRenderer, CoglOnscreenTemplate, CoglSwapChain and CoglDisplay. Conceptually a CoglRenderer represents a means for rendering. Cogl supports rendering via OpenGL or OpenGL ES 1/2.0 and those APIs are accessed through a number of different windowing APIs such as GLX, EGL, SDL or WGL and more. Potentially in the future Cogl could render using D3D or even by using libdrm and directly banging the hardware. All these choices are wrapped up in the configuration of a CoglRenderer. Conceptually a CoglDisplay represents a display pipeline for a renderer. Although Cogl doesn't aim to provide a detailed abstraction of display hardware, on some platforms we can give control over multiple display planes (On TV platforms for instance video content may be on one plane and 3D would be on another so a CoglDisplay lets you select the plane up-front.) Another aspect of CoglDisplay is that it lets us negotiate a display pipeline that best supports the type of CoglOnscreen framebuffers we are planning to create. For instance if you want transparent CoglOnscreen framebuffers then we have to be sure the display pipeline wont discard the alpha component of your framebuffers. Or if you want to use double/tripple buffering that requires support from the display pipeline. CoglOnscreenTemplate and CoglSwapChain are how we describe our default CoglOnscreen framebuffer configuration which can affect the configuration of the display pipeline. The default/simple way we expect most CoglContexts to be constructed will be via something like: if (!cogl_context_new (NULL, &error)) g_error ("Failed to construct a CoglContext: %s", error->message); Where that NULL is for an optional "display" parameter and NULL says to Cogl "please just try to do something sensible". If you want some more control though you can manually construct a CoglDisplay something like: display = cogl_display_new (NULL, NULL); cogl_gdl_display_set_plane (display, plane); if (!cogl_display_setup (display, &error)) g_error ("Failed to setup a CoglDisplay: %s", error->message); And in a similar fashion to cogl_context_new() you can optionally pass a NULL "renderer" and/or a NULL "onscreen template" so Cogl will try to just do something sensible. If you need to change the CoglOnscreen defaults you can provide a template something like: chain = cogl_swap_chain_new (); cogl_swap_chain_set_has_alpha (chain, TRUE); cogl_swap_chain_set_length (chain, 3); onscreen_template = cogl_onscreen_template_new (chain); cogl_onscreen_template_set_pixel_format (onscreen_template, COGL_PIXEL_FORMAT_RGB565); display = cogl_display_new (NULL, onscreen_template); if (!cogl_display_setup (display, &error)) g_error ("Failed to setup a CoglDisplay: %s", error->message);
2011-02-25 17:06:50 +00:00
}
}
Updates GLES1 support for CoglMaterial This updates cogl/gles in line with the integration of CoglMaterial throughout Cogl that has been done for cogl/gl. Note: This is still buggy, but at least it builds again and test-actors works. Some GLES2 specific changes were made, but these haven't been tested yet.
2009-01-26 11:07:35 +00:00
Avoid referencing file scope context in _context_new() cogl_context_new() had a mixture of references to the file scope context variable (_context) and the local (context) variable. This renames the file scope variable to _cogl_context to catch unnecessary references to the old name and fixes the code accordingly to reference the local variable instead. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 33a9397ee1ae1729200be2e5084cf43cebb64289)
2012-09-10 09:42:03 +00:00
return _cogl_context;
Merged clutter-ivan branch into trunk. svn merge \ https://svn.o-hand.com/repos/clutter/trunk/clutter@2509 \ https://svn.o-hand.com/repos/clutter/branches/clutter-ivan@HEAD
2008-04-25 13:37:36 +00:00
}
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 18:51:25 +00:00
context: Add an accessor to get display associated with the context https://bugzilla.gnome.org/show_bug.cgi?id=657347 Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-08-25 16:39:35 +00:00
CoglDisplay *
cogl_context_get_display (CoglContext *context)
{
return context->display;
}
Moves all EGL code down from Clutter to Cogl As was recently done for the GLX window system code, this commit moves the EGL window system code down from the Clutter backend code into a Cogl winsys. Note: currently the cogl/configure.ac is hard coded to only build the GLX winsys so currently this is only available when building Cogl as part of Clutter.
2011-02-25 00:31:41 +00:00
#ifdef COGL_HAS_EGL_SUPPORT
EGLDisplay
fix namespace for cogl_context_egl_get_egl_context This renames cogl_context_egl_get_egl_context to cogl_egl_context_get_egl_context to be consistent with other platform specific APIs. Signed-off-by: Neil Roberts <neil@linux.intel.com>
2011-07-01 00:48:55 +00:00
cogl_egl_context_get_egl_display (CoglContext *context)
Moves all EGL code down from Clutter to Cogl As was recently done for the GLX window system code, this commit moves the EGL window system code down from the Clutter backend code into a Cogl winsys. Note: currently the cogl/configure.ac is hard coded to only build the GLX winsys so currently this is only available when building Cogl as part of Clutter.
2011-02-25 00:31:41 +00:00
{
Add a vtable of indirection to the winsys code So that we can dynamically select what winsys backend to use at runtime we need to have some indirection to how code accesses the winsys instead of simply calling _cogl_winsys* functions that would collide if we wanted to compile more than one backend into Cogl.
2011-02-25 11:29:08 +00:00
const CoglWinsysVtable *winsys = _cogl_context_get_winsys (context);
cogl-winsys: Explicitly comment which vfuncs are optional Some of the virtual functions in CoglWinsysVtable only need to be implemented for specific backends or when a specific feature is advertised. This splits the vtable struct into two commented sections marking which are optional and which are required. Wherever an optional function is used there is now a g_return_if_fail to ensure there is an implementation.
2011-05-10 12:51:41 +00:00
/* This should only be called for EGL contexts */
Start to reduce dependence on glib Since we've had several developers from admirable projects say they would like to use Cogl but would really prefer not to pull in gobject,gmodule and glib as extra dependencies we are investigating if we can get to the point where glib is only an optional dependency. Actually we feel like we only make minimal use of glib anyway, so it may well be quite straightforward to achieve this. This adds a --disable-glib configure option that can be used to disable features that depend on glib. Actually --disable-glib doesn't strictly disable glib at this point because it's more helpful if cogl continues to build as we make incremental progress towards this. The first use of glib that this patch tackles is the use of g_return_val_if_fail and g_return_if_fail which have been replaced with equivalent _COGL_RETURN_VAL_IF_FAIL and _COGL_RETURN_IF_FAIL macros. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 21:34:30 +00:00
_COGL_RETURN_VAL_IF_FAIL (winsys->context_egl_get_egl_display != NULL, NULL);
cogl-winsys: Explicitly comment which vfuncs are optional Some of the virtual functions in CoglWinsysVtable only need to be implemented for specific backends or when a specific feature is advertised. This splits the vtable struct into two commented sections marking which are optional and which are required. Wherever an optional function is used there is now a g_return_if_fail to ensure there is an implementation.
2011-05-10 12:51:41 +00:00
Add a vtable of indirection to the winsys code So that we can dynamically select what winsys backend to use at runtime we need to have some indirection to how code accesses the winsys instead of simply calling _cogl_winsys* functions that would collide if we wanted to compile more than one backend into Cogl.
2011-02-25 11:29:08 +00:00
return winsys->context_egl_get_egl_display (context);
Moves all EGL code down from Clutter to Cogl As was recently done for the GLX window system code, this commit moves the EGL window system code down from the Clutter backend code into a Cogl winsys. Note: currently the cogl/configure.ac is hard coded to only build the GLX winsys so currently this is only available when building Cogl as part of Clutter.
2011-02-25 00:31:41 +00:00
}
#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
Combine _cogl_context_check_gl_version and update_features into one The _cogl_context_check_gl_version function is meant to be called once Cogl has a GL context so that it can check whether the context found is supported by Cogl. However, only the stub winsys was calling this and it was doing it before Cogl had a chance to retrieve the function pointer for glString so it would just crash. This patch combines the two functions into one so that _cogl_context_update_features returns a gboolean and a GError. Then it can just check the context itself. https://bugzilla.gnome.org/show_bug.cgi?id=654440 Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-07-13 17:29:56 +00:00
_cogl_context_update_features (CoglContext *context,
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)
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 19:44:56 +00:00
{
Add a vtable for the driver Cogl already had a vtable for the texture driver. This ended up being used for some things that are not strictly related to texturing such as converting between pixel formats and GL enums. Some other functions that are driver dependent such as updating the features were not indirected through a vtable but instead switched directly by looking at the ctx->driver enum value. This patch normalises to the two uses by adding a separate vtable for driver functions not related to texturing and moves the pixel format conversion functions to it from the texture driver vtable. It also adds a context parameter to all of the functions in the new driver vtable so that they won't have to rely on the global context.
2012-03-22 16:32:56 +00:00
return context->driver_vtable->update_features (context, error);
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 19:44:56 +00:00
}
Flush matrices in the progend and flip with a vector Previously flushing the matrices was performed as part of the framebuffer state. When on GLES2 this matrix flushing is actually diverted so that it only keeps a reference to the intended matrix stack. This is necessary because on GLES2 there are no builtin uniforms so it can't actually flush the matrices until the program for the pipeline is generated. When the matrices are flushed it would store the age of modifications on the matrix stack so that it could detect when the matrix hasn't changed and avoid flushing it. This patch changes it so that the pipeline is responsible for flushing the matrices even when we are using the GL builtins. The same mechanism for detecting unmodified matrix stacks is used in all cases. There is a new CoglMatrixStackCache type which is used to store a reference to the intended matrix stack along with its last flushed age. There are now two of these attached to the CoglContext to track the flushed state for the global matrix builtins and also two for each glsl progend program state to track the flushed state for a program. The framebuffer matrix flush now just updates the intended matrix stacks without actually trying to flush. When a vertex snippet is attached to the pipeline, the GLSL vertend will now avoid using the projection matrix to flip the rendering. This is necessary because any vertex snippet may cause the projection matrix not to be used. Instead the flip is done as a forced final step by multiplying cogl_position_out by a vec4 uniform. This uniform is updated as part of the progend pre_paint depending on whether the framebuffer is offscreen or not. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-29 14:21:07 +00:00
void
Re-design the matrix stack using a graph of ops This re-designs the matrix stack so we now keep track of each separate operation such as rotating, scaling, translating and multiplying as immutable, ref-counted nodes in a graph. Being a "graph" here means that different transformations composed of a sequence of linked operation nodes may share nodes. The first node in a matrix-stack is always a LOAD_IDENTITY operation. As an example consider if an application where to draw three rectangles A, B and C something like this: cogl_framebuffer_scale (fb, 2, 2, 2); cogl_framebuffer_push_matrix(fb); cogl_framebuffer_translate (fb, 10, 0, 0); cogl_framebuffer_push_matrix(fb); cogl_framebuffer_rotate (fb, 45, 0, 0, 1); cogl_framebuffer_draw_rectangle (...); /* A */ cogl_framebuffer_pop_matrix(fb); cogl_framebuffer_draw_rectangle (...); /* B */ cogl_framebuffer_pop_matrix(fb); cogl_framebuffer_push_matrix(fb); cogl_framebuffer_set_modelview_matrix (fb, &mv); cogl_framebuffer_draw_rectangle (...); /* C */ cogl_framebuffer_pop_matrix(fb); That would result in a graph of nodes like this: LOAD_IDENTITY | SCALE / \ SAVE LOAD | | TRANSLATE RECTANGLE(C) | \ SAVE RECTANGLE(B) | ROTATE | RECTANGLE(A) Each push adds a SAVE operation which serves as a marker to rewind too when a corresponding pop is issued and also each SAVE node may also store a cached matrix representing the composition of all its ancestor nodes. This means if we repeatedly need to resolve a real CoglMatrix for a given node then we don't need to repeat the composition. Some advantages of this design are: - A single pointer to any node in the graph can now represent a complete, immutable transformation that can be logged for example into a journal. Previously we were storing a full CoglMatrix in each journal entry which is 16 floats for the matrix itself as well as space for flags and another 16 floats for possibly storing a cache of the inverse. This means that we significantly reduce the size of the journal when drawing lots of primitives and we also avoid copying over 128 bytes per entry. - It becomes much cheaper to check for equality. In cases where some (unlikely) false negatives are allowed simply comparing the pointers of two matrix stack graph entries is enough. Previously we would use memcmp() to compare matrices. - It becomes easier to do comparisons of transformations. By looking for the common ancestry between nodes we can determine the operations that differentiate the transforms and use those to gain a high level understanding of the differences. For example we use this in the journal to be able to efficiently determine when two rectangle transforms only differ by some translation so that we can perform software clipping. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit f75aee93f6b293ca7a7babbd8fcc326ee6bf7aef)
2012-02-20 15:59:48 +00:00
_cogl_context_set_current_projection_entry (CoglContext *context,
CoglMatrixEntry *entry)
Flush matrices in the progend and flip with a vector Previously flushing the matrices was performed as part of the framebuffer state. When on GLES2 this matrix flushing is actually diverted so that it only keeps a reference to the intended matrix stack. This is necessary because on GLES2 there are no builtin uniforms so it can't actually flush the matrices until the program for the pipeline is generated. When the matrices are flushed it would store the age of modifications on the matrix stack so that it could detect when the matrix hasn't changed and avoid flushing it. This patch changes it so that the pipeline is responsible for flushing the matrices even when we are using the GL builtins. The same mechanism for detecting unmodified matrix stacks is used in all cases. There is a new CoglMatrixStackCache type which is used to store a reference to the intended matrix stack along with its last flushed age. There are now two of these attached to the CoglContext to track the flushed state for the global matrix builtins and also two for each glsl progend program state to track the flushed state for a program. The framebuffer matrix flush now just updates the intended matrix stacks without actually trying to flush. When a vertex snippet is attached to the pipeline, the GLSL vertend will now avoid using the projection matrix to flip the rendering. This is necessary because any vertex snippet may cause the projection matrix not to be used. Instead the flip is done as a forced final step by multiplying cogl_position_out by a vec4 uniform. This uniform is updated as part of the progend pre_paint depending on whether the framebuffer is offscreen or not. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-29 14:21:07 +00:00
{
matrix-stack: make CoglMatrixStack public We have found several times now when writing code using Cogl that it would really help if Cogl's matrix stack api was public as a utility api. In Rig for example we want to avoid redundant arithmetic when deriving the matrices of entities used to render and we aren't able to simply use the framebuffer's matrix stack to achieve this. Also when implementing cairo-cogl we found that it would be really useful if we could have a matrix stack utility api. (cherry picked from commit d17a01fd935d88fab96fe6cc0b906c84026c0067)
2012-11-20 17:08:43 +00:00
cogl_matrix_entry_ref (entry);
Re-design the matrix stack using a graph of ops This re-designs the matrix stack so we now keep track of each separate operation such as rotating, scaling, translating and multiplying as immutable, ref-counted nodes in a graph. Being a "graph" here means that different transformations composed of a sequence of linked operation nodes may share nodes. The first node in a matrix-stack is always a LOAD_IDENTITY operation. As an example consider if an application where to draw three rectangles A, B and C something like this: cogl_framebuffer_scale (fb, 2, 2, 2); cogl_framebuffer_push_matrix(fb); cogl_framebuffer_translate (fb, 10, 0, 0); cogl_framebuffer_push_matrix(fb); cogl_framebuffer_rotate (fb, 45, 0, 0, 1); cogl_framebuffer_draw_rectangle (...); /* A */ cogl_framebuffer_pop_matrix(fb); cogl_framebuffer_draw_rectangle (...); /* B */ cogl_framebuffer_pop_matrix(fb); cogl_framebuffer_push_matrix(fb); cogl_framebuffer_set_modelview_matrix (fb, &mv); cogl_framebuffer_draw_rectangle (...); /* C */ cogl_framebuffer_pop_matrix(fb); That would result in a graph of nodes like this: LOAD_IDENTITY | SCALE / \ SAVE LOAD | | TRANSLATE RECTANGLE(C) | \ SAVE RECTANGLE(B) | ROTATE | RECTANGLE(A) Each push adds a SAVE operation which serves as a marker to rewind too when a corresponding pop is issued and also each SAVE node may also store a cached matrix representing the composition of all its ancestor nodes. This means if we repeatedly need to resolve a real CoglMatrix for a given node then we don't need to repeat the composition. Some advantages of this design are: - A single pointer to any node in the graph can now represent a complete, immutable transformation that can be logged for example into a journal. Previously we were storing a full CoglMatrix in each journal entry which is 16 floats for the matrix itself as well as space for flags and another 16 floats for possibly storing a cache of the inverse. This means that we significantly reduce the size of the journal when drawing lots of primitives and we also avoid copying over 128 bytes per entry. - It becomes much cheaper to check for equality. In cases where some (unlikely) false negatives are allowed simply comparing the pointers of two matrix stack graph entries is enough. Previously we would use memcmp() to compare matrices. - It becomes easier to do comparisons of transformations. By looking for the common ancestry between nodes we can determine the operations that differentiate the transforms and use those to gain a high level understanding of the differences. For example we use this in the journal to be able to efficiently determine when two rectangle transforms only differ by some translation so that we can perform software clipping. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit f75aee93f6b293ca7a7babbd8fcc326ee6bf7aef)
2012-02-20 15:59:48 +00:00
if (context->current_projection_entry)
matrix-stack: make CoglMatrixStack public We have found several times now when writing code using Cogl that it would really help if Cogl's matrix stack api was public as a utility api. In Rig for example we want to avoid redundant arithmetic when deriving the matrices of entities used to render and we aren't able to simply use the framebuffer's matrix stack to achieve this. Also when implementing cairo-cogl we found that it would be really useful if we could have a matrix stack utility api. (cherry picked from commit d17a01fd935d88fab96fe6cc0b906c84026c0067)
2012-11-20 17:08:43 +00:00
cogl_matrix_entry_unref (context->current_projection_entry);
Re-design the matrix stack using a graph of ops This re-designs the matrix stack so we now keep track of each separate operation such as rotating, scaling, translating and multiplying as immutable, ref-counted nodes in a graph. Being a "graph" here means that different transformations composed of a sequence of linked operation nodes may share nodes. The first node in a matrix-stack is always a LOAD_IDENTITY operation. As an example consider if an application where to draw three rectangles A, B and C something like this: cogl_framebuffer_scale (fb, 2, 2, 2); cogl_framebuffer_push_matrix(fb); cogl_framebuffer_translate (fb, 10, 0, 0); cogl_framebuffer_push_matrix(fb); cogl_framebuffer_rotate (fb, 45, 0, 0, 1); cogl_framebuffer_draw_rectangle (...); /* A */ cogl_framebuffer_pop_matrix(fb); cogl_framebuffer_draw_rectangle (...); /* B */ cogl_framebuffer_pop_matrix(fb); cogl_framebuffer_push_matrix(fb); cogl_framebuffer_set_modelview_matrix (fb, &mv); cogl_framebuffer_draw_rectangle (...); /* C */ cogl_framebuffer_pop_matrix(fb); That would result in a graph of nodes like this: LOAD_IDENTITY | SCALE / \ SAVE LOAD | | TRANSLATE RECTANGLE(C) | \ SAVE RECTANGLE(B) | ROTATE | RECTANGLE(A) Each push adds a SAVE operation which serves as a marker to rewind too when a corresponding pop is issued and also each SAVE node may also store a cached matrix representing the composition of all its ancestor nodes. This means if we repeatedly need to resolve a real CoglMatrix for a given node then we don't need to repeat the composition. Some advantages of this design are: - A single pointer to any node in the graph can now represent a complete, immutable transformation that can be logged for example into a journal. Previously we were storing a full CoglMatrix in each journal entry which is 16 floats for the matrix itself as well as space for flags and another 16 floats for possibly storing a cache of the inverse. This means that we significantly reduce the size of the journal when drawing lots of primitives and we also avoid copying over 128 bytes per entry. - It becomes much cheaper to check for equality. In cases where some (unlikely) false negatives are allowed simply comparing the pointers of two matrix stack graph entries is enough. Previously we would use memcmp() to compare matrices. - It becomes easier to do comparisons of transformations. By looking for the common ancestry between nodes we can determine the operations that differentiate the transforms and use those to gain a high level understanding of the differences. For example we use this in the journal to be able to efficiently determine when two rectangle transforms only differ by some translation so that we can perform software clipping. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit f75aee93f6b293ca7a7babbd8fcc326ee6bf7aef)
2012-02-20 15:59:48 +00:00
context->current_projection_entry = entry;
Flush matrices in the progend and flip with a vector Previously flushing the matrices was performed as part of the framebuffer state. When on GLES2 this matrix flushing is actually diverted so that it only keeps a reference to the intended matrix stack. This is necessary because on GLES2 there are no builtin uniforms so it can't actually flush the matrices until the program for the pipeline is generated. When the matrices are flushed it would store the age of modifications on the matrix stack so that it could detect when the matrix hasn't changed and avoid flushing it. This patch changes it so that the pipeline is responsible for flushing the matrices even when we are using the GL builtins. The same mechanism for detecting unmodified matrix stacks is used in all cases. There is a new CoglMatrixStackCache type which is used to store a reference to the intended matrix stack along with its last flushed age. There are now two of these attached to the CoglContext to track the flushed state for the global matrix builtins and also two for each glsl progend program state to track the flushed state for a program. The framebuffer matrix flush now just updates the intended matrix stacks without actually trying to flush. When a vertex snippet is attached to the pipeline, the GLSL vertend will now avoid using the projection matrix to flip the rendering. This is necessary because any vertex snippet may cause the projection matrix not to be used. Instead the flip is done as a forced final step by multiplying cogl_position_out by a vec4 uniform. This uniform is updated as part of the progend pre_paint depending on whether the framebuffer is offscreen or not. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-29 14:21:07 +00:00
}
void
Re-design the matrix stack using a graph of ops This re-designs the matrix stack so we now keep track of each separate operation such as rotating, scaling, translating and multiplying as immutable, ref-counted nodes in a graph. Being a "graph" here means that different transformations composed of a sequence of linked operation nodes may share nodes. The first node in a matrix-stack is always a LOAD_IDENTITY operation. As an example consider if an application where to draw three rectangles A, B and C something like this: cogl_framebuffer_scale (fb, 2, 2, 2); cogl_framebuffer_push_matrix(fb); cogl_framebuffer_translate (fb, 10, 0, 0); cogl_framebuffer_push_matrix(fb); cogl_framebuffer_rotate (fb, 45, 0, 0, 1); cogl_framebuffer_draw_rectangle (...); /* A */ cogl_framebuffer_pop_matrix(fb); cogl_framebuffer_draw_rectangle (...); /* B */ cogl_framebuffer_pop_matrix(fb); cogl_framebuffer_push_matrix(fb); cogl_framebuffer_set_modelview_matrix (fb, &mv); cogl_framebuffer_draw_rectangle (...); /* C */ cogl_framebuffer_pop_matrix(fb); That would result in a graph of nodes like this: LOAD_IDENTITY | SCALE / \ SAVE LOAD | | TRANSLATE RECTANGLE(C) | \ SAVE RECTANGLE(B) | ROTATE | RECTANGLE(A) Each push adds a SAVE operation which serves as a marker to rewind too when a corresponding pop is issued and also each SAVE node may also store a cached matrix representing the composition of all its ancestor nodes. This means if we repeatedly need to resolve a real CoglMatrix for a given node then we don't need to repeat the composition. Some advantages of this design are: - A single pointer to any node in the graph can now represent a complete, immutable transformation that can be logged for example into a journal. Previously we were storing a full CoglMatrix in each journal entry which is 16 floats for the matrix itself as well as space for flags and another 16 floats for possibly storing a cache of the inverse. This means that we significantly reduce the size of the journal when drawing lots of primitives and we also avoid copying over 128 bytes per entry. - It becomes much cheaper to check for equality. In cases where some (unlikely) false negatives are allowed simply comparing the pointers of two matrix stack graph entries is enough. Previously we would use memcmp() to compare matrices. - It becomes easier to do comparisons of transformations. By looking for the common ancestry between nodes we can determine the operations that differentiate the transforms and use those to gain a high level understanding of the differences. For example we use this in the journal to be able to efficiently determine when two rectangle transforms only differ by some translation so that we can perform software clipping. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit f75aee93f6b293ca7a7babbd8fcc326ee6bf7aef)
2012-02-20 15:59:48 +00:00
_cogl_context_set_current_modelview_entry (CoglContext *context,
CoglMatrixEntry *entry)
Flush matrices in the progend and flip with a vector Previously flushing the matrices was performed as part of the framebuffer state. When on GLES2 this matrix flushing is actually diverted so that it only keeps a reference to the intended matrix stack. This is necessary because on GLES2 there are no builtin uniforms so it can't actually flush the matrices until the program for the pipeline is generated. When the matrices are flushed it would store the age of modifications on the matrix stack so that it could detect when the matrix hasn't changed and avoid flushing it. This patch changes it so that the pipeline is responsible for flushing the matrices even when we are using the GL builtins. The same mechanism for detecting unmodified matrix stacks is used in all cases. There is a new CoglMatrixStackCache type which is used to store a reference to the intended matrix stack along with its last flushed age. There are now two of these attached to the CoglContext to track the flushed state for the global matrix builtins and also two for each glsl progend program state to track the flushed state for a program. The framebuffer matrix flush now just updates the intended matrix stacks without actually trying to flush. When a vertex snippet is attached to the pipeline, the GLSL vertend will now avoid using the projection matrix to flip the rendering. This is necessary because any vertex snippet may cause the projection matrix not to be used. Instead the flip is done as a forced final step by multiplying cogl_position_out by a vec4 uniform. This uniform is updated as part of the progend pre_paint depending on whether the framebuffer is offscreen or not. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-29 14:21:07 +00:00
{
matrix-stack: make CoglMatrixStack public We have found several times now when writing code using Cogl that it would really help if Cogl's matrix stack api was public as a utility api. In Rig for example we want to avoid redundant arithmetic when deriving the matrices of entities used to render and we aren't able to simply use the framebuffer's matrix stack to achieve this. Also when implementing cairo-cogl we found that it would be really useful if we could have a matrix stack utility api. (cherry picked from commit d17a01fd935d88fab96fe6cc0b906c84026c0067)
2012-11-20 17:08:43 +00:00
cogl_matrix_entry_ref (entry);
Re-design the matrix stack using a graph of ops This re-designs the matrix stack so we now keep track of each separate operation such as rotating, scaling, translating and multiplying as immutable, ref-counted nodes in a graph. Being a "graph" here means that different transformations composed of a sequence of linked operation nodes may share nodes. The first node in a matrix-stack is always a LOAD_IDENTITY operation. As an example consider if an application where to draw three rectangles A, B and C something like this: cogl_framebuffer_scale (fb, 2, 2, 2); cogl_framebuffer_push_matrix(fb); cogl_framebuffer_translate (fb, 10, 0, 0); cogl_framebuffer_push_matrix(fb); cogl_framebuffer_rotate (fb, 45, 0, 0, 1); cogl_framebuffer_draw_rectangle (...); /* A */ cogl_framebuffer_pop_matrix(fb); cogl_framebuffer_draw_rectangle (...); /* B */ cogl_framebuffer_pop_matrix(fb); cogl_framebuffer_push_matrix(fb); cogl_framebuffer_set_modelview_matrix (fb, &mv); cogl_framebuffer_draw_rectangle (...); /* C */ cogl_framebuffer_pop_matrix(fb); That would result in a graph of nodes like this: LOAD_IDENTITY | SCALE / \ SAVE LOAD | | TRANSLATE RECTANGLE(C) | \ SAVE RECTANGLE(B) | ROTATE | RECTANGLE(A) Each push adds a SAVE operation which serves as a marker to rewind too when a corresponding pop is issued and also each SAVE node may also store a cached matrix representing the composition of all its ancestor nodes. This means if we repeatedly need to resolve a real CoglMatrix for a given node then we don't need to repeat the composition. Some advantages of this design are: - A single pointer to any node in the graph can now represent a complete, immutable transformation that can be logged for example into a journal. Previously we were storing a full CoglMatrix in each journal entry which is 16 floats for the matrix itself as well as space for flags and another 16 floats for possibly storing a cache of the inverse. This means that we significantly reduce the size of the journal when drawing lots of primitives and we also avoid copying over 128 bytes per entry. - It becomes much cheaper to check for equality. In cases where some (unlikely) false negatives are allowed simply comparing the pointers of two matrix stack graph entries is enough. Previously we would use memcmp() to compare matrices. - It becomes easier to do comparisons of transformations. By looking for the common ancestry between nodes we can determine the operations that differentiate the transforms and use those to gain a high level understanding of the differences. For example we use this in the journal to be able to efficiently determine when two rectangle transforms only differ by some translation so that we can perform software clipping. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit f75aee93f6b293ca7a7babbd8fcc326ee6bf7aef)
2012-02-20 15:59:48 +00:00
if (context->current_modelview_entry)
matrix-stack: make CoglMatrixStack public We have found several times now when writing code using Cogl that it would really help if Cogl's matrix stack api was public as a utility api. In Rig for example we want to avoid redundant arithmetic when deriving the matrices of entities used to render and we aren't able to simply use the framebuffer's matrix stack to achieve this. Also when implementing cairo-cogl we found that it would be really useful if we could have a matrix stack utility api. (cherry picked from commit d17a01fd935d88fab96fe6cc0b906c84026c0067)
2012-11-20 17:08:43 +00:00
cogl_matrix_entry_unref (context->current_modelview_entry);
Re-design the matrix stack using a graph of ops This re-designs the matrix stack so we now keep track of each separate operation such as rotating, scaling, translating and multiplying as immutable, ref-counted nodes in a graph. Being a "graph" here means that different transformations composed of a sequence of linked operation nodes may share nodes. The first node in a matrix-stack is always a LOAD_IDENTITY operation. As an example consider if an application where to draw three rectangles A, B and C something like this: cogl_framebuffer_scale (fb, 2, 2, 2); cogl_framebuffer_push_matrix(fb); cogl_framebuffer_translate (fb, 10, 0, 0); cogl_framebuffer_push_matrix(fb); cogl_framebuffer_rotate (fb, 45, 0, 0, 1); cogl_framebuffer_draw_rectangle (...); /* A */ cogl_framebuffer_pop_matrix(fb); cogl_framebuffer_draw_rectangle (...); /* B */ cogl_framebuffer_pop_matrix(fb); cogl_framebuffer_push_matrix(fb); cogl_framebuffer_set_modelview_matrix (fb, &mv); cogl_framebuffer_draw_rectangle (...); /* C */ cogl_framebuffer_pop_matrix(fb); That would result in a graph of nodes like this: LOAD_IDENTITY | SCALE / \ SAVE LOAD | | TRANSLATE RECTANGLE(C) | \ SAVE RECTANGLE(B) | ROTATE | RECTANGLE(A) Each push adds a SAVE operation which serves as a marker to rewind too when a corresponding pop is issued and also each SAVE node may also store a cached matrix representing the composition of all its ancestor nodes. This means if we repeatedly need to resolve a real CoglMatrix for a given node then we don't need to repeat the composition. Some advantages of this design are: - A single pointer to any node in the graph can now represent a complete, immutable transformation that can be logged for example into a journal. Previously we were storing a full CoglMatrix in each journal entry which is 16 floats for the matrix itself as well as space for flags and another 16 floats for possibly storing a cache of the inverse. This means that we significantly reduce the size of the journal when drawing lots of primitives and we also avoid copying over 128 bytes per entry. - It becomes much cheaper to check for equality. In cases where some (unlikely) false negatives are allowed simply comparing the pointers of two matrix stack graph entries is enough. Previously we would use memcmp() to compare matrices. - It becomes easier to do comparisons of transformations. By looking for the common ancestry between nodes we can determine the operations that differentiate the transforms and use those to gain a high level understanding of the differences. For example we use this in the journal to be able to efficiently determine when two rectangle transforms only differ by some translation so that we can perform software clipping. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit f75aee93f6b293ca7a7babbd8fcc326ee6bf7aef)
2012-02-20 15:59:48 +00:00
context->current_modelview_entry = entry;
Flush matrices in the progend and flip with a vector Previously flushing the matrices was performed as part of the framebuffer state. When on GLES2 this matrix flushing is actually diverted so that it only keeps a reference to the intended matrix stack. This is necessary because on GLES2 there are no builtin uniforms so it can't actually flush the matrices until the program for the pipeline is generated. When the matrices are flushed it would store the age of modifications on the matrix stack so that it could detect when the matrix hasn't changed and avoid flushing it. This patch changes it so that the pipeline is responsible for flushing the matrices even when we are using the GL builtins. The same mechanism for detecting unmodified matrix stacks is used in all cases. There is a new CoglMatrixStackCache type which is used to store a reference to the intended matrix stack along with its last flushed age. There are now two of these attached to the CoglContext to track the flushed state for the global matrix builtins and also two for each glsl progend program state to track the flushed state for a program. The framebuffer matrix flush now just updates the intended matrix stacks without actually trying to flush. When a vertex snippet is attached to the pipeline, the GLSL vertend will now avoid using the projection matrix to flip the rendering. This is necessary because any vertex snippet may cause the projection matrix not to be used. Instead the flip is done as a forced final step by multiplying cogl_position_out by a vec4 uniform. This uniform is updated as part of the progend pre_paint depending on whether the framebuffer is offscreen or not. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-29 14:21:07 +00:00
}
Add conf vars to trick Cogl to think extensions are disabled This adds two new configuration environment variables: COGL_DISABLE_GL_EXTENSIONS and COGL_OVERRIDE_GL_VERSION The variables can also be set in the cogl.conf file using the same names. The first one is a list of GL extension names separated by commas. When set Cogl will assume any extension listed here is not available by removing it from the string returned from glGetString(GL_EXTENSIONS). If the string is set in both the config file and the environment variable then the union of the two lists will be used. The second overrides the value returned from glGetString(GL_VERSION). If the string is set in both places the version from the environment variable will take priority. These are sometimes useful for debugging Cogl to test the various combinations of extensions. It could also be useful to work around driver bugs where an extension is badly supported and it would be better not to use it. The variables in cogl-config that just set a global char * variable have been put together in an array instead of having a separate blob of code for each one in order to make it simpler to add new variables. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ec69c2dc576c78664e0b73879365cb7414ecf441)
2012-07-31 15:30:33 +00:00
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
char **
Add conf vars to trick Cogl to think extensions are disabled This adds two new configuration environment variables: COGL_DISABLE_GL_EXTENSIONS and COGL_OVERRIDE_GL_VERSION The variables can also be set in the cogl.conf file using the same names. The first one is a list of GL extension names separated by commas. When set Cogl will assume any extension listed here is not available by removing it from the string returned from glGetString(GL_EXTENSIONS). If the string is set in both the config file and the environment variable then the union of the two lists will be used. The second overrides the value returned from glGetString(GL_VERSION). If the string is set in both places the version from the environment variable will take priority. These are sometimes useful for debugging Cogl to test the various combinations of extensions. It could also be useful to work around driver bugs where an extension is badly supported and it would be better not to use it. The variables in cogl-config that just set a global char * variable have been put together in an array instead of having a separate blob of code for each one in order to make it simpler to add new variables. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ec69c2dc576c78664e0b73879365cb7414ecf441)
2012-07-31 15:30:33 +00:00
_cogl_context_get_gl_extensions (CoglContext *context)
{
const char *env_disabled_extensions;
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
char **ret;
Add conf vars to trick Cogl to think extensions are disabled This adds two new configuration environment variables: COGL_DISABLE_GL_EXTENSIONS and COGL_OVERRIDE_GL_VERSION The variables can also be set in the cogl.conf file using the same names. The first one is a list of GL extension names separated by commas. When set Cogl will assume any extension listed here is not available by removing it from the string returned from glGetString(GL_EXTENSIONS). If the string is set in both the config file and the environment variable then the union of the two lists will be used. The second overrides the value returned from glGetString(GL_VERSION). If the string is set in both places the version from the environment variable will take priority. These are sometimes useful for debugging Cogl to test the various combinations of extensions. It could also be useful to work around driver bugs where an extension is badly supported and it would be better not to use it. The variables in cogl-config that just set a global char * variable have been put together in an array instead of having a separate blob of code for each one in order to make it simpler to add new variables. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ec69c2dc576c78664e0b73879365cb7414ecf441)
2012-07-31 15:30:33 +00:00
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
/* In GL 3, querying GL_EXTENSIONS is deprecated so we have to build
* the array using glGetStringi instead */
if (context->driver == COGL_DRIVER_GL3)
Add conf vars to trick Cogl to think extensions are disabled This adds two new configuration environment variables: COGL_DISABLE_GL_EXTENSIONS and COGL_OVERRIDE_GL_VERSION The variables can also be set in the cogl.conf file using the same names. The first one is a list of GL extension names separated by commas. When set Cogl will assume any extension listed here is not available by removing it from the string returned from glGetString(GL_EXTENSIONS). If the string is set in both the config file and the environment variable then the union of the two lists will be used. The second overrides the value returned from glGetString(GL_VERSION). If the string is set in both places the version from the environment variable will take priority. These are sometimes useful for debugging Cogl to test the various combinations of extensions. It could also be useful to work around driver bugs where an extension is badly supported and it would be better not to use it. The variables in cogl-config that just set a global char * variable have been put together in an array instead of having a separate blob of code for each one in order to make it simpler to add new variables. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ec69c2dc576c78664e0b73879365cb7414ecf441)
2012-07-31 15:30:33 +00:00
{
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
int num_extensions, i;
Add conf vars to trick Cogl to think extensions are disabled This adds two new configuration environment variables: COGL_DISABLE_GL_EXTENSIONS and COGL_OVERRIDE_GL_VERSION The variables can also be set in the cogl.conf file using the same names. The first one is a list of GL extension names separated by commas. When set Cogl will assume any extension listed here is not available by removing it from the string returned from glGetString(GL_EXTENSIONS). If the string is set in both the config file and the environment variable then the union of the two lists will be used. The second overrides the value returned from glGetString(GL_VERSION). If the string is set in both places the version from the environment variable will take priority. These are sometimes useful for debugging Cogl to test the various combinations of extensions. It could also be useful to work around driver bugs where an extension is badly supported and it would be better not to use it. The variables in cogl-config that just set a global char * variable have been put together in an array instead of having a separate blob of code for each one in order to make it simpler to add new variables. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ec69c2dc576c78664e0b73879365cb7414ecf441)
2012-07-31 15:30:33 +00:00
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
context->glGetIntegerv (GL_NUM_EXTENSIONS, &num_extensions);
Add conf vars to trick Cogl to think extensions are disabled This adds two new configuration environment variables: COGL_DISABLE_GL_EXTENSIONS and COGL_OVERRIDE_GL_VERSION The variables can also be set in the cogl.conf file using the same names. The first one is a list of GL extension names separated by commas. When set Cogl will assume any extension listed here is not available by removing it from the string returned from glGetString(GL_EXTENSIONS). If the string is set in both the config file and the environment variable then the union of the two lists will be used. The second overrides the value returned from glGetString(GL_VERSION). If the string is set in both places the version from the environment variable will take priority. These are sometimes useful for debugging Cogl to test the various combinations of extensions. It could also be useful to work around driver bugs where an extension is badly supported and it would be better not to use it. The variables in cogl-config that just set a global char * variable have been put together in an array instead of having a separate blob of code for each one in order to make it simpler to add new variables. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ec69c2dc576c78664e0b73879365cb7414ecf441)
2012-07-31 15:30:33 +00:00
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
ret = g_malloc (sizeof (char *) * (num_extensions + 1));
for (i = 0; i < num_extensions; i++)
{
const char *ext =
(const char *) context->glGetStringi (GL_EXTENSIONS, i);
ret[i] = g_strdup (ext);
}
ret[num_extensions] = NULL;
}
else
{
const char *all_extensions =
(const char *) context->glGetString (GL_EXTENSIONS);
Add conf vars to trick Cogl to think extensions are disabled This adds two new configuration environment variables: COGL_DISABLE_GL_EXTENSIONS and COGL_OVERRIDE_GL_VERSION The variables can also be set in the cogl.conf file using the same names. The first one is a list of GL extension names separated by commas. When set Cogl will assume any extension listed here is not available by removing it from the string returned from glGetString(GL_EXTENSIONS). If the string is set in both the config file and the environment variable then the union of the two lists will be used. The second overrides the value returned from glGetString(GL_VERSION). If the string is set in both places the version from the environment variable will take priority. These are sometimes useful for debugging Cogl to test the various combinations of extensions. It could also be useful to work around driver bugs where an extension is badly supported and it would be better not to use it. The variables in cogl-config that just set a global char * variable have been put together in an array instead of having a separate blob of code for each one in order to make it simpler to add new variables. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ec69c2dc576c78664e0b73879365cb7414ecf441)
2012-07-31 15:30:33 +00:00
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
ret = g_strsplit (all_extensions, " ", 0 /* max tokens */);
}
Add conf vars to trick Cogl to think extensions are disabled This adds two new configuration environment variables: COGL_DISABLE_GL_EXTENSIONS and COGL_OVERRIDE_GL_VERSION The variables can also be set in the cogl.conf file using the same names. The first one is a list of GL extension names separated by commas. When set Cogl will assume any extension listed here is not available by removing it from the string returned from glGetString(GL_EXTENSIONS). If the string is set in both the config file and the environment variable then the union of the two lists will be used. The second overrides the value returned from glGetString(GL_VERSION). If the string is set in both places the version from the environment variable will take priority. These are sometimes useful for debugging Cogl to test the various combinations of extensions. It could also be useful to work around driver bugs where an extension is badly supported and it would be better not to use it. The variables in cogl-config that just set a global char * variable have been put together in an array instead of having a separate blob of code for each one in order to make it simpler to add new variables. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ec69c2dc576c78664e0b73879365cb7414ecf441)
2012-07-31 15:30:33 +00:00
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
if ((env_disabled_extensions = g_getenv ("COGL_DISABLE_GL_EXTENSIONS"))
|| _cogl_config_disable_gl_extensions)
{
char **split_env_disabled_extensions;
char **split_conf_disabled_extensions;
char **src, **dst;
Add conf vars to trick Cogl to think extensions are disabled This adds two new configuration environment variables: COGL_DISABLE_GL_EXTENSIONS and COGL_OVERRIDE_GL_VERSION The variables can also be set in the cogl.conf file using the same names. The first one is a list of GL extension names separated by commas. When set Cogl will assume any extension listed here is not available by removing it from the string returned from glGetString(GL_EXTENSIONS). If the string is set in both the config file and the environment variable then the union of the two lists will be used. The second overrides the value returned from glGetString(GL_VERSION). If the string is set in both places the version from the environment variable will take priority. These are sometimes useful for debugging Cogl to test the various combinations of extensions. It could also be useful to work around driver bugs where an extension is badly supported and it would be better not to use it. The variables in cogl-config that just set a global char * variable have been put together in an array instead of having a separate blob of code for each one in order to make it simpler to add new variables. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ec69c2dc576c78664e0b73879365cb7414ecf441)
2012-07-31 15:30:33 +00:00
if (env_disabled_extensions)
split_env_disabled_extensions =
g_strsplit (env_disabled_extensions,
",",
0 /* no max tokens */);
else
split_env_disabled_extensions = NULL;
if (_cogl_config_disable_gl_extensions)
split_conf_disabled_extensions =
g_strsplit (_cogl_config_disable_gl_extensions,
",",
0 /* no max tokens */);
else
split_conf_disabled_extensions = NULL;
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
for (dst = ret, src = ret;
*src;
src++)
Add conf vars to trick Cogl to think extensions are disabled This adds two new configuration environment variables: COGL_DISABLE_GL_EXTENSIONS and COGL_OVERRIDE_GL_VERSION The variables can also be set in the cogl.conf file using the same names. The first one is a list of GL extension names separated by commas. When set Cogl will assume any extension listed here is not available by removing it from the string returned from glGetString(GL_EXTENSIONS). If the string is set in both the config file and the environment variable then the union of the two lists will be used. The second overrides the value returned from glGetString(GL_VERSION). If the string is set in both places the version from the environment variable will take priority. These are sometimes useful for debugging Cogl to test the various combinations of extensions. It could also be useful to work around driver bugs where an extension is badly supported and it would be better not to use it. The variables in cogl-config that just set a global char * variable have been put together in an array instead of having a separate blob of code for each one in order to make it simpler to add new variables. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ec69c2dc576c78664e0b73879365cb7414ecf441)
2012-07-31 15:30:33 +00:00
{
char **d;
if (split_env_disabled_extensions)
for (d = split_env_disabled_extensions; *d; d++)
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
if (!strcmp (*src, *d))
Add conf vars to trick Cogl to think extensions are disabled This adds two new configuration environment variables: COGL_DISABLE_GL_EXTENSIONS and COGL_OVERRIDE_GL_VERSION The variables can also be set in the cogl.conf file using the same names. The first one is a list of GL extension names separated by commas. When set Cogl will assume any extension listed here is not available by removing it from the string returned from glGetString(GL_EXTENSIONS). If the string is set in both the config file and the environment variable then the union of the two lists will be used. The second overrides the value returned from glGetString(GL_VERSION). If the string is set in both places the version from the environment variable will take priority. These are sometimes useful for debugging Cogl to test the various combinations of extensions. It could also be useful to work around driver bugs where an extension is badly supported and it would be better not to use it. The variables in cogl-config that just set a global char * variable have been put together in an array instead of having a separate blob of code for each one in order to make it simpler to add new variables. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ec69c2dc576c78664e0b73879365cb7414ecf441)
2012-07-31 15:30:33 +00:00
goto disabled;
if (split_conf_disabled_extensions)
for (d = split_conf_disabled_extensions; *d; d++)
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
if (!strcmp (*src, *d))
Add conf vars to trick Cogl to think extensions are disabled This adds two new configuration environment variables: COGL_DISABLE_GL_EXTENSIONS and COGL_OVERRIDE_GL_VERSION The variables can also be set in the cogl.conf file using the same names. The first one is a list of GL extension names separated by commas. When set Cogl will assume any extension listed here is not available by removing it from the string returned from glGetString(GL_EXTENSIONS). If the string is set in both the config file and the environment variable then the union of the two lists will be used. The second overrides the value returned from glGetString(GL_VERSION). If the string is set in both places the version from the environment variable will take priority. These are sometimes useful for debugging Cogl to test the various combinations of extensions. It could also be useful to work around driver bugs where an extension is badly supported and it would be better not to use it. The variables in cogl-config that just set a global char * variable have been put together in an array instead of having a separate blob of code for each one in order to make it simpler to add new variables. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ec69c2dc576c78664e0b73879365cb7414ecf441)
2012-07-31 15:30:33 +00:00
goto disabled;
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
*(dst++) = *src;
continue;
Add conf vars to trick Cogl to think extensions are disabled This adds two new configuration environment variables: COGL_DISABLE_GL_EXTENSIONS and COGL_OVERRIDE_GL_VERSION The variables can also be set in the cogl.conf file using the same names. The first one is a list of GL extension names separated by commas. When set Cogl will assume any extension listed here is not available by removing it from the string returned from glGetString(GL_EXTENSIONS). If the string is set in both the config file and the environment variable then the union of the two lists will be used. The second overrides the value returned from glGetString(GL_VERSION). If the string is set in both places the version from the environment variable will take priority. These are sometimes useful for debugging Cogl to test the various combinations of extensions. It could also be useful to work around driver bugs where an extension is badly supported and it would be better not to use it. The variables in cogl-config that just set a global char * variable have been put together in an array instead of having a separate blob of code for each one in order to make it simpler to add new variables. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ec69c2dc576c78664e0b73879365cb7414ecf441)
2012-07-31 15:30:33 +00:00
disabled:
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
g_free (*src);
Add conf vars to trick Cogl to think extensions are disabled This adds two new configuration environment variables: COGL_DISABLE_GL_EXTENSIONS and COGL_OVERRIDE_GL_VERSION The variables can also be set in the cogl.conf file using the same names. The first one is a list of GL extension names separated by commas. When set Cogl will assume any extension listed here is not available by removing it from the string returned from glGetString(GL_EXTENSIONS). If the string is set in both the config file and the environment variable then the union of the two lists will be used. The second overrides the value returned from glGetString(GL_VERSION). If the string is set in both places the version from the environment variable will take priority. These are sometimes useful for debugging Cogl to test the various combinations of extensions. It could also be useful to work around driver bugs where an extension is badly supported and it would be better not to use it. The variables in cogl-config that just set a global char * variable have been put together in an array instead of having a separate blob of code for each one in order to make it simpler to add new variables. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ec69c2dc576c78664e0b73879365cb7414ecf441)
2012-07-31 15:30:33 +00:00
continue;
}
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
*dst = NULL;
Add conf vars to trick Cogl to think extensions are disabled This adds two new configuration environment variables: COGL_DISABLE_GL_EXTENSIONS and COGL_OVERRIDE_GL_VERSION The variables can also be set in the cogl.conf file using the same names. The first one is a list of GL extension names separated by commas. When set Cogl will assume any extension listed here is not available by removing it from the string returned from glGetString(GL_EXTENSIONS). If the string is set in both the config file and the environment variable then the union of the two lists will be used. The second overrides the value returned from glGetString(GL_VERSION). If the string is set in both places the version from the environment variable will take priority. These are sometimes useful for debugging Cogl to test the various combinations of extensions. It could also be useful to work around driver bugs where an extension is badly supported and it would be better not to use it. The variables in cogl-config that just set a global char * variable have been put together in an array instead of having a separate blob of code for each one in order to make it simpler to add new variables. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ec69c2dc576c78664e0b73879365cb7414ecf441)
2012-07-31 15:30:33 +00:00
if (split_env_disabled_extensions)
g_strfreev (split_env_disabled_extensions);
if (split_conf_disabled_extensions)
g_strfreev (split_conf_disabled_extensions);
}
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
return ret;
Add conf vars to trick Cogl to think extensions are disabled This adds two new configuration environment variables: COGL_DISABLE_GL_EXTENSIONS and COGL_OVERRIDE_GL_VERSION The variables can also be set in the cogl.conf file using the same names. The first one is a list of GL extension names separated by commas. When set Cogl will assume any extension listed here is not available by removing it from the string returned from glGetString(GL_EXTENSIONS). If the string is set in both the config file and the environment variable then the union of the two lists will be used. The second overrides the value returned from glGetString(GL_VERSION). If the string is set in both places the version from the environment variable will take priority. These are sometimes useful for debugging Cogl to test the various combinations of extensions. It could also be useful to work around driver bugs where an extension is badly supported and it would be better not to use it. The variables in cogl-config that just set a global char * variable have been put together in an array instead of having a separate blob of code for each one in order to make it simpler to add new variables. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ec69c2dc576c78664e0b73879365cb7414ecf441)
2012-07-31 15:30:33 +00:00
}
const char *
_cogl_context_get_gl_version (CoglContext *context)
{
const char *version_override;
if ((version_override = g_getenv ("COGL_OVERRIDE_GL_VERSION")))
return version_override;
else if (_cogl_config_override_gl_version)
return _cogl_config_override_gl_version;
else
return (const char *) context->glGetString (GL_VERSION);
}
Reference in New Issue Copy Permalink