2009-04-27 10:48:12 -04:00
|
|
|
/*
|
|
|
|
|
* Cogl
|
|
|
|
|
*
|
|
|
|
|
* An object oriented GL/GLES Abstraction/Utility Layer
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) 2007,2008,2009 Intel Corporation.
|
|
|
|
|
*
|
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
|
* version 2 of the License, or (at your option) any later version.
|
|
|
|
|
*
|
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
|
*
|
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
2010-03-01 07:56:10 -05:00
|
|
|
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
*
|
|
|
|
|
*
|
2009-04-27 10:48:12 -04:00
|
|
|
*/
|
|
|
|
|
|
2012-06-20 13:49:08 -04:00
|
|
|
#if !defined(__COGL_H_INSIDE__) && !defined(COGL_COMPILATION)
|
Adds a CoglMaterial abstraction, which includes support for multi-texturing
My previous work to provide muti-texturing support has been extended into
a CoglMaterial abstraction that adds control over the texture combine
functions (controlling how multiple texture layers are blended together),
the gl blend function (used for blending the final primitive with the
framebuffer), the alpha function (used to discard fragments based on
their alpha channel), describing attributes such as a diffuse, ambient and
specular color (for use with the standard OpenGL lighting model), and
per layer rotations. (utilizing the new CoglMatrix utility API)
For now the only way this abstraction is exposed is via a new
cogl_material_rectangle function, that is similar to cogl_texture_rectangle
but doesn't take a texture handle (the source material is pulled from
the context), and the array of texture coordinates is extended to be able
to supply coordinates for each layer.
Note: this function doesn't support sliced textures; supporting sliced
textures is a non trivial problem, considering the ability to rotate layers.
Note: cogl_material_rectangle, has quite a few workarounds, for a number of
other limitations within Cogl a.t.m.
Note: The GLES1/2 multi-texturing support has yet to be updated to use
the material abstraction.
2008-12-11 15:11:30 -05:00
|
|
|
#error "Only <cogl/cogl.h> can be included directly."
|
|
|
|
|
#endif
|
|
|
|
|
|
2010-10-27 13:54:57 -04:00
|
|
|
#ifndef __COGL_PIPELINE_H__
|
|
|
|
|
#define __COGL_PIPELINE_H__
|
Adds a CoglMaterial abstraction, which includes support for multi-texturing
My previous work to provide muti-texturing support has been extended into
a CoglMaterial abstraction that adds control over the texture combine
functions (controlling how multiple texture layers are blended together),
the gl blend function (used for blending the final primitive with the
framebuffer), the alpha function (used to discard fragments based on
their alpha channel), describing attributes such as a diffuse, ambient and
specular color (for use with the standard OpenGL lighting model), and
per layer rotations. (utilizing the new CoglMatrix utility API)
For now the only way this abstraction is exposed is via a new
cogl_material_rectangle function, that is similar to cogl_texture_rectangle
but doesn't take a texture handle (the source material is pulled from
the context), and the array of texture coordinates is extended to be able
to supply coordinates for each layer.
Note: this function doesn't support sliced textures; supporting sliced
textures is a non trivial problem, considering the ability to rotate layers.
Note: cogl_material_rectangle, has quite a few workarounds, for a number of
other limitations within Cogl a.t.m.
Note: The GLES1/2 multi-texturing support has yet to be updated to use
the material abstraction.
2008-12-11 15:11:30 -05:00
|
|
|
|
2012-02-18 11:03:10 -05:00
|
|
|
/* We forward declare the CoglPipeline type here to avoid some circular
|
|
|
|
|
* dependency issues with the following headers.
|
|
|
|
|
*/
|
|
|
|
|
typedef struct _CoglPipeline CoglPipeline;
|
|
|
|
|
|
Adds a CoglMaterial abstraction, which includes support for multi-texturing
My previous work to provide muti-texturing support has been extended into
a CoglMaterial abstraction that adds control over the texture combine
functions (controlling how multiple texture layers are blended together),
the gl blend function (used for blending the final primitive with the
framebuffer), the alpha function (used to discard fragments based on
their alpha channel), describing attributes such as a diffuse, ambient and
specular color (for use with the standard OpenGL lighting model), and
per layer rotations. (utilizing the new CoglMatrix utility API)
For now the only way this abstraction is exposed is via a new
cogl_material_rectangle function, that is similar to cogl_texture_rectangle
but doesn't take a texture handle (the source material is pulled from
the context), and the array of texture coordinates is extended to be able
to supply coordinates for each layer.
Note: this function doesn't support sliced textures; supporting sliced
textures is a non trivial problem, considering the ability to rotate layers.
Note: cogl_material_rectangle, has quite a few workarounds, for a number of
other limitations within Cogl a.t.m.
Note: The GLES1/2 multi-texturing support has yet to be updated to use
the material abstraction.
2008-12-11 15:11:30 -05:00
|
|
|
#include <cogl/cogl-types.h>
|
2012-02-18 11:03:10 -05:00
|
|
|
#include <cogl/cogl-context.h>
|
2011-11-17 11:52:21 -05:00
|
|
|
#include <cogl/cogl-snippet.h>
|
Adds a CoglMaterial abstraction, which includes support for multi-texturing
My previous work to provide muti-texturing support has been extended into
a CoglMaterial abstraction that adds control over the texture combine
functions (controlling how multiple texture layers are blended together),
the gl blend function (used for blending the final primitive with the
framebuffer), the alpha function (used to discard fragments based on
their alpha channel), describing attributes such as a diffuse, ambient and
specular color (for use with the standard OpenGL lighting model), and
per layer rotations. (utilizing the new CoglMatrix utility API)
For now the only way this abstraction is exposed is via a new
cogl_material_rectangle function, that is similar to cogl_texture_rectangle
but doesn't take a texture handle (the source material is pulled from
the context), and the array of texture coordinates is extended to be able
to supply coordinates for each layer.
Note: this function doesn't support sliced textures; supporting sliced
textures is a non trivial problem, considering the ability to rotate layers.
Note: cogl_material_rectangle, has quite a few workarounds, for a number of
other limitations within Cogl a.t.m.
Note: The GLES1/2 multi-texturing support has yet to be updated to use
the material abstraction.
2008-12-11 15:11:30 -05:00
|
|
|
|
2012-11-22 13:01:10 -05:00
|
|
|
COGL_BEGIN_DECLS
|
2011-09-08 19:40:06 -04:00
|
|
|
|
2011-09-07 20:21:24 -04:00
|
|
|
#ifdef COGL_ENABLE_EXPERIMENTAL_API
|
|
|
|
|
|
Adds a CoglMaterial abstraction, which includes support for multi-texturing
My previous work to provide muti-texturing support has been extended into
a CoglMaterial abstraction that adds control over the texture combine
functions (controlling how multiple texture layers are blended together),
the gl blend function (used for blending the final primitive with the
framebuffer), the alpha function (used to discard fragments based on
their alpha channel), describing attributes such as a diffuse, ambient and
specular color (for use with the standard OpenGL lighting model), and
per layer rotations. (utilizing the new CoglMatrix utility API)
For now the only way this abstraction is exposed is via a new
cogl_material_rectangle function, that is similar to cogl_texture_rectangle
but doesn't take a texture handle (the source material is pulled from
the context), and the array of texture coordinates is extended to be able
to supply coordinates for each layer.
Note: this function doesn't support sliced textures; supporting sliced
textures is a non trivial problem, considering the ability to rotate layers.
Note: cogl_material_rectangle, has quite a few workarounds, for a number of
other limitations within Cogl a.t.m.
Note: The GLES1/2 multi-texturing support has yet to be updated to use
the material abstraction.
2008-12-11 15:11:30 -05:00
|
|
|
/**
|
2010-10-27 13:54:57 -04:00
|
|
|
* SECTION:cogl-pipeline
|
|
|
|
|
* @short_description: Functions for creating and manipulating the GPU
|
|
|
|
|
* pipeline
|
Adds a CoglMaterial abstraction, which includes support for multi-texturing
My previous work to provide muti-texturing support has been extended into
a CoglMaterial abstraction that adds control over the texture combine
functions (controlling how multiple texture layers are blended together),
the gl blend function (used for blending the final primitive with the
framebuffer), the alpha function (used to discard fragments based on
their alpha channel), describing attributes such as a diffuse, ambient and
specular color (for use with the standard OpenGL lighting model), and
per layer rotations. (utilizing the new CoglMatrix utility API)
For now the only way this abstraction is exposed is via a new
cogl_material_rectangle function, that is similar to cogl_texture_rectangle
but doesn't take a texture handle (the source material is pulled from
the context), and the array of texture coordinates is extended to be able
to supply coordinates for each layer.
Note: this function doesn't support sliced textures; supporting sliced
textures is a non trivial problem, considering the ability to rotate layers.
Note: cogl_material_rectangle, has quite a few workarounds, for a number of
other limitations within Cogl a.t.m.
Note: The GLES1/2 multi-texturing support has yet to be updated to use
the material abstraction.
2008-12-11 15:11:30 -05:00
|
|
|
*
|
2010-10-27 13:54:57 -04:00
|
|
|
* Cogl allows creating and manipulating objects representing the full
|
|
|
|
|
* configuration of the GPU pipeline. In simplified terms the GPU
|
|
|
|
|
* pipeline takes primitive geometry as the input, it first performs
|
|
|
|
|
* vertex processing, allowing you to deform your geometry, then
|
|
|
|
|
* rasterizes that (turning it from pure geometry into fragments) then
|
|
|
|
|
* performs fragment processing including depth testing and texture
|
|
|
|
|
* mapping. Finally it blends the result with the framebuffer.
|
Adds a CoglMaterial abstraction, which includes support for multi-texturing
My previous work to provide muti-texturing support has been extended into
a CoglMaterial abstraction that adds control over the texture combine
functions (controlling how multiple texture layers are blended together),
the gl blend function (used for blending the final primitive with the
framebuffer), the alpha function (used to discard fragments based on
their alpha channel), describing attributes such as a diffuse, ambient and
specular color (for use with the standard OpenGL lighting model), and
per layer rotations. (utilizing the new CoglMatrix utility API)
For now the only way this abstraction is exposed is via a new
cogl_material_rectangle function, that is similar to cogl_texture_rectangle
but doesn't take a texture handle (the source material is pulled from
the context), and the array of texture coordinates is extended to be able
to supply coordinates for each layer.
Note: this function doesn't support sliced textures; supporting sliced
textures is a non trivial problem, considering the ability to rotate layers.
Note: cogl_material_rectangle, has quite a few workarounds, for a number of
other limitations within Cogl a.t.m.
Note: The GLES1/2 multi-texturing support has yet to be updated to use
the material abstraction.
2008-12-11 15:11:30 -05:00
|
|
|
*/
|
2010-06-22 09:02:17 -04:00
|
|
|
|
2010-10-27 13:54:57 -04:00
|
|
|
#define COGL_PIPELINE(OBJECT) ((CoglPipeline *)OBJECT)
|
2010-06-22 09:02:17 -04:00
|
|
|
|
Adds a CoglMaterial abstraction, which includes support for multi-texturing
My previous work to provide muti-texturing support has been extended into
a CoglMaterial abstraction that adds control over the texture combine
functions (controlling how multiple texture layers are blended together),
the gl blend function (used for blending the final primitive with the
framebuffer), the alpha function (used to discard fragments based on
their alpha channel), describing attributes such as a diffuse, ambient and
specular color (for use with the standard OpenGL lighting model), and
per layer rotations. (utilizing the new CoglMatrix utility API)
For now the only way this abstraction is exposed is via a new
cogl_material_rectangle function, that is similar to cogl_texture_rectangle
but doesn't take a texture handle (the source material is pulled from
the context), and the array of texture coordinates is extended to be able
to supply coordinates for each layer.
Note: this function doesn't support sliced textures; supporting sliced
textures is a non trivial problem, considering the ability to rotate layers.
Note: cogl_material_rectangle, has quite a few workarounds, for a number of
other limitations within Cogl a.t.m.
Note: The GLES1/2 multi-texturing support has yet to be updated to use
the material abstraction.
2008-12-11 15:11:30 -05:00
|
|
|
/**
|
2010-10-27 13:54:57 -04:00
|
|
|
* cogl_pipeline_new:
|
2012-02-18 11:03:10 -05:00
|
|
|
* @context: a #CoglContext
|
Adds a CoglMaterial abstraction, which includes support for multi-texturing
My previous work to provide muti-texturing support has been extended into
a CoglMaterial abstraction that adds control over the texture combine
functions (controlling how multiple texture layers are blended together),
the gl blend function (used for blending the final primitive with the
framebuffer), the alpha function (used to discard fragments based on
their alpha channel), describing attributes such as a diffuse, ambient and
specular color (for use with the standard OpenGL lighting model), and
per layer rotations. (utilizing the new CoglMatrix utility API)
For now the only way this abstraction is exposed is via a new
cogl_material_rectangle function, that is similar to cogl_texture_rectangle
but doesn't take a texture handle (the source material is pulled from
the context), and the array of texture coordinates is extended to be able
to supply coordinates for each layer.
Note: this function doesn't support sliced textures; supporting sliced
textures is a non trivial problem, considering the ability to rotate layers.
Note: cogl_material_rectangle, has quite a few workarounds, for a number of
other limitations within Cogl a.t.m.
Note: The GLES1/2 multi-texturing support has yet to be updated to use
the material abstraction.
2008-12-11 15:11:30 -05:00
|
|
|
*
|
2010-10-27 13:54:57 -04:00
|
|
|
* Allocates and initializes a default simple pipeline that will color
|
|
|
|
|
* a primitive white.
|
2008-12-22 11:19:49 -05:00
|
|
|
*
|
2010-10-27 13:54:57 -04:00
|
|
|
* Return value: a pointer to a new #CoglPipeline
|
2011-09-07 20:21:24 -04:00
|
|
|
*
|
|
|
|
|
* Since: 2.0
|
|
|
|
|
* Stability: Unstable
|
Adds a CoglMaterial abstraction, which includes support for multi-texturing
My previous work to provide muti-texturing support has been extended into
a CoglMaterial abstraction that adds control over the texture combine
functions (controlling how multiple texture layers are blended together),
the gl blend function (used for blending the final primitive with the
framebuffer), the alpha function (used to discard fragments based on
their alpha channel), describing attributes such as a diffuse, ambient and
specular color (for use with the standard OpenGL lighting model), and
per layer rotations. (utilizing the new CoglMatrix utility API)
For now the only way this abstraction is exposed is via a new
cogl_material_rectangle function, that is similar to cogl_texture_rectangle
but doesn't take a texture handle (the source material is pulled from
the context), and the array of texture coordinates is extended to be able
to supply coordinates for each layer.
Note: this function doesn't support sliced textures; supporting sliced
textures is a non trivial problem, considering the ability to rotate layers.
Note: cogl_material_rectangle, has quite a few workarounds, for a number of
other limitations within Cogl a.t.m.
Note: The GLES1/2 multi-texturing support has yet to be updated to use
the material abstraction.
2008-12-11 15:11:30 -05:00
|
|
|
*/
|
2010-10-27 13:54:57 -04:00
|
|
|
CoglPipeline *
|
2012-02-18 11:03:10 -05:00
|
|
|
cogl_pipeline_new (CoglContext *context);
|
Adds a CoglMaterial abstraction, which includes support for multi-texturing
My previous work to provide muti-texturing support has been extended into
a CoglMaterial abstraction that adds control over the texture combine
functions (controlling how multiple texture layers are blended together),
the gl blend function (used for blending the final primitive with the
framebuffer), the alpha function (used to discard fragments based on
their alpha channel), describing attributes such as a diffuse, ambient and
specular color (for use with the standard OpenGL lighting model), and
per layer rotations. (utilizing the new CoglMatrix utility API)
For now the only way this abstraction is exposed is via a new
cogl_material_rectangle function, that is similar to cogl_texture_rectangle
but doesn't take a texture handle (the source material is pulled from
the context), and the array of texture coordinates is extended to be able
to supply coordinates for each layer.
Note: this function doesn't support sliced textures; supporting sliced
textures is a non trivial problem, considering the ability to rotate layers.
Note: cogl_material_rectangle, has quite a few workarounds, for a number of
other limitations within Cogl a.t.m.
Note: The GLES1/2 multi-texturing support has yet to be updated to use
the material abstraction.
2008-12-11 15:11:30 -05:00
|
|
|
|
2009-11-11 07:50:48 -05:00
|
|
|
/**
|
2010-10-27 13:54:57 -04:00
|
|
|
* cogl_pipeline_copy:
|
|
|
|
|
* @source: a #CoglPipeline object to copy
|
2009-11-11 07:50:48 -05:00
|
|
|
*
|
2010-10-27 13:54:57 -04:00
|
|
|
* Creates a new pipeline with the configuration copied from the
|
|
|
|
|
* source pipeline.
|
2009-11-11 07:50:48 -05:00
|
|
|
*
|
|
|
|
|
* We would strongly advise developers to always aim to use
|
2010-10-27 13:54:57 -04:00
|
|
|
* cogl_pipeline_copy() instead of cogl_pipeline_new() whenever there will
|
|
|
|
|
* be any similarity between two pipelines. Copying a pipeline helps Cogl
|
|
|
|
|
* keep track of a pipelines ancestry which we may use to help minimize GPU
|
2009-11-11 07:50:48 -05:00
|
|
|
* state changes.
|
|
|
|
|
*
|
2010-10-27 13:54:57 -04:00
|
|
|
* Returns: a pointer to the newly allocated #CoglPipeline
|
2009-11-11 07:50:48 -05:00
|
|
|
*
|
2010-10-27 13:54:57 -04:00
|
|
|
* Since: 2.0
|
2011-09-07 20:21:24 -04:00
|
|
|
* Stability: Unstable
|
2009-11-11 07:50:48 -05:00
|
|
|
*/
|
2010-10-27 13:54:57 -04:00
|
|
|
CoglPipeline *
|
|
|
|
|
cogl_pipeline_copy (CoglPipeline *source);
|
Adds a CoglMaterial abstraction, which includes support for multi-texturing
My previous work to provide muti-texturing support has been extended into
a CoglMaterial abstraction that adds control over the texture combine
functions (controlling how multiple texture layers are blended together),
the gl blend function (used for blending the final primitive with the
framebuffer), the alpha function (used to discard fragments based on
their alpha channel), describing attributes such as a diffuse, ambient and
specular color (for use with the standard OpenGL lighting model), and
per layer rotations. (utilizing the new CoglMatrix utility API)
For now the only way this abstraction is exposed is via a new
cogl_material_rectangle function, that is similar to cogl_texture_rectangle
but doesn't take a texture handle (the source material is pulled from
the context), and the array of texture coordinates is extended to be able
to supply coordinates for each layer.
Note: this function doesn't support sliced textures; supporting sliced
textures is a non trivial problem, considering the ability to rotate layers.
Note: cogl_material_rectangle, has quite a few workarounds, for a number of
other limitations within Cogl a.t.m.
Note: The GLES1/2 multi-texturing support has yet to be updated to use
the material abstraction.
2008-12-11 15:11:30 -05:00
|
|
|
|
|
|
|
|
/**
|
2010-10-27 13:54:57 -04:00
|
|
|
* cogl_is_pipeline:
|
2012-04-16 09:14:10 -04:00
|
|
|
* @object: A #CoglObject
|
2009-02-19 06:55:54 -05:00
|
|
|
*
|
2012-04-16 09:14:10 -04:00
|
|
|
* Gets whether the given @object references an existing pipeline object.
|
2009-02-19 06:55:54 -05:00
|
|
|
*
|
2012-04-16 09:14:10 -04:00
|
|
|
* Return value: %TRUE if the @object references a #CoglPipeline,
|
2009-02-19 06:55:54 -05:00
|
|
|
* %FALSE otherwise
|
2011-09-07 20:21:24 -04:00
|
|
|
*
|
|
|
|
|
* Since: 2.0
|
|
|
|
|
* Stability: Unstable
|
2009-02-19 06:55:54 -05:00
|
|
|
*/
|
Switch use of primitive glib types to c99 equivalents
The coding style has for a long time said to avoid using redundant glib
data types such as gint or gchar etc because we feel that they make the
code look unnecessarily foreign to developers coming from outside of the
Gnome developer community.
Note: When we tried to find the historical rationale for the types we
just found that they were apparently only added for consistent syntax
highlighting which didn't seem that compelling.
Up until now we have been continuing to use some of the platform
specific type such as gint{8,16,32,64} and gsize but this patch switches
us over to using the standard c99 equivalents instead so we can further
ensure that our code looks familiar to the widest range of C developers
who might potentially contribute to Cogl.
So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this
switches all Cogl code to instead use the int{8,16,32,64}_t and
uint{8,16,32,64}_t c99 types instead.
Instead of gsize we now use size_t
For now we are not going to use the c99 _Bool type and instead we have
introduced a new CoglBool type to use instead of gboolean.
Reviewed-by: Neil Roberts <neil@linux.intel.com>
(cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
|
|
|
CoglBool
|
2012-04-16 09:14:10 -04:00
|
|
|
cogl_is_pipeline (void *object);
|
Fully integrates CoglMaterial throughout the rest of Cogl
This glues CoglMaterial in as the fundamental way that Cogl describes how to
fill in geometry.
It adds cogl_set_source (), which is used to set the material which will be
used by all subsequent drawing functions
It adds cogl_set_source_texture as a convenience for setting up a default
material with a single texture layer, and cogl_set_source_color is now also
a convenience for setting up a material with a solid fill.
"drawing functions" include, cogl_rectangle, cogl_texture_rectangle,
cogl_texture_multiple_rectangles, cogl_texture_polygon (though the
cogl_texture_* funcs have been renamed; see below for details),
cogl_path_fill/stroke and cogl_vertex_buffer_draw*.
cogl_texture_rectangle, cogl_texture_multiple_rectangles and
cogl_texture_polygon no longer take a texture handle; instead the current
source material is referenced. The functions have also been renamed to:
cogl_rectangle_with_texture_coords, cogl_rectangles_with_texture_coords
and cogl_polygon respectivly.
Most code that previously did:
cogl_texture_rectangle (tex_handle, x, y,...);
needs to be changed to now do:
cogl_set_source_texture (tex_handle);
cogl_rectangle_with_texture_coords (x, y,....);
In the less likely case where you were blending your source texture with a color
like:
cogl_set_source_color4ub (r,g,b,a); /* where r,g,b,a isn't just white */
cogl_texture_rectangle (tex_handle, x, y,...);
you will need your own material to do that:
mat = cogl_material_new ();
cogl_material_set_color4ub (r,g,b,a);
cogl_material_set_layer (mat, 0, tex_handle));
cogl_set_source_material (mat);
Code that uses the texture coordinates, 0, 0, 1, 1 don't need to use
cog_rectangle_with_texure_coords since these are the coordinates that
cogl_rectangle will use.
For cogl_texture_polygon; as well as dropping the texture handle, the
n_vertices and vertices arguments were transposed for consistency. So
code previously written as:
cogl_texture_polygon (tex_handle, 3, verts, TRUE);
need to be written as:
cogl_set_source_texture (tex_handle);
cogl_polygon (verts, 3, TRUE);
All of the unit tests have been updated to now use the material API and
test-cogl-material has been renamed to test-cogl-multitexture since any
textured quad is now technically a test of CoglMaterial but this test
specifically creates a material with multiple texture layers.
Note: The GLES backend has not been updated yet; that will be done in a
following commit.
2009-01-23 11:15:40 -05:00
|
|
|
|
2010-07-05 16:33:26 -04:00
|
|
|
/**
|
2010-10-27 13:54:57 -04:00
|
|
|
* CoglPipelineLayerCallback:
|
|
|
|
|
* @pipeline: The #CoglPipeline whos layers are being iterated
|
2010-07-05 16:33:26 -04:00
|
|
|
* @layer_index: The current layer index
|
2010-10-27 13:54:57 -04:00
|
|
|
* @user_data: The private data passed to cogl_pipeline_foreach_layer()
|
2010-07-05 16:33:26 -04:00
|
|
|
*
|
2010-10-27 13:54:57 -04:00
|
|
|
* The callback prototype used with cogl_pipeline_foreach_layer() for
|
|
|
|
|
* iterating all the layers of a @pipeline.
|
2010-07-05 16:33:26 -04:00
|
|
|
*
|
2010-10-27 13:54:57 -04:00
|
|
|
* Since: 2.0
|
2010-07-05 16:33:26 -04:00
|
|
|
* Stability: Unstable
|
|
|
|
|
*/
|
Switch use of primitive glib types to c99 equivalents
The coding style has for a long time said to avoid using redundant glib
data types such as gint or gchar etc because we feel that they make the
code look unnecessarily foreign to developers coming from outside of the
Gnome developer community.
Note: When we tried to find the historical rationale for the types we
just found that they were apparently only added for consistent syntax
highlighting which didn't seem that compelling.
Up until now we have been continuing to use some of the platform
specific type such as gint{8,16,32,64} and gsize but this patch switches
us over to using the standard c99 equivalents instead so we can further
ensure that our code looks familiar to the widest range of C developers
who might potentially contribute to Cogl.
So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this
switches all Cogl code to instead use the int{8,16,32,64}_t and
uint{8,16,32,64}_t c99 types instead.
Instead of gsize we now use size_t
For now we are not going to use the c99 _Bool type and instead we have
introduced a new CoglBool type to use instead of gboolean.
Reviewed-by: Neil Roberts <neil@linux.intel.com>
(cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
|
|
|
typedef CoglBool (*CoglPipelineLayerCallback) (CoglPipeline *pipeline,
|
2010-07-05 16:33:26 -04:00
|
|
|
int layer_index,
|
|
|
|
|
void *user_data);
|
|
|
|
|
|
|
|
|
|
/**
|
2010-10-27 13:54:57 -04:00
|
|
|
* cogl_pipeline_foreach_layer:
|
|
|
|
|
* @pipeline: A #CoglPipeline object
|
|
|
|
|
* @callback: A #CoglPipelineLayerCallback to be called for each layer
|
2010-07-05 16:33:26 -04:00
|
|
|
* index
|
|
|
|
|
* @user_data: Private data that will be passed to the callback
|
|
|
|
|
*
|
2010-10-27 13:54:57 -04:00
|
|
|
* Iterates all the layer indices of the given @pipeline.
|
2010-07-05 16:33:26 -04:00
|
|
|
*
|
2010-10-27 13:54:57 -04:00
|
|
|
* Since: 2.0
|
2010-07-05 16:33:26 -04:00
|
|
|
* Stability: Unstable
|
|
|
|
|
*/
|
|
|
|
|
void
|
2010-10-27 13:54:57 -04:00
|
|
|
cogl_pipeline_foreach_layer (CoglPipeline *pipeline,
|
|
|
|
|
CoglPipelineLayerCallback callback,
|
2010-07-05 16:33:26 -04:00
|
|
|
void *user_data);
|
|
|
|
|
|
cogl-pipeline: Add support for setting uniform values
This adds the following new public experimental functions to set
uniform values on a CoglPipeline:
void
cogl_pipeline_set_uniform_1f (CoglPipeline *pipeline,
int uniform_location,
float value);
void
cogl_pipeline_set_uniform_1i (CoglPipeline *pipeline,
int uniform_location,
int value);
void
cogl_pipeline_set_uniform_float (CoglPipeline *pipeline,
int uniform_location,
int n_components,
int count,
const float *value);
void
cogl_pipeline_set_uniform_int (CoglPipeline *pipeline,
int uniform_location,
int n_components,
int count,
const int *value);
void
cogl_pipeline_set_uniform_matrix (CoglPipeline *pipeline,
int uniform_location,
int dimensions,
int count,
gboolean transpose,
const float *value);
These are similar to the old functions used to set uniforms on a
CoglProgram. To get a value to pass in as the uniform_location there
is also:
int
cogl_pipeline_get_uniform_location (CoglPipeline *pipeline,
const char *uniform_name);
Conceptually the uniform locations are tied to the pipeline so that
whenever setting a value for a new pipeline the application is
expected to call this function. However in practice the uniform
locations are global to the CoglContext. The names are stored in a
linked list where the position in the list is the uniform location.
The global indices are used so that each pipeline can store a mask of
which uniforms it overrides. That way it is quicker to detect which
uniforms are different from the last pipeline that used the same
CoglProgramState so it can avoid flushing uniforms that haven't
changed. Currently the values are not actually compared which means
that it will only avoid flushing a uniform if there is a common
ancestor that sets the value (or if the same pipeline is being flushed
again - in which case the pipeline and its common ancestor are the
same thing).
The uniform values are stored in the big state of the pipeline as a
sparse linked list. A bitmask stores which values have been overridden
and only overridden values are stored in the linked list.
Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-03 13:20:43 -04:00
|
|
|
/**
|
|
|
|
|
* cogl_pipeline_get_uniform_location:
|
|
|
|
|
* @pipeline: A #CoglPipeline object
|
|
|
|
|
* @uniform_name: The name of a uniform
|
|
|
|
|
*
|
|
|
|
|
* This is used to get an integer representing the uniform with the
|
|
|
|
|
* name @uniform_name. The integer can be passed to functions such as
|
|
|
|
|
* cogl_pipeline_set_uniform_1f() to set the value of a uniform.
|
|
|
|
|
*
|
|
|
|
|
* This function will always return a valid integer. Ie, unlike
|
|
|
|
|
* OpenGL, it does not return -1 if the uniform is not available in
|
|
|
|
|
* this pipeline so it can not be used to test whether uniforms are
|
|
|
|
|
* present. It is not necessary to set the program on the pipeline
|
|
|
|
|
* before calling this function.
|
|
|
|
|
*
|
|
|
|
|
* Return value: A integer representing the location of the given uniform.
|
|
|
|
|
*
|
|
|
|
|
* Since: 2.0
|
|
|
|
|
* Stability: Unstable
|
|
|
|
|
*/
|
|
|
|
|
int
|
|
|
|
|
cogl_pipeline_get_uniform_location (CoglPipeline *pipeline,
|
|
|
|
|
const char *uniform_name);
|
|
|
|
|
|
|
|
|
|
|
2010-05-26 06:33:32 -04:00
|
|
|
#endif /* COGL_ENABLE_EXPERIMENTAL_API */
|
|
|
|
|
|
2012-11-22 13:01:10 -05:00
|
|
|
COGL_END_DECLS
|
2008-12-22 11:19:49 -05:00
|
|
|
|
2010-10-27 13:54:57 -04:00
|
|
|
#endif /* __COGL_PIPELINE_H__ */
|