Materials

## Materials Materials — Fuctions for creating and manipulating materials |

## Synopsis

    CoglHandle          cogl_material_new                   (void);
    CoglHandle          cogl_material_ref                   (CoglHandle handle);
    void                cogl_material_unref                 (CoglHandle handle);
    gboolean            cogl_is_material                    (CoglHandle handle);
    void                cogl_material_set_color             (CoglHandle material,
                                                             const CoglColor *color);
    void                cogl_material_set_color4ub          (CoglHandle material,
                                                             guint8 red,
                                                             guint8 green,
                                                             guint8 blue,
                                                             guint8 alpha);
    void                cogl_material_set_color4f           (CoglHandle material,
                                                             float red,
                                                             float green,
                                                             float blue,
                                                             float alpha);
    void                cogl_material_get_color             (CoglHandle material,
                                                             CoglColor *color);
    void                cogl_material_set_ambient           (CoglHandle material,
                                                             const CoglColor *ambient);
    void                cogl_material_get_ambient           (CoglHandle material,
                                                             CoglColor *ambient);
    void                cogl_material_set_diffuse           (CoglHandle material,
                                                             const CoglColor *diffuse);
    void                cogl_material_get_diffuse           (CoglHandle material,
                                                             CoglColor *diffuse);
    void                cogl_material_set_ambient_and_diffuse
                                                            (CoglHandle material,
                                                             const CoglColor *color);
    void                cogl_material_set_emission          (CoglHandle material,
                                                             const CoglColor *emission);
    void                cogl_material_get_emission          (CoglHandle material,
                                                             CoglColor *emission);
    void                cogl_material_set_specular          (CoglHandle material,
                                                             const CoglColor *specular);
    void                cogl_material_get_specular          (CoglHandle material,
                                                             CoglColor *specular);
    void                cogl_material_set_shininess         (CoglHandle material,
                                                             float shininess);
    float               cogl_material_get_shininess         (CoglHandle material);
    enum                CoglMaterialAlphaFunc;
    void                cogl_material_set_alpha_test_function
                                                            (CoglHandle material,
                                                             CoglMaterialAlphaFunc alpha_func,
                                                             float alpha_reference);
    enum                CoglBlendStringError;
    #define             COGL_BLEND_STRING_ERROR
    gboolean            cogl_material_set_blend             (CoglHandle material,
                                                             const char *blend_string,
                                                             GError **error);
    void                cogl_material_set_blend_constant    (CoglHandle material,
                                                             CoglColor *constant_color);
    void                cogl_material_set_layer             (CoglHandle material,
                                                             int layer_index,
                                                             CoglHandle texture);
    void                cogl_material_remove_layer          (CoglHandle material,
                                                             gint layer_index);
    gboolean            cogl_material_set_layer_combine     (CoglHandle material,
                                                             gint layer_index,
                                                             const char *blend_string,
                                                             GError **error);
    void                cogl_material_set_layer_combine_constant
                                                            (CoglHandle material,
                                                             int layer_index,
                                                             CoglColor *constant);
    void                cogl_material_set_layer_matrix      (CoglHandle material,
                                                             int layer_index,
                                                             CoglMatrix *matrix);
    const GList *       cogl_material_get_layers            (CoglHandle material);
    int                 cogl_material_get_n_layers          (CoglHandle material);
    enum                CoglMaterialFilter;
    void                cogl_material_set_layer_filters     (CoglHandle handle,
                                                             gint layer_index,
                                                             CoglMaterialFilter min_filter,
                                                             CoglMaterialFilter mag_filter);
    CoglMaterialLayerType  cogl_material_layer_get_type     (CoglHandle layer_handle);
    CoglHandle          cogl_material_layer_get_texture     (CoglHandle layer_handle);
    CoglMaterialFilter  cogl_material_layer_get_min_filter  (CoglHandle layer_handle);
    CoglMaterialFilter  cogl_material_layer_get_mag_filter  (CoglHandle layer_handle);

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

    CoglHandle          cogl_material_new                   (void);

Allocates and initializes a blank white material

Returns : | a handle to the new material

### cogl_material_ref ()

    CoglHandle          cogl_material_ref                   (CoglHandle handle);

Increment the reference count for a cogl material.

`handle` : | a `CoglHandle`.
Returns : | the `handle`. Since 1.0

### cogl_material_unref ()

    void                cogl_material_unref                 (CoglHandle handle);

Decrement the reference count for a cogl material.

Since 1.0

`handle` : | a `CoglHandle`.

### 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             (CoglHandle material,
                                                             const CoglColor *color);

This is 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

`material` : | A CoglMaterial object
`color` : | The components of the color

### cogl_material_set_color4ub ()

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

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

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

Since 1.0

`material` : | A CoglMaterial object
`red` : | The red component
`green` : | The green component
`blue` : | The blue component
`alpha` : | The alpha component

### cogl_material_set_color4f ()

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

This is 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

`material` : | A CoglMaterial object
`red` : | The red component
`green` : | The green component
`blue` : | The blue component
`alpha` : | The alpha component

### cogl_material_get_color ()

    void                cogl_material_get_color             (CoglHandle material,
                                                             CoglColor *color);

This retrieves the current material color.

Since 1.0

`material` : | A CoglMaterial object
`color` : | The location to store the color

### cogl_material_set_ambient ()

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

Exposing the standard OpenGL lighting model; this function sets the material's ambient color. 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 most aparent where the light hits at a slant.

The default value is (0.2, 0.2, 0.2, 1.0)

Since 1.0

`material` : | A CoglMaterial object
`ambient` : | The components of the desired ambient color

### cogl_material_get_ambient ()

    void                cogl_material_get_ambient           (CoglHandle material,
                                                             CoglColor *ambient);

This retrieves the materials current ambient color.

Since 1.0

`material` : | A CoglMaterial object
`ambient` : | The location to store the ambient color

### cogl_material_set_diffuse ()

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

Exposing the standard OpenGL lighting model; this function sets the material's diffuse color. 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

`material` : | A CoglMaterial object
`diffuse` : | The components of the desired diffuse color

### cogl_material_get_diffuse ()

    void                cogl_material_get_diffuse           (CoglHandle material,
                                                             CoglColor *diffuse);

This retrieves the materials current diffuse color.

Since 1.0

`material` : | A CoglMaterial object
`diffuse` : | The location to store the diffuse color

### cogl_material_set_ambient_and_diffuse ()

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

This is a convenience for setting the diffuse and ambient color of the material at the same time.

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

`material` : | A CoglMaterial object
`color` : | The components of the desired ambient and diffuse colors

### cogl_material_set_emission ()

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

Exposing the standard OpenGL lighting model; this function sets the material's emissive color. 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

`material` : | A CoglMaterial object
`emission` : | The components of the desired emissive color

### cogl_material_get_emission ()

    void                cogl_material_get_emission          (CoglHandle material,
                                                             CoglColor *emission);

This retrieves the materials current emission color.

Since 1.0

`material` : | A CoglMaterial object
`emission` : | The location to store the emission color

### cogl_material_set_specular ()

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

Exposing the standard OpenGL lighting model; this function sets the material's specular color. 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

`material` : | A CoglMaterial object
`specular` : | The components of the desired specular color

### cogl_material_get_specular ()

    void                cogl_material_get_specular          (CoglHandle material,
                                                             CoglColor *specular);

This retrieves the materials current specular color.

Since 1.0

`material` : | A CoglMaterial object
`specular` : | The location to store the specular color

### cogl_material_set_shininess ()

    void                cogl_material_set_shininess         (CoglHandle material,
                                                             float shininess);

This function sets the materials shininess which determines how specular highlights are calculated. A higher shininess will produce smaller brigher highlights.

The default value is 0.0

Since 1.0

`material` : | A CoglMaterial object
`shininess` : | The desired shininess; range: [0.0, 1.0]

### cogl_material_get_shininess ()

    float               cogl_material_get_shininess         (CoglHandle material);

This retrieves the materials current emission color.

`material` : | A CoglMaterial object
Returns : | The materials current shininess value Since 1.0

### enum CoglMaterialAlphaFunc

    typedef enum _CoglMaterialAlphaFunc
    {
      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
                                                            (CoglHandle 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

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

### 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;

### COGL_BLEND_STRING_ERROR

    #define COGL_BLEND_STRING_ERROR (cogl_blend_string_error_quark ())

### cogl_material_set_blend ()

    gboolean            cogl_material_set_blend             (CoglHandle material,
                                                             const char *blend_string,
                                                             GError **error);

If not already familiar; please refer here for an overview of what blend strings are and there 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>))

### Warning

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.

###### Examples

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.

`material` : | A CoglMaterial object
`blend_string` : | A Cogl blend string describing the desired blend function.
`error` : | 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 dont support this. 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 blending is supported by the underlying driver/hardware. If there was an error, it returns FALSE.

Since 1.0

### cogl_material_set_blend_constant ()

    void                cogl_material_set_blend_constant    (CoglHandle material,
                                                             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_layer ()

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

Since 1.0

`material` : | A CoglHandle for a material object
`layer_index` : | the index of the layer
`texture` : | a CoglHandle for the layer object

### cogl_material_remove_layer ()

    void                cogl_material_remove_layer          (CoglHandle material,
                                                             gint layer_index);

`material` : |
`layer_index` : |

### cogl_material_set_layer_combine ()

    gboolean            cogl_material_set_layer_combine     (CoglHandle material,
                                                             gint 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()`

### Example

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

### 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. If there was an error, it returns FALSE.

Since 1.0

### cogl_material_set_layer_combine_constant ()

    void                cogl_material_set_layer_combine_constant
                                                            (CoglHandle material,
                                                             int layer_index,
                                                             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

`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

### cogl_material_set_layer_matrix ()

    void                cogl_material_set_layer_matrix      (CoglHandle material,
                                                             int layer_index,
                                                             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_get_layers ()

    const GList *       cogl_material_get_layers            (CoglHandle material);

This function lets you access a materials internal list of layers for iteration.

`material` : | a CoglHandle for a material
Returns : | element-type Handle) (transfer none. element-type Handle. transfer none.

### cogl_material_get_n_layers ()

    int                 cogl_material_get_n_layers          (CoglHandle material);

Retrieves the number of layers defined for the given `material`

`material` : | a CoglHandle for a material
Returns : | the number of layers

Since 1.0

### enum CoglMaterialFilter

    typedef enum _CoglMaterialFilter
    {
      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     (CoglHandle handle,
                                                             gint 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%.

`handle` : | a CoglHandle to a material.
`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.

### cogl_material_layer_get_type ()

    CoglMaterialLayerType  cogl_material_layer_get_type     (CoglHandle layer_handle);

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_handle` : | A CoglHandle for a material layer
Returns : | the type of the layer

### cogl_material_layer_get_texture ()

    CoglHandle          cogl_material_layer_get_texture     (CoglHandle layer_handle);

This lets you extract a CoglTexture handle for a specific layer.

### Note

In the future, we may support purely GLSL based layers which will likely return `COGL_INVALID_HANDLE` if you try to get the texture. Considering this, you can call cogl_material_layer_get_type first, to check it is of type `COGL_MATERIAL_LAYER_TYPE_TEXTURE`.

`layer_handle` : | A CoglHandle for a material layer
Returns : | a CoglHandle for the texture inside `layer_handle`

### cogl_material_layer_get_min_filter ()

    CoglMaterialFilter  cogl_material_layer_get_min_filter  (CoglHandle layer_handle);

Query the currently set downscaling filter for a cogl material layer.

`layer_handle` : | a CoglHandle for a material layer
Returns : | the current downscaling filter for a cogl material layer.

### cogl_material_layer_get_mag_filter ()

    CoglMaterialFilter  cogl_material_layer_get_mag_filter  (CoglHandle layer_handle);

Query the currently set downscaling filter for a cogl material layer.

`layer_handle` : | a CoglHandle for a material layer
Returns : | the current downscaling filter for a cogl material layer.