Retrieves the current ambient color for material

Parameters:

Cogl.Color ambient Required (not null)

The location to store the ambient color

Returns:

none

Retrieves the current material color.

Returns:

Cogl.Color

Retrieves the current diffuse color for material

Parameters:

Cogl.Color diffuse Required (not null)

The location to store the diffuse color

Returns:

none

Retrieves the materials current emission color.

Parameters:

Cogl.Color emission Required (not null)

The location to store the emission color

Returns:

none

Gets whether point sprite coordinate generation is enabled for this
texture layer.
point sprite coordinates.

Parameters:

gint32 layer_index Required (not null)

the layer number to check.

Returns:

gboolean whether the texture coordinates will be replaced with

Parameters:

gint32 layer_index Required (not null)

Returns:

Cogl.MaterialWrapMode

Parameters:

gint32 layer_index Required (not null)

Returns:

Cogl.MaterialWrapMode

Parameters:

gint32 layer_index Required (not null)

Returns:

Cogl.MaterialWrapMode

This function lets you access a material's internal list of layers
for iteration.
You should avoid using this API if possible since it was only
made public by mistake and will be deprecated when we have
suitable alternative.
It's important to understand that the list returned may not
remain valid if you modify the material or any of the layers in any
way and so you would have to re-get the list in that
situation.
list of CoglMaterialLayer's that can be passed to the
cogl_material_layer_* functions. The list is owned by Cogl and it
should not be modified or freed

Returns:

Array A

Retrieves the number of layers defined for the given material

Returns:

gint32 the number of layers

Returns:

gfloat

Retrieves the materials current emission color.

Returns:

gfloat The materials current shininess value

Retrieves the materials current specular color.

Parameters:

Cogl.Color specular Required (not null)

The location to store the specular color

Returns:

none

Returns:

void*

This function removes a layer from your material

Parameters:

gint32 layer_index Required (not null)

Specifies the layer you want to remove

Returns:

none

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_MATERIAL_ALPHA_FUNC_ALWAYS

Parameters:

Cogl.MaterialAlphaFunc alpha_func Required (not null)

A CoglMaterialAlphaFunc constant

gfloat alpha_reference Required (not null)

A reference point that the chosen alpha function uses to compare incoming fragments to.

Returns:

none

Sets the material'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)

Parameters:

Cogl.Color ambient Required (not null)

The components of the desired ambient color

Returns:

none

Conveniently sets the diffuse and ambient color of material at the same
time. See cogl_material_set_ambient() and cogl_material_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)

Parameters:

Cogl.Color color Required (not null)

The components of the desired ambient and diffuse colors

Returns:

none

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:
|[
<channel-mask>=ADD(SRC_COLOR*(<factor>), DST_COLOR*(<factor>))
]|
The brackets around blend factors are currently not
optional!
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_material_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:

0: (0, 0, 0, 0)
1: (1, 1, 1, 1)
SRC_ALPHA_SATURATE_FACTOR: (f,f,f,1) where f = MIN(SRC_COLOR[A],1-DST_COLOR[A])

Remember; all color components are normalized to the range [0, 1]
before computing the result of blending.


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]))"




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:
|[
RGBA = ADD (SRC_COLOR, DST_COLOR*(1-SRC_COLOR[A]))
]|
That gives normal alpha-blending when the calculated color for the material
is in premultiplied form.
described blending is supported by the underlying driver/hardware. If
there was an error, FALSE is returned and error is set accordingly (if
present).

Parameters:

String blend_string Required (not null)

A Cogl blend string describing the desired blend function.

Returns:

gboolean TRUE if the blend string was successfully parsed, and the

When blending is setup to reference a CONSTANT blend factor then
blending will depend on the constant set with this function.

Parameters:

Cogl.Color constant_color Required (not null)

The constant color you want

Returns:

none

Sets the basic color of the material, used when no lighting is enabled.
Note that if you don't add any layers to the material then the color
will be blended unmodified with the destination; the default blend
semi-transparent red. See cogl_color_premultiply().
The default value is (1.0, 1.0, 1.0, 1.0)

Parameters:

Cogl.Color color Required (not null)

The components of the color

Returns:

none

Sets the basic color of the material, used when no lighting is enabled.
The default value is (1.0, 1.0, 1.0, 1.0)

Parameters:

gfloat red Required (not null)

The red component

gfloat green Required (not null)

The green component

gfloat blue Required (not null)

The blue component

gfloat alpha Required (not null)

The alpha component

Returns:

none

Sets the basic color of the material, used when no lighting is enabled.
The default value is (0xff, 0xff, 0xff, 0xff)

Parameters:

guint8 red Required (not null)

The red component

guint8 green Required (not null)

The green component

guint8 blue Required (not null)

The blue component

guint8 alpha Required (not null)

The alpha component

Returns:

none

Sets the material'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)

Parameters:

Cogl.Color diffuse Required (not null)

The components of the desired diffuse color

Returns:

none

Sets the material'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)

Parameters:

Cogl.Color emission Required (not null)

The components of the desired emissive color

Returns:

none

In addition to the standard OpenGL lighting model a Cogl material may have
one or more layers comprised of textures that can be blended together in
order, with a number of different texture combine modes. This function
defines a new texture layer.
The index values of multiple layers do not have to be consecutive; it is
only their relative order that is important.
In the future, we may define other types of material layers, such
as purely GLSL based layers.

Parameters:

gint32 layer_index Required (not null)

the index of the layer

void* texture Required (not null)

a CoglHandle for the layer object

Returns:

none

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:

REPLACE(arg0) = arg0
MODULATE(arg0, arg1) = arg0 x arg1
ADD(arg0, arg1) = arg0 + arg1
ADD_SIGNED(arg0, arg1) = arg0 + arg1 - 0.5
INTERPOLATE(arg0, arg1, arg2) = arg0 x arg2 + arg1 x (1 - arg2)
SUBTRACT(arg0, arg1) = arg0 - arg1


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_material_set_layer_constant()


PRIMARY
Use the color of the material as set with
cogl_material_set_color()


PREVIOUS
Either use the texture color from the previous layer, or
if this is layer 0, use the color of the material as set with
cogl_material_set_color()




This is effectively what the default blending is:

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_material_set_layer_constant.

RGBA = INTERPOLATE (PREVIOUS, TEXTURE, CONSTANT[A])


You can't give a multiplication factor for arguments as you can
with blending.
described texture combining is supported by the underlying driver and
or hardware. On failure, FALSE is returned and error is set

Parameters:

gint32 layer_index Required (not null)

Specifies the layer you want define a combine function for

String blend_string Required (not null)

A Cogl blend string describing the desired texture combine function.

Returns:

gboolean TRUE if the blend string was successfully parsed, and the

When you are using the 'CONSTANT' color source in a layer combine
description then you can use this function to define its value.

Parameters:

gint32 layer_index Required (not null)

Specifies the layer you want to specify a constant used for texture combining

Cogl.Color constant Required (not null)

The constant color you want

Returns:

none

Changes the decimation and interpolation filters used when a texture is
drawn at other scales than 100%.

Parameters:

gint32 layer_index Required (not null)

the layer number to change.

Cogl.MaterialFilter min_filter Required (not null)

the filter used when scaling a texture down.

Cogl.MaterialFilter mag_filter Required (not null)

the filter used when magnifying a texture.

Returns:

none

This function lets you set a matrix that can be used to e.g. translate
and rotate a single layer of a material used to fill your geometry.

Parameters:

gint32 layer_index Required (not null)

the index for the layer inside material

Cogl.Matrix matrix Required (not null)

the transformation matrix for the layer

Returns:

none

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.

Parameters:

gint32 layer_index Required (not null)

the layer number to change.

gboolean enable Required (not null)

whether to enable point sprite coord generation.

Returns:

gboolean TRUE if the function succeeds, FALSE otherwise.

Sets the wrap mode for both coordinates of texture lookups on this
layer. This is equivalent to calling
cogl_material_set_layer_wrap_mode_s() and
cogl_material_set_layer_wrap_mode_t() separately.

Parameters:

gint32 layer_index Required (not null)

the layer number to change.

Cogl.MaterialWrapMode mode Required (not null)

the new wrap mode

Returns:

none

Parameters:

gint32 layer_index Required (not null)

Cogl.MaterialWrapMode mode Required (not null)

Returns:

none

Sets the wrap mode for the 's' coordinate of texture lookups on this layer.

Parameters:

gint32 layer_index Required (not null)

the layer number to change.

Cogl.MaterialWrapMode mode Required (not null)

the new wrap mode

Returns:

none

Sets the wrap mode for the 't' coordinate of texture lookups on this layer.

Parameters:

gint32 layer_index Required (not null)

the layer number to change.

Cogl.MaterialWrapMode mode Required (not null)

the new wrap mode

Returns:

none

Parameters:

gfloat point_size Required (not null)

Returns:

none

Sets the materials shininess, in the standard OpenGL lighting model,
which determines how specular highlights are calculated. A higher
The default value is 0.0

Parameters:

gfloat shininess Required (not null)

The desired shininess; range: [0.0, 1.0]

Returns:

none

Sets the material'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)

Parameters:

Cogl.Color specular Required (not null)

The components of the desired specular color

Returns:

none

Parameters:

void* program Required (not null)

Returns:

none