Materials

Materials — Fuctions for creating and manipulating materials

Synopsis

CoglMaterial *      cogl_material_new                   (void);
CoglMaterial *      cogl_material_copy                  (CoglMaterial *source);
gboolean            cogl_is_material                    (CoglHandle handle);
void                cogl_material_set_color             (CoglMaterial *material,
                                                         const CoglColor *color);
void                cogl_material_set_color4ub          (CoglMaterial *material,
                                                         guint8 red,
                                                         guint8 green,
                                                         guint8 blue,
                                                         guint8 alpha);
void                cogl_material_set_color4f           (CoglMaterial *material,
                                                         float red,
                                                         float green,
                                                         float blue,
                                                         float alpha);
void                cogl_material_get_color             (CoglMaterial *material,
                                                         CoglColor *color);
void                cogl_material_set_ambient           (CoglMaterial *material,
                                                         const CoglColor *ambient);
void                cogl_material_get_ambient           (CoglMaterial *material,
                                                         CoglColor *ambient);
void                cogl_material_set_diffuse           (CoglMaterial *material,
                                                         const CoglColor *diffuse);
void                cogl_material_get_diffuse           (CoglMaterial *material,
                                                         CoglColor *diffuse);
void                cogl_material_set_ambient_and_diffuse
                                                        (CoglMaterial *material,
                                                         const CoglColor *color);
void                cogl_material_set_emission          (CoglMaterial *material,
                                                         const CoglColor *emission);
void                cogl_material_get_emission          (CoglMaterial *material,
                                                         CoglColor *emission);
void                cogl_material_set_specular          (CoglMaterial *material,
                                                         const CoglColor *specular);
void                cogl_material_get_specular          (CoglMaterial *material,
                                                         CoglColor *specular);
void                cogl_material_set_shininess         (CoglMaterial *material,
                                                         float shininess);
float               cogl_material_get_shininess         (CoglMaterial *material);
enum                CoglMaterialAlphaFunc;
void                cogl_material_set_alpha_test_function
                                                        (CoglMaterial *material,
                                                         CoglMaterialAlphaFunc alpha_func,
                                                         float alpha_reference);
#define             COGL_BLEND_STRING_ERROR
enum                CoglBlendStringError;
gboolean            cogl_material_set_blend             (CoglMaterial *material,
                                                         const char *blend_string,
                                                         GError **error);
void                cogl_material_set_blend_constant    (CoglMaterial *material,
                                                         const CoglColor *constant_color);
void                cogl_material_set_point_size        (CoglHandle material,
                                                         float point_size);
float               cogl_material_get_point_size        (CoglHandle material);
void                cogl_material_set_layer             (CoglMaterial *material,
                                                         int layer_index,
                                                         CoglHandle texture);
void                cogl_material_remove_layer          (CoglMaterial *material,
                                                         int layer_index);
gboolean            cogl_material_set_layer_combine     (CoglMaterial *material,
                                                         int layer_index,
                                                         const char *blend_string,
                                                         GError **error);
void                cogl_material_set_layer_combine_constant
                                                        (CoglMaterial *material,
                                                         int layer_index,
                                                         const CoglColor *constant);
void                cogl_material_set_layer_matrix      (CoglMaterial *material,
                                                         int layer_index,
                                                         const CoglMatrix *matrix);
gboolean            cogl_material_set_layer_point_sprite_coords_enabled
                                                        (CoglMaterial *material,
                                                         int layer_index,
                                                         gboolean enable,
                                                         GError **error);
gboolean            cogl_material_get_layer_point_sprite_coords_enabled
                                                        (CoglMaterial *material,
                                                         int layer_index);
int                 cogl_material_get_n_layers          (CoglMaterial *material);
enum                CoglMaterialFilter;
void                cogl_material_set_layer_filters     (CoglMaterial *material,
                                                         int layer_index,
                                                         CoglMaterialFilter min_filter,
                                                         CoglMaterialFilter mag_filter);
enum                CoglMaterialLayerType;
CoglMaterialLayerType  cogl_material_layer_get_type     (CoglMaterialLayer *layer);
CoglHandle          cogl_material_layer_get_texture     (CoglMaterialLayer *layer);
CoglMaterialFilter  cogl_material_layer_get_min_filter  (CoglMaterialLayer *layer);
CoglMaterialFilter  cogl_material_layer_get_mag_filter  (CoglMaterialLayer *layer);
enum                CoglMaterialWrapMode;
void                cogl_material_set_layer_wrap_mode   (CoglMaterial *material,
                                                         int layer_index,
                                                         CoglMaterialWrapMode mode);
void                cogl_material_set_layer_wrap_mode_s (CoglMaterial *material,
                                                         int layer_index,
                                                         CoglMaterialWrapMode mode);
void                cogl_material_set_layer_wrap_mode_t (CoglMaterial *material,
                                                         int layer_index,
                                                         CoglMaterialWrapMode mode);
void                cogl_material_set_layer_wrap_mode_p (CoglMaterial *material,
                                                         int layer_index,
                                                         CoglMaterialWrapMode mode);
CoglMaterialWrapMode  cogl_material_layer_get_wrap_mode_s
                                                        (CoglMaterialLayer *layer);
CoglMaterialWrapMode  cogl_material_layer_get_wrap_mode_t
                                                        (CoglMaterialLayer *layer);
CoglMaterialWrapMode  cogl_material_layer_get_wrap_mode_p
                                                        (CoglMaterialLayer *layer);

Description

COGL allows creating and manipulating materials used to fill in geometry. Materials may simply be lighting attributes (such as an ambient and diffuse colour) or might represent one or more textures blended together.

Details

cogl_material_new ()

CoglMaterial *      cogl_material_new                   (void);

Allocates and initializes a blank white material

Returns :

a pointer to a new CoglMaterial

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.

source :

a CoglMaterial object to copy

Returns :

a pointer to the newly allocated CoglMaterial

Since 1.2


cogl_is_material ()

gboolean            cogl_is_material                    (CoglHandle handle);

Gets whether the given handle references an existing material object.

handle :

A CoglHandle

Returns :

TRUE if the handle references a CoglMaterial, FALSE otherwise

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)

material :

A CoglMaterial object

color :

The components of the color

Since 1.0


cogl_material_set_color4ub ()

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

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

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

material :

A CoglMaterial object

red :

The red component

green :

The green component

blue :

The blue component

alpha :

The alpha component

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)

material :

A CoglMaterial object

red :

The red component

green :

The green component

blue :

The blue component

alpha :

The alpha component

Since 1.0


cogl_material_get_color ()

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

Retrieves the current material color.

material :

A CoglMaterial object

color :

The location to store the color. [out]

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)

material :

A CoglMaterial object

ambient :

The components of the desired ambient color

Since 1.0


cogl_material_get_ambient ()

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

Retrieves the current ambient color for material

material :

A CoglMaterial object

ambient :

The location to store the ambient color

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)

material :

A CoglMaterial object

diffuse :

The components of the desired diffuse color

Since 1.0


cogl_material_get_diffuse ()

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

Retrieves the current diffuse color for material

material :

A CoglMaterial object

diffuse :

The location to store the diffuse color

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)

material :

A CoglMaterial object

color :

The components of the desired ambient and diffuse colors

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)

material :

A CoglMaterial object

emission :

The components of the desired emissive color

Since 1.0


cogl_material_get_emission ()

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

Retrieves the materials current emission color.

material :

A CoglMaterial object

emission :

The location to store the 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)

material :

A CoglMaterial object

specular :

The components of the desired specular color

Since 1.0


cogl_material_get_specular ()

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

Retrieves the materials current specular color.

material :

A CoglMaterial object

specular :

The location to store the 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

material :

A CoglMaterial object

shininess :

The desired shininess; must be >= 0.0

Since 1.0


cogl_material_get_shininess ()

float               cogl_material_get_shininess         (CoglMaterial *material);

Retrieves the materials current emission color.

material :

A CoglMaterial object

Returns :

The materials current shininess value

Since 1.0


enum CoglMaterialAlphaFunc

typedef enum {
  COGL_MATERIAL_ALPHA_FUNC_NEVER    = GL_NEVER,
  COGL_MATERIAL_ALPHA_FUNC_LESS	    = GL_LESS,
  COGL_MATERIAL_ALPHA_FUNC_EQUAL    = GL_EQUAL,
  COGL_MATERIAL_ALPHA_FUNC_LEQUAL   = GL_LEQUAL,
  COGL_MATERIAL_ALPHA_FUNC_GREATER  = GL_GREATER,
  COGL_MATERIAL_ALPHA_FUNC_NOTEQUAL = GL_NOTEQUAL,
  COGL_MATERIAL_ALPHA_FUNC_GEQUAL   = GL_GEQUAL,
  COGL_MATERIAL_ALPHA_FUNC_ALWAYS   = GL_ALWAYS
} 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.

COGL_MATERIAL_ALPHA_FUNC_NEVER

Never let the fragment through.

COGL_MATERIAL_ALPHA_FUNC_LESS

Let the fragment through if the incoming alpha value is less than the reference alpha value

COGL_MATERIAL_ALPHA_FUNC_EQUAL

Let the fragment through if the incoming alpha value equals the reference alpha value

COGL_MATERIAL_ALPHA_FUNC_LEQUAL

Let the fragment through if the incoming alpha value is less than or equal to the reference alpha value

COGL_MATERIAL_ALPHA_FUNC_GREATER

Let the fragment through if the incoming alpha value is greater than the reference alpha value

COGL_MATERIAL_ALPHA_FUNC_NOTEQUAL

Let the fragment through if the incoming alpha value does not equal the reference alpha value

COGL_MATERIAL_ALPHA_FUNC_GEQUAL

Let the fragment through if the incoming alpha value is greater than or equal to the reference alpha value.

COGL_MATERIAL_ALPHA_FUNC_ALWAYS

Always let the fragment through.

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

material :

A CoglMaterial object

alpha_func :

A CoglMaterialAlphaFunc constant

alpha_reference :

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

Since 1.0


COGL_BLEND_STRING_ERROR

#define COGL_BLEND_STRING_ERROR (cogl_blend_string_error_quark ())

GError domain for blend string parser errors

Since 1.0


enum CoglBlendStringError

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

COGL_BLEND_STRING_ERROR_PARSE_ERROR

Generic parse error

COGL_BLEND_STRING_ERROR_ARGUMENT_PARSE_ERROR

Argument parse error

COGL_BLEND_STRING_ERROR_INVALID_ERROR

Internal parser error

COGL_BLEND_STRING_ERROR_GPU_UNSUPPORTED_ERROR

Blend string not supported by the GPU

Since 1.0


cogl_material_set_blend ()

gboolean            cogl_material_set_blend             (CoglMaterial *material,
                                                         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>))

Warning

The brackets around blend factors are currently not optional!

This is the list of source-names usable as blend factors:

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

Note

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

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

material :

A CoglMaterial object

blend_string :

A Cogl blend string describing the desired blend function.

error :

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

material :

A CoglMaterial object

constant_color :

The constant color you want

Since 1.0


cogl_material_set_point_size ()

void                cogl_material_set_point_size        (CoglHandle 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.

material :

a CoglHandle to a material.

size :

the new point size.

Since 1.4


cogl_material_get_point_size ()

float               cogl_material_get_point_size        (CoglHandle material);

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

material :

a CoglHandle to a material.

Returns :

the point size of the material.

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.

Note

In the future, we may define other types of material layers, such as purely GLSL based layers.

material :

A CoglMaterial object

layer_index :

the index of the layer

texture :

a CoglHandle for the layer object

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

material :

A CoglMaterial object

layer_index :

Specifies the layer you want to remove

cogl_material_set_layer_combine ()

gboolean            cogl_material_set_layer_combine     (CoglMaterial *material,
                                                         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:

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

Layer Combine Examples

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

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

Note

You can't give a multiplication factor for arguments as you can with blending.

material :

A CoglMaterial object

layer_index :

Specifies the layer you want define a combine function for

blend_string :

A Cogl blend string describing the desired texture combine function.

error :

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

material :

A CoglMaterial object

layer_index :

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

constant :

The constant color you want

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.

material :

A CoglMaterial object

layer_index :

the index for the layer inside material

matrix :

the transformation matrix for the layer

cogl_material_set_layer_point_sprite_coords_enabled ()

gboolean            cogl_material_set_layer_point_sprite_coords_enabled
                                                        (CoglMaterial *material,
                                                         int layer_index,
                                                         gboolean enable,
                                                         GError **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.

material :

a CoglHandle to a material.

layer_index :

the layer number to change.

enable :

whether to enable point sprite coord generation.

error :

A return location for a GError, or NULL to ignore errors.

Returns :

TRUE if the function succeeds, FALSE otherwise.

Since 1.4


cogl_material_get_layer_point_sprite_coords_enabled ()

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

material :

a CoglHandle to a material.

layer_index :

the layer number to check.

Returns :

whether the texture coordinates will be replaced with point sprite coordinates.

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

material :

A CoglMaterial object

Returns :

the number of layers

Since 1.0


enum CoglMaterialFilter

typedef enum {
  COGL_MATERIAL_FILTER_NEAREST = GL_NEAREST,
  COGL_MATERIAL_FILTER_LINEAR = GL_LINEAR,
  COGL_MATERIAL_FILTER_NEAREST_MIPMAP_NEAREST = GL_NEAREST_MIPMAP_NEAREST,
  COGL_MATERIAL_FILTER_LINEAR_MIPMAP_NEAREST = GL_LINEAR_MIPMAP_NEAREST,
  COGL_MATERIAL_FILTER_NEAREST_MIPMAP_LINEAR = GL_NEAREST_MIPMAP_LINEAR,
  COGL_MATERIAL_FILTER_LINEAR_MIPMAP_LINEAR = GL_LINEAR_MIPMAP_LINEAR
} 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.

COGL_MATERIAL_FILTER_NEAREST

Measuring in manhatten distance from the, current pixel center, use the nearest texture texel

COGL_MATERIAL_FILTER_LINEAR

Use the weighted average of the 4 texels nearest the current pixel center

COGL_MATERIAL_FILTER_NEAREST_MIPMAP_NEAREST

Select the mimap level whose texel size most closely matches the current pixel, and use the COGL_MATERIAL_FILTER_NEAREST criterion

COGL_MATERIAL_FILTER_LINEAR_MIPMAP_NEAREST

Select the mimap level whose texel size most closely matches the current pixel, and use the COGL_MATERIAL_FILTER_LINEAR criterion

COGL_MATERIAL_FILTER_NEAREST_MIPMAP_LINEAR

Select the two mimap levels whose texel size most closely matches the current pixel, use the COGL_MATERIAL_FILTER_NEAREST criterion on each one and take their weighted average

COGL_MATERIAL_FILTER_LINEAR_MIPMAP_LINEAR

Select the two mimap levels whose texel size most closely matches the current pixel, use the COGL_MATERIAL_FILTER_LINEAR criterion on each one and take their weighted average

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

material :

A CoglMaterial object

layer_index :

the layer number to change.

min_filter :

the filter used when scaling a texture down.

mag_filter :

the filter used when magnifying a texture.

enum CoglMaterialLayerType

typedef enum {
  COGL_MATERIAL_LAYER_TYPE_TEXTURE
} CoglMaterialLayerType;

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

COGL_MATERIAL_LAYER_TYPE_TEXTURE

The layer represents a texture

Since 1.0


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.

layer :

A CoglMaterialLayer object

Returns :

the type of the layer

cogl_material_layer_get_texture ()

CoglHandle          cogl_material_layer_get_texture     (CoglMaterialLayer *layer);

Extracts a texture handle for a specific layer.

Note

In the future Cogl may support purely GLSL based layers; for those layers this function which will likely return COGL_INVALID_HANDLE if you try to get the texture handle from them. Considering this scenario, you should call cogl_material_layer_get_type() first in order check it is of type COGL_MATERIAL_LAYER_TYPE_TEXTURE before calling this function.

layer :

A CoglMaterialLayer object

Returns :

a CoglHandle for the texture inside the layer. [transfer none]

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

layer :

a CoglHandle for a material layer

Returns :

the current downscaling filter

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

layer :

A CoglMaterialLayer object

Returns :

the current downscaling filter

enum CoglMaterialWrapMode

typedef enum {
  COGL_MATERIAL_WRAP_MODE_REPEAT = GL_REPEAT,
  COGL_MATERIAL_WRAP_MODE_CLAMP_TO_EDGE = GL_CLAMP_TO_EDGE,
  COGL_MATERIAL_WRAP_MODE_AUTOMATIC = GL_ALWAYS
} 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.

COGL_MATERIAL_WRAP_MODE_REPEAT

The texture will be repeated. This is useful for example to draw a tiled background.

COGL_MATERIAL_WRAP_MODE_CLAMP_TO_EDGE

The coordinates outside the range 0→1 will sample copies of the edge pixels of the texture. This is useful to avoid artifacts if only one copy of the texture is being rendered.

COGL_MATERIAL_WRAP_MODE_AUTOMATIC

Cogl will try to automatically decide which of the above two to use. For cogl_rectangle(), it will use repeat mode if any of the texture coordinates are outside the range 0→1, otherwise it will use clamp to edge. For cogl_polygon() it will always use repeat mode. For cogl_vertex_buffer_draw() it will use repeat mode except for layers that have point sprite coordinate generation enabled. This is the default value.

Since 1.4


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.

material :

A CoglMaterial object

layer_index :

the layer number to change.

mode :

the new wrap mode

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.

material :

A CoglMaterial object

layer_index :

the layer number to change.

mode :

the new wrap mode

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.

material :

A CoglMaterial object

layer_index :

the layer number to change.

mode :

the new wrap mode

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.

material :

A CoglMaterial object

layer_index :

the layer number to change.

mode :

the new wrap mode

Since 1.4


cogl_material_layer_get_wrap_mode_s ()

CoglMaterialWrapMode  cogl_material_layer_get_wrap_mode_s
                                                        (CoglMaterialLayer *layer);

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

layer :

A CoglMaterialLayer object

Returns :

the wrap mode value for the s coordinate.

Since 1.4


cogl_material_layer_get_wrap_mode_t ()

CoglMaterialWrapMode  cogl_material_layer_get_wrap_mode_t
                                                        (CoglMaterialLayer *layer);

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

layer :

A CoglMaterialLayer object

Returns :

the wrap mode value for the t coordinate.

Since 1.4


cogl_material_layer_get_wrap_mode_p ()

CoglMaterialWrapMode  cogl_material_layer_get_wrap_mode_p
                                                        (CoglMaterialLayer *layer);

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

layer :

A CoglMaterialLayer object

Returns :

the wrap mode value for the p coordinate.

Since 1.4