isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-26 10:00:45 -05:00
Code Issues Packages Projects Releases Wiki Activity
f5bb20212b
mutter/cogl/cogl-context.c

500 lines
16 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 09:37:36 -04: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 10:48:12 -04: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 09:37:36 -04: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 10:48:12 -04: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 09:37:36 -04: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 10:48:12 -04: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 09:37:36 -04:00
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
Remove mentions of the FSF address Since using addresses that might change is something that finally the FSF acknowledge as a plausible scenario (after changing address twice), the license blurb in the source files should use the URI for getting the license in case the library did not come with it. Not that URIs cannot possibly change, but at least it's easier to set up a redirection at the same place. As a side note: this commit closes the oldes bug in Clutter's bug report tool. http://bugzilla.openedhand.com/show_bug.cgi?id=521
2010-03-01 07:56:10 -05:00
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*
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 09:37:36 -04:00
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "cogl.h"
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-04 20:00:25 -04: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 09:37:36 -04: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 08:28:33 -04:00
#include "cogl-private.h"
#include "cogl-winsys-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 16:11:42 -04: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 09:37:36 -04: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 18:25:52 -04: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 06:29:08 -05: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 09:01:57 -04: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 06:07:35 -05:00
#include "cogl-texture-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 13:54:57 -04: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 14:06:35 -05:00
#include "cogl-framebuffer-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-03 20:27:47 -04:00
#include "cogl2-path.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 09:37:36 -04: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 06:07:35 -05:00
#include <string.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 10:25:51 -04: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 11:56:41 -05: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 10:25:51 -04:00
#define glActiveTexture _context->drv.pf_glActiveTexture
#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 09:33:55 -04: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-04 20:00:25 -04: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-27 20:34:33 -04:00
extern void
_cogl_create_context_driver (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 09:37:36 -04:00
static CoglContext *_context = NULL;
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 13:37:47 -05: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 09:28:00 -05:00
if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_DISABLE_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 13:37:47 -05:00
ctx->feature_flags &= ~COGL_FEATURE_VBOS;
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 09:28:00 -05:00
if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_DISABLE_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 13:37:47 -05:00
ctx->feature_flags &= ~COGL_FEATURE_PBOS;
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 09:28:00 -05:00
if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_DISABLE_ARBFP)))
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 13:37:47 -05:00
ctx->feature_flags &= ~COGL_FEATURE_SHADERS_ARBFP;
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 09:28:00 -05:00
if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_DISABLE_GLSL)))
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 13:37:47 -05:00
ctx->feature_flags &= ~COGL_FEATURE_SHADERS_GLSL;
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 09:28:00 -05:00
if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_DISABLE_NPOT_TEXTURES)))
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 13:37:47 -05:00
ctx->feature_flags &= ~(COGL_FEATURE_TEXTURE_NPOT |
COGL_FEATURE_TEXTURE_NPOT_BASIC |
COGL_FEATURE_TEXTURE_NPOT_MIPMAP |
COGL_FEATURE_TEXTURE_NPOT_REPEAT);
}
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 06:29:08 -05: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 12:06:50 -05: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-04 20:00:25 -04: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 12:06:50 -05:00
cogl_context_new (CoglDisplay *display,
GError **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 09:37:36 -04: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-04 20:00:25 -04: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 06:07:35 -05:00
GLubyte default_texture_data[] = { 0xff, 0xff, 0xff, 0x0 };
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-04 20:00:25 -04:00
unsigned long enable_flags = 0;
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 06:29:08 -05: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 18:24:34 -04:00
int i;
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 06:07:35 -05:00
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 16:11:42 -04:00
#ifdef CLUTTER_ENABLE_PROFILE
/* 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 09:37:36 -04:00
/* Allocate context memory */
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-04 20:00:25 -04:00
context = g_malloc (sizeof (CoglContext));
/* 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 08:28:33 -04: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-04 20:00:25 -04:00
*/
_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 06:07:35 -05: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 09:37:36 -04:00
/* Init default values */
Moves all GLX code down from Clutter to Cogl This migrates all the GLX window system code down from the Clutter backend code into a Cogl winsys. Moving OpenGL window system binding code down from Clutter into Cogl is the biggest blocker to having Cogl become a standalone 3D graphics library, so this is an important step in that direction.
2010-11-05 08:28:33 -04:00
context->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 06:07:35 -05: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-04 20:00:25 -04: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 08:50:36 -04:00
Moves all GLX code down from Clutter to Cogl This migrates all the GLX window system code down from the Clutter backend code into a Cogl winsys. Moving OpenGL window system binding code down from Clutter into Cogl is the biggest blocker to having Cogl become a standalone 3D graphics library, so this is an important step in that direction.
2010-11-05 08:28:33 -04:00
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 10:39:14 -04: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 08:28:33 -04:00
if (!display)
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 12:06:50 -05:00
display = cogl_display_new (NULL, NULL);
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 08:28:33 -04:00
context->display = display;
#ifdef COGL_HAS_FULL_WINSYS
cogl-context: Initialize context->stub_winsys If Cogl is built using a full Winsys then it wasn't initialising context->stub_winsys which sometimes made it crash later on.
2011-04-21 11:44:15 -04:00
context->stub_winsys = FALSE;
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 06:29:08 -05:00
winsys = _cogl_context_get_winsys (context);
if (!winsys->context_init (context, error))
Moves all GLX code down from Clutter to Cogl This migrates all the GLX window system code down from the Clutter backend code into a Cogl winsys. Moving OpenGL window system binding code down from Clutter into Cogl is the biggest blocker to having Cogl become a standalone 3D graphics library, so this is an important step in that direction.
2010-11-05 08:28:33 -04:00
{
cogl_object_unref (display);
g_free (context);
return NULL;
}
#else
/* In this case Clutter is still responsible for creating a GL
* context. */
context->stub_winsys = TRUE;
if (!_cogl_gl_check_version (error))
{
g_free (context);
return NULL;
}
_cogl_gl_update_features (context);
#ifdef COGL_HAS_XLIB_SUPPORT
_cogl_xlib_query_damage_extension ();
#endif
#endif
[cogl] Ensure features are initialized first in cogl_create_context Previously some context initializing was being done without valid feature flags.
2009-10-22 07:35:33 -04: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-04 20:34:37 -04: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 07:35:33 -04: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 13:54:57 -04: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 09:57:36 -04: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 07:50:48 -05: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-04 20:00:25 -04:00
context->enable_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 06:07:35 -05: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-04 20:00:25 -04:00
context->enable_backface_culling = FALSE;
context->flushed_front_winding = COGL_FRONT_WINDING_COUNTER_CLOCKWISE;
[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 13:53:51 -04: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-04 20:00:25 -04: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 11:13:01 -04: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-04 20:00:25 -04: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 05:01:43 -04: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-04 20:00:25 -04: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 05:01:43 -04:00
g_array_new (FALSE, FALSE, sizeof (CoglTextureUnit));
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 13:54:57 -04:00
/* See cogl-pipeline.c for more details about why we leave texture unit 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 05:01:43 -04:00
* active by default... */
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-04 20:00:25 -04:00
context->active_texture_unit = 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 05:01:43 -04:00
GE (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-28 21:58:27 -04: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-04 20:00:25 -04: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 15:18:26 -04: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-04 20:00:25 -04:00
context->opaque_color_pipeline = cogl_pipeline_new ();
context->blended_color_pipeline = cogl_pipeline_new ();
context->texture_pipeline = cogl_pipeline_new ();
context->codegen_header_buffer = g_string_new ("");
context->codegen_source_buffer = g_string_new ("");
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 05:01:43 -04: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-04 20:00:25 -04: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 08:45:09 -05: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-04 20:00:25 -04:00
context->default_gl_texture_2d_tex = COGL_INVALID_HANDLE;
context->default_gl_texture_rect_tex = COGL_INVALID_HANDLE;
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 06:07:35 -05: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-04 20:00:25 -04:00
context->framebuffers = NULL;
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 12:28:34 -05: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-04 20:00:25 -04: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 14:31:53 -05: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-04 20:00:25 -04:00
context->journal_clip_bounds = NULL;
Support cogl_texture_multiple_rectangles in GL ES backend
2008-12-09 10:10:33 -05: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-04 20:00:25 -04: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 12:17:22 -04: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-04 20:00:25 -04: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 05:01:43 -04: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-04 20:00:25 -04:00
context->pipeline0_nodes =
CoglMaterial: Implements sparse materials design This is a complete overhaul of the data structures used to manage CoglMaterial state. We have these requirements that were aiming to meet: (Note: the references to "renderlists" correspond to the effort to support scenegraph level shuffling of Clutter actor primitives so we can minimize GPU state changes) Sparse State: We wanted a design that allows sparse descriptions of state so it scales well as we make CoglMaterial responsible for more and more state. It needs to scale well in terms of memory usage and the cost of operations we need to apply to materials such as comparing, copying and flushing their state. I.e. we would rather have these things scale by the number of real changes a material represents not by how much overall state CoglMaterial becomes responsible for. Cheap Copies: As we add support for renderlists in Clutter we will need to be able to get an immutable handle for a given material's current state so that we can retain a record of a primitive with its associated material without worrying that changes to the original material will invalidate that record. No more flush override options: We want to get rid of the flush overrides mechanism we currently use to deal with texture fallbacks, wrap mode changes and to handle the use of highlevel CoglTextures that need to be resolved into lowlevel textures before flushing the material state. The flush options structure has been expanding in size and the structure is logged with every journal entry so it is not an approach that scales well at all. It also makes flushing material state that much more complex. Weak Materials: Again for renderlists we need a way to create materials derived from other materials but without the strict requirement that modifications to the original material wont affect the derived ("weak") material. The only requirement is that its possible to later check if the original material has been changed. A summary of the new design: A CoglMaterial now basically represents a diff against its parent. Each material has a single parent and a mask of state that it changes. Each group of state (such as the blending state) has an "authority" which is found by walking up from a given material through its ancestors checking the difference mask until a match for that group is found. There is only one root node to the graph of all materials, which is the default material first created when Cogl is being initialized. All the groups of state are divided into two types, such that infrequently changed state belongs in a separate "BigState" structure that is only allocated and attached to a material when necessary. CoglMaterialLayers are another sparse structure. Like CoglMaterials they represent a diff against their parent and all the layers are part of another graph with the "default_layer_0" layer being the root node that Cogl creates during initialization. Copying a material is now basically just a case of slice allocating a CoglMaterial, setting the parent to be the source being copied and zeroing the mask of changes. Flush overrides should now be handled by simply relying on the cheapness of copying a material and making changes to it. (This will be done in a follow on commit) Weak material support will be added in a follow on commit.
2010-04-08 07:21:04 -04:00
g_array_sized_new (FALSE, FALSE, sizeof (CoglHandle), 20);
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-04 20:00:25 -04:00
context->pipeline1_nodes =
CoglMaterial: Implements sparse materials design This is a complete overhaul of the data structures used to manage CoglMaterial state. We have these requirements that were aiming to meet: (Note: the references to "renderlists" correspond to the effort to support scenegraph level shuffling of Clutter actor primitives so we can minimize GPU state changes) Sparse State: We wanted a design that allows sparse descriptions of state so it scales well as we make CoglMaterial responsible for more and more state. It needs to scale well in terms of memory usage and the cost of operations we need to apply to materials such as comparing, copying and flushing their state. I.e. we would rather have these things scale by the number of real changes a material represents not by how much overall state CoglMaterial becomes responsible for. Cheap Copies: As we add support for renderlists in Clutter we will need to be able to get an immutable handle for a given material's current state so that we can retain a record of a primitive with its associated material without worrying that changes to the original material will invalidate that record. No more flush override options: We want to get rid of the flush overrides mechanism we currently use to deal with texture fallbacks, wrap mode changes and to handle the use of highlevel CoglTextures that need to be resolved into lowlevel textures before flushing the material state. The flush options structure has been expanding in size and the structure is logged with every journal entry so it is not an approach that scales well at all. It also makes flushing material state that much more complex. Weak Materials: Again for renderlists we need a way to create materials derived from other materials but without the strict requirement that modifications to the original material wont affect the derived ("weak") material. The only requirement is that its possible to later check if the original material has been changed. A summary of the new design: A CoglMaterial now basically represents a diff against its parent. Each material has a single parent and a mask of state that it changes. Each group of state (such as the blending state) has an "authority" which is found by walking up from a given material through its ancestors checking the difference mask until a match for that group is found. There is only one root node to the graph of all materials, which is the default material first created when Cogl is being initialized. All the groups of state are divided into two types, such that infrequently changed state belongs in a separate "BigState" structure that is only allocated and attached to a material when necessary. CoglMaterialLayers are another sparse structure. Like CoglMaterials they represent a diff against their parent and all the layers are part of another graph with the "default_layer_0" layer being the root node that Cogl creates during initialization. Copying a material is now basically just a case of slice allocating a CoglMaterial, setting the parent to be the source being copied and zeroing the mask of changes. Flush overrides should now be handled by simply relying on the cheapness of copying a material and making changes to it. (This will be done in a follow on commit) Weak material support will be added in a follow on commit.
2010-04-08 07:21:04 -04:00
g_array_sized_new (FALSE, FALSE, sizeof (CoglHandle), 20);
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-04 20:00:25 -04:00
_cogl_bitmask_init (&context->arrays_enabled);
_cogl_bitmask_init (&context->temp_bitmask);
_cogl_bitmask_init (&context->arrays_to_change);
[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 10:33:38 -05: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-04 20:00:25 -04:00
context->max_texture_units = -1;
context->max_texture_image_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 05:01:43 -04: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-04 20:00:25 -04:00
context->current_program = COGL_INVALID_HANDLE;
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 05:01:43 -04: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-04 20:00:25 -04: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 05:01:43 -04: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-04 20:00:25 -04: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 07:21:04 -04: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-04 20:00:25 -04: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 06:33:32 -04: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-04 20:00:25 -04:00
context->point_size_cache = 1.0f;
cogl-material: Add a property for setting the point size This adds cogl_material_{get,set}_point_size. If the point size is not 1.0f then glPointSize will be called when the material is flushed. http://bugzilla.openedhand.com/show_bug.cgi?id=2047
2010-03-22 05:32:17 -04: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-04 20:00:25 -04: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 06:33:32 -04:00
context: only declare arbfp cache for GL We were trying to declare and initializing an arbfp program cache for GLES but since the prototypes for the _hash and _equal functions were only available for GL this broke the GLES builds. By #ifdefing the code to conditionally declare/initialize for GL only this should hopefully fix GLES builds.
2010-12-07 11:44:36 -05: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 11:56:41 -05:00
_context->arbfp_cache = g_hash_table_new (_cogl_pipeline_fragend_arbfp_hash,
_cogl_pipeline_fragend_arbfp_equal);
context: only declare arbfp cache for GL We were trying to declare and initializing an arbfp program cache for GLES but since the prototypes for the _hash and _equal functions were only available for GL this broke the GLES builds. By #ifdefing the code to conditionally declare/initialize for GL only this should hopefully fix GLES builds.
2010-12-07 11:44:36 -05:00
#endif
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 07:01:18 -05: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 18:24:34 -04: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-04 20:00:25 -04: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 18:24:34 -04: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-04 20:00:25 -04: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 13:08:45 -04:00
Moves all GLX code down from Clutter to Cogl This migrates all the GLX window system code down from the Clutter backend code into a Cogl winsys. Moving OpenGL window system binding code down from Clutter into Cogl is the biggest blocker to having Cogl become a standalone 3D graphics library, so this is an important step in that direction.
2010-11-05 08:28:33 -04:00
/* 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... */
if (context->stub_winsys)
{
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 13:20:14 -04:00
Moves all GLX code down from Clutter to Cogl This migrates all the GLX window system code down from the Clutter backend code into a Cogl winsys. Moving OpenGL window system binding code down from Clutter into Cogl is the biggest blocker to having Cogl become a standalone 3D graphics library, so this is an important step in that direction.
2010-11-05 08:28:33 -04:00
_context->current_clip_stack_valid = FALSE;
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 14:06:35 -05: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-04 20:00:25 -04:00
context->dirty_bound_framebuffer = TRUE;
context->dirty_gl_viewport = TRUE;
Bug 1164 - Implements the proposed Mesh API * clutter/cogl/cogl-mesh.h * clutter/cogl/cogl-types.h * clutter/cogl/cogl.h.in * clutter/cogl/common/Makefile.am * clutter/cogl/common/cogl-mesh-private.h * clutter/cogl/common/cogl-mesh.c * clutter/cogl/gl/cogl-context.c * clutter/cogl/gl/cogl-context.h * clutter/cogl/gl/cogl-defines.h.in * clutter/cogl/gl/cogl.c * clutter/cogl/gles/cogl-context.c * clutter/cogl/gles/cogl-context.h * doc/reference/cogl/cogl-docs.sgml * doc/reference/cogl/cogl-sections.txt: The Mesh API provides a means for submitting an extensible number of per vertex attributes to OpenGL in a way that doesn't require format conversions and so that the data can be mapped into the GPU (in vertex buffer objects) for - hopefully - fast re-use. There are a number of things we can potentially use this API for, but right now this just provides a foundation to build on. Please read the extensive list of TODO items in cogl-mesh.c for examples. Please refer to the cogl-mesh section in the reference manual for documentation of the API. * tests/conform/Makefile.am * tests/conform/test-conform-main.c * tests/conform/test-mesh-contiguous.c * tests/conform/test-mesh-interleved.c * tests/conform/test-mesh-mutability.c: Privides basic coverage testing for the mesh API.
2008-11-10 13:53:14 -05: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-04 20:00:25 -04:00
context->current_path = cogl2_path_new ();
context->stencil_pipeline = cogl_pipeline_new ();
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 13:42:50 -04: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-04 20:00:25 -04: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-27 20:34:33 -04: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-04 20:00:25 -04:00
context->quad_buffer_indices_byte = COGL_INVALID_HANDLE;
context->quad_buffer_indices = COGL_INVALID_HANDLE;
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 07:48:58 -04: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-04 20:00:25 -04: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 07:48:58 -04: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-04 20:00:25 -04:00
context->texture_download_pipeline = COGL_INVALID_HANDLE;
context->blit_texture_pipeline = COGL_INVALID_HANDLE;
[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 06:36:11 -04:00
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 13:02:05 -05:00
#ifndef HAVE_COGL_GLES2
[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 14:04:13 -04: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
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 13:02:05 -05:00
* 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
*/
[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 14:04:13 -04:00
GE (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 13:02:05 -05: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 14:04:13 -04:00
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 07:31:51 -05:00
#ifdef HAVE_COGL_GLES2
_context->flushed_modelview_stack = NULL;
_context->flushed_projection_stack = NULL;
#endif
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 06:07:35 -05: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-04 20:00:25 -04:00
context->default_gl_texture_2d_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 06:07:35 -05:00
cogl_texture_new_from_data (1, /* width */
1, /* height */
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-27 20:34:33 -04:00
COGL_TEXTURE_NO_SLICING,
COGL_PIXEL_FORMAT_RGBA_8888_PRE, /* data format */
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 06:07:35 -05:00
/* internal format */
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-27 20:34:33 -04:00
COGL_PIXEL_FORMAT_RGBA_8888_PRE,
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 06:07:35 -05:00
0, /* auto calc row stride */
Another Cogl gl vs gles normalizaion pass This tries to make a number of files more comparable with the intention of moving some code into cogl/common/ Files normalized: cogl.c cogl-context.c cogl-context.h cogl-texture.c
2009-01-28 09:09:51 -05:00
default_texture_data);
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-04 20:00:25 -04:00
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 06:07:35 -05:00
cogl_texture_new_from_data (1, /* width */
1, /* height */
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-27 20:34:33 -04:00
COGL_TEXTURE_NO_SLICING,
COGL_PIXEL_FORMAT_RGBA_8888_PRE, /* data format */
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 06:07:35 -05:00
/* internal format */
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-27 20:34:33 -04:00
COGL_PIXEL_FORMAT_RGBA_8888_PRE,
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 06:07:35 -05:00
0, /* auto calc row stride */
Another Cogl gl vs gles normalizaion pass This tries to make a number of files more comparable with the intention of moving some code into cogl/common/ Files normalized: cogl.c cogl-context.c cogl-context.h cogl-texture.c
2009-01-28 09:09:51 -05:00
default_texture_data);
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 06:07:35 -05: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-04 20:00:25 -04:00
cogl_push_source (context->opaque_color_pipeline);
_cogl_pipeline_flush_gl_state (context->opaque_color_pipeline, FALSE, 0);
cogl: rename cogl_enable to _cogl_enable Every now and then someone sees the cogl_enable API and gets confused, thinking its public API so this renames the symbol to be clear that it's is an internal only API.
2010-03-19 05:16:08 -04:00
_cogl_enable (enable_flags);
[cogl] Use clockwise face winding for offscreen buffers with culling enabled Because Cogl defines the origin for texture as top left and offscreen draw buffers can be used to render to textures, we (internally) force all offscreen rendering to be upside down. (because OpenGL defines the origin to be bottom left) By forcing the users scene to be rendered upside down though we also reverse the winding order of all the drawn triangles which may interfere with the users use of backface culling. This patch ensures that we reverse the winding order for a front face (if culling is in use) while rendering offscreen so we don't conflict with the users back face culling.
2009-10-22 14:01:52 -04:00
_cogl_flush_face_winding ();
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 06:07:35 -05: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-04 20:00:25 -04:00
context->atlases = NULL;
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 08:06:32 -05:00
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 10:35:30 -05:00
_context->buffer_map_fallback_array = g_byte_array_new ();
_context->buffer_map_fallback_in_use = FALSE;
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 09:33:55 -04:00
/* As far as I can tell, GL_POINT_SPRITE doesn't have any effect
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
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 13:54:57 -04:00
each pipeline to track whether any layers have point sprite
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 09:12:10 -05:00
coords enabled. We don't need to do this for GLES2 because point
sprites are handled using a builtin varying in the shader. */
#ifndef HAVE_COGL_GLES2
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 09:33:55 -04:00
if (cogl_features_available (COGL_FEATURE_POINT_SPRITE))
GE (glEnable (GL_POINT_SPRITE));
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 09:12:10 -05: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 09:33:55 -04: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-04 20:00:25 -04:00
return _cogl_context_object_new (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 09:37:36 -04: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-04 20:00:25 -04: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 09:37:36 -04: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 06:29:08 -05: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 10:16:14 -04:00
[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-28 21:58:27 -04:00
_cogl_destroy_texture_units ();
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-04 20:00:25 -04: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 09:34:34 -04: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-04 20:00:25 -04: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 08:45:09 -05: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-04 20:00:25 -04:00
if (context->default_gl_texture_2d_tex)
cogl_handle_unref (context->default_gl_texture_2d_tex);
if (context->default_gl_texture_rect_tex)
cogl_handle_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 06:07:35 -05: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-04 20:00:25 -04:00
if (context->opaque_color_pipeline)
cogl_handle_unref (context->opaque_color_pipeline);
if (context->blended_color_pipeline)
cogl_handle_unref (context->blended_color_pipeline);
if (context->texture_pipeline)
cogl_handle_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 06:07:35 -05: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-04 20:00:25 -04:00
if (context->blit_texture_pipeline)
cogl_handle_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 12:45:47 -05: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-04 20:00:25 -04: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 06:07:35 -05: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-04 20:00:25 -04: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 12:17:22 -04: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-04 20:00:25 -04:00
if (context->quad_buffer_indices_byte)
cogl_handle_unref (context->quad_buffer_indices_byte);
if (context->quad_buffer_indices)
cogl_handle_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 07:48:58 -04: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-04 20:00:25 -04: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 07:48:58 -04: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-04 20:00:25 -04:00
if (context->default_pipeline)
cogl_handle_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 07:50:48 -05: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-04 20:00:25 -04:00
if (context->dummy_layer_dependant)
cogl_handle_unref (context->dummy_layer_dependant);
if (context->default_layer_n)
cogl_handle_unref (context->default_layer_n);
if (context->default_layer_0)
cogl_handle_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 07:21:04 -04: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-04 20:00:25 -04: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 10:28:12 -04: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-04 20:00:25 -04:00
g_slist_free (context->atlases);
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 08:06:32 -05: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-04 20:00:25 -04:00
_cogl_bitmask_destroy (&context->arrays_enabled);
_cogl_bitmask_destroy (&context->temp_bitmask);
_cogl_bitmask_destroy (&context->arrays_to_change);
cogl: Use a CoglBitmask to store the list of used texcoord arrays Instead of directly using a guint32 to store a bitmask for each used texcoord array, it now stores them in a CoglBitmask. This removes the limitation of 32 layers (although there are still other places in Cogl that imply this restriction). To disable texcoord arrays code should call _cogl_disable_other_texcoord_arrays which takes a bitmask of texcoord arrays that should not be disabled. There are two extra bitmasks stored in the CoglContext which are used temporarily for this function to avoid allocating a new bitmask each time. http://bugzilla.openedhand.com/show_bug.cgi?id=2132
2010-05-24 07:40:11 -04:00
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-04 20:00:25 -04: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 08:50:36 -04:00
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 07:31:51 -05:00
#ifdef HAVE_COGL_GLES2
if (_context->flushed_modelview_stack)
cogl_object_unref (_context->flushed_modelview_stack);
if (_context->flushed_projection_stack)
cogl_object_unref (_context->flushed_projection_stack);
#endif
context: only declare arbfp cache for GL We were trying to declare and initializing an arbfp program cache for GLES but since the prototypes for the _hash and _equal functions were only available for GL this broke the GLES builds. By #ifdefing the code to conditionally declare/initialize for GL only this should hopefully fix GLES builds.
2010-12-07 11:44:36 -05:00
#ifdef HAVE_COGL_GL
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-04 20:00:25 -04:00
g_hash_table_unref (context->arbfp_cache);
context: only declare arbfp cache for GL We were trying to declare and initializing an arbfp program cache for GLES but since the prototypes for the _hash and _equal functions were only available for GL this broke the GLES builds. By #ifdefing the code to conditionally declare/initialize for GL only this should hopefully fix GLES builds.
2010-12-07 11:44:36 -05:00
#endif
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 07:01:18 -05: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-04 20:00:25 -04: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 10:35:30 -05: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 12:06:50 -05: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-04 20:00:25 -04: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 09:37:36 -04: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 07:18:29 -04: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 09:37:36 -04: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 12:06:50 -05:00
GError *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 06:07:35 -05:00
/* Create if doesn't exist yet */
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 09:37:36 -04:00
if (_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 12:06:50 -05:00
{
_context = cogl_context_new (NULL, &error);
if (!_context)
{
g_warning ("Failed to create default context: %s",
error->message);
g_error_free (error);
}
}
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 06:07:35 -05: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 09:37:36 -04:00
return _context;
}
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 13:51:25 -05:00
void
Moves all GLX code down from Clutter to Cogl This migrates all the GLX window system code down from the Clutter backend code into a Cogl winsys. Moving OpenGL window system binding code down from Clutter into Cogl is the biggest blocker to having Cogl become a standalone 3D graphics library, so this is an important step in that direction.
2010-11-05 08:28:33 -04:00
cogl_set_default_context (CoglContext *context)
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 13:51:25 -05:00
{
Moves all GLX code down from Clutter to Cogl This migrates all the GLX window system code down from the Clutter backend code into a Cogl winsys. Moving OpenGL window system binding code down from Clutter into Cogl is the biggest blocker to having Cogl become a standalone 3D graphics library, so this is an important step in that direction.
2010-11-05 08:28:33 -04:00
cogl_object_ref (context);
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 13:51:25 -05:00
Moves all GLX code down from Clutter to Cogl This migrates all the GLX window system code down from the Clutter backend code into a Cogl winsys. Moving OpenGL window system binding code down from Clutter into Cogl is the biggest blocker to having Cogl become a standalone 3D graphics library, so this is an important step in that direction.
2010-11-05 08:28:33 -04:00
if (_context)
cogl_object_unref (_context);
_context = context;
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 13:51:25 -05:00
}
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-24 19:31:41 -05:00
#ifdef COGL_HAS_EGL_SUPPORT
EGLDisplay
cogl_context_egl_get_egl_display (CoglContext *context)
{
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 06:29:08 -05:00
const CoglWinsysVtable *winsys = _cogl_context_get_winsys (context);
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-24 19:31:41 -05:00
}
#endif
Reference in New Issue Copy Permalink