Computes the cosine of angle

Parameters:

gint32 angle Required (not null)

an angle expressed using CoglAngle

Returns:

gint32 the cosine of the passed angle

Computes the sine of angle

Parameters:

gint32 angle Required (not null)

an angle expressed using CoglAngle

Returns:

gint32 the sine of the passed angle

Computes the tangent of angle

Parameters:

gint32 angle Required (not null)

an angle expressed using CoglAngle

Returns:

gint32 the tangent of the passed angle

We do not advise nor reliably support the interleaving of raw GL drawing and
Cogl drawing functions, but if you insist, cogl_begin_gl() and cogl_end_gl()
provide a simple mechanism that may at least give you a fighting chance of
succeeding.
through the modification of GL state; that will never be reliably supported,
but if you are trying to do something like:
|[
{
- setup some OpenGL state.
- draw using OpenGL (e.g. glDrawArrays() )
- reset modified OpenGL state.
- continue using Cogl to draw
}
]|
You should surround blocks of drawing using raw GL with cogl_begin_gl()
and cogl_end_gl():
|[
{
cogl_begin_gl ();
- setup some OpenGL state.
- draw using OpenGL (e.g. glDrawArrays() )
- reset modified OpenGL state.
cogl_end_gl ();
- continue using Cogl to draw
}
]|
Don't ever try and do:
|[
{
- setup some OpenGL state.
- use Cogl to draw
- reset modified OpenGL state.
}
]|
When the internals of Cogl evolves, this is very liable to break.
This function will flush all batched primitives, and subsequently flush
all internal Cogl state to OpenGL as if it were going to draw something
itself.
The result is that the OpenGL modelview matrix will be setup; the state
corresponding to the current source material will be set up and other world
state such as backface culling, depth and fogging enabledness will be sent
to OpenGL.
No special material state is flushed, so if you want Cogl to setup a
simplified material state it is your responsibility to set a simple source
material before calling cogl_begin_gl(). E.g. by calling
cogl_set_source_color4ub().
It is your responsibility to restore any OpenGL state that you modify
to how it was after calling cogl_begin_gl() if you don't do this then the
result of further Cogl calls is undefined.
You can not nest begin/end blocks.
Again we would like to stress, we do not advise the use of this API and if
possible we would prefer to improve Cogl than have developers require raw
OpenGL.

Returns:

none

Returns:

guint32

Parses an image file enough to extract the width and height
of the bitmap.

Parameters:

String filename Required (not null)

the file to check

Object out_values

gint32 width

gint32 height

Returns:

gboolean TRUE if the image was successfully parsed

Returns:

guint32

Check whether name occurs in list of extensions in ext.
not appropriate to expose OpenGL extensions through the Cogl API. This
function can be replaced by the following equivalent code:
|[
]|

Parameters:

String name Required (not null)

extension to check for

String ext Required (not null)

list of extensions

Returns:

gboolean TRUE if the extension occurs in the list, FALSE otherwise.

Clears all the auxiliary buffers identified in the buffers mask, and if
that includes the color buffer then the specified color is used.

Parameters:

Cogl.Color color Required (not null)

Background color to clear to

guint32 buffers Required (not null)

A mask of CoglBufferBit's identifying which auxiliary buffers to clear

Returns:

none

Ensures that the current clipping region has been set in GL. This
will automatically be called before any Cogl primitives but it
maybe be neccessary to call if you are using raw GL calls with
clipping.

Returns:

none

Reverts the clipping region to the state before the last call to
cogl_clip_push().

Returns:

none

Specifies a rectangular clipping area for all subsequent drawing
operations. Any drawing commands that extend outside the rectangle
will be clipped so that only the portion inside the rectangle will
be displayed. The rectangle dimensions are transformed by the
current model-view matrix.
The rectangle is intersected with the current clip region. To undo
the effect of this function, call cogl_clip_pop().
with other API that specify rectangles in model space, and when used
with a coordinate space that puts the origin at the center and y+
extending up, it's awkward to use. Please use cogl_clip_push_rectangle()
instead

Parameters:

gfloat x_offset Required (not null)

left edge of the clip rectangle

gfloat y_offset Required (not null)

top edge of the clip rectangle

gfloat width Required (not null)

width of the clip rectangle

gfloat height Required (not null)

height of the clip rectangle

Returns:

none

Sets a new clipping area using the current path. The current path
is then cleared. The clipping area is intersected with the previous
clipping area. To restore the previous clipping area, call
cogl_clip_pop().

Returns:

none

Sets a new clipping area using the current path. The current path
is then cleared. The clipping area is intersected with the previous
clipping area. To restore the previous clipping area, call
cogl_clip_pop().

Returns:

none

Specifies a rectangular clipping area for all subsequent drawing
operations. Any drawing commands that extend outside the rectangle
will be clipped so that only the portion inside the rectangle will
be displayed. The rectangle dimensions are transformed by the
current model-view matrix.
The rectangle is intersected with the current clip region. To undo
the effect of this function, call cogl_clip_pop().

Parameters:

gfloat x0 Required (not null)

x coordinate for top left corner of the clip rectangle

gfloat y0 Required (not null)

y coordinate for top left corner of the clip rectangle

gfloat x1 Required (not null)

x coordinate for bottom right corner of the clip rectangle

gfloat y1 Required (not null)

y coordinate for bottom right corner of the clip rectangle

Returns:

none

Specifies a rectangular clipping area for all subsequent drawing
operations. Any drawing commands that extend outside the rectangle
will be clipped so that only the portion inside the rectangle will
be displayed. The rectangle dimensions are not transformed by the
current model-view matrix.
The rectangle is intersected with the current clip region. To undo
the effect of this function, call cogl_clip_pop().

Parameters:

gfloat x_offset Required (not null)

left edge of the clip rectangle in window coordinates

gfloat y_offset Required (not null)

top edge of the clip rectangle in window coordinates

gfloat width Required (not null)

width of the clip rectangle

gfloat height Required (not null)

height of the clip rectangle

Returns:

none

Specifies a rectangular clipping area for all subsequent drawing
operations. Any drawing commands that extend outside the rectangle
will be clipped so that only the portion inside the rectangle will
be displayed. The rectangle dimensions are not transformed by the
current model-view matrix.
The rectangle is intersected with the current clip region. To undo
the effect of this function, call cogl_clip_pop().

Parameters:

gint32 x_offset Required (not null)

left edge of the clip rectangle in window coordinates

gint32 y_offset Required (not null)

top edge of the clip rectangle in window coordinates

gint32 width Required (not null)

width of the clip rectangle

gint32 height Required (not null)

height of the clip rectangle

Returns:

none

Restore the state of the clipping stack that was previously saved
by cogl_clip_stack_save().
the clip stack when switching back from an offscreen framebuffer,
but it's not necessary anymore given that framebuffers now own
separate clip stacks which will be automatically switched between
when a new buffer is set. Calling this function has no effect

Returns:

none

Save the entire state of the clipping stack and then clear all
clipping. The previous state can be returned to with
cogl_clip_stack_restore(). Each call to cogl_clip_push() after this
must be matched by a call to cogl_clip_pop() before calling
cogl_clip_stack_restore().
clip stack when switching to an offscreen framebuffer, but it's
not necessary anymore given that framebuffers now own separate
clip stacks which will be automatically switched between when a
new buffer is set. Calling this function has no effect

Returns:

none

Compares two CoglColors and checks if they are the same.
This function can be passed to g_hash_table_new() as the key_equal_func
parameter, when using CoglColors as keys in a GHashTable.

Parameters:

void* v1 Required (not null)

a CoglColor

void* v2 Required (not null)

a CoglColor

Returns:

gboolean TRUE if the two colors are the same.

This function disables fogging, so primitives drawn afterwards will not be
blended with any previously set fog color.

Returns:

none

Parameters:

gdouble value Required (not null)

Returns:

gint32

Parameters:

gdouble value Required (not null)

Returns:

gint32

Parameters:

gdouble value Required (not null)

Returns:

guint32

Parameters:

Cogl.VerticesMode mode Required (not null)

gint32 first_vertex Required (not null)

gint32 n_vertices Required (not null)

Cogl.Attribute attributes Required (not null)

Returns:

none

Parameters:

Cogl.VerticesMode mode Required (not null)

gint32 first_vertex Required (not null)

gint32 n_vertices Required (not null)

Cogl.Indices indices Required (not null)

Cogl.Attribute attributes Required (not null)

Returns:

none

This is the counterpart to cogl_begin_gl() used to delimit blocks of drawing
code using raw OpenGL. Please refer to cogl_begin_gl() for full details.

Returns:

none

Checks whether the given COGL features are available. Multiple
features can be checked for by or-ing them together with the '|'
operator. TRUE is only returned if all of the requested features
are available.

Parameters:

Cogl.FeatureFlags features Required (not null)

A bitmask of features to check for

Returns:

gboolean TRUE if the features are available, FALSE otherwise.

Computes the arc tangent of a.

Parameters:

gint32 a Required (not null)

a CoglFixed number

Returns:

gint32 the arc tangent of the passed value, in fixed point notation

Computes the arc tangent of a / b but uses the sign of both
arguments to return the angle in right quadrant.
notation

Parameters:

gint32 a Required (not null)

the numerator as a CoglFixed number

gint32 b Required (not null)

the denominator as a CoglFixed number

Returns:

gint32 the arc tangent of the passed fraction, in fixed point

Computes the cosine of angle.

Parameters:

gint32 angle Required (not null)

a CoglFixed number

Returns:

gint32 the cosine of the passed angle, in fixed point notation

Parameters:

gint32 a Required (not null)

gint32 b Required (not null)

Returns:

gint32

Returns:

Number

Calculates base 2 logarithm.
This function is some 2.5 times faster on x86, and over 12 times faster on
fpu-less arm, than using libc log().

Parameters:

guint32 x Required (not null)

value to calculate base 2 logarithm from

Returns:

gint32 base 2 logarithm.

Parameters:

gint32 a Required (not null)

gint32 b Required (not null)

Returns:

gint32

Parameters:

gint32 a Required (not null)

gint32 b Required (not null)

gint32 c Required (not null)

Returns:

gint32

Calculates x to the y power.

Parameters:

guint32 x Required (not null)

base

gint32 y Required (not null)

CoglFixed exponent

Returns:

guint32 the power of x to the y

Calculates 2 to the x power.
This function is around 11 times faster on x86, and around 22 times faster
on fpu-less arm than libc pow(2, x).

Parameters:

gint32 x Required (not null)

a CoglFixed number

Returns:

guint32 the power of 2 to the passed value

Computes the sine of angle.

Parameters:

gint32 angle Required (not null)

a CoglFixed number

Returns:

gint32 the sine of the passed angle, in fixed point notation

Computes the square root of x.
notation

Parameters:

gint32 x Required (not null)

a CoglFixed number

Returns:

gint32 the square root of the passed value, in floating point

Computes the tangent of angle.

Parameters:

gint32 angle Required (not null)

a CoglFixed number

Returns:

gint32 the tangent of the passed angle, in fixed point notation

This function should only need to be called in exceptional circumstances.
As an optimization Cogl drawing functions may batch up primitives
internally, so if you are trying to use raw GL outside of Cogl you stand a
better chance of being successful if you ask Cogl to flush any batched
geometry before making your state changes.
It only ensure that the underlying driver is issued all the commands
necessary to draw the batched primitives. It provides no guarantees about
when the driver will complete the rendering.
This provides no guarantees about the GL state upon returning and to avoid
confusing Cogl you should aim to restore any changes you make before
resuming use of Cogl.
If you are making state changes with the intention of affecting Cogl drawing
primitives you are 100% on your own since you stand a good chance of
conflicting with Cogl internals. For example clutter-gst which currently
uses direct GL calls to bind ARBfp programs will very likely break when Cogl
starts to use ARBfb programs itself for the material API.

Returns:

none

Replaces the current projection matrix with a perspective matrix
for the given viewing frustum.

Parameters:

gfloat left Required (not null)

Left clipping plane

gfloat right Required (not null)

Right clipping plane

gfloat bottom Required (not null)

Bottom clipping plane

gfloat top Required (not null)

Top clipping plane

gfloat z_near Required (not null)

Nearest visible point

gfloat z_far Required (not null)

Furthest visible point along the z-axis

Returns:

none

Queries if backface culling has been enabled via
cogl_set_backface_culling_enabled()

Returns:

gboolean TRUE if backface culling is enabled, and FALSE otherwise

Gets the number of bitplanes used for each of the color components
in the color buffer. Pass NULL for any of the arguments if the
value is not required.

Returns:

red: gint32

green: gint32

blue: gint32

alpha: gint32

Queries if depth testing has been enabled via cogl_set_depth_test_enable()
instead.

Returns:

gboolean TRUE if depth testing is enabled, and FALSE otherwise

Returns all of the features supported by COGL.

Returns:

Cogl.FeatureFlags A logical OR of all the supported COGL features.

Stores the current model-view matrix in matrix.

Returns:

Cogl.Matrix

Stores the current projection matrix in matrix.

Returns:

Cogl.Matrix

Stores the current viewport in v. v[0] and v[1] get the x and y
position of the viewport and v[2] and v[3] get the width and
height.

Returns:

Array

Returns:

Number

Parameters:

Cogl.Indices indices Required (not null)

Returns:

Cogl.IndicesType

Parameters:

void* object Required (not null)

Returns:

gboolean

Checks whether handle is a CoglHandle for a bitmap
and FALSE otherwise

Parameters:

void* handle Required (not null)

a CoglHandle for a bitmap

Returns:

gboolean TRUE if the passed handle represents a bitmap,

Parameters:

void* object Required (not null)

Returns:

gboolean

Parameters:

void* object Required (not null)

Returns:

gboolean

Gets whether the given handle references an existing material object.
FALSE otherwise

Parameters:

void* handle Required (not null)

A CoglHandle

Returns:

gboolean TRUE if the handle references a CoglMaterial,

Determines whether the given CoglHandle references an offscreen buffer
object.
FALSE otherwise

Parameters:

void* handle Required (not null)

A CoglHandle for an offscreen buffer

Returns:

gboolean TRUE if the handle references an offscreen buffer,

Gets whether the given handle references an existing path object.
FALSE otherwise

Parameters:

void* handle Required (not null)

A CoglHandle

Returns:

gboolean TRUE if the handle references a CoglPath,

Parameters:

void* handle Required (not null)

Returns:

gboolean

Parameters:

void* object Required (not null)

Returns:

gboolean

Parameters:

void* object Required (not null)

Returns:

gboolean

Gets whether the given handle references an existing program object.
FALSE otherwise

Parameters:

void* handle Required (not null)

A CoglHandle

Returns:

gboolean TRUE if the handle references a program,

Gets whether the given handle references an existing shader object.
FALSE otherwise

Parameters:

void* handle Required (not null)

A CoglHandle

Returns:

gboolean TRUE if the handle references a shader,

Gets whether the given handle references an existing texture object.
FALSE otherwise

Parameters:

void* handle Required (not null)

A CoglHandle

Returns:

gboolean TRUE if the handle references a texture, and

Parameters:

void* handle Required (not null)

Returns:

gboolean

Parameters:

void* object Required (not null)

Returns:

gboolean

Checks whether handle is a Vertex Buffer Object
otherwise

Parameters:

void* handle Required (not null)

a CoglHandle for a vertex buffer object

Returns:

gboolean TRUE if the handle is a VBO, and FALSE

Checks whether handle is a handle to the indices for a vertex
buffer object
otherwise

Parameters:

void* handle Required (not null)

a CoglHandle

Returns:

gboolean TRUE if the handle is indices, and FALSE

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.

Parameters:

Cogl.MaterialLayer layer Required (not null)

A CoglMaterialLayer object

Returns:

Cogl.MaterialLayerType the type of the layer

Compares two matrices to see if they represent the same
transformation. Although internally the matrices may have different
annotations associated with them and may potentially have a cached
inverse matrix these are not considered in the comparison.

Parameters:

void* v1 Required (not null)

A 4x4 transformation matrix

void* v2 Required (not null)

A 4x4 transformation matrix

Returns:

gboolean

This creates an offscreen buffer object using the given texture as the
primary color buffer. It doesn't just initialize the contents of the
offscreen buffer with the texture; they are tightly bound so that
drawing to the offscreen buffer effectivly updates the contents of the
given texture. You don't need to destroy the offscreen buffer before
you can use the texture again.
if it wasn't possible to create the buffer.

Parameters:

void* handle Required (not null)

A CoglHandle for a Cogl texture

Returns:

void* a CoglHandle for the new offscreen buffer or COGL_INVALID_HANDLE

Replaces the current projection matrix with an orthographic projection
matrix. See to see how the matrix is
calculated.

This function copies the arguments from OpenGL's glOrtho() even
though they are unnecessarily confusing due to the z near and z far
arguments actually being a "distance" from the origin, where
negative values are behind the viewer, instead of coordinates for
the z clipping planes which would have been consistent with the
left, right bottom and top arguments.

Parameters:

gfloat left Required (not null)

The coordinate for the left clipping plane

gfloat right Required (not null)

The coordinate for the right clipping plane

gfloat bottom Required (not null)

The coordinate for the bottom clipping plane

gfloat top Required (not null)

The coordinate for the top clipping plane

gfloat near Required (not null)

The distance to the near clipping plane (negative if the plane is behind the viewer)

gfloat far Required (not null)

The distance for the far clipping plane (negative if the plane is behind the viewer)

Returns:

none

Adds an elliptical arc segment to the current path. A straight line
segment will link the current pen location with the first vertex
of the arc. If you perform a move_to to the arcs start just before
drawing it you create a free standing arc.
The angles are measured in degrees where 0° is in the direction of
the positive X axis and 90° is in the direction of the positive Y
axis. The angle of the arc begins at angle_1 and heads towards
otherwise it will increase).

Parameters:

gfloat center_x Required (not null)

X coordinate of the elliptical arc center

gfloat center_y Required (not null)

Y coordinate of the elliptical arc center

gfloat radius_x Required (not null)

X radius of the elliptical arc

gfloat radius_y Required (not null)

Y radius of the elliptical arc

gfloat angle_1 Required (not null)

Angle in degrees at which the arc begin

gfloat angle_2 Required (not null)

Angle in degrees at which the arc ends

Returns:

none

Closes the path being constructed by adding a straight line segment
to it that ends at the first vertex of the path.

Returns:

none

Adds a cubic bezier curve segment to the current path with the given
second, third and fourth control points and using current pen location
as the first control point.

Parameters:

gfloat x_1 Required (not null)

X coordinate of the second bezier control point

gfloat y_1 Required (not null)

Y coordinate of the second bezier control point

gfloat x_2 Required (not null)

X coordinate of the third bezier control point

gfloat y_2 Required (not null)

Y coordinate of the third bezier control point

gfloat x_3 Required (not null)

X coordinate of the fourth bezier control point

gfloat y_3 Required (not null)

Y coordinate of the fourth bezier control point

Returns:

none

Constructs an ellipse shape. If there is an existing path this will
start a new disjoint sub-path.

Parameters:

gfloat center_x Required (not null)

X coordinate of the ellipse center

gfloat center_y Required (not null)

Y coordinate of the ellipse center

gfloat radius_x Required (not null)

X radius of the ellipse

gfloat radius_y Required (not null)

Y radius of the ellipse

Returns:

none

Fills the interior of the constructed shape using the current
drawing color. The current path is then cleared. To use the path
again, call cogl_path_fill_preserve() instead.
The interior of the shape is determined using the fill rule of the
path. See CoglPathFillRule for details.

Returns:

none

Fills the interior of the constructed shape using the current
drawing color and preserves the path to be used again. See
cogl_path_fill() for a description what is considered the interior
of the shape.

Returns:

none

Returns:

Cogl.PathFillRule the fill rule that is used for the current path.

Constructs a straight line shape starting and ending at the given
coordinates. If there is an existing path this will start a new
disjoint sub-path.

Parameters:

gfloat x_1 Required (not null)

X coordinate of the start line vertex

gfloat y_1 Required (not null)

Y coordinate of the start line vertex

gfloat x_2 Required (not null)

X coordinate of the end line vertex

gfloat y_2 Required (not null)

Y coordinate of the end line vertex

Returns:

none

Adds a straight line segment to the current path that ends at the
given coordinates.

Parameters:

gfloat x Required (not null)

X coordinate of the end line vertex

gfloat y Required (not null)

Y coordinate of the end line vertex

Returns:

none

Moves the pen to the given location. If there is an existing path
this will start a new disjoint subpath.

Parameters:

gfloat x Required (not null)

X coordinate of the pen location to move to.

gfloat y Required (not null)

Y coordinate of the pen location to move to.

Returns:

none

Clears the current path and starts a new one. Creating a new path
also resets the fill rule to the default which is
COGL_PATH_FILL_RULE_EVEN_ODD.

Returns:

none

Constructs a polygonal shape of the given number of vertices. If
there is an existing path this will start a new disjoint sub-path.
The coords array must contain 2 * num_points values. The first value
represents the X coordinate of the first vertex, the second value
represents the Y coordinate of the first vertex, continuing in the same
fashion for the rest of the vertices.

Parameters:

Array coords Required (not null)

A pointer to the first element of an array of fixed-point values that specify the vertex coordinates.

gint32 num_points Required (not null)

The total number of vertices.

Returns:

none

Constructs a series of straight line segments, starting from the
first given vertex coordinate. If there is an existing path this
will start a new disjoint sub-path. Each subsequent segment starts
where the previous one ended and ends at the next given vertex
coordinate.
The coords array must contain 2 * num_points values. The first value
represents the X coordinate of the first vertex, the second value
represents the Y coordinate of the first vertex, continuing in the same
fashion for the rest of the vertices. (num_points - 1) segments will
be constructed.

Parameters:

Array coords Required (not null)

A pointer to the first element of an array of fixed-point values that specify the vertex coordinates.

gint32 num_points Required (not null)

The total number of vertices.

Returns:

none

Constructs a rectangular shape at the given coordinates. If there
is an existing path this will start a new disjoint sub-path.

Parameters:

gfloat x_1 Required (not null)

X coordinate of the top-left corner.

gfloat y_1 Required (not null)

Y coordinate of the top-left corner.

gfloat x_2 Required (not null)

X coordinate of the bottom-right corner.

gfloat y_2 Required (not null)

Y coordinate of the bottom-right corner.

Returns:

none

Adds a cubic bezier curve segment to the current path with the given
second, third and fourth control points and using current pen location
as the first control point. The given coordinates are relative to the
current pen location.

Parameters:

gfloat x_1 Required (not null)

X coordinate of the second bezier control point

gfloat y_1 Required (not null)

Y coordinate of the second bezier control point

gfloat x_2 Required (not null)

X coordinate of the third bezier control point

gfloat y_2 Required (not null)

Y coordinate of the third bezier control point

gfloat x_3 Required (not null)

X coordinate of the fourth bezier control point

gfloat y_3 Required (not null)

Y coordinate of the fourth bezier control point

Returns:

none

Adds a straight line segment to the current path that ends at the
given coordinates relative to the current pen location.

Parameters:

gfloat x Required (not null)

X offset from the current pen location of the end line vertex

gfloat y Required (not null)

Y offset from the current pen location of the end line vertex

Returns:

none

Moves the pen to the given offset relative to the current pen
location. If there is an existing path this will start a new
disjoint subpath.

Parameters:

gfloat x Required (not null)

X offset from the current pen location to move the pen to.

gfloat y Required (not null)

Y offset from the current pen location to move the pen to.

Returns:

none

Constructs a rectangular shape with rounded corners. If there is an
existing path this will start a new disjoint sub-path.

Parameters:

gfloat x_1 Required (not null)

X coordinate of the top-left corner.

gfloat y_1 Required (not null)

Y coordinate of the top-left corner.

gfloat x_2 Required (not null)

X coordinate of the bottom-right corner.

gfloat y_2 Required (not null)

Y coordinate of the bottom-right corner.

gfloat radius Required (not null)

Radius of the corner arcs.

gfloat arc_step Required (not null)

Angle increment resolution for subdivision of the corner arcs.

Returns:

none

Sets the fill rule of the current path to fill_rule. This will
affect how the path is filled when cogl_path_fill() is later
called. Note that the fill rule state is attached to the path so
calling cogl_get_path() will preserve the fill rule and calling
cogl_path_new() will reset the fill rule back to the default.

Parameters:

Cogl.PathFillRule fill_rule Required (not null)

The new fill rule.

Returns:

none

Strokes the constructed shape using the current drawing color and a
width of 1 pixel (regardless of the current transformation
matrix). To current path is then cleared. To use the path again,
call cogl_path_stroke_preserve() instead.

Returns:

none

Strokes the constructed shape using the current drawing color and
preserves the path to be used again.

Returns:

none

Replaces the current projection matrix with a perspective matrix
based on the provided values.

Parameters:

gfloat fovy Required (not null)

Vertical of view angle in degrees.

gfloat aspect Required (not null)

Aspect ratio of diesplay

gfloat z_near Required (not null)

Nearest visible point

gfloat z_far Required (not null)

Furthest visible point along the z-axis

Returns:

none

Parameters:

void* pipeline Required (not null)

Returns:

gfloat

Parameters:

void* pipeline Required (not null)

gfloat point_size Required (not null)

Returns:

none

Draws a convex polygon using the current source material to fill / texture
with according to the texture coordinates passed.
If use_color is TRUE then the color will be changed for each vertex using
the value specified in the color member of CoglTextureVertex. This can be
used for example to make the texture fade out by setting the alpha value of
the color.
All of the texture coordinates must be in the range [0,1] and repeating the
texture is not supported.
Because of the way this function is implemented it will currently
only work if either the texture is not sliced or the backend is not
OpenGL ES and the minifying and magnifying functions are both set
to COGL_MATERIAL_FILTER_NEAREST.

Parameters:

Cogl.TextureVertex vertices Required (not null)

An array of CoglTextureVertex structs

guint32 n_vertices Required (not null)

The length of the vertices array

gboolean use_color Required (not null)

TRUE if the color member of CoglTextureVertex should be used

Returns:

none

Restore cogl_set_draw_buffer() state.

Returns:

none

Restores the framebuffer that was previously at the top of the stack.
All subsequent drawing will be redirected to this framebuffer.

Returns:

none

Restores the current model-view matrix from the matrix stack.

Returns:

none

Returns:

none

Attaches a shader to a program object, a program can have one vertex shader
and one fragment shader attached.

Parameters:

void* program_handle Required (not null)

a CoglHandle for a shdaer program.

void* shader_handle Required (not null)

a CoglHandle for a vertex of fragment shader.

Returns:

none

Retrieve the location (offset) of a uniform variable in a shader program,
a uniform is a variable that is constant for all vertices/fragments for a
shader object and is possible to modify as an external parameter.
This uniform can be set using cogl_program_uniform_1f() when the
program is in use.

Parameters:

void* handle Required (not null)

a CoglHandle for a shader program.

String uniform_name Required (not null)

the name of a uniform.

Returns:

gint32 the offset of a uniform in a specified program.

Links a program making it ready for use.

Parameters:

void* handle Required (not null)

a CoglHandle for a shader program.

Returns:

none

Parameters:

void* program Required (not null)

gint32 uniform_location Required (not null)

gfloat value Required (not null)

Returns:

none

Parameters:

void* program Required (not null)

gint32 uniform_location Required (not null)

gint32 value Required (not null)

Returns:

none

Parameters:

void* program Required (not null)

gint32 uniform_location Required (not null)

gint32 n_components Required (not null)

gint32 count Required (not null)

Array value Required (not null)

Returns:

none

Parameters:

void* program Required (not null)

gint32 uniform_location Required (not null)

gint32 n_components Required (not null)

gint32 count Required (not null)

Array value Required (not null)

Returns:

none

Parameters:

void* program Required (not null)

gint32 uniform_location Required (not null)

gint32 dimensions Required (not null)

gint32 count Required (not null)

gboolean transpose Required (not null)

Array value Required (not null)

Returns:

none

Changes the value of a floating point uniform in the currently
used (see cogl_program_use()) shader program.

Parameters:

gint32 uniform_no Required (not null)

the unform to set.

gfloat value Required (not null)

the new value of the uniform.

Returns:

none

Changes the value of an integer uniform in the currently
used (see cogl_program_use()) shader program.

Parameters:

gint32 uniform_no Required (not null)

the unform to set.

gint32 value Required (not null)

the new value of the uniform.

Returns:

none

Changes the value of a float vector uniform, or uniform array in the
currently used (see cogl_program_use()) shader program.

Parameters:

gint32 uniform_no Required (not null)

the uniform to set.

gint32 size Required (not null)

Size of float vector.

gint32 count Required (not null)

Size of array of uniforms.

Array value Required (not null)

the new value of the uniform.

Returns:

none

Changes the value of a int vector uniform, or uniform array in the
currently used (see cogl_program_use()) shader program.

Parameters:

gint32 uniform_no Required (not null)

the uniform to set.

gint32 size Required (not null)

Size of int vector.

gint32 count Required (not null)

Size of array of uniforms.

Array value Required (not null)

the new value of the uniform.

Returns:

none

Changes the value of a matrix uniform, or uniform array in the
currently used (see cogl_program_use()) shader program. The size
parameter is used to determine the square size of the matrix.

Parameters:

gint32 uniform_no Required (not null)

the uniform to set.

gint32 size Required (not null)

Size of matrix.

gint32 count Required (not null)

Size of array of uniforms.

gboolean transpose Required (not null)

Whether to transpose the matrix when setting the uniform.

Array value Required (not null)

the new value of the uniform.

Returns:

none

Activate a specific shader program replacing that part of the GL
rendering pipeline, if passed in COGL_INVALID_HANDLE the default
behavior of GL is reinstated.

Parameters:

void* handle Required (not null)

a CoglHandle for a shader program or COGL_INVALID_HANDLE.

Returns:

none

Save cogl_set_draw_buffer() state.

Returns:

none

Redirects all subsequent drawing to the specified framebuffer. This can
either be an offscreen buffer created with cogl_offscreen_new_to_texture ()
or in the future it may be an onscreen framebuffer too.
You should understand that a framebuffer owns the following state:

The projection matrix
The modelview matrix stack
The viewport
The clip stack

So these items will automatically be saved and restored when you
push and pop between different framebuffers.
Also remember a newly allocated framebuffer will have an identity matrix for
the projection and modelview matrices which gives you a coordinate space
like OpenGL with (-1, -1) corresponding to the top left of the viewport,
(1, 1) corresponding to the bottom right and +z coming out towards the
viewer.
If you want to set up a coordinate space like Clutter does with (0, 0)
corresponding to the top left and (framebuffer_width, framebuffer_height)
corresponding to the bottom right you can do so like this:
|[
static void
setup_viewport (unsigned int width,
unsigned int height,
float fovy,
float aspect,
float z_near,
float z_far)
{
float z_camera;
CoglMatrix projection_matrix;
CoglMatrix mv_matrix;
cogl_set_viewport (0, 0, width, height);
cogl_perspective (fovy, aspect, z_near, z_far);
cogl_get_projection_matrix (&projection_matrix);
z_camera = 0.5 * projection_matrix.xx;
cogl_matrix_init_identity (&mv_matrix);
cogl_matrix_translate (&mv_matrix, -0.5f, -0.5f, -z_camera);
cogl_matrix_scale (&mv_matrix, 1.0f / width, -1.0f / height, 1.0f / width);
cogl_matrix_translate (&mv_matrix, 0.0f, -1.0 * height, 0.0f);
cogl_set_modelview_matrix (&mv_matrix);
}
static void
my_init_framebuffer (ClutterStage *stage,
CoglFramebuffer *framebuffer,
unsigned int framebuffer_width,
unsigned int framebuffer_height)
{
ClutterPerspective perspective;
clutter_stage_get_perspective (stage, &perspective);
cogl_push_framebuffer (framebuffer);
setup_viewport (framebuffer_width,
framebuffer_height,
perspective.fovy,
perspective.aspect,
perspective.z_near,
perspective.z_far);
}
]|
The previous framebuffer can be restored by calling cogl_pop_framebuffer()

Parameters:

Cogl.Framebuffer buffer Required (not null)

A CoglFramebuffer object, either onscreen or offscreen.

Returns:

none

Stores the current model-view matrix on the matrix stack. The matrix
can later be restored with cogl_pop_matrix().

Returns:

none

Parameters:

void* material Required (not null)

Returns:

none

This reads a rectangle of pixels from the current framebuffer where
position (0, 0) is the top left. The pixel at (x, y) is the first
read, and the data is returned with a rowstride of (width * 4).
Currently Cogl assumes that the framebuffer is in a premultiplied
format so if format is non-premultiplied it will convert it. To
read the pixel values without any conversion you should either
specify a format that doesn't use an alpha channel or use one of
the formats ending in PRE.

Parameters:

gint32 x Required (not null)

The window x position to start reading from

gint32 y Required (not null)

The window y position to start reading from

gint32 width Required (not null)

The width of the rectangle you want to read

gint32 height Required (not null)

The height of the rectangle you want to read

Cogl.ReadPixelsFlags source Required (not null)

Identifies which auxillary buffer you want to read (only COGL_READ_PIXELS_COLOR_BUFFER supported currently)

Cogl.PixelFormat format Required (not null)

The pixel format you want the result in (only COGL_PIXEL_FORMAT_RGBA_8888 supported currently)

guint8 pixels Required (not null)

The location to write the pixel data.

Returns:

none

Fills a rectangle at the given coordinates with the current source material

Parameters:

gfloat x_1 Required (not null)

X coordinate of the top-left corner

gfloat y_1 Required (not null)

Y coordinate of the top-left corner

gfloat x_2 Required (not null)

X coordinate of the bottom-right corner

gfloat y_2 Required (not null)

Y coordinate of the bottom-right corner

Returns:

none

This function draws a rectangle using the current source material to
texture or fill with. As a material may contain multiple texture layers
this interface lets you supply texture coordinates for each layer of the
material.
The first pair of coordinates are for the first layer (with the smallest
layer index) and if you supply less texture coordinates than there are
layers in the current source material then default texture coordinates
(0.0, 0.0, 1.0, 1.0) are generated.

Parameters:

gfloat x1 Required (not null)

x coordinate upper left on screen.

gfloat y1 Required (not null)

y coordinate upper left on screen.

gfloat x2 Required (not null)

x coordinate lower right on screen.

gfloat y2 Required (not null)

y coordinate lower right on screen.

Array tex_coords Required (not null)

An array containing groups of 4 float values: [tx1, ty1, tx2, ty2] that are interpreted as two texture coordinates; one for the upper left texel, and one for the lower right texel. Each value should be between 0.0 and 1.0, where the coordinate (0.0, 0.0) represents the top left of the texture, and (1.0, 1.0) the bottom right.

gint32 tex_coords_len Required (not null)

The length of the tex_coords array. (e.g. for one layer and one group of texture coordinates, this would be 4)

Returns:

none

Draw a rectangle using the current material and supply texture coordinates
to be used for the first texture layer of the material. To draw the entire
texture pass in tx1=0.0 ty1=0.0 tx2=1.0 ty2=1.0.

Parameters:

gfloat x1 Required (not null)

x coordinate upper left on screen.

gfloat y1 Required (not null)

y coordinate upper left on screen.

gfloat x2 Required (not null)

x coordinate lower right on screen.

gfloat y2 Required (not null)

y coordinate lower right on screen.

gfloat tx1 Required (not null)

x part of texture coordinate to use for upper left pixel

gfloat ty1 Required (not null)

y part of texture coordinate to use for upper left pixel

gfloat tx2 Required (not null)

x part of texture coordinate to use for lower right pixel

gfloat ty2 Required (not null)

y part of texture coordinate to use for left pixel

Returns:

none

Draws a series of rectangles in the same way that
cogl_rectangle() does. In some situations it can give a
significant performance boost to use this function rather than
calling cogl_rectangle() separately for each rectangle.
parameters x1, y1, x2, and y2, and have the same
meaning as in cogl_rectangle().

Parameters:

Array verts Required (not null)

an array of vertices

guint32 n_rects Required (not null)

number of rectangles to draw

Returns:

none

Draws a series of rectangles in the same way that
cogl_rectangle_with_texture_coords() does. In some situations it can give a
significant performance boost to use this function rather than
calling cogl_rectangle_with_texture_coords() separately for each rectangle.
parameters x1, y1, x2, y2, tx1, ty1, tx2 and ty2 and have the same
meaning as in cogl_rectangle_with_texture_coords().

Parameters:

Array verts Required (not null)

an array of vertices

guint32 n_rects Required (not null)

number of rectangles to draw

Returns:

none

Multiplies the current model-view matrix by one that rotates the
model around the vertex specified by x, y and z. The rotation
follows the right-hand thumb rule so for example rotating by 10
degrees about the vertex (0, 0, 1) causes a small counter-clockwise
rotation.

Parameters:

gfloat angle Required (not null)

Angle in degrees to rotate.

gfloat x Required (not null)

X-component of vertex to rotate around.

gfloat y Required (not null)

Y-component of vertex to rotate around.

gfloat z Required (not null)

Z-component of vertex to rotate around.

Returns:

none

Multiplies the current model-view matrix by one that scales the x,
y and z axes by the given values.

Parameters:

gfloat x Required (not null)

Amount to scale along the x-axis

gfloat y Required (not null)

Amount to scale along the y-axis

gfloat z Required (not null)

Amount to scale along the z-axis

Returns:

none

Sets whether textures positioned so that their backface is showing
should be hidden. This can be used to efficiently draw two-sided
textures or fully closed cubes without enabling depth testing. This
only affects calls to the cogl_rectangle* family of functions and
cogl_vertex_buffer_draw*. Backface culling is disabled by default.

Parameters:

gboolean setting Required (not null)

TRUE to enable backface culling or FALSE to disable.

Returns:

none

Sets whether depth testing is enabled. If it is disabled then the
order that actors are layered on the screen depends solely on the
order specified using clutter_actor_raise() and
clutter_actor_lower(), otherwise it will also take into account the
actor's depth. Depth testing is disabled by default.
instead.

Parameters:

gboolean setting Required (not null)

TRUE to enable depth testing or FALSE to disable.

Returns:

none

Redirects all subsequent drawing to the specified framebuffer. This
can either be an offscreen buffer created with
cogl_offscreen_new_to_texture () or you can revert to your original
on screen window buffer.
the type of CoglHandle given instead.

Parameters:

Cogl.BufferTarget target Required (not null)

A CoglBufferTarget that specifies what kind of framebuffer you are setting as the render target.

void* offscreen Required (not null)

If you are setting a framebuffer of type COGL_OFFSCREEN_BUFFER then this is a CoglHandle for the offscreen buffer.

Returns:

none

Enables fogging. Fogging causes vertices that are further away from the eye
to be rendered with a different color. The color is determined according to
the chosen fog mode; at it's simplest the color is linearly interpolated so
that vertices at z_near are drawn fully with their original color and
vertices at z_far are drawn fully with fog_color. Fogging will remain
enabled until you call cogl_disable_fog().
The fogging functions only work correctly when primitives use
unmultiplied alpha colors. By default Cogl will premultiply textures
and cogl_set_source_color() will premultiply colors, so unless you
explicitly load your textures requesting an unmultiplied internal format
and use cogl_material_set_color() you can only use fogging with fully
opaque primitives. This might improve in the future when we can depend
on fragment shaders.

Parameters:

Cogl.Color fog_color Required (not null)

The color of the fog

Cogl.FogMode mode Required (not null)

A CoglFogMode that determines the equation used to calculate the fogging blend factor.

gfloat density Required (not null)

Used by COGL_FOG_MODE_EXPONENTIAL and by COGL_FOG_MODE_EXPONENTIAL_SQUARED equations.

gfloat z_near Required (not null)

Position along Z axis where no fogging should be applied

gfloat z_far Required (not null)

Position along Z axis where full fogging should be applied

Returns:

none

This redirects all subsequent drawing to the specified framebuffer. This can
either be an offscreen buffer created with cogl_offscreen_new_to_texture ()
or in the future it may be an onscreen framebuffers too.

Parameters:

Cogl.Framebuffer buffer Required (not null)

A CoglFramebuffer object, either onscreen or offscreen.

Returns:

none

Loads matrix as the new model-view matrix.

Parameters:

Cogl.Matrix matrix Required (not null)

the new model-view matrix

Returns:

none

Loads matrix as the new projection matrix.

Parameters:

Cogl.Matrix matrix Required (not null)

the new projection matrix

Returns:

none

This function sets the source material that will be used to fill subsequent
geometry emitted via the cogl API.
In the future we may add the ability to set a front facing material,
and a back facing material, in which case this function will set both to the
same.

Parameters:

void* material Required (not null)

A CoglHandle for a material

Returns:

none

This is a convenience function for creating a solid fill source material
from the given color. This color will be used for any subsequent drawing
operation.
The color will be premultiplied by Cogl, so the color should be
semi-transparent red.
See also cogl_set_source_color4ub() and cogl_set_source_color4f()
if you already have the color components.

Parameters:

Cogl.Color color Required (not null)

a CoglColor

Returns:

none

This is a convenience function for creating a solid fill source material
from the given color using normalized values for each component. This color
will be used for any subsequent drawing operation.
The value for each component is a fixed point number in the range
between 0 and %1.0. If the values passed in are outside that
range, they will be clamped.

Parameters:

gfloat red Required (not null)

value of the red channel, between 0 and %1.0

gfloat green Required (not null)

value of the green channel, between 0 and %1.0

gfloat blue Required (not null)

value of the blue channel, between 0 and %1.0

gfloat alpha Required (not null)

value of the alpha channel, between 0 and %1.0

Returns:

none

This is a convenience function for creating a solid fill source material
from the given color using unsigned bytes for each component. This
color will be used for any subsequent drawing operation.
The value for each component is an unsigned byte in the range
between 0 and 255.

Parameters:

guint8 red Required (not null)

value of the red channel, between 0 and 255

guint8 green Required (not null)

value of the green channel, between 0 and 255

guint8 blue Required (not null)

value of the blue channel, between 0 and 255

guint8 alpha Required (not null)

value of the alpha channel, between 0 and 255

Returns:

none

This is a convenience function for creating a material with the first
layer set to texture_handle and setting that material as the source with
cogl_set_source.
and cogl_set_source_texture. If you need to blend a texture with a color then
you can create a simple material like this:

material = cogl_material_new ();
cogl_material_set_color4ub (material, 0xff, 0x00, 0x00, 0x80);
cogl_material_set_layer (material, 0, tex_handle);
cogl_set_source (material);

Parameters:

void* texture_handle Required (not null)

The Cogl texture you want as your source

Returns:

none

Replaces the current viewport with the given values.

Parameters:

gint32 x Required (not null)

X offset of the viewport

gint32 y Required (not null)

Y offset of the viewport

gint32 width Required (not null)

Width of the viewport

gint32 height Required (not null)

Height of the viewport

Returns:

none

Compiles the shader, no return value, but the shader is now ready for
linking into a program.

Parameters:

void* handle Required (not null)

CoglHandle for a shader.

Returns:

none

Retrieves the information log for a coglobject, can be used in conjunction
with cogl_shader_get_parameteriv() to retrieve the compiler warnings/error
messages that caused a shader to not compile correctly, mainly useful for
debugging purposes.
g_free() to free it

Parameters:

void* handle Required (not null)

CoglHandle for a shader.

Returns:

String a newly allocated string containing the info log. Use

Retrieves the type of a shader CoglHandle
or COGL_SHADER_TYPE_FRAGMENT if the shader is a frament processor

Parameters:

void* handle Required (not null)

CoglHandle for a shader.

Returns:

Cogl.ShaderType COGL_SHADER_TYPE_VERTEX if the shader is a vertex processor

Retrieves whether a shader CoglHandle has been compiled

Parameters:

void* handle Required (not null)

CoglHandle for a shader.

Returns:

gboolean TRUE if the shader object has sucessfully be compiled

Replaces the current GLSL source associated with a shader with a new
one.

Parameters:

void* shader Required (not null)

CoglHandle for a shader.

String source Required (not null)

GLSL shader source.

Returns:

none

Very fast fixed point implementation of square root for integers.
This function is at least 6x faster than clib sqrt() on x86, and (this is
not a typo!) about 500x faster on ARM without FPU. It's error is less than
5% for arguments smaller than COGL_SQRTI_ARG_5_PERCENT and less than 10%
for narguments smaller than COGL_SQRTI_ARG_10_PERCENT. The maximum
argument that can be passed to this function is COGL_SQRTI_ARG_MAX.

Parameters:

gint32 x Required (not null)

integer value

Returns:

gint32 integer square root.

Copies the pixel data from a cogl texture to system memory.
is not valid

Parameters:

void* handle Required (not null)

a CoglHandle for a texture.

Cogl.PixelFormat format Required (not null)

the CoglPixelFormat to store the texture as.

guint32 rowstride Required (not null)

the rowstride of data or retrieved from texture if none is specified.

guint8 data Required (not null)

memory location to write contents of buffer, or NULL if we're only querying the data size through the return value.

Returns:

gint32 the size of the texture data in bytes, or 0 if the texture

Queries the CoglPixelFormat of a cogl texture.

Parameters:

void* handle Required (not null)

a CoglHandle for a texture.

Returns:

Cogl.PixelFormat the CoglPixelFormat of the GPU side texture

Queries the GL handles for a GPU side texture through its CoglHandle.
If the texture is spliced the data for the first sub texture will be
queried.
if the handle was invalid

Parameters:

void* handle Required (not null)

a CoglHandle for a texture.

Object out_values

GL.uint out_gl_handle

GL.enum out_gl_target

Returns:

gboolean TRUE if the handle was successfully retrieved, FALSE

Queries the height of a cogl texture.

Parameters:

void* handle Required (not null)

a CoglHandle for a texture.

Returns:

guint32 the height of the GPU side texture in pixels

Queries the maximum wasted (unused) pixels in one dimension of a GPU side
texture.

Parameters:

void* handle Required (not null)

a CoglHandle for a texture.

Returns:

gint32 the maximum waste

Queries the rowstride of a cogl texture.

Parameters:

void* handle Required (not null)

a CoglHandle for a texture.

Returns:

guint32 the offset in bytes between each consequetive row of pixels

Queries the width of a cogl texture.

Parameters:

void* handle Required (not null)

a CoglHandle for a texture.

Returns:

guint32 the width of the GPU side texture in pixels

Queries if a texture is sliced (stored as multiple GPU side tecture
objects).
is stored as a single GPU texture

Parameters:

void* handle Required (not null)

a CoglHandle for a texture.

Returns:

gboolean TRUE if the texture is sliced, FALSE if the texture

Sets the pixels in a rectangular subregion of handle from an in-memory
buffer containing pixel data.
FALSE otherwise

Parameters:

void* handle Required (not null)

a CoglHandle.

gint32 src_x Required (not null)

upper left coordinate to use from source data.

gint32 src_y Required (not null)

upper left coordinate to use from source data.

gint32 dst_x Required (not null)

upper left destination horizontal coordinate.

gint32 dst_y Required (not null)

upper left destination vertical coordinate.

guint32 dst_width Required (not null)

width of destination region to write.

guint32 dst_height Required (not null)

height of destination region to write.

gint32 width Required (not null)

width of source data buffer.

gint32 height Required (not null)

height of source data buffer.

Cogl.PixelFormat format Required (not null)

the CoglPixelFormat used in the source buffer.

guint32 rowstride Required (not null)

rowstride of source buffer (computed from width if none specified)

guint8 data Required (not null)

the actual pixel data.

Returns:

gboolean TRUE if the subregion upload was successful, and

Multiplies the current model-view matrix by the given matrix.

Parameters:

Cogl.Matrix matrix Required (not null)

the matrix to multiply with the current model-view

Returns:

none

Multiplies the current model-view matrix by one that translates the
model along all three axes according to the given values.

Parameters:

gfloat x Required (not null)

Distance to translate along the x-axis

gfloat y Required (not null)

Distance to translate along the y-axis

gfloat z Required (not null)

Distance to translate along the z-axis

Returns:

none

Parameters:

void* v1 Required (not null)

void* v2 Required (not null)

Returns:

gboolean

Adds an attribute to a buffer.
You either can use one of the built-in names such as "gl_Vertex", or
"gl_MultiTexCoord0" to add standard attributes, like positions, colors
and normals, or you can add custom attributes for use in shaders.
The number of vertices declared when calling cogl_vertex_buffer_new()
determines how many attribute values will be read from the supplied
The data for your attribute isn't copied anywhere until you call
cogl_vertex_buffer_submit(), or issue a draw call which automatically
submits pending attribute changes. so the supplied pointer must remain
valid until then. If you are updating an existing attribute (done by
re-adding it) then you still need to re-call cogl_vertex_buffer_submit()
to commit the changes to the GPU. Be carefull to minimize the number
of calls to cogl_vertex_buffer_submit(), though.
If you are interleving attributes it is assumed that each interleaved
attribute starts no farther than +- stride bytes from the other attributes
it is interleved with. I.e. this is ok:

|-0-0-0-0-0-0-0-0-0-0|

This is not ok:

|- - - - -0-0-0-0-0-0 0 0 0 0|

(Though you can have multiple groups of interleved attributes)

Parameters:

void* handle Required (not null)

A vertex buffer handle

String attribute_name Required (not null)

The name of your attribute. It should be a valid GLSL variable name and standard attribute types must use one of following built-in names: (Note: they correspond to the built-in names of GLSL) "gl_Color" "gl_Normal" "gl_MultiTexCoord0, gl_MultiTexCoord1, ..." "gl_Vertex" To support adding multiple variations of the same attribute the name can have a detail component, E.g. "gl_Color::active" or "gl_Color::inactive"

guint8 n_components Required (not null)

The number of components per attribute and must be 1, 2, 3 or 4

Cogl.AttributeType type Required (not null)

a CoglAttributeType specifying the data type of each component.

gboolean normalized Required (not null)

If TRUE, this specifies that values stored in an integer format should be mapped into the range [-1.0, 1.0] or [0.0, 1.0] for unsigned values. If FALSE they are converted to floats directly.

guint16 stride Required (not null)

This specifies the number of bytes from the start of one attribute value to the start of the next value (for the same attribute). So, for example, with a position interleved with color like this: XYRGBAXYRGBAXYRGBA, then if each letter represents a byte, the stride for both attributes is 6. The special value 0 means the values are stored sequentially in memory.

void* pointer Required (not null)

This addresses the first attribute in the vertex array. This must remain valid until you either call cogl_vertex_buffer_submit() or issue a draw call.

Returns:

none

Deletes an attribute from a buffer. You will need to call
cogl_vertex_buffer_submit() or issue a draw call to commit this
change to the GPU.

Parameters:

void* handle Required (not null)

A vertex buffer handle

String attribute_name Required (not null)

The name of a previously added attribute

Returns:

none

Disables a previosuly added attribute.
Since it can be costly to add and remove new attributes to buffers; to make
individual buffers more reuseable it is possible to enable and disable
attributes before using a buffer for drawing.
You don't need to call cogl_vertex_buffer_submit() after using this
function.

Parameters:

void* handle Required (not null)

A vertex buffer handle

String attribute_name Required (not null)

The name of the attribute you want to disable

Returns:

none

Allows you to draw geometry using all or a subset of the
vertices in a vertex buffer.
Any un-submitted attribute changes are automatically submitted before
drawing.

Parameters:

void* handle Required (not null)

A vertex buffer handle

Cogl.VerticesMode mode Required (not null)

A CoglVerticesMode specifying how the vertices should be interpreted.

gint32 first Required (not null)

Specifies the index of the first vertex you want to draw with

gint32 count Required (not null)

Specifies the number of vertices you want to draw.

Returns:

none

This function lets you use an array of indices to specify the vertices
within your vertex buffer that you want to draw. The indices themselves
are created by calling cogl_vertex_buffer_indices_new ()
Any un-submitted attribute changes are automatically submitted before
drawing.

Parameters:

void* handle Required (not null)

A vertex buffer handle

Cogl.VerticesMode mode Required (not null)

A CoglVerticesMode specifying how the vertices should be interpreted.

void* indices Required (not null)

A CoglHandle for a set of indices allocated via cogl_vertex_buffer_indices_new ()

gint32 min_index Required (not null)

Specifies the minimum vertex index contained in indices

gint32 max_index Required (not null)

Specifies the maximum vertex index contained in indices

gint32 indices_offset Required (not null)

An offset into named indices. The offset marks the first index to use for drawing.

gint32 count Required (not null)

Specifies the number of vertices you want to draw.

Returns:

none

Enables a previosuly disabled attribute.
Since it can be costly to add and remove new attributes to buffers; to make
individual buffers more reuseable it is possible to enable and disable
attributes before using a buffer for drawing.
You don't need to call cogl_vertex_buffer_submit() after using this function

Parameters:

void* handle Required (not null)

A vertex buffer handle

String attribute_name Required (not null)

The name of the attribute you want to enable

Returns:

none

Retrieves the number of vertices that handle represents

Parameters:

void* handle Required (not null)

A vertex buffer handle

Returns:

guint32 the number of vertices

Queries back the data type used for the given indices

Parameters:

void* indices Required (not null)

Returns:

Cogl.IndicesType The CoglIndicesType used

Submits all the user added attributes to the GPU; once submitted, the
attributes can be used for drawing.
You should aim to minimize calls to this function since it implies
validating your data; it potentially incurs a transport cost (especially if
you are using GLX indirect rendering) and potentially a format conversion
cost if the GPU doesn't natively support any of the given attribute formats.

Parameters:

void* handle Required (not null)

A vertex buffer handle

Returns:

none

Replace the current viewport with the given values.

Parameters:

guint32 width Required (not null)

Width of the viewport

guint32 height Required (not null)

Height of the viewport

Returns:

none