isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-12-26 12:52:14 +00:00
Code Issues Packages Projects Releases Wiki Activity
c281b6dd93
mutter/cogl/cogl.h

155 lines
4.0 KiB
C
Raw Normal View History

Merged clutter-ivan branch into trunk. svn merge \ https://svn.o-hand.com/repos/clutter/trunk/clutter@2509 \ https://svn.o-hand.com/repos/clutter/branches/clutter-ivan@HEAD
2008-04-25 13:37:36 +00:00
/*
[cogl] Updates all file headers and removes lots of trailing white space Adds missing notices, and ensures all the notices are consistent. The Cogl blurb also now reads: * Cogl * * An object oriented GL/GLES Abstraction/Utility Layer
2009-04-27 14:48:12 +00:00
* Cogl
Merged clutter-ivan branch into trunk. svn merge \ https://svn.o-hand.com/repos/clutter/trunk/clutter@2509 \ https://svn.o-hand.com/repos/clutter/branches/clutter-ivan@HEAD
2008-04-25 13:37:36 +00:00
*
[cogl] Updates all file headers and removes lots of trailing white space Adds missing notices, and ensures all the notices are consistent. The Cogl blurb also now reads: * Cogl * * An object oriented GL/GLES Abstraction/Utility Layer
2009-04-27 14:48:12 +00:00
* An object oriented GL/GLES Abstraction/Utility Layer
Merged clutter-ivan branch into trunk. svn merge \ https://svn.o-hand.com/repos/clutter/trunk/clutter@2509 \ https://svn.o-hand.com/repos/clutter/branches/clutter-ivan@HEAD
2008-04-25 13:37:36 +00:00
*
[cogl] Updates all file headers and removes lots of trailing white space Adds missing notices, and ensures all the notices are consistent. The Cogl blurb also now reads: * Cogl * * An object oriented GL/GLES Abstraction/Utility Layer
2009-04-27 14:48:12 +00:00
* Copyright (C) 2008,2009 Intel Corporation.
Merged clutter-ivan branch into trunk. svn merge \ https://svn.o-hand.com/repos/clutter/trunk/clutter@2509 \ https://svn.o-hand.com/repos/clutter/branches/clutter-ivan@HEAD
2008-04-25 13:37:36 +00:00
*
* This library is free software; you can redistribute it and/or
[cogl] Updates all file headers and removes lots of trailing white space Adds missing notices, and ensures all the notices are consistent. The Cogl blurb also now reads: * Cogl * * An object oriented GL/GLES Abstraction/Utility Layer
2009-04-27 14:48:12 +00:00
Merged clutter-ivan branch into trunk. svn merge \ https://svn.o-hand.com/repos/clutter/trunk/clutter@2509 \ https://svn.o-hand.com/repos/clutter/branches/clutter-ivan@HEAD
2008-04-25 13:37:36 +00:00
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
Remove mentions of the FSF address Since using addresses that might change is something that finally the FSF acknowledge as a plausible scenario (after changing address twice), the license blurb in the source files should use the URI for getting the license in case the library did not come with it. Not that URIs cannot possibly change, but at least it's easier to set up a redirection at the same place. As a side note: this commit closes the oldes bug in Clutter's bug report tool. http://bugzilla.openedhand.com/show_bug.cgi?id=521
2010-03-01 12:56:10 +00:00
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*
Merged clutter-ivan branch into trunk. svn merge \ https://svn.o-hand.com/repos/clutter/trunk/clutter@2509 \ https://svn.o-hand.com/repos/clutter/branches/clutter-ivan@HEAD
2008-04-25 13:37:36 +00:00
*/
#ifndef __COGL_H__
#define __COGL_H__
Add runtime debug messages for COGL Clutter is able to show debug messages written using the CLUTTER_NOTE() macro at runtime, either by using an environment variable: CLUTTER_DEBUG=... or by using a command line switch: --clutter-debug=... --clutter-no-debug=... Both are parsed during the initialization process by using the GOption API. COGL would benefit from having the same support. In order to do this, we need a cogl_get_option_group() function in COGL that sets up a GOptionGroup for COGL and adds a pre-parse hook that will check the COGL_DEBUG environment variable. The OptionGroup will also install two command line switches: --cogl-debug --cogl-no-debug With the same semantics of the Clutter ones. During Clutter initialization, the COGL option group will be attached to the GOptionContext used to parse the command line options passed to a Clutter application. Every debug message written using: COGL_NOTE (SECTION, "message format", arguments); Will then be printed only if SECTION was enabled at runtime. This whole machinery, like the equivalent one in Clutter, depends on a compile time switch, COGL_ENABLE_DEBUG, which is enabled at the same time as CLUTTER_ENABLE_DEBUG. Having two different symbols allows greater granularity.
2009-02-23 12:47:02 +00:00
#define __COGL_H_INSIDE__
cogl: Adds COGL_ENABLE_EXPERIMENTAL_2_0_API define For now this new define is simply an alias for COGL_ENABLE_EXPERIMENTAL_API but the intention is that we will also use it to start experimenting with changes that need to break the existing Cogl API in incompatible ways.
2010-11-03 20:26:20 +00:00
#ifdef COGL_ENABLE_EXPERIMENTAL_2_0_API
path 2.0: update path API for experimental 2.0 API When COGL_ENABLE_EXPERIMENTAL_2_0_API is defined cogl.h will now include cogl2-path.h which changes cogl_path_new() so it can directly return a CoglPath pointer; it no longer exposes a prototype for cogl_{get,set}_path and all the remaining cogl_path_ functions now take an explicit path as their first argument. The idea is that we want to encourage developers to retain path objects for as long as possible so they can take advantage of us uploading the path geometry to the GPU. Currently although it is possible to start a new path and query the current path, it is not convenient. The other thing is that we want to get Cogl to the point where nothing depends on a global, current context variable. This will allow us to one day define a sensible threading model if/when that is ever desired.
2010-11-04 00:27:47 +00:00
#ifndef COGL_ENABLE_EXPERIMENTAL_API
cogl: Adds COGL_ENABLE_EXPERIMENTAL_2_0_API define For now this new define is simply an alias for COGL_ENABLE_EXPERIMENTAL_API but the intention is that we will also use it to start experimenting with changes that need to break the existing Cogl API in incompatible ways.
2010-11-03 20:26:20 +00:00
#define COGL_ENABLE_EXPERIMENTAL_API
#endif
path 2.0: update path API for experimental 2.0 API When COGL_ENABLE_EXPERIMENTAL_2_0_API is defined cogl.h will now include cogl2-path.h which changes cogl_path_new() so it can directly return a CoglPath pointer; it no longer exposes a prototype for cogl_{get,set}_path and all the remaining cogl_path_ functions now take an explicit path as their first argument. The idea is that we want to encourage developers to retain path objects for as long as possible so they can take advantage of us uploading the path geometry to the GPU. Currently although it is possible to start a new path and query the current path, it is not convenient. The other thing is that we want to get Cogl to the point where nothing depends on a global, current context variable. This will allow us to one day define a sensible threading model if/when that is ever desired.
2010-11-04 00:27:47 +00:00
#endif
cogl: Adds COGL_ENABLE_EXPERIMENTAL_2_0_API define For now this new define is simply an alias for COGL_ENABLE_EXPERIMENTAL_API but the intention is that we will also use it to start experimenting with changes that need to break the existing Cogl API in incompatible ways.
2010-11-03 20:26:20 +00:00
matrix gtype: registers a boxed type for CoglMatrix To allow us to have gobject properties that accept a CoglMatrix value we need to register a GType. This adds a cogl_gtype_matrix_get_type function that will register a static boxed type called "CoglMatrix". This adds a new section to the reference manual for GType integration functions.
2010-11-29 21:42:06 +00:00
/* We currently keep gtype integration delimited in case we eventually
* want to split it out into a separate utility library when Cogl
* becomes a standalone project. (like cairo-gobject.so)
*/
#define _COGL_SUPPORTS_GTYPE_INTEGRATION
cogl.h: Exclude 1.x headers if 2.0 api requested Now if COGL_ENABLE_EXPERIMENTAL_2_0_API has been defined when including cogl.h then headers that correspond to 1.x only apis that we plan to drop won't be included any more. If COGL_ENABLE_EXPERIMENTAL_API is defined then you can still mix and match 2.0 api with 1.x api in a single compilation unit. Note: it's still possible that some 1.x symbols will still be available when COGL_ENABLE_EXPERIMENTAL_2_0_API is defined since this patch doesn't go through the shared headers adding guards around deprecated functions. This only affects people playing with the experimental api. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-18 01:41:20 +00:00
/*
* API common to the 1.x and 2.0 api...
*/
build: Make cogl.h not conditional on driver defines The main COGL header cogl.h is currently created at configure time because it conditionally includes the driver-dependent defines. This sometimes leads to a stale cogl.h with old definitions which can break the build until you clean out the whole tree and start from scratch. We can generate a stable cogl-defines.h at build time from the equivalent driver-dependent header and let cogl.h include that file instead.
2009-11-18 17:35:07 +00:00
#include <cogl/cogl-defines.h>
Add compiler deprecation warnings This adds compiler symbol deprecation declarations for old Cogl APIs so that users can easily see via compiler warning when they are using these symbols, and also see a hint for what the apis should be replaced with. So that users of Cogl can manage when to show these warnings this introduces a scheme borrowed from glib whereby you can declare what version of the Cogl api you are using: COGL_VERSION_MIN_REQUIRED can be defined to indicate the oldest Cogl api that the application wants to use. Cogl will only warn about deprecations for symbols that were deprecated earlier than this required version. If this is left undefined then by default Cogl will warn about all deprecations. COGL_VERSION_MAX_ALLOWED can be defined to indicate the newest api that the application uses. If the application uses symbols newer than this then Cogl will give a warning about that. This patch removes the need to maintain the COGL_DISABLE_DEPRECATED guards around deprecated symbols. This patch fixes a few uses of deprecated symbols in the examples/ Reviewed-by: Neil Roberts <neil@linux.intel.com>
2013-03-22 21:18:53 +00:00
#include <cogl/cogl-macros.h>
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 18:28:27 +00:00
#include <cogl/cogl-error.h>
2008-10-30 Emmanuele Bassi <ebassi@linux.intel.com> Bug 1219 - Clean up cogl.h * clutter/cogl/cogl.h.in: * clutter/cogl/cogl-offscreen.h: * clutter/cogl/cogl-path.h: * clutter/cogl/cogl-shader.h: * clutter/cogl/cogl-texture.h: * clutter/cogl/cogl-types.h: Split up the massive cogl.h file into sub-header for each section of the API. * clutter/cogl/gl/*: * clutter/cogl/gles/*: Update the GL and GLES implementations of COGL to cope with the new header structure. * doc/reference/cogl/Makefile.am: Fix symbol retrieval.
2008-10-30 17:25:00 +00:00
CoglObject: Adds cogl_object_{get,set}_user_data This provides a mechanism for associating private data with any CoglObject. We expect Clutter will use this to associate weak materials with normal materials.
2010-05-27 21:24:56 +00:00
#include <cogl/cogl-object.h>
Move all types/prototypes from cogl.h -> cogl[1]-context.h So we can get to the point where cogl.h is merely an aggregation of header includes for the 1.x api this moves all the function prototypes and type definitions into a cogl-context.h and a new cogl1-context.h. Ideally no code internally should ever need to include cogl.h as it just represents the public facing header for accessing the 1.x api which should only be used by Clutter. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-17 21:46:39 +00:00
#include <cogl/cogl1-context.h>
Clean up cogl.h template The inclusion order is mostly random, and it should really be in alphabetic order, just like clutter.h. Also, cogl-vertex-buffer.h is included twice.
2009-11-06 15:06:39 +00:00
#include <cogl/cogl-bitmap.h>
2008-10-30 Emmanuele Bassi <ebassi@linux.intel.com> Bug 1210 - Add CoglColor API * clutter/cogl/cogl-color.h: * clutter/cogl/cogl.h.in: * clutter/cogl/common/Makefile.am: * clutter/cogl/common/cogl-color.c: * clutter/cogl/gl/Makefile.am: * clutter/cogl/gl/cogl.c: * clutter/cogl/gles/Makefile.am: * clutter/cogl/gles/cogl-texture.c: * clutter/cogl/gles/cogl.c: Add a new color-type, to be used by COGL. CoglColor is optimized to allow the minimum amount of conversions possible for both GL and GLES implementations. * clutter/clutter-actor.c: * clutter/clutter-clone-texture.c: * clutter/clutter-entry.c: * clutter/clutter-main.c: * clutter/clutter-rectangle.c: * clutter/clutter-stage.c: * clutter/clutter-texture.c: Use CoglColor when needed. * clutter/pango/pangoclutter-render.c: Use CoglColor when needed. * doc/reference/cogl/cogl-docs.sgml: * doc/reference/cogl/cogl-sections.txt: Update the documentation. * tests/test-cogl-offscreen.c: * tests/test-cogl-primitives.c: * tests/test-cogl-tex-convert.c: * tests/test-cogl-tex-foreign.c: * tests/test-cogl-tex-getset.c: * tests/test-cogl-tex-polygon.c: * tests/test-cogl-tex-tile.c: * tests/test-paint-wrapper.c: Update the tests. * README: Update release notes.
2008-10-30 16:50:07 +00:00
#include <cogl/cogl-color.h>
Clean up cogl.h template The inclusion order is mostly random, and it should really be in alphabetic order, just like clutter.h. Also, cogl-vertex-buffer.h is included twice.
2009-11-06 15:06:39 +00:00
#include <cogl/cogl-matrix.h>
matrix-stack: make CoglMatrixStack public We have found several times now when writing code using Cogl that it would really help if Cogl's matrix stack api was public as a utility api. In Rig for example we want to avoid redundant arithmetic when deriving the matrices of entities used to render and we aren't able to simply use the framebuffer's matrix stack to achieve this. Also when implementing cairo-cogl we found that it would be really useful if we could have a matrix stack utility api. (cherry picked from commit d17a01fd935d88fab96fe6cc0b906c84026c0067)
2012-11-20 17:08:43 +00:00
#include <cogl/cogl-matrix-stack.h>
Clean up cogl.h template The inclusion order is mostly random, and it should really be in alphabetic order, just like clutter.h. Also, cogl-vertex-buffer.h is included twice.
2009-11-06 15:06:39 +00:00
#include <cogl/cogl-offscreen.h>
cogl: cleanly separate primitives + paths code The function prototypes for the primitives API were spread between cogl-path.h and cogl-texture.h and should have been in a cogl-primitives.h. As well as shuffling the prototypes around into more sensible places this commit splits the cogl-path API out from cogl-primitives.c into a cogl-path.c
2010-02-10 22:30:37 +00:00
#include <cogl/cogl-primitives.h>
2008-10-30 Emmanuele Bassi <ebassi@linux.intel.com> Bug 1219 - Clean up cogl.h * clutter/cogl/cogl.h.in: * clutter/cogl/cogl-offscreen.h: * clutter/cogl/cogl-path.h: * clutter/cogl/cogl-shader.h: * clutter/cogl/cogl-texture.h: * clutter/cogl/cogl-types.h: Split up the massive cogl.h file into sub-header for each section of the API. * clutter/cogl/gl/*: * clutter/cogl/gles/*: Update the GL and GLES implementations of COGL to cope with the new header structure. * doc/reference/cogl/Makefile.am: Fix symbol retrieval.
2008-10-30 17:25:00 +00:00
#include <cogl/cogl-texture.h>
#include <cogl/cogl-types.h>
Add a cogl-version header This adds a version header which contains macros to define which version of Cogl the application is being compiled against. This helps applications that want to support multiple incompatible versions of Cogl at compile time. The macros are called COGL_VERSION_{MAJOR,MINOR,MICRO}. This does not match Clutter which names them CLUTTER_{MAJOR,MINOR,MICRO}_VERSION but I think the former is nicer and it at least matches Cairo and Pango. The values of the macro are defined to COGL_VERSION_*_INTERNAL which is generated by the configure script into cogl-defines.h. There is also a macro for the entire version as a string called COGL_VERSION_STRING. The internal utility macros for encoding a 3 part version number into a single integer have been moved into the new header so they can be used publicly as a convenient way to check if the version is within a particular range. There is also a COGL_VERSION_CHECK macro for the very common case that a feature will be used since a particular version of Cogl. There is a macro called COGL_VERSION which contains the pre-encoded version of Cogl being compiled against for convenience. Unlike in Clutter this patch does not add any runtime version identification mechanism. A test case is also added which just contains static asserts to sanity check the macros. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3480cf140dc355fa87ab3fbcf0aeeb0124798a8f)
2012-04-23 13:09:19 +00:00
#include <cogl/cogl-version.h>
Clean up cogl.h template The inclusion order is mostly random, and it should really be in alphabetic order, just like clutter.h. Also, cogl-vertex-buffer.h is included twice.
2009-11-06 15:06:39 +00:00
cogl.h: Exclude 1.x headers if 2.0 api requested Now if COGL_ENABLE_EXPERIMENTAL_2_0_API has been defined when including cogl.h then headers that correspond to 1.x only apis that we plan to drop won't be included any more. If COGL_ENABLE_EXPERIMENTAL_API is defined then you can still mix and match 2.0 api with 1.x api in a single compilation unit. Note: it's still possible that some 1.x symbols will still be available when COGL_ENABLE_EXPERIMENTAL_2_0_API is defined since this patch doesn't go through the shared headers adding guards around deprecated functions. This only affects people playing with the experimental api. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-18 01:41:20 +00:00
/*
* 1.x only api...
*/
#ifndef COGL_ENABLE_EXPERIMENTAL_2_0_API
#include <cogl/cogl-path.h>
#include <cogl/cogl-clip-state.h>
#include <cogl/cogl-vertex-buffer.h>
[cogl] Generate enumeration GTypes COGL is starting to have more enumerations than I can handle by hand. Let's use glib-mkenums and be done with it.
2009-05-29 11:31:47 +00:00
#include <cogl/cogl-enum-types.h>
cogl.h: Exclude 1.x headers if 2.0 api requested Now if COGL_ENABLE_EXPERIMENTAL_2_0_API has been defined when including cogl.h then headers that correspond to 1.x only apis that we plan to drop won't be included any more. If COGL_ENABLE_EXPERIMENTAL_API is defined then you can still mix and match 2.0 api with 1.x api in a single compilation unit. Note: it's still possible that some 1.x symbols will still be available when COGL_ENABLE_EXPERIMENTAL_2_0_API is defined since this patch doesn't go through the shared headers adding guards around deprecated functions. This only affects people playing with the experimental api. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-18 01:41:20 +00:00
#include <cogl/cogl-fixed.h>
#include <cogl/cogl-material-compat.h>
#include <cogl/cogl-shader.h>
#endif
Merged clutter-ivan branch into trunk. svn merge \ https://svn.o-hand.com/repos/clutter/trunk/clutter@2509 \ https://svn.o-hand.com/repos/clutter/branches/clutter-ivan@HEAD
2008-04-25 13:37:36 +00:00
cogl.h: Exclude 1.x headers if 2.0 api requested Now if COGL_ENABLE_EXPERIMENTAL_2_0_API has been defined when including cogl.h then headers that correspond to 1.x only apis that we plan to drop won't be included any more. If COGL_ENABLE_EXPERIMENTAL_API is defined then you can still mix and match 2.0 api with 1.x api in a single compilation unit. Note: it's still possible that some 1.x symbols will still be available when COGL_ENABLE_EXPERIMENTAL_2_0_API is defined since this patch doesn't go through the shared headers adding guards around deprecated functions. This only affects people playing with the experimental api. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-18 01:41:20 +00:00
/*
* 2.0 api that's compatible with the 1.x api...
*/
cogl-buffer: add an abstract class around openGL's buffer objects Buffer objects are cool! This abstracts the buffer API first introduced by GL_ARB_vertex_buffer_object and then extended to other objects. The coglBuffer abstract class is intended to be the base class of all the buffer objects, letting the user map() buffers. If the underlying implementation does not support buffer objects (or only support VBO but not FBO for instance), fallback paths should be provided.
2010-01-10 17:28:24 +00:00
#if defined (COGL_ENABLE_EXPERIMENTAL_API)
Moves all GLX code down from Clutter to Cogl This migrates all the GLX window system code down from the Clutter backend code into a Cogl winsys. Moving OpenGL window system binding code down from Clutter into Cogl is the biggest blocker to having Cogl become a standalone 3D graphics library, so this is an important step in that direction.
2010-11-05 12:28:33 +00:00
#include <cogl/cogl-swap-chain.h>
#include <cogl/cogl-renderer.h>
renderer: expose CoglOutputs This adds a cogl_renderer_foreach_output() function that can be used to iterate the display outputs for a particular renderer. This also updates cogl-info to use this new api so it can dump out all the output information. Reviewed-by: Owen W. Taylor <otaylor@fishsoup.net> (cherry picked from commit a2abf4c4c1fd5aeafd761f965d07a0fe9a362afc)
2013-01-21 01:18:25 +00:00
#include <cogl/cogl-output.h>
Moves all GLX code down from Clutter to Cogl This migrates all the GLX window system code down from the Clutter backend code into a Cogl winsys. Moving OpenGL window system binding code down from Clutter into Cogl is the biggest blocker to having Cogl become a standalone 3D graphics library, so this is an important step in that direction.
2010-11-05 12:28:33 +00:00
#include <cogl/cogl-display.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-05 00:00:25 +00:00
#include <cogl/cogl-context.h>
cogl-buffer: add an abstract class around openGL's buffer objects Buffer objects are cool! This abstracts the buffer API first introduced by GL_ARB_vertex_buffer_object and then extended to other objects. The coglBuffer abstract class is intended to be the base class of all the buffer objects, letting the user map() buffers. If the underlying implementation does not support buffer objects (or only support VBO but not FBO for instance), fallback paths should be provided.
2010-01-10 17:28:24 +00:00
#include <cogl/cogl-buffer.h>
Rename CoglPixelArray to CoglPixelBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to strongly imply a relationship between CoglBuffers and CoglPixelBuffers and be consistent with the CoglAttributeBuffer and CoglIndexBuffer APIs.
2011-03-02 15:19:57 +00:00
#include <cogl/cogl-pixel-buffer.h>
math: Adds an experimental cogl_vector3_* API This adds a math utility API for handling 3 component, single precision float vectors with the following; mostly self explanatory functions: cogl_vector3_init cogl_vector3_init_zero cogl_vector3_equal cogl_vector3_equal_with_epsilon cogl_vector3_copy cogl_vector3_free cogl_vector3_invert cogl_vector3_add cogl_vector3_subtract cogl_vector3_multiply_scalar cogl_vector3_divide_scalar cogl_vector3_normalize cogl_vector3_magnitude cogl_vector3_cross_product cogl_vector3_dot_product cogl_vector3_distance Since the API is experimental you will need to define COGL_ENABLE_EXPERIMENTAL_API before including cogl.h if you want to use the API.
2010-05-20 13:54:44 +00:00
#include <cogl/cogl-vector.h>
math: Adds an experimental euler API This adds an experimental CoglEuler data type and the following new functions: cogl_euler_init cogl_euler_init_from_matrix cogl_euler_init_from_quaternion cogl_euler_equal cogl_euler_copy cogl_euler_free cogl_quaternion_init_from_euler Since this is experimental API you need to define COGL_ENABLE_EXPERIMENTAL_API before including cogl.h
2010-02-25 01:40:29 +00:00
#include <cogl/cogl-euler.h>
math: Adds an experimental quaternion API This adds an experimental quaternion utility API. It's not yet fully documented but it's complete enough that people can start to experiment with using it. It adds the following functions: cogl_quaternion_init_identity cogl_quaternion_init cogl_quaternion_init_from_angle_vector cogl_quaternion_init_from_array cogl_quaternion_init_from_x_rotation cogl_quaternion_init_from_y_rotation cogl_quaternion_init_from_z_rotation cogl_quaternion_equal cogl_quaternion_copy cogl_quaternion_free cogl_quaternion_get_rotation_angle cogl_quaternion_get_rotation_axis cogl_quaternion_normalize cogl_quaternion_dot_product cogl_quaternion_invert cogl_quaternion_multiply cogl_quaternion_pow cogl_quaternion_slerp cogl_quaternion_nlerp cogl_quaternion_squad cogl_get_static_identity_quaternion cogl_get_static_zero_quaternion Since it's experimental API you'll need to define COGL_ENABLE_EXPERIMENTAL_API before including cogl.h.
2010-02-25 01:40:29 +00:00
#include <cogl/cogl-quaternion.h>
Make CoglTexture2D public as experimental API This exposes a CoglTexture2D typedef and adds the following experimental API: cogl_is_texture_2d cogl_texture_2d_new_with_size cogl_texture_2d_new_from_data cogl_texture_2d_new_from_foreign Since this is experimental API you need to define COGL_ENABLE_EXPERIMENTAL_API before including cogl.h. Note: With these new entrypoints we now expect a CoglContext pointer to be passed in, instead of assuming there is a default context. The aim is that for Cogl 2.0 we won't have a default context so this is a step in that direction.
2011-05-16 23:05:54 +00:00
#include <cogl/cogl-texture-2d.h>
texture-2d: factor out all GL specific code This factors out all of the OpenGL specific code in cogl-texture-2d.c into cogl-texture-2d-gl.c and where necessary adds indirection through the CoglDriver vtable so that we can eventually start to experiment with non-OpenGL backends for Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit ec57588671696bbe7ce714bdfe7324236146c9c0)
2012-09-10 20:45:33 +00:00
#include <cogl/cogl-texture-2d-gl.h>
texture: Make CoglTextureRectangle experimentally public This exposes CoglTextureRectangle in the experimental cogl 2.0 api. For now we just expose a single constructor; cogl_texture_rectangle_new_with_size() but we can add more later. This is part of going work to improve our texture apis with more emphasis on providing low-level access to the varying semantics of different texture types understood by the gpu instead of only trying to present a lowest common denominator api. CoglTextureRectangle is notably useful for never being restricted to power of two sizes and for being sampled with non-normalized texture coordinates which can be convenient for use a lookup tables in glsl due to not needing separate uniforms for mapping normalized coordinates to texels. Unlike CoglTexture2D though rectangle textures can't have a mipmap and they only support the _CLAMP_TO_EDGE wrap mode. Applications wanting to use CoglTextureRectangle should first check cogl_has_feature (COGL_FEATURE_ID_TEXTURE_RECTANGLE). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-14 08:25:12 +00:00
#include <cogl/cogl-texture-rectangle.h>
Add a Cogl texture 3D backend This adds a publicly exposed experimental API for a 3D texture backend. There is a feature flag which can be checked for whether 3D textures are supported. Although we require OpenGL 1.2 which has 3D textures in core, GLES only provides them through an extension so the feature can be used to detect that. The textures can be created with one of two new API functions :- cogl_texture_3d_new_with_size and cogl_texture_3d_new_from_data There is also internally a new_from_bitmap function. new_from_data is implemented in terms of this function. The two constructors are effectively the only way to upload data to a 3D texture. It does not work to call glTexImage2D with the GL_TEXTURE_3D target so the virtual for cogl_texture_set_region does nothing. It would be possible to make cogl_texture_get_data do something sensible like returning all of the images as a single long image but this is not currently implemented and instead the virtual just always fails. We may want to add API specific to the 3D texture backend to get and set a sub region of the texture. All of those three functions can throw a GError. This will happen if the GPU does not support 3D textures or it does not support NPOTs and an NPOT size is requested. It will also fail if the FBO extension is not supported and the COGL_TEXTURE_NO_AUTO_MIPMAP flag is not given. This could be avoided by copying the code for the GL_GENERATE_MIPMAP TexParameter fallback, but in the interests of keeping the code simple this is not yet done. This adds a couple of functions to cogl-texture-driver for uploading 3D data and querying the 3D proxy texture. prep_gl_for_pixels_upload_full now also takes sets the GL_UNPACK_IMAGE_HEIGHT parameter so that 3D textures can have padding between the images. Whenever 3D texture is uploading, both the height of the images and the height of all of the data is specified (either explicitly or implicilty from the CoglBitmap) so that the image height can be deduced by dividing by the depth.
2010-07-01 21:04:59 +00:00
#include <cogl/cogl-texture-3d.h>
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
#include <cogl/cogl-texture-2d-sliced.h>
texture: Make CoglSubTexture experimental public api This exposes cogl_sub_texture_new() and cogl_is_sub_texture() as experimental public API. Previously sub-textures were only exposed via cogl_texture_new_from_sub_texture() so there wasn't a corresponding CoglSubTexture type. A CoglSubTexture is a high-level texture defined as a sub-region of some other parent texture. CoglSubTextures are high level textures that implement the CoglMetaTexture interface which can be used to manually handle texture repeating. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-21 10:36:25 +00:00
#include <cogl/cogl-sub-texture.h>
meta-texture: This publicly exposes CoglMetaTexture CoglMetaTexture is an interface for dealing with high level textures that may be comprised of one or more low-level textures internally. The interface allows the development of primitive drawing APIs that can draw with high-level textures (such as atlas textures) even though the GPU doesn't natively understand these texture types. There is currently just one function that's part of this interface: cogl_meta_texture_foreach_in_region() which allows an application to resolve the internal, low-level textures of a high-level texture. cogl_rectangle() uses this API for example so that it can easily emulate the _REPEAT wrap mode for textures that the hardware can't natively handle repeating of. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 13:13:03 +00:00
#include <cogl/cogl-meta-texture.h>
Add a CoglPrimitiveTexture interface This interface represents any textures that are backed by a single texture in GL and that can be used directly with the cogl_framebuffer_draw_attributes family of functions. This currently equates to CoglTexture2D, CoglTexture3D and CoglTextureRectangle. The interface currently has only one method called cogl_primitive_set_auto_mipmap. This replaces the COGL_TEXTURE_NO_AUTO_MIPMAP flag from the CoglTextureFlags parameter in the constructors. None of the other flags in CoglTextureFlags make sense for primitive textures so it doesn't seem like a good idea to need them for primitive constructors. There is a boolean in the vtable to mark whether a texture type is primitive which the new cogl_is_primitive function uses. There is also a new texture virtual called set_auto_mipmap which is only required to be implemented for primitive textures. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-04-04 14:09:43 +00:00
#include <cogl/cogl-primitive-texture.h>
Rename CoglIndexArray to CoglIndexBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to strongly imply a relationship between CoglBuffers and CoglIndexBuffers and be consistent with the CoglAttributeBuffer and CoglPixelBuffer APIs.
2011-03-02 23:31:19 +00:00
#include <cogl/cogl-index-buffer.h>
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
#include <cogl/cogl-attribute-buffer.h>
cogl: Adds experimental CoglIndices API CoglIndices define a range of indices inside a CoglIndexArray. I.e. a CoglIndexArray is simply a buffer of N bytes and you can then instantiate multiple CoglIndices collections that define a sub-region of a CoglIndexArray by specifying a start offset and an index data type.
2010-10-12 11:48:58 +00:00
#include <cogl/cogl-indices.h>
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
#include <cogl/cogl-attribute.h>
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
#include <cogl/cogl-primitive.h>
Add CoglDepthState API Instead of simply extending the cogl_pipeline_ namespace to add api for controlling the depth testing state we now break the api out. This adds a CoglDepthState type that can be stack allocated. The members of the structure are private but we have the following API to setup the state: cogl_depth_state_init cogl_depth_state_set_test_enabled cogl_depth_state_get_test_enabled cogl_depth_state_set_test_function cogl_depth_state_get_test_function cogl_depth_state_set_writing_enabled cogl_depth_state_get_writing_enabled cogl_depth_state_set_range cogl_depth_state_get_range This removes the following experimental API which is now superseded: cogl_material_set_depth_test_enabled cogl_material_get_depth_test_enabled cogl_material_set_depth_test_function cogl_material_get_depth_test_function cogl_material_set_depth_writing_enabled cogl_material_get_depth_writing_enabled cogl_material_set_depth_range cogl_material_get_depth_range Once a CoglDepthState structure is setup it can be set on a pipeline using cogl_pipeline_set_depth_state().
2011-04-14 17:12:03 +00:00
#include <cogl/cogl-depth-state.h>
cogl: rename CoglMaterial -> CoglPipeline This applies an API naming change that's been deliberated over for a while now which is to rename CoglMaterial to CoglPipeline. For now the new pipeline API is marked as experimental and public headers continue to talk about materials not pipelines. The CoglMaterial API is now maintained in terms of the cogl_pipeline API internally. Currently this API is targeting Cogl 2.0 so we will have time to integrate it properly with other upcoming Cogl 2.0 work. The basic reasons for the rename are: - That the term "material" implies to many people that they are constrained to fragment processing; perhaps as some kind of high-level texture abstraction. - In Clutter they get exposed by ClutterTexture actors which may be re-inforcing this misconception. - When comparing how other frameworks use the term material, a material sometimes describes a multi-pass fragment processing technique which isn't the case in Cogl. - In code, "CoglPipeline" will hopefully be a much more self documenting summary of what these objects represent; a full GPU pipeline configuration including, for example, vertex processing, fragment processing and blending. - When considering the API documentation story, at some point we need a document introducing developers to how the "GPU pipeline" works so it should become intuitive that CoglPipeline maps back to that description of the GPU pipeline. - This is consistent in terminology and concept to OpenGL 4's new pipeline object which is a container for program objects. Note: The cogl-material.[ch] files have been renamed to cogl-material-compat.[ch] because otherwise git doesn't seem to treat the change as a moving the old cogl-material.c->cogl-pipeline.c and so we loose all our git-blame history.
2010-10-27 17:54:57 +00:00
#include <cogl/cogl-pipeline.h>
pipeline: split out all core state apis Since cogl-pipeline.c has become very unwieldy this make a start at trying to shape this code back into a manageable state. This patche moves all the API relating to core pipeline state into cogl-pipeline-state.c. This doesn't move code relating to layer state out nor does it move any of the code supporting the core design of CoglPipeline itself. This change alone factors out 2k lines of code from cogl-pipeline.c which is obviously a good start. The next step will be to factor out the layer state and then probably look at breaking all of this state code down into state-groups. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-09-07 22:44:37 +00:00
#include <cogl/cogl-pipeline-state.h>
pipeline: split out all layer state apis As part of an on-going effort to get cogl-pipeline.c into a more maintainable state this splits out all the apis relating just to layer state. This just leaves code relating to the core CoglPipeline and CoglPipelineLayer design left in cogl-pipeline.c. This splits out around 2k more lines from cogl-pipeline.c although we are still left with nearly 4k lines so we still have some way to go! Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-09-07 23:42:22 +00:00
#include <cogl/cogl-pipeline-layer-state.h>
Add a CoglSnippet type This adds a CoglObject called CoglSnippet which will be used to store strings used as GLSL snippets to be attached at hook points to a CoglPipeline. The snippets can currently contain three strings: declarations - This will be placed in the global scope and is intended to be used to declare uniforms, attributes and functions. pre - This will be inserted before the hook point. post - This will be inserted after the hook point. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-17 16:38:49 +00:00
#include <cogl/cogl-snippet.h>
Moves all GLX code down from Clutter to Cogl This migrates all the GLX window system code down from the Clutter backend code into a Cogl winsys. Moving OpenGL window system binding code down from Clutter into Cogl is the biggest blocker to having Cogl become a standalone 3D graphics library, so this is an important step in that direction.
2010-11-05 12:28:33 +00:00
#include <cogl/cogl-framebuffer.h>
framebuffer: split out CoglOnscreen code This factors out the CoglOnscreen code from cogl-framebuffer.c so we now have cogl-onscreen.c, cogl-onscreen.h and cogl-onscreen-private.h. Notably some of the functions pulled out are currently namespaced as cogl_framebuffer but we know we are planning on renaming them to be in the cogl_onscreen namespace; such as cogl_framebuffer_swap_buffers(). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 20:31:04 +00:00
#include <cogl/cogl-onscreen.h>
onscreen: Add CoglFrameInfo and _add_frame_callback() api Add a CoglFrameInfo object that tracks timing information for frames that are drawn. We track a frame counter and frame timing information for each CoglOnscreen. Internally a CoglFrameInfo is automatically created for each frame, delimited by cogl_onscreen_swap_buffers() or cogl_onscreen_swap_region() calls. CoglFrameInfos are delivered to applications via frame event callbacks that can be registered with a new cogl_onscreen_add_frame_callback() api. Two initial event types (dispatched on all platforms) have been defined; a _SYNC event used for throttling the frame rate of applications and a _COMPLETE event used so signify the end of a frame. Note: This new _add_frame_callback() api makes the cogl_onscreen_add_swap_complete_callback() api redundant and so it should be considered deprecated. Since the _add_swap_complete_callback() api is still experimental api, we will be looking to quickly migrate users to the new api so we can remove the old api. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 700401667db2522045e4623d78797b17f9184501)
2012-11-12 16:58:10 +00:00
#include <cogl/cogl-frame-info.h>
Add support for main loop integration This adds two new functions: void cogl_poll_get_info (CoglContext *context, CoglPollFD **poll_fds, int *n_poll_fds, gint64 *timeout); void cogl_poll_dispatch (CoglContext *context, const CoglPollFD *poll_fds, int n_poll_fds); The application is expected to call the first function whenever it is about to block to go idle, and the second function whenever it comes out of idle. This gives Cogl winsys's the ability poll file descriptors for events. For example when handing swap complete notifications, it can report that it needs to block on a file descriptor. The two functions are backed by winsys virtual functions. There are currently no implementations. The default handler for get_info just reports no file descriptors and an infinite timeout. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-16 17:49:28 +00:00
#include <cogl/cogl-poll.h>
Add fence API cogl_framebuffer_add_fence creates a synchronisation fence, which will invoke a user-specified callback when the GPU has finished executing all commands provided to it up to that point in time. Support is currently provided for GL 3.x's GL_ARB_sync extension, and EGL's EGL_KHR_fence_sync (when used with OpenGL ES). Signed-off-by: Daniel Stone <daniel@fooishbar.org> Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> https://bugzilla.gnome.org/show_bug.cgi?id=691752 (cherry picked from commit e6d37470da9294adc1554c0a8c91aa2af560ed9f)
2013-01-11 01:13:34 +00:00
#include <cogl/cogl-fence.h>
kms: Adds api to get at the kms file descriptor This adds a cogl_kms_renderer_get_kms_fd() function that lets developers access the kms file descriptor being used for controlling the kernel mode setting. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-23 15:37:51 +00:00
#if defined (COGL_HAS_EGL_PLATFORM_KMS_SUPPORT)
#include <cogl/cogl-kms-renderer.h>
kms: defer setting crtc modes until first swap buffers Instead of creating a dummy framebuffer allocation just so we can setup crtc modes during display_setup we now wait until the first swap_buffers request before setting up the crtc modes. This patch also adds a cogl_kms_display_queue_modes_reset() function that allows developers to explicitly queue a reset of the crtc modes. The idea is that applications that handle VT switching can use this for VT enter events to explicitly ensure their mode is restored since modes are often not automatically restored correctly. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-30 11:06:41 +00:00
#include <cogl/cogl-kms-display.h>
kms: Adds api to get at the kms file descriptor This adds a cogl_kms_renderer_get_kms_fd() function that lets developers access the kms file descriptor being used for controlling the kernel mode setting. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-23 15:37:51 +00:00
#endif
Adds initial GLES2 integration support This makes it possible to integrate existing GLES2 code with applications using Cogl as the rendering api. Currently all GLES2 usage is handled with separate GLES2 contexts to ensure that GLES2 api usage doesn't interfere with Cogl's own use of OpenGL[ES]. The api has been designed though so we can provide tighter integration later. The api would allow us to support GLES2 virtualized on top of an OpenGL/GLX driver as well as GLES2 virtualized on the core rendering api of Cogl itself. Virtualizing the GLES2 support on Cogl will allow us to take advantage of Cogl debugging facilities as well as let us optimize the cost of allocating multiple GLES2 contexts and switching between them which can both be very expensive with many drivers. As as a side effect of this patch Cogl can also now be used as a portable window system binding API for GLES2 as an alternative to EGL. Parts of this patch are based on work done by Tomeu Vizoso <tomeu.vizoso@collabora.com> who did the first iteration of adding GLES2 API support to Cogl so that WebGL support could be added to webkit-clutter. This patch adds a very minimal cogl-gles2-context example that shows how to create a gles2 context, clear the screen to a random color and also draw a triangle with the cogl api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 4bb6eff3dbd50d8fef7d6bdbed55c5aaa70036a8)
2012-03-06 03:21:30 +00:00
#ifdef COGL_HAS_WIN32_SUPPORT
Include cogl-win32-renderer.h in cogl.h on Windows Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-07-14 08:22:26 +00:00
#include <cogl/cogl-win32-renderer.h>
#endif
Add a utility to make a GSource out of a CoglContext The GSource is created using cogl_glib_source_new which takes a pointer to a CoglContext. The source calls cogl_poll_get_info() in its prepare function and cogl_poll_dispatch() in its dispatch function. The poll FDs on the source are updated according to what Cogl reports. The header is only included and the source only compiled if Cogl is configured with GLib support. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 14:38:28 +00:00
#ifdef COGL_HAS_GLIB_SUPPORT
#include <cogl/cogl-glib-source.h>
#endif
Moves all GLX code down from Clutter to Cogl This migrates all the GLX window system code down from the Clutter backend code into a Cogl winsys. Moving OpenGL window system binding code down from Clutter into Cogl is the biggest blocker to having Cogl become a standalone 3D graphics library, so this is an important step in that direction.
2010-11-05 12:28:33 +00:00
/* XXX: This will definitly go away once all the Clutter winsys
* code has been migrated down into Cogl! */
#include <cogl/cogl-clutter.h>
cogl-buffer: add an abstract class around openGL's buffer objects Buffer objects are cool! This abstracts the buffer API first introduced by GL_ARB_vertex_buffer_object and then extended to other objects. The coglBuffer abstract class is intended to be the base class of all the buffer objects, letting the user map() buffers. If the underlying implementation does not support buffer objects (or only support VBO but not FBO for instance), fallback paths should be provided.
2010-01-10 17:28:24 +00:00
#endif
Rework sdl integration api This re-works the SDL integration api to simplify the integration for application developers and also allow Cogl to know when the application is about to go idle waiting for events so it can perform idle book-keeping work. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-04-06 10:16:19 +00:00
#ifdef COGL_HAS_SDL_SUPPORT
#include <cogl/cogl-sdl.h>
#endif
cogl-buffer: add an abstract class around openGL's buffer objects Buffer objects are cool! This abstracts the buffer API first introduced by GL_ARB_vertex_buffer_object and then extended to other objects. The coglBuffer abstract class is intended to be the base class of all the buffer objects, letting the user map() buffers. If the underlying implementation does not support buffer objects (or only support VBO but not FBO for instance), fallback paths should be provided.
2010-01-10 17:28:24 +00:00
cogl.h: Exclude 1.x headers if 2.0 api requested Now if COGL_ENABLE_EXPERIMENTAL_2_0_API has been defined when including cogl.h then headers that correspond to 1.x only apis that we plan to drop won't be included any more. If COGL_ENABLE_EXPERIMENTAL_API is defined then you can still mix and match 2.0 api with 1.x api in a single compilation unit. Note: it's still possible that some 1.x symbols will still be available when COGL_ENABLE_EXPERIMENTAL_2_0_API is defined since this patch doesn't go through the shared headers adding guards around deprecated functions. This only affects people playing with the experimental api. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-18 01:41:20 +00:00
/*
* 2.0 only api...
*/
#ifdef COGL_ENABLE_EXPERIMENTAL_2_0_API
#include <cogl/cogl2-path.h>
Add compatibility API for functions removed after 1.9.8 The cleanup in 185630085 removed some symbols that were previously exported as public experimental API in Cogl 1.9.8. That release is already well after the point where we were meant to freeze the ABI so we probably shouldn't be breaking it again. This patch adds the removed functions back in so that for 1.9.10 we won't have to bump the soname. The symbols are bundled together in a new file called cogl2-compatibility.c so that they will be easy to remove again after we can break ABI. It is expected that we will revert this patch immediately after branching for Cogl 1.10. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-09 16:09:13 +00:00
/* This header will be removed in Cogl 1.12 */
#include <cogl/cogl2-compatibility.h>
cogl.h: Exclude 1.x headers if 2.0 api requested Now if COGL_ENABLE_EXPERIMENTAL_2_0_API has been defined when including cogl.h then headers that correspond to 1.x only apis that we plan to drop won't be included any more. If COGL_ENABLE_EXPERIMENTAL_API is defined then you can still mix and match 2.0 api with 1.x api in a single compilation unit. Note: it's still possible that some 1.x symbols will still be available when COGL_ENABLE_EXPERIMENTAL_2_0_API is defined since this patch doesn't go through the shared headers adding guards around deprecated functions. This only affects people playing with the experimental api. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-18 01:41:20 +00:00
#endif
/*
* API deprecations
*/
#include <cogl/cogl-deprecated.h>
2008-06-12 Emmanuele Bassi <ebassi@openedhand.com> * doc/reference/cogl/Makefile.am: Ignore cogl/gl and cogl/gles when building the documentation. * clutter/cogl/cogl.h.in: Add sections in the header file.
2008-06-12 17:21:16 +00:00
/**
* SECTION:cogl
* @short_description: General purpose API
*
* General utility functions for COGL.
*/
2008-10-30 Emmanuele Bassi <ebassi@linux.intel.com> Bug 1212 - Allow only a single include file for Clutter * clutter/*.h: Only allow including clutter.h in third party code. * clutter/cogl/cogl-color.h: * clutter/cogl/cogl-fixed.h: * clutter/cogl/cogl.h.in: Only allow including cogl.h in third party code. * clutter/cogl/common/Makefile.am: * clutter/cogl/gl/Makefile.am: * clutter/cogl/gles/Makefile.am: * clutter/eglnative/Makefile.am: * clutter/eglx/Makefile.am: * clutter/fruity/Makefile.am: * clutter/glx/Makefile.am: * clutter/glx/clutter-glx.h: * clutter/osx/Makefile.am: * clutter/pango/Makefile.am: * clutter/sdl/Makefile.am: * clutter/win32/Makefile.am: * clutter/x11/Makefile.am: Fix build environment. * clutter/x11/clutter-x11-texture-pixmap.h: * clutter/x11/clutter-x11.h: Fix inclusion rules. * tests/test-pixmap.c: Fix inclusion of GdkPixbuf header. * README: Update release notes.
2008-10-30 17:04:34 +00:00
#undef __COGL_H_INSIDE__
Merged clutter-ivan branch into trunk. svn merge \ https://svn.o-hand.com/repos/clutter/trunk/clutter@2509 \ https://svn.o-hand.com/repos/clutter/branches/clutter-ivan@HEAD
2008-04-25 13:37:36 +00:00
#endif /* __COGL_H__ */
Reference in New Issue Copy Permalink