2009-04-27 14:48:12 +00: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 12:56:10 +00:00
|
|
|
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
*
|
|
|
|
|
*
|
2009-04-27 14:48:12 +00: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 20:11:30 +00:00
|
|
|
#if !defined(__COGL_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
|
|
|
|
|
#error "Only <cogl/cogl.h> can be included directly."
|
|
|
|
|
#endif
|
|
|
|
|
|
2010-10-27 17:54:57 +00: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 20:11:30 +00:00
|
|
|
|
|
|
|
|
#include <cogl/cogl-types.h>
|
2011-11-17 16:52:21 +00: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 20:11:30 +00:00
|
|
|
|
2011-09-08 23:40:06 +00:00
|
|
|
G_BEGIN_DECLS
|
|
|
|
|
|
2011-09-08 00:21:24 +00: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 20:11:30 +00:00
|
|
|
/**
|
2010-10-27 17:54:57 +00: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 20:11:30 +00:00
|
|
|
*
|
2010-10-27 17:54:57 +00: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 20:11:30 +00:00
|
|
|
*/
|
2010-10-27 17:54:57 +00:00
|
|
|
typedef struct _CoglPipeline CoglPipeline;
|
2010-06-22 13:02:17 +00:00
|
|
|
|
2010-10-27 17:54:57 +00:00
|
|
|
#define COGL_PIPELINE(OBJECT) ((CoglPipeline *)OBJECT)
|
2010-06-22 13:02:17 +00: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 20:11:30 +00:00
|
|
|
/**
|
2010-10-27 17:54:57 +00:00
|
|
|
* cogl_pipeline_new:
|
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 20:11:30 +00:00
|
|
|
*
|
2010-10-27 17:54:57 +00:00
|
|
|
* Allocates and initializes a default simple pipeline that will color
|
|
|
|
|
* a primitive white.
|
2008-12-22 16:19:49 +00:00
|
|
|
*
|
2010-10-27 17:54:57 +00:00
|
|
|
* Return value: a pointer to a new #CoglPipeline
|
2011-09-08 00:21:24 +00: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 20:11:30 +00:00
|
|
|
*/
|
2010-10-27 17:54:57 +00:00
|
|
|
CoglPipeline *
|
|
|
|
|
cogl_pipeline_new (void);
|
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 20:11:30 +00:00
|
|
|
|
2009-11-11 12:50:48 +00:00
|
|
|
/**
|
2010-10-27 17:54:57 +00:00
|
|
|
* cogl_pipeline_copy:
|
|
|
|
|
* @source: a #CoglPipeline object to copy
|
2009-11-11 12:50:48 +00:00
|
|
|
*
|
2010-10-27 17:54:57 +00:00
|
|
|
* Creates a new pipeline with the configuration copied from the
|
|
|
|
|
* source pipeline.
|
2009-11-11 12:50:48 +00:00
|
|
|
*
|
|
|
|
|
* We would strongly advise developers to always aim to use
|
2010-10-27 17:54:57 +00: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 12:50:48 +00:00
|
|
|
* state changes.
|
|
|
|
|
*
|
2010-10-27 17:54:57 +00:00
|
|
|
* Returns: a pointer to the newly allocated #CoglPipeline
|
2009-11-11 12:50:48 +00:00
|
|
|
*
|
2010-10-27 17:54:57 +00:00
|
|
|
* Since: 2.0
|
2011-09-08 00:21:24 +00:00
|
|
|
* Stability: Unstable
|
2009-11-11 12:50:48 +00:00
|
|
|
*/
|
2010-10-27 17:54:57 +00: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 20:11:30 +00:00
|
|
|
|
|
|
|
|
/**
|
2010-10-27 17:54:57 +00:00
|
|
|
* cogl_is_pipeline:
|
2009-02-19 11:55:54 +00:00
|
|
|
* @handle: A CoglHandle
|
|
|
|
|
*
|
2010-10-27 17:54:57 +00:00
|
|
|
* Gets whether the given handle references an existing pipeline object.
|
2009-02-19 11:55:54 +00:00
|
|
|
*
|
2010-10-27 17:54:57 +00:00
|
|
|
* Return value: %TRUE if the handle references a #CoglPipeline,
|
2009-02-19 11:55:54 +00:00
|
|
|
* %FALSE otherwise
|
2011-09-08 00:21:24 +00:00
|
|
|
*
|
|
|
|
|
* Since: 2.0
|
|
|
|
|
* Stability: Unstable
|
2009-02-19 11:55:54 +00:00
|
|
|
*/
|
cogl: improves header and coding style consistency
We've had complaints that our Cogl code/headers are a bit "special" so
this is a first pass at tidying things up by giving them some
consistency. These changes are all consistent with how new code in Cogl
is being written, but the style isn't consistently applied across all
code yet.
There are two parts to this patch; but since each one required a large
amount of effort to maintain tidy indenting it made sense to combine the
changes to reduce the time spent re indenting the same lines.
The first change is to use a consistent style for declaring function
prototypes in headers. Cogl headers now consistently use this style for
prototypes:
return_type
cogl_function_name (CoglType arg0,
CoglType arg1);
Not everyone likes this style, but it seems that most of the currently
active Cogl developers agree on it.
The second change is to constrain the use of redundant glib data types
in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all
been replaced with int, unsigned int, float, long, unsigned long and char
respectively. When talking about pixel data; use of guchar has been
replaced with guint8, otherwise unsigned char can be used.
The glib types that we continue to use for portability are gboolean,
gint{8,16,32,64}, guint{8,16,32,64} and gsize.
The general intention is that Cogl should look palatable to the widest
range of C programmers including those outside the Gnome community so
- especially for the public API - we want to minimize the number of
foreign looking typedefs.
2010-02-10 01:57:32 +00:00
|
|
|
gboolean
|
2010-10-27 17:54:57 +00:00
|
|
|
cogl_is_pipeline (CoglHandle handle);
|
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 16:15:40 +00:00
|
|
|
|
2010-07-05 20:33:26 +00:00
|
|
|
/**
|
2010-10-27 17:54:57 +00:00
|
|
|
* CoglPipelineLayerCallback:
|
|
|
|
|
* @pipeline: The #CoglPipeline whos layers are being iterated
|
2010-07-05 20:33:26 +00:00
|
|
|
* @layer_index: The current layer index
|
2010-10-27 17:54:57 +00:00
|
|
|
* @user_data: The private data passed to cogl_pipeline_foreach_layer()
|
2010-07-05 20:33:26 +00:00
|
|
|
*
|
2010-10-27 17:54:57 +00:00
|
|
|
* The callback prototype used with cogl_pipeline_foreach_layer() for
|
|
|
|
|
* iterating all the layers of a @pipeline.
|
2010-07-05 20:33:26 +00:00
|
|
|
*
|
2010-10-27 17:54:57 +00:00
|
|
|
* Since: 2.0
|
2010-07-05 20:33:26 +00:00
|
|
|
* Stability: Unstable
|
|
|
|
|
*/
|
2010-10-27 17:54:57 +00:00
|
|
|
typedef gboolean (*CoglPipelineLayerCallback) (CoglPipeline *pipeline,
|
2010-07-05 20:33:26 +00:00
|
|
|
int layer_index,
|
|
|
|
|
void *user_data);
|
|
|
|
|
|
|
|
|
|
/**
|
2010-10-27 17:54:57 +00:00
|
|
|
* cogl_pipeline_foreach_layer:
|
|
|
|
|
* @pipeline: A #CoglPipeline object
|
|
|
|
|
* @callback: A #CoglPipelineLayerCallback to be called for each layer
|
2010-07-05 20:33:26 +00:00
|
|
|
* index
|
|
|
|
|
* @user_data: Private data that will be passed to the callback
|
|
|
|
|
*
|
2010-10-27 17:54:57 +00:00
|
|
|
* Iterates all the layer indices of the given @pipeline.
|
2010-07-05 20:33:26 +00:00
|
|
|
*
|
2010-10-27 17:54:57 +00:00
|
|
|
* Since: 2.0
|
2010-07-05 20:33:26 +00:00
|
|
|
* Stability: Unstable
|
|
|
|
|
*/
|
|
|
|
|
void
|
2010-10-27 17:54:57 +00:00
|
|
|
cogl_pipeline_foreach_layer (CoglPipeline *pipeline,
|
|
|
|
|
CoglPipelineLayerCallback callback,
|
2010-07-05 20:33:26 +00: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 17:20:43 +00: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 10:33:32 +00:00
|
|
|
#endif /* COGL_ENABLE_EXPERIMENTAL_API */
|
|
|
|
|
|
2008-12-22 16:19:49 +00:00
|
|
|
G_END_DECLS
|
|
|
|
|
|
2010-10-27 17:54:57 +00:00
|
|
|
#endif /* __COGL_PIPELINE_H__ */
|