Cogl 2.0 Reference Manual | ||||
---|---|---|---|---|
Top | Description |
CoglPipeline * cogl_pipeline_new (void
); CoglPipeline * cogl_pipeline_copy (CoglPipeline *source
); gboolean cogl_is_pipeline (CoglHandle handle
); void cogl_pipeline_set_color (CoglPipeline *pipeline
,const CoglColor *color
); void cogl_pipeline_set_color4ub (CoglPipeline *pipeline
,guint8 red
,guint8 green
,guint8 blue
,guint8 alpha
); void cogl_pipeline_set_color4f (CoglPipeline *pipeline
,float red
,float green
,float blue
,float alpha
); void cogl_pipeline_get_color (CoglPipeline *pipeline
,CoglColor *color
); void cogl_pipeline_set_ambient (CoglPipeline *pipeline
,const CoglColor *ambient
); void cogl_pipeline_get_ambient (CoglPipeline *pipeline
,CoglColor *ambient
); void cogl_pipeline_set_diffuse (CoglPipeline *pipeline
,const CoglColor *diffuse
); void cogl_pipeline_get_diffuse (CoglPipeline *pipeline
,CoglColor *diffuse
); #define cogl_pipeline_set_ambient_and_diffuse void cogl_pipeline_set_emission (CoglPipeline *pipeline
,const CoglColor *emission
); void cogl_pipeline_get_emission (CoglPipeline *pipeline
,CoglColor *emission
); void cogl_pipeline_set_specular (CoglPipeline *pipeline
,const CoglColor *specular
); void cogl_pipeline_get_specular (CoglPipeline *pipeline
,CoglColor *specular
); void cogl_pipeline_set_shininess (CoglPipeline *pipeline
,float shininess
); float cogl_pipeline_get_shininess (CoglPipeline *pipeline
); #define cogl_pipeline_set_alpha_test_function #define COGL_BLEND_STRING_ERROR enum CoglBlendStringError; gboolean cogl_pipeline_set_blend (CoglPipeline *pipeline
,const char *blend_string
,GError **error
); void cogl_pipeline_set_blend_constant (CoglPipeline *pipeline
,const CoglColor *constant_color
); void cogl_pipeline_set_point_size (CoglPipeline *pipeline
,float point_size
); float cogl_pipeline_get_point_size (CoglPipeline *pipeline
); CoglColorMask cogl_pipeline_get_color_mask (CoglPipeline *pipeline
); void cogl_pipeline_set_color_mask (CoglPipeline *pipeline
,CoglColorMask color_mask
); enum CoglPipelineCullFaceMode; void cogl_pipeline_set_cull_face_mode (CoglPipeline *pipeline
,CoglPipelineCullFaceMode cull_face_mode
); enum CoglWinding; void cogl_pipeline_set_front_face_winding (CoglPipeline *pipeline
,CoglWinding front_winding
); void cogl_pipeline_set_layer_texture (CoglPipeline *pipeline
,int layer_index
,CoglTexture *texture
); void cogl_pipeline_set_layer_filters (CoglPipeline *pipeline
,int layer_index
,CoglPipelineFilter min_filter
,CoglPipelineFilter mag_filter
); #define cogl_pipeline_set_layer_wrap_mode #define cogl_pipeline_set_layer_wrap_mode_s #define cogl_pipeline_set_layer_wrap_mode_t #define cogl_pipeline_set_layer_wrap_mode_p gboolean cogl_pipeline_set_layer_combine (CoglPipeline *pipeline
,int layer_index
,const char *blend_string
,GError **error
); #define cogl_pipeline_set_layer_combine_constant void cogl_pipeline_set_layer_matrix (CoglPipeline *pipeline
,int layer_index
,const CoglMatrix *matrix
); #define cogl_pipeline_set_layer_point_sprite_coords_enabled #define cogl_pipeline_get_layer_point_sprite_coords_enabled void cogl_pipeline_remove_layer (CoglPipeline *pipeline
,int layer_index
); int cogl_pipeline_get_n_layers (CoglPipeline *pipeline
); void cogl_pipeline_foreach_layer (CoglPipeline *pipeline
,CoglPipelineLayerCallback callback
,void *user_data
); #define cogl_pipeline_get_uniform_location #define cogl_pipeline_set_uniform_1f #define cogl_pipeline_set_uniform_1i #define cogl_pipeline_set_uniform_float #define cogl_pipeline_set_uniform_int #define cogl_pipeline_set_uniform_matrix void cogl_pipeline_add_snippet (CoglPipeline *pipeline
,CoglSnippet *snippet
); void cogl_pipeline_add_layer_snippet (CoglPipeline *pipeline
,int layer
,CoglSnippet *snippet
);
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.
CoglPipeline * cogl_pipeline_new (void
);
Allocates and initializes a default simple pipeline that will color a primitive white.
Returns : |
a pointer to a new CoglPipeline |
Since 2.0
Stability Level: Unstable
CoglPipeline * cogl_pipeline_copy (CoglPipeline *source
);
Creates a new pipeline with the configuration copied from the source pipeline.
We would strongly advise developers to always aim to use
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
state changes.
|
a CoglPipeline object to copy |
Returns : |
a pointer to the newly allocated CoglPipeline |
Since 2.0
Stability Level: Unstable
gboolean cogl_is_pipeline (CoglHandle handle
);
Gets whether the given handle references an existing pipeline object.
Since 2.0
Stability Level: Unstable
void cogl_pipeline_set_color (CoglPipeline *pipeline
,const CoglColor *color
);
Sets the basic color of the pipeline, used when no lighting is enabled.
Note that if you don't add any layers to the pipeline then the color
will be blended unmodified with the destination; the default blend
expects premultiplied colors: for example, use (0.5, 0.0, 0.0, 0.5) for
semi-transparent red. See cogl_color_premultiply()
.
The default value is (1.0, 1.0, 1.0, 1.0)
|
A CoglPipeline object |
|
The components of the color |
Since 2.0
Stability Level: Unstable
void cogl_pipeline_set_color4ub (CoglPipeline *pipeline
,guint8 red
,guint8 green
,guint8 blue
,guint8 alpha
);
Sets the basic color of the pipeline, used when no lighting is enabled.
The default value is (0xff, 0xff, 0xff, 0xff)
|
A CoglPipeline object |
|
The red component |
|
The green component |
|
The blue component |
|
The alpha component |
Since 2.0
Stability Level: Unstable
void cogl_pipeline_set_color4f (CoglPipeline *pipeline
,float red
,float green
,float blue
,float alpha
);
Sets the basic color of the pipeline, used when no lighting is enabled.
The default value is (1.0, 1.0, 1.0, 1.0)
|
A CoglPipeline object |
|
The red component |
|
The green component |
|
The blue component |
|
The alpha component |
Since 2.0
Stability Level: Unstable
void cogl_pipeline_get_color (CoglPipeline *pipeline
,CoglColor *color
);
Retrieves the current pipeline color.
|
A CoglPipeline object |
|
The location to store the color. [out] |
Since 2.0
Stability Level: Unstable
void cogl_pipeline_set_ambient (CoglPipeline *pipeline
,const CoglColor *ambient
);
Sets the pipeline's ambient color, in the standard OpenGL lighting model. The ambient color affects the overall color of the object.
Since the diffuse color will be intense when the light hits the surface directly, the ambient will be most apparent where the light hits at a slant.
The default value is (0.2, 0.2, 0.2, 1.0)
|
A CoglPipeline object |
|
The components of the desired ambient color |
Since 2.0
Stability Level: Unstable
void cogl_pipeline_get_ambient (CoglPipeline *pipeline
,CoglColor *ambient
);
Retrieves the current ambient color for pipeline
|
A CoglPipeline object |
|
The location to store the ambient color |
Since 2.0
Stability Level: Unstable
void cogl_pipeline_set_diffuse (CoglPipeline *pipeline
,const CoglColor *diffuse
);
Sets the pipeline's diffuse color, in the standard OpenGL lighting model. The diffuse color is most intense where the light hits the surface directly - perpendicular to the surface.
The default value is (0.8, 0.8, 0.8, 1.0)
|
A CoglPipeline object |
|
The components of the desired diffuse color |
Since 2.0
Stability Level: Unstable
void cogl_pipeline_get_diffuse (CoglPipeline *pipeline
,CoglColor *diffuse
);
Retrieves the current diffuse color for pipeline
|
A CoglPipeline object |
|
The location to store the diffuse color |
Since 2.0
Stability Level: Unstable
#define cogl_pipeline_set_ambient_and_diffuse
Conveniently sets the diffuse and ambient color of pipeline
at the same
time. See cogl_pipeline_set_ambient()
and cogl_pipeline_set_diffuse()
.
The default ambient color is (0.2, 0.2, 0.2, 1.0)
The default diffuse color is (0.8, 0.8, 0.8, 1.0)
|
A CoglPipeline object |
|
The components of the desired ambient and diffuse colors |
Since 2.0
Stability Level: Unstable
void cogl_pipeline_set_emission (CoglPipeline *pipeline
,const CoglColor *emission
);
Sets the pipeline's emissive color, in the standard OpenGL lighting model. It will look like the surface is a light source emitting this color.
The default value is (0.0, 0.0, 0.0, 1.0)
|
A CoglPipeline object |
|
The components of the desired emissive color |
Since 2.0
Stability Level: Unstable
void cogl_pipeline_get_emission (CoglPipeline *pipeline
,CoglColor *emission
);
Retrieves the pipelines current emission color.
|
A CoglPipeline object |
|
The location to store the emission color |
Since 2.0
Stability Level: Unstable
void cogl_pipeline_set_specular (CoglPipeline *pipeline
,const CoglColor *specular
);
Sets the pipeline's specular color, in the standard OpenGL lighting model. The intensity of the specular color depends on the viewport position, and is brightest along the lines of reflection.
The default value is (0.0, 0.0, 0.0, 1.0)
|
A CoglPipeline object |
|
The components of the desired specular color |
Since 2.0
Stability Level: Unstable
void cogl_pipeline_get_specular (CoglPipeline *pipeline
,CoglColor *specular
);
Retrieves the pipelines current specular color.
|
A CoglPipeline object |
|
The location to store the specular color |
Since 2.0
Stability Level: Unstable
void cogl_pipeline_set_shininess (CoglPipeline *pipeline
,float shininess
);
Sets the shininess of the pipeline, in the standard OpenGL lighting
model, which determines the size of the specular highlights. A
higher shininess
will produce smaller highlights which makes the
object appear more shiny.
The default value is 0.0
|
A CoglPipeline object |
|
The desired shininess; must be >= 0.0 |
Since 2.0
Stability Level: Unstable
float cogl_pipeline_get_shininess (CoglPipeline *pipeline
);
Retrieves the pipelines current emission color.
|
A CoglPipeline object |
Returns : |
The pipelines current shininess value |
Since 2.0
Stability Level: Unstable
#define cogl_pipeline_set_alpha_test_function
Before a primitive is blended with the framebuffer, it goes through an alpha test stage which lets you discard fragments based on the current alpha value. This function lets you change the function used to evaluate the alpha channel, and thus determine which fragments are discarded and which continue on to the blending stage.
The default is COGL_PIPELINE_ALPHA_FUNC_ALWAYS
|
A CoglPipeline object |
|
A CoglPipelineAlphaFunc constant |
|
A reference point that the chosen alpha function uses to compare incoming fragments to. |
Since 2.0
Stability Level: Unstable
#define COGL_BLEND_STRING_ERROR (cogl_blend_string_error_quark ())
GError domain for blend string parser errors
Since 1.0
typedef enum { /*< prefix=COGL_BLEND_STRING_ERROR >*/ COGL_BLEND_STRING_ERROR_PARSE_ERROR, COGL_BLEND_STRING_ERROR_ARGUMENT_PARSE_ERROR, COGL_BLEND_STRING_ERROR_INVALID_ERROR, COGL_BLEND_STRING_ERROR_GPU_UNSUPPORTED_ERROR } CoglBlendStringError;
Error enumeration for the blend strings parser
Generic parse error | |
Argument parse error | |
Internal parser error | |
Blend string not supported by the GPU |
Since 1.0
gboolean cogl_pipeline_set_blend (CoglPipeline *pipeline
,const char *blend_string
,GError **error
);
If not already familiar; please refer here for an overview of what blend strings are, and their syntax.
Blending occurs after the alpha test function, and combines fragments with the framebuffer.
Currently the only blend function Cogl exposes is ADD()
. So any valid
blend statements will be of the form:
1 |
<channel-mask>=ADD(SRC_COLOR*(<factor>), DST_COLOR*(<factor>)) |
This is the list of source-names usable as blend factors:
SRC_COLOR: The color of the in comming fragment
DST_COLOR: The color of the framebuffer
CONSTANT: The constant set via cogl_pipeline_set_blend_constant()
The source names can be used according to the color-source and factor syntax, so for example "(1-SRC_COLOR[A])" would be a valid factor, as would "(CONSTANT[RGB])"
These can also be used as factors:
Example 1. Blend Strings/1
Blend a non-premultiplied source over a destination with premultiplied alpha:
"RGB = ADD(SRC_COLOR*(SRC_COLOR[A]), DST_COLOR*(1-SRC_COLOR[A]))" "A = ADD(SRC_COLOR, DST_COLOR*(1-SRC_COLOR[A]))"
Example 2. Blend Strings/2
Blend a premultiplied source over a destination with premultiplied alpha
"RGBA = ADD(SRC_COLOR, DST_COLOR*(1-SRC_COLOR[A]))"
The default blend string is:
1 |
RGBA = ADD (SRC_COLOR, DST_COLOR*(1-SRC_COLOR[A])) |
That gives normal alpha-blending when the calculated color for the pipeline is in premultiplied form.
|
A CoglPipeline object |
|
A Cogl blend string describing the desired blend function. |
|
return location for a GError that may report lack of driver
support if you give separate blend string statements for the alpha
channel and RGB channels since some drivers, or backends such as
GLES 1.1, don't support this feature. May be NULL , in which case a
warning will be printed out using GLib's logging facilities if an
error is encountered. |
Returns : |
TRUE if the blend string was successfully parsed, and the
described blending is supported by the underlying driver/hardware. If
there was an error, FALSE is returned and error is set accordingly (if
present). |
Since 2.0
Stability Level: Unstable
void cogl_pipeline_set_blend_constant (CoglPipeline *pipeline
,const CoglColor *constant_color
);
When blending is setup to reference a CONSTANT blend factor then blending will depend on the constant set with this function.
|
A CoglPipeline object |
|
The constant color you want |
Since 2.0
Stability Level: Unstable
void cogl_pipeline_set_point_size (CoglPipeline *pipeline
,float point_size
);
Changes the size of points drawn when COGL_VERTICES_MODE_POINTS
is
used with the vertex buffer API. Note that typically the GPU will
only support a limited minimum and maximum range of point sizes. If
the chosen point size is outside that range then the nearest value
within that range will be used instead. The size of a point is in
screen space so it will be the same regardless of any
transformations. The default point size is 1.0.
|
a CoglPipeline pointer |
|
the new point size. |
Since 2.0
Stability Level: Unstable
float cogl_pipeline_get_point_size (CoglPipeline *pipeline
);
Get the size of points drawn when COGL_VERTICES_MODE_POINTS
is
used with the vertex buffer API.
|
a CoglPipeline pointer |
Returns : |
the point size of the pipeline . |
Since 2.0
Stability Level: Unstable
CoglColorMask cogl_pipeline_get_color_mask (CoglPipeline *pipeline
);
Gets the current CoglColorMask of which channels would be written to the current framebuffer. Each bit set in the mask means that the corresponding color would be written.
|
a CoglPipeline object. |
Returns : |
A CoglColorMask |
Since 1.8
Stability Level: Unstable
void cogl_pipeline_set_color_mask (CoglPipeline *pipeline
,CoglColorMask color_mask
);
Defines a bit mask of which color channels should be written to the
current framebuffer. If a bit is set in color_mask
that means that
color will be written.
|
a CoglPipeline object. |
|
A CoglColorMask of which color channels to write to the current framebuffer. |
Since 1.8
Stability Level: Unstable
typedef enum { COGL_PIPELINE_CULL_FACE_MODE_NONE, COGL_PIPELINE_CULL_FACE_MODE_FRONT, COGL_PIPELINE_CULL_FACE_MODE_BACK, COGL_PIPELINE_CULL_FACE_MODE_BOTH } CoglPipelineCullFaceMode;
Specifies which faces should be culled. This can be set on a
pipeline using cogl_pipeline_set_cull_face_mode()
.
void cogl_pipeline_set_cull_face_mode (CoglPipeline *pipeline
,CoglPipelineCullFaceMode cull_face_mode
);
Sets which faces will be culled when drawing. Face culling can be
used to increase efficiency by avoiding drawing faces that would
get overridden. For example, if a model has gaps so that it is
impossible to see the inside then faces which are facing away from
the screen will never be seen so there is no point in drawing
them. This can be acheived by setting the cull face mode to
COGL_PIPELINE_CULL_FACE_MODE_BACK
.
Face culling relies on the primitives being drawn with a specific
order to represent which faces are facing inside and outside the
model. This order can be specified by calling
cogl_pipeline_set_front_face_winding()
.
Status: Unstable
|
A CoglPipeline |
|
The new mode to set |
Since 2.0
typedef enum { COGL_WINDING_CLOCKWISE, COGL_WINDING_COUNTER_CLOCKWISE } CoglWinding;
Enum used to represent the two directions of rotation. This can be
used to set the front face for culling by calling
cogl_pipeline_set_front_face_winding()
.
void cogl_pipeline_set_front_face_winding (CoglPipeline *pipeline
,CoglWinding front_winding
);
The order of the vertices within a primitive specifies whether it
is considered to be front or back facing. This function specifies
which order is considered to be the front
faces. COGL_WINDING_COUNTER_CLOCKWISE
sets the front faces to
primitives with vertices in a counter-clockwise order and
COGL_WINDING_CLOCKWISE
sets them to be clockwise. The default is
COGL_WINDING_COUNTER_CLOCKWISE
.
Status: Unstable
Since 2.0
void cogl_pipeline_set_layer_texture (CoglPipeline *pipeline
,int layer_index
,CoglTexture *texture
);
void cogl_pipeline_set_layer_filters (CoglPipeline *pipeline
,int layer_index
,CoglPipelineFilter min_filter
,CoglPipelineFilter mag_filter
);
Changes the decimation and interpolation filters used when a texture is drawn at other scales than 100%.
|
A CoglPipeline object |
|
the layer number to change. |
|
the filter used when scaling a texture down. |
|
the filter used when magnifying a texture. |
#define cogl_pipeline_set_layer_wrap_mode
Sets the wrap mode for all three coordinates of texture lookups on
this layer. This is equivalent to calling
cogl_pipeline_set_layer_wrap_mode_s()
,
cogl_pipeline_set_layer_wrap_mode_t()
and
cogl_pipeline_set_layer_wrap_mode_p()
separately.
|
A CoglPipeline object |
|
the layer number to change. |
|
the new wrap mode |
Since 2.0
#define cogl_pipeline_set_layer_wrap_mode_s
Sets the wrap mode for the 's' coordinate of texture lookups on this layer.
|
A CoglPipeline object |
|
the layer number to change. |
|
the new wrap mode |
Since 2.0
#define cogl_pipeline_set_layer_wrap_mode_t
Sets the wrap mode for the 't' coordinate of texture lookups on this layer.
|
A CoglPipeline object |
|
the layer number to change. |
|
the new wrap mode |
Since 2.0
#define cogl_pipeline_set_layer_wrap_mode_p
Sets the wrap mode for the 'p' coordinate of texture lookups on this layer. 'p' is the third coordinate.
|
A CoglPipeline object |
|
the layer number to change. |
|
the new wrap mode |
Since 2.0
gboolean cogl_pipeline_set_layer_combine (CoglPipeline *pipeline
,int layer_index
,const char *blend_string
,GError **error
);
If not already familiar; you can refer here for an overview of what blend strings are and there syntax.
These are all the functions available for texture combining:
DOT3_RGB(arg0, arg1) = 4 x ((arg0[R] - 0.5)) * (arg1[R] - 0.5) + (arg0[G] - 0.5)) * (arg1[G] - 0.5) + (arg0[B] - 0.5)) * (arg1[B] - 0.5))
DOT3_RGBA(arg0, arg1) = 4 x ((arg0[R] - 0.5)) * (arg1[R] - 0.5) + (arg0[G] - 0.5)) * (arg1[G] - 0.5) + (arg0[B] - 0.5)) * (arg1[B] - 0.5))
Refer to the color-source syntax for describing the arguments. The valid source names for texture combining are:
TEXTURE |
Use the color from the current texture layer |
TEXTURE_0, TEXTURE_1, etc |
Use the color from the specified texture layer |
CONSTANT |
Use the color from the constant given with
cogl_pipeline_set_layer_constant()
|
PRIMARY |
Use the color of the pipeline as set with
cogl_pipeline_set_color()
|
PREVIOUS |
Either use the texture color from the previous layer, or
if this is layer 0, use the color of the pipeline as set with
cogl_pipeline_set_color()
|
This is effectively what the default blending is:
1 |
RGBA = MODULATE (PREVIOUS, TEXTURE) |
This could be used to cross-fade between two images, using the alpha component of a constant as the interpolator. The constant color is given by calling cogl_pipeline_set_layer_constant.
1 |
RGBA = INTERPOLATE (PREVIOUS, TEXTURE, CONSTANT[A]) |
|
A CoglPipeline object |
|
Specifies the layer you want define a combine function for |
|
A Cogl blend string describing the desired texture combine function. |
|
A GError that may report parse errors or lack of GPU/driver
support. May be NULL , in which case a warning will be printed out if an
error is encountered. |
Returns : |
TRUE if the blend string was successfully parsed, and the
described texture combining is supported by the underlying driver and
or hardware. On failure, FALSE is returned and error is set |
Since 2.0
#define cogl_pipeline_set_layer_combine_constant
When you are using the 'CONSTANT' color source in a layer combine description then you can use this function to define its value.
|
A CoglPipeline object |
|
Specifies the layer you want to specify a constant used for texture combining |
|
The constant color you want |
Since 2.0
void cogl_pipeline_set_layer_matrix (CoglPipeline *pipeline
,int layer_index
,const CoglMatrix *matrix
);
This function lets you set a matrix that can be used to e.g. translate and rotate a single layer of a pipeline used to fill your geometry.
|
A CoglPipeline object |
|
the index for the layer inside pipeline
|
|
the transformation matrix for the layer |
#define cogl_pipeline_set_layer_point_sprite_coords_enabled
When rendering points, if enable
is TRUE
then the texture
coordinates for this layer will be replaced with coordinates that
vary from 0.0 to 1.0 across the primitive. The top left of the
point will have the coordinates 0.0,0.0 and the bottom right will
have 1.0,1.0. If enable
is FALSE
then the coordinates will be
fixed for the entire point.
This function will only work if COGL_FEATURE_POINT_SPRITE
is
available. If the feature is not available then the function will
return FALSE
and set error
.
|
a CoglHandle to a pipeline. |
|
the layer number to change. |
|
whether to enable point sprite coord generation. |
|
A return location for a GError, or NULL to ignore errors. |
Returns : |
TRUE if the function succeeds, FALSE otherwise. |
Since 2.0
#define cogl_pipeline_get_layer_point_sprite_coords_enabled
Gets whether point sprite coordinate generation is enabled for this texture layer.
|
a CoglHandle to a pipeline. |
|
the layer number to check. |
Returns : |
whether the texture coordinates will be replaced with point sprite coordinates. |
Since 2.0
void cogl_pipeline_remove_layer (CoglPipeline *pipeline
,int layer_index
);
This function removes a layer from your pipeline
|
A CoglPipeline object |
|
Specifies the layer you want to remove |
int cogl_pipeline_get_n_layers (CoglPipeline *pipeline
);
Retrieves the number of layers defined for the given pipeline
|
A CoglPipeline object |
Returns : |
the number of layers |
Since 2.0
void cogl_pipeline_foreach_layer (CoglPipeline *pipeline
,CoglPipelineLayerCallback callback
,void *user_data
);
Iterates all the layer indices of the given pipeline
.
|
A CoglPipeline object |
|
A CoglPipelineLayerCallback to be called for each layer index |
|
Private data that will be passed to the callback |
Since 2.0
Stability Level: Unstable
#define cogl_pipeline_get_uniform_location
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.
|
A CoglPipeline object |
|
The name of a uniform |
Returns : |
A integer representing the location of the given uniform. |
Since 2.0
Stability Level: Unstable
#define cogl_pipeline_set_uniform_1f
Sets a new value for the uniform at uniform_location
. If this
pipeline has a user program attached and is later used as a source
for drawing, the given value will be assigned to the uniform which
can be accessed from the shader's source. The value for
uniform_location
should be retrieved from the string name of the
uniform by calling cogl_pipeline_get_uniform_location()
.
This function should be used to set uniforms that are of type float. It can also be used to set a single member of a float array uniform.
|
A CoglPipeline object |
|
The uniform's location identifier |
|
The new value for the uniform |
Since 2.0
Stability Level: Unstable
#define cogl_pipeline_set_uniform_1i
Sets a new value for the uniform at uniform_location
. If this
pipeline has a user program attached and is later used as a source
for drawing, the given value will be assigned to the uniform which
can be accessed from the shader's source. The value for
uniform_location
should be retrieved from the string name of the
uniform by calling cogl_pipeline_get_uniform_location()
.
This function should be used to set uniforms that are of type int. It can also be used to set a single member of a int array uniform or a sampler uniform.
|
A CoglPipeline object |
|
The uniform's location identifier |
|
The new value for the uniform |
Since 2.0
Stability Level: Unstable
#define cogl_pipeline_set_uniform_float
Sets new values for the uniform at uniform_location
. If this
pipeline has a user program attached and is later used as a source
for drawing, the given values will be assigned to the uniform which
can be accessed from the shader's source. The value for
uniform_location
should be retrieved from the string name of the
uniform by calling cogl_pipeline_get_uniform_location()
.
This function can be used to set any floating point type uniform,
including float arrays and float vectors. For example, to set a
single vec4 uniform you would use 4 for n_components
and 1 for
count
. To set an array of 8 float values, you could use 1 for
n_components
and 8 for count
.
|
A CoglPipeline object |
|
The uniform's location identifier |
|
The number of components in the corresponding uniform's type |
|
The number of values to set |
|
Pointer to the new values to set |
Since 2.0
Stability Level: Unstable
#define cogl_pipeline_set_uniform_int
Sets new values for the uniform at uniform_location
. If this
pipeline has a user program attached and is later used as a source
for drawing, the given values will be assigned to the uniform which
can be accessed from the shader's source. The value for
uniform_location
should be retrieved from the string name of the
uniform by calling cogl_pipeline_get_uniform_location()
.
This function can be used to set any integer type uniform,
including int arrays and int vectors. For example, to set a single
ivec4 uniform you would use 4 for n_components
and 1 for
count
. To set an array of 8 int values, you could use 1 for
n_components
and 8 for count
.
|
A CoglPipeline object |
|
The uniform's location identifier |
|
The number of components in the corresponding uniform's type |
|
The number of values to set |
|
Pointer to the new values to set |
Since 2.0
Stability Level: Unstable
#define cogl_pipeline_set_uniform_matrix
Sets new values for the uniform at uniform_location
. If this
pipeline has a user program attached and is later used as a source
for drawing, the given values will be assigned to the uniform which
can be accessed from the shader's source. The value for
uniform_location
should be retrieved from the string name of the
uniform by calling cogl_pipeline_get_uniform_location()
.
This function can be used to set any matrix type uniform, including
matrix arrays. For example, to set a single mat4 uniform you would
use 4 for dimensions
and 1 for count
. To set an array of 8
mat3 values, you could use 3 for dimensions
and 8 for count
.
If transpose
is FALSE
then the matrix is expected to be in
column-major order or if it is TRUE
then the matrix is in
row-major order. You can pass a CoglMatrix by calling by passing
the result of cogl_matrix_get_array()
in value
and setting
transpose
to FALSE
.
|
A CoglPipeline object |
|
The uniform's location identifier |
|
The size of the matrix |
|
The number of values to set |
|
Whether to transpose the matrix |
|
Pointer to the new values to set |
Since 2.0
Stability Level: Unstable
void cogl_pipeline_add_snippet (CoglPipeline *pipeline
,CoglSnippet *snippet
);
Adds a shader snippet to pipeline
. The snippet will wrap around or
replace some part of the pipeline as defined by the hook point in
snippet
. Note that some hook points are specific to a layer and
must be added with cogl_pipeline_add_layer_snippet()
instead.
|
A CoglPipeline |
|
The CoglSnippet to add to the vertex processing hook |
Since 1.10
Stability Level: Unstable
void cogl_pipeline_add_layer_snippet (CoglPipeline *pipeline
,int layer
,CoglSnippet *snippet
);
Adds a shader snippet that will hook on to the given layer of the
pipeline. The exact part of the pipeline that the snippet wraps
around depends on the hook that is given to
cogl_snippet_new()
. Note that some hooks can't be used with a layer
and need to be added with cogl_pipeline_add_snippet()
instead.
|
A CoglPipeline |
|
The layer to hook the snippet to |
|
A CoglSnippet |
Since 1.10
Stability Level: Unstable