isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-12-27 05:12:15 +00:00
Code Issues Packages Projects Releases Wiki Activity
01e744455d
mutter/cogl/cogl.h

144 lines
3.7 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__
#include <glib.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>
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>
#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>
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>
#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: 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>
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>
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>
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>
#endif
Fix testing of undefined macro constants to check for definedness instead Reviewed-By: Robert Bragg <robert@linux.intel.com>
2011-07-02 11:39:56 +00:00
#if defined (COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT)
Updates wayland symbol names to be consistent This updates the public wayland symbols to follow the pattern cogl_wayland_blah instead of cogl_blah_wayland. Signed-off-by: Neil Roberts <neil@linux.intel.com>
2011-06-28 13:57:05 +00:00
#include <cogl/cogl-wayland-renderer.h>
#endif
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
#if COGL_HAS_WIN32_SUPPORT
#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
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>
#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