CoglMaterialLayerCallback ()

CoglBool
(*CoglMaterialLayerCallback) (CoglMaterial *material,
                              int layer_index,
                              void *user_data);

The callback prototype used with cogl_material_foreach_layer() for iterating all the layers of a material .

Since: 1.4

Stability Level: Unstable

cogl_material_new ()

CoglMaterial *
cogl_material_new (void);

Allocates and initializes a blank white material

cogl_material_copy ()

CoglMaterial *
cogl_material_copy (CoglMaterial *source);

Creates a new material with the configuration copied from the source material.

We would strongly advise developers to always aim to use cogl_material_copy() instead of cogl_material_new() whenever there will be any similarity between two materials. Copying a material helps Cogl keep track of a materials ancestry which we may use to help minimize GPU state changes.

Since: 1.2

cogl_is_material ()

CoglBool
cogl_is_material (CoglHandle handle);

Gets whether the given handle references an existing material object.

cogl_material_set_color ()

void
cogl_material_set_color (CoglMaterial *material,
                         const CoglColor *color);

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

Since: 1.0

cogl_material_set_color4ub ()

void
cogl_material_set_color4ub (CoglMaterial *material,
                            uint8_t red,
                            uint8_t green,
                            uint8_t blue,
                            uint8_t alpha);

Sets the basic color of the material, used when no lighting is enabled.

The default value is (0xff, 0xff, 0xff, 0xff)

Since: 1.0

cogl_material_set_color4f ()

void
cogl_material_set_color4f (CoglMaterial *material,
                           float red,
                           float green,
                           float blue,
                           float alpha);

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)

Since: 1.0

cogl_material_get_color ()

void
cogl_material_get_color (CoglMaterial *material,
                         CoglColor *color);

Retrieves the current material color.

Since: 1.0

cogl_material_set_ambient ()

void
cogl_material_set_ambient (CoglMaterial *material,
                           const CoglColor *ambient);

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)

Since: 1.0

cogl_material_get_ambient ()

void
cogl_material_get_ambient (CoglMaterial *material,
                           CoglColor *ambient);

Retrieves the current ambient color for material

Since: 1.0

cogl_material_set_diffuse ()

void
cogl_material_set_diffuse (CoglMaterial *material,
                           const CoglColor *diffuse);

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)

Since: 1.0

cogl_material_get_diffuse ()

void
cogl_material_get_diffuse (CoglMaterial *material,
                           CoglColor *diffuse);

Retrieves the current diffuse color for material

Since: 1.0

cogl_material_set_ambient_and_diffuse ()

void
cogl_material_set_ambient_and_diffuse (CoglMaterial *material,
                                       const CoglColor *color);

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)

Since: 1.0

cogl_material_set_emission ()

void
cogl_material_set_emission (CoglMaterial *material,
                            const CoglColor *emission);

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)

Since: 1.0

cogl_material_get_emission ()

void
cogl_material_get_emission (CoglMaterial *material,
                            CoglColor *emission);

Retrieves the materials current emission color.

Since: 1.0

cogl_material_set_specular ()

void
cogl_material_set_specular (CoglMaterial *material,
                            const CoglColor *specular);

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)

Since: 1.0

cogl_material_get_specular ()

void
cogl_material_get_specular (CoglMaterial *material,
                            CoglColor *specular);

Retrieves the materials current specular color.

Since: 1.0

cogl_material_set_shininess ()

void
cogl_material_set_shininess (CoglMaterial *material,
                             float shininess);

Sets the shininess of the material, 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

Since: 1.0

cogl_material_get_shininess ()

float
cogl_material_get_shininess (CoglMaterial *material);

Retrieves the materials current emission color.

Since: 1.0

cogl_material_set_alpha_test_function ()

void
cogl_material_set_alpha_test_function (CoglMaterial *material,
                                       CoglMaterialAlphaFunc alpha_func,
                                       float alpha_reference);

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

Since: 1.0

COGL_BLEND_STRING_ERROR

#define COGL_BLEND_STRING_ERROR (cogl_blend_string_error_quark ())

CoglError domain for blend string parser errors

Since: 1.0

cogl_material_set_blend ()

CoglBool
cogl_material_set_blend (CoglMaterial *material,
                         const char *blend_string,
                         CoglError **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:

The source names can be used according to the

so for example "(1-SRC_COLOR[A])" would be a valid factor, as would "(CONSTANT[RGB])"

These can also be used as factors:

"RGB = ADD(SRC_COLOR*(SRC_COLOR[A]), DST_COLOR*(1-SRC_COLOR[A]))"
"A   = ADD(SRC_COLOR, DST_COLOR*(1-SRC_COLOR[A]))"
  

"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 material is in premultiplied form.

Since: 1.0

cogl_material_set_blend_constant ()

void
cogl_material_set_blend_constant (CoglMaterial *material,
                                  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.

Since: 1.0

cogl_material_set_point_size ()

void
cogl_material_set_point_size (CoglMaterial *material,
                              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.

Since: 1.4

cogl_material_get_point_size ()

float
cogl_material_get_point_size (CoglMaterial *material);

Get the size of points drawn when COGL_VERTICES_MODE_POINTS is used with the vertex buffer API.

Since: 1.4

cogl_material_set_layer ()

void
cogl_material_set_layer (CoglMaterial *material,
                         int layer_index,
                         CoglHandle texture);

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.

Since: 1.0

cogl_material_remove_layer ()

void
cogl_material_remove_layer (CoglMaterial *material,
                            int layer_index);

This function removes a layer from your material

cogl_material_set_layer_combine ()

CoglBool
cogl_material_set_layer_combine (CoglMaterial *material,
                                 int layer_index,
                                 const char *blend_string,
                                 CoglError **error);

If not already familiar; you can refer

strings are and there syntax.

These are all the functions available for texture combining:

Refer to the

describing the arguments. The valid source names for texture combining are:

1

RGBA = MODULATE (PREVIOUS, TEXTURE)

1

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

Since: 1.0

cogl_material_set_layer_combine_constant ()

void
cogl_material_set_layer_combine_constant
                               (CoglMaterial *material,
                                int layer_index,
                                const CoglColor *constant);

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

Since: 1.0

cogl_material_set_layer_matrix ()

void
cogl_material_set_layer_matrix (CoglMaterial *material,
                                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 material used to fill your geometry.

cogl_material_set_layer_point_sprite_coords_enabled ()

CoglBool
cogl_material_set_layer_point_sprite_coords_enabled
                               (CoglMaterial *material,
                                int layer_index,
                                CoglBool enable,
                                CoglError **error);

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 .

Since: 1.4

cogl_material_get_layer_point_sprite_coords_enabled ()

CoglBool
cogl_material_get_layer_point_sprite_coords_enabled
                               (CoglMaterial *material,
                                int layer_index);

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

Since: 1.4

cogl_material_get_n_layers ()

int
cogl_material_get_n_layers (CoglMaterial *material);

Retrieves the number of layers defined for the given material

Since: 1.0

cogl_material_set_layer_filters ()

void
cogl_material_set_layer_filters (CoglMaterial *material,
                                 int layer_index,
                                 CoglMaterialFilter min_filter,
                                 CoglMaterialFilter mag_filter);

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

cogl_material_layer_get_type ()

CoglMaterialLayerType
cogl_material_layer_get_type (CoglMaterialLayer *layer);

Retrieves the type of the layer

Currently there is only one type of layer defined: COGL_MATERIAL_LAYER_TYPE_TEXTURE, but considering we may add purely GLSL based layers in the future, you should write code that checks the type first.

cogl_material_layer_get_texture ()

CoglHandle
cogl_material_layer_get_texture (CoglMaterialLayer *layer);

Extracts a texture handle for a specific layer.

cogl_material_layer_get_min_filter ()

CoglMaterialFilter
cogl_material_layer_get_min_filter (CoglMaterialLayer *layer);

Queries the currently set downscaling filter for a material layer

cogl_material_layer_get_mag_filter ()

CoglMaterialFilter
cogl_material_layer_get_mag_filter (CoglMaterialLayer *layer);

Queries the currently set downscaling filter for a material later

cogl_material_set_layer_wrap_mode ()

void
cogl_material_set_layer_wrap_mode (CoglMaterial *material,
                                   int layer_index,
                                   CoglMaterialWrapMode mode);

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

Since: 1.4

cogl_material_set_layer_wrap_mode_s ()

void
cogl_material_set_layer_wrap_mode_s (CoglMaterial *material,
                                     int layer_index,
                                     CoglMaterialWrapMode mode);

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

Since: 1.4

cogl_material_set_layer_wrap_mode_t ()

void
cogl_material_set_layer_wrap_mode_t (CoglMaterial *material,
                                     int layer_index,
                                     CoglMaterialWrapMode mode);

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

Since: 1.4

cogl_material_set_layer_wrap_mode_p ()

void
cogl_material_set_layer_wrap_mode_p (CoglMaterial *material,
                                     int layer_index,
                                     CoglMaterialWrapMode mode);

Sets the wrap mode for the 'p' coordinate of texture lookups on this layer. 'p' is the third coordinate.

Since: 1.4

cogl_material_get_layer_wrap_mode_s ()

CoglMaterialWrapMode
cogl_material_get_layer_wrap_mode_s (CoglMaterial *material,
                                     int layer_index);

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

Since: 1.6

cogl_material_get_layer_wrap_mode_t ()

CoglMaterialWrapMode
cogl_material_get_layer_wrap_mode_t (CoglMaterial *material,
                                     int layer_index);

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

Since: 1.6

cogl_material_get_layer_wrap_mode_p ()

CoglMaterialWrapMode
cogl_material_get_layer_wrap_mode_p (CoglMaterial *material,
                                     int layer_index);

Returns the wrap mode for the 'p' coordinate of texture lookups on this layer.

Since: 1.6

cogl_material_wrap_mode_get_type ()

GType
cogl_material_wrap_mode_get_type (void);

cogl_material_set_user_program ()

void
cogl_material_set_user_program (CoglMaterial *material,
                                CoglHandle program);

Associates a linked CoglProgram with the given material so that the program can take full control of vertex and/or fragment processing.

This is an example of how it can be used to associate an ARBfp program with a CoglMaterial:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

CoglHandle shader;
CoglHandle program;
CoglMaterial *material;

shader = cogl_create_shader (COGL_SHADER_TYPE_FRAGMENT);
cogl_shader_source (shader,
                    "!!ARBfp1.0\n"
                    "MOV result.color,fragment.color;\n"
                    "END\n");
cogl_shader_compile (shader);

program = cogl_create_program ();
cogl_program_attach_shader (program, shader);
cogl_program_link (program);

material = cogl_material_new ();
cogl_material_set_user_program (material, program);

cogl_set_source_color4ub (0xff, 0x00, 0x00, 0xff);
cogl_rectangle (0, 0, 100, 100);

It is possibly worth keeping in mind that this API is not part of the long term design for how we want to expose shaders to Cogl developers (We are planning on deprecating the cogl_program and cogl_shader APIs in favour of a "snippet" framework) but in the meantime we hope this will handle most practical GLSL and ARBfp requirements.

Also remember you need to check for either the COGL_FEATURE_SHADERS_GLSL or COGL_FEATURE_SHADERS_ARBFP before using the cogl_program or cogl_shader API.

Since: 1.4

cogl_material_get_user_program ()

CoglHandle
cogl_material_get_user_program (CoglMaterial *material);

Queries what user program has been associated with the given material using cogl_material_set_user_program().

Since: 1.4

cogl_material_foreach_layer ()

void
cogl_material_foreach_layer (CoglMaterial *material,
                             CoglMaterialLayerCallback callback,
                             void *user_data);

Iterates all the layer indices of the given material .

Since: 1.4

Stability Level: Unstable

CoglMaterial

typedef struct _CoglMaterial CoglMaterial;

CoglMaterialLayer

typedef struct _CoglMaterialLayer CoglMaterialLayer;

enum CoglMaterialAlphaFunc

Alpha testing happens before blending primitives with the framebuffer and gives an opportunity to discard fragments based on a comparison with the incoming alpha value and a reference alpha value. The CoglMaterialAlphaFunc determines how the comparison is done.

enum CoglBlendStringError

Error enumeration for the blend strings parser

Since: 1.0

enum CoglMaterialFilter

Texture filtering is used whenever the current pixel maps either to more than one texture element (texel) or less than one. These filter enums correspond to different strategies used to come up with a pixel color, by possibly referring to multiple neighbouring texels and taking a weighted average or simply using the nearest texel.

enum CoglMaterialLayerType

Available types of layers for a CoglMaterial. This enumeration might be expanded in later versions.

Since: 1.0

enum CoglMaterialWrapMode

The wrap mode specifies what happens when texture coordinates outside the range 0→1 are used. Note that if the filter mode is anything but COGL_MATERIAL_FILTER_NEAREST then texels outside the range 0→1 might be used even when the coordinate is exactly 0 or 1 because OpenGL will try to sample neighbouring pixels. For example if you are trying to render the full texture then you may get artifacts around the edges when the pixels from the other side are merged in if the wrap mode is set to repeat.

Since: 1.4