Top 
Functions
Functions
cogl_primitive_new ()
CoglPrimitive * cogl_primitive_new (CoglVerticesMode mode
,int n_vertices
,...
);
Combines a set of CoglAttributes with a specific draw mode
and defines a vertex count so a CoglPrimitive object can be retained and
drawn later with no addition information required.
The value passed as n_vertices
will simply update the
CoglPrimitive n_vertices
property as if
cogl_primitive_set_n_vertices()
were called. This property defines
the number of vertices to read when drawing.
Parameters
mode 
A CoglVerticesMode defining how to draw the vertices 

n_vertices 
The number of vertices to process when drawing 

... 
A 
Since: 1.6
Stability Level: Unstable
cogl_primitive_new_with_attributes ()
CoglPrimitive * cogl_primitive_new_with_attributes (CoglVerticesMode mode
,int n_vertices
,CoglAttribute **attributes
,int n_attributes
);
Combines a set of CoglAttributes with a specific draw mode
and defines a vertex count so a CoglPrimitive object can be retained and
drawn later with no addition information required.
The value passed as n_vertices
will simply update the
CoglPrimitive n_vertices
property as if
cogl_primitive_set_n_vertices()
were called. This property defines
the number of vertices to read when drawing.
Parameters
mode 
A CoglVerticesMode defining how to draw the vertices 

n_vertices 
The number of vertices to process when drawing 

attributes 
An array of CoglAttribute 

n_attributes 
The number of attributes 
Since: 1.6
Stability Level: Unstable
cogl_primitive_new_p2 ()
CoglPrimitive * cogl_primitive_new_p2 (CoglContext *context
,CoglVerticesMode mode
,int n_vertices
,const CoglVertexP2 *data
);
Provides a convenient way to describe a primitive, such as a single triangle strip or a triangle fan, that will internally allocate the necessary CoglAttributeBuffer storage, describe the position attribute with a CoglAttribute and upload your data.
For example to draw a convex polygon you can do:
1 2 3 4 5 6 7 8 9 
CoglVertexP2 triangle[] = { { 0, 300 }, { 150, 0, }, { 300, 300 } }; prim = cogl_primitive_new_p2 (COGL_VERTICES_MODE_TRIANGLE_FAN, 3, triangle); cogl_primitive_draw (prim); 
The value passed as n_vertices
is initially used to determine how
much can be read from data
but it will also be used to update the
CoglPrimitive n_vertices
property as if
cogl_primitive_set_n_vertices()
were called. This property defines
the number of vertices to read when drawing.
COGL_TEXTURE_NO_SLICING
flag to all textures that
might be used while drawing with this API. If your hardware doesn't
support nonpower of two textures (For example you are using GLES
1.1) then you will need to make sure your assets are resized to a
poweroftwo size (though they don't have to be square)Parameters
context 

mode 
A CoglVerticesMode defining how to draw the vertices 

n_vertices 
The number of vertices to read from 

data 
(type Cogl.VertexP2): An array of CoglVertexP2 vertices. 
[array length=n_vertices] 
Returns
A newly allocated CoglPrimitive
with a reference of 1. This can be freed using cogl_object_unref()
.
[transfer full]
Since: 1.6
Stability Level: Unstable
cogl_primitive_new_p3 ()
CoglPrimitive * cogl_primitive_new_p3 (CoglContext *context
,CoglVerticesMode mode
,int n_vertices
,const CoglVertexP3 *data
);
Provides a convenient way to describe a primitive, such as a single triangle strip or a triangle fan, that will internally allocate the necessary CoglAttributeBuffer storage, describe the position attribute with a CoglAttribute and upload your data.
For example to draw a convex polygon you can do:
1 2 3 4 5 6 7 8 9 
CoglVertexP3 triangle[] = { { 0, 300, 0 }, { 150, 0, 0 }, { 300, 300, 0 } }; prim = cogl_primitive_new_p3 (COGL_VERTICES_MODE_TRIANGLE_FAN, 3, triangle); cogl_primitive_draw (prim); 
The value passed as n_vertices
is initially used to determine how
much can be read from data
but it will also be used to update the
CoglPrimitive n_vertices
property as if
cogl_primitive_set_n_vertices()
were called. This property defines
the number of vertices to read when drawing.
COGL_TEXTURE_NO_SLICING
flag to all textures that
might be used while drawing with this API. If your hardware doesn't
support nonpower of two textures (For example you are using GLES
1.1) then you will need to make sure your assets are resized to a
poweroftwo size (though they don't have to be square)Parameters
context 

mode 
A CoglVerticesMode defining how to draw the vertices 

n_vertices 
The number of vertices to read from 

data 
(type Cogl.VertexP3): An array of CoglVertexP3 vertices. 
[array length=n_vertices] 
Returns
A newly allocated CoglPrimitive
with a reference of 1. This can be freed using cogl_object_unref()
.
[transfer full]
Since: 1.6
Stability Level: Unstable
cogl_primitive_new_p2c4 ()
CoglPrimitive * cogl_primitive_new_p2c4 (CoglContext *context
,CoglVerticesMode mode
,int n_vertices
,const CoglVertexP2C4 *data
);
Provides a convenient way to describe a primitive, such as a single triangle strip or a triangle fan, that will internally allocate the necessary CoglAttributeBuffer storage, describe the position and color attributes with CoglAttributes and upload your data.
For example to draw a convex polygon with a linear gradient you can do:
1 2 3 4 5 6 7 8 9 
CoglVertexP2C4 triangle[] = { { 0, 300, 0xff, 0x00, 0x00, 0xff }, { 150, 0, 0x00, 0xff, 0x00, 0xff }, { 300, 300, 0xff, 0x00, 0x00, 0xff } }; prim = cogl_primitive_new_p2c4 (COGL_VERTICES_MODE_TRIANGLE_FAN, 3, triangle); cogl_primitive_draw (prim); 
The value passed as n_vertices
is initially used to determine how
much can be read from data
but it will also be used to update the
CoglPrimitive n_vertices
property as if
cogl_primitive_set_n_vertices()
were called. This property defines
the number of vertices to read when drawing.
COGL_TEXTURE_NO_SLICING
flag to all textures that
might be used while drawing with this API. If your hardware doesn't
support nonpower of two textures (For example you are using GLES
1.1) then you will need to make sure your assets are resized to a
poweroftwo size (though they don't have to be square)Parameters
context 

mode 
A CoglVerticesMode defining how to draw the vertices 

n_vertices 
The number of vertices to read from 

data 
(type Cogl.VertexP2C4): An array of CoglVertexP2C4 vertices. 
[array length=n_vertices] 
Returns
A newly allocated CoglPrimitive
with a reference of 1. This can be freed using cogl_object_unref()
.
[transfer full]
Since: 1.6
Stability Level: Unstable
cogl_primitive_new_p3c4 ()
CoglPrimitive * cogl_primitive_new_p3c4 (CoglContext *context
,CoglVerticesMode mode
,int n_vertices
,const CoglVertexP3C4 *data
);
Provides a convenient way to describe a primitive, such as a single triangle strip or a triangle fan, that will internally allocate the necessary CoglAttributeBuffer storage, describe the position and color attributes with CoglAttributes and upload your data.
For example to draw a convex polygon with a linear gradient you can do:
1 2 3 4 5 6 7 8 9 
CoglVertexP3C4 triangle[] = { { 0, 300, 0, 0xff, 0x00, 0x00, 0xff }, { 150, 0, 0, 0x00, 0xff, 0x00, 0xff }, { 300, 300, 0, 0xff, 0x00, 0x00, 0xff } }; prim = cogl_primitive_new_p3c4 (COGL_VERTICES_MODE_TRIANGLE_FAN, 3, triangle); cogl_primitive_draw (prim); 
The value passed as n_vertices
is initially used to determine how
much can be read from data
but it will also be used to update the
CoglPrimitive n_vertices
property as if
cogl_primitive_set_n_vertices()
were called. This property defines
the number of vertices to read when drawing.
COGL_TEXTURE_NO_SLICING
flag to all textures that
might be used while drawing with this API. If your hardware doesn't
support nonpower of two textures (For example you are using GLES
1.1) then you will need to make sure your assets are resized to a
poweroftwo size (though they don't have to be square)Parameters
context 

mode 
A CoglVerticesMode defining how to draw the vertices 

n_vertices 
The number of vertices to read from 

data 
(type Cogl.VertexP3C4): An array of CoglVertexP3C4 vertices. 
[array length=n_vertices] 
Returns
A newly allocated CoglPrimitive
with a reference of 1. This can be freed using cogl_object_unref()
.
[transfer full]
Since: 1.6
Stability Level: Unstable
cogl_primitive_new_p2t2 ()
CoglPrimitive * cogl_primitive_new_p2t2 (CoglContext *context
,CoglVerticesMode mode
,int n_vertices
,const CoglVertexP2T2 *data
);
Provides a convenient way to describe a primitive, such as a single triangle strip or a triangle fan, that will internally allocate the necessary CoglAttributeBuffer storage, describe the position and texture coordinate attributes with CoglAttributes and upload your data.
For example to draw a convex polygon with texture mapping you can do:
1 2 3 4 5 6 7 8 9 
CoglVertexP2T2 triangle[] = { { 0, 300, 0.0, 1.0}, { 150, 0, 0.5, 0.0}, { 300, 300, 1.0, 1.0} }; prim = cogl_primitive_new_p2t2 (COGL_VERTICES_MODE_TRIANGLE_FAN, 3, triangle); cogl_primitive_draw (prim); 
The value passed as n_vertices
is initially used to determine how
much can be read from data
but it will also be used to update the
CoglPrimitive n_vertices
property as if
cogl_primitive_set_n_vertices()
were called. This property defines
the number of vertices to read when drawing.
COGL_TEXTURE_NO_SLICING
flag to all textures that
might be used while drawing with this API. If your hardware doesn't
support nonpower of two textures (For example you are using GLES
1.1) then you will need to make sure your assets are resized to a
poweroftwo size (though they don't have to be square)Parameters
context 

mode 
A CoglVerticesMode defining how to draw the vertices 

n_vertices 
The number of vertices to read from 

data 
(type Cogl.VertexP2T2): An array of CoglVertexP2T2 vertices. 
[array length=n_vertices] 
Returns
A newly allocated CoglPrimitive
with a reference of 1. This can be freed using cogl_object_unref()
.
[transfer full]
Since: 1.6
Stability Level: Unstable
cogl_primitive_new_p3t2 ()
CoglPrimitive * cogl_primitive_new_p3t2 (CoglContext *context
,CoglVerticesMode mode
,int n_vertices
,const CoglVertexP3T2 *data
);
Provides a convenient way to describe a primitive, such as a single triangle strip or a triangle fan, that will internally allocate the necessary CoglAttributeBuffer storage, describe the position and texture coordinate attributes with CoglAttributes and upload your data.
For example to draw a convex polygon with texture mapping you can do:
1 2 3 4 5 6 7 8 9 
CoglVertexP3T2 triangle[] = { { 0, 300, 0, 0.0, 1.0}, { 150, 0, 0, 0.5, 0.0}, { 300, 300, 0, 1.0, 1.0} }; prim = cogl_primitive_new_p3t2 (COGL_VERTICES_MODE_TRIANGLE_FAN, 3, triangle); cogl_primitive_draw (prim); 
The value passed as n_vertices
is initially used to determine how
much can be read from data
but it will also be used to update the
CoglPrimitive n_vertices
property as if
cogl_primitive_set_n_vertices()
were called. This property defines
the number of vertices to read when drawing.
COGL_TEXTURE_NO_SLICING
flag to all textures that
might be used while drawing with this API. If your hardware doesn't
support nonpower of two textures (For example you are using GLES
1.1) then you will need to make sure your assets are resized to a
poweroftwo size (though they don't have to be square)Parameters
context 

mode 
A CoglVerticesMode defining how to draw the vertices 

n_vertices 
The number of vertices to read from 

data 
(type Cogl.VertexP3T2): An array of CoglVertexP3T2 vertices. 
[array length=n_vertices] 
Returns
A newly allocated CoglPrimitive
with a reference of 1. This can be freed using cogl_object_unref()
.
[transfer full]
Since: 1.6
Stability Level: Unstable
cogl_primitive_new_p2t2c4 ()
CoglPrimitive * cogl_primitive_new_p2t2c4 (CoglContext *context
,CoglVerticesMode mode
,int n_vertices
,const CoglVertexP2T2C4 *data
);
Provides a convenient way to describe a primitive, such as a single triangle strip or a triangle fan, that will internally allocate the necessary CoglAttributeBuffer storage, describe the position, texture coordinate and color attributes with CoglAttributes and upload your data.
For example to draw a convex polygon with texture mapping and a linear gradient you can do:
1 2 3 4 5 6 7 8 9 
CoglVertexP2T2C4 triangle[] = { { 0, 300, 0.0, 1.0, 0xff, 0x00, 0x00, 0xff}, { 150, 0, 0.5, 0.0, 0x00, 0xff, 0x00, 0xff}, { 300, 300, 1.0, 1.0, 0xff, 0x00, 0x00, 0xff} }; prim = cogl_primitive_new_p2t2c4 (COGL_VERTICES_MODE_TRIANGLE_FAN, 3, triangle); cogl_primitive_draw (prim); 
The value passed as n_vertices
is initially used to determine how
much can be read from data
but it will also be used to update the
CoglPrimitive n_vertices
property as if
cogl_primitive_set_n_vertices()
were called. This property defines
the number of vertices to read when drawing.
COGL_TEXTURE_NO_SLICING
flag to all textures that
might be used while drawing with this API. If your hardware doesn't
support nonpower of two textures (For example you are using GLES
1.1) then you will need to make sure your assets are resized to a
poweroftwo size (though they don't have to be square)Parameters
context 

mode 
A CoglVerticesMode defining how to draw the vertices 

n_vertices 
The number of vertices to read from 

data 
(type Cogl.VertexP2T2C4): An array of CoglVertexP2T2C4 vertices. 
[array length=n_vertices] 
Returns
A newly allocated CoglPrimitive
with a reference of 1. This can be freed using cogl_object_unref()
.
[transfer full]
Since: 1.6
Stability Level: Unstable
cogl_primitive_new_p3t2c4 ()
CoglPrimitive * cogl_primitive_new_p3t2c4 (CoglContext *context
,CoglVerticesMode mode
,int n_vertices
,const CoglVertexP3T2C4 *data
);
Provides a convenient way to describe a primitive, such as a single triangle strip or a triangle fan, that will internally allocate the necessary CoglAttributeBuffer storage, describe the position, texture coordinate and color attributes with CoglAttributes and upload your data.
For example to draw a convex polygon with texture mapping and a linear gradient you can do:
1 2 3 4 5 6 7 8 9 
CoglVertexP3T2C4 triangle[] = { { 0, 300, 0, 0.0, 1.0, 0xff, 0x00, 0x00, 0xff}, { 150, 0, 0, 0.5, 0.0, 0x00, 0xff, 0x00, 0xff}, { 300, 300, 0, 1.0, 1.0, 0xff, 0x00, 0x00, 0xff} }; prim = cogl_primitive_new_p3t2c4 (COGL_VERTICES_MODE_TRIANGLE_FAN, 3, triangle); cogl_primitive_draw (prim); 
The value passed as n_vertices
is initially used to determine how
much can be read from data
but it will also be used to update the
CoglPrimitive n_vertices
property as if
cogl_primitive_set_n_vertices()
were called. This property defines
the number of vertices to read when drawing.
COGL_TEXTURE_NO_SLICING
flag to all textures that
might be used while drawing with this API. If your hardware doesn't
support nonpower of two textures (For example you are using GLES
1.1) then you will need to make sure your assets are resized to a
poweroftwo size (though they don't have to be square)Parameters
context 

mode 
A CoglVerticesMode defining how to draw the vertices 

n_vertices 
The number of vertices to read from 

data 
(type Cogl.VertexP3T2C4): An array of CoglVertexP3T2C4 vertices. 
[array length=n_vertices] 
Returns
A newly allocated CoglPrimitive
with a reference of 1. This can be freed using cogl_object_unref()
.
[transfer full]
Since: 1.6
Stability Level: Unstable
cogl_is_primitive ()
CoglBool
cogl_is_primitive (void *object
);
Gets whether the given object references a CoglPrimitive.
Since: 1.6
Stability Level: Unstable
cogl_primitive_set_first_vertex ()
void cogl_primitive_set_first_vertex (CoglPrimitive *primitive
,int first_vertex
);
cogl_primitive_get_n_vertices ()
int
cogl_primitive_get_n_vertices (CoglPrimitive *primitive
);
Queries the number of vertices to read when drawing the given
primitive
. Usually this value is implicitly set when associating
vertex data or indices with a CoglPrimitive.
If cogl_primitive_set_indices()
has been used to associate a
sequence of CoglIndices with the given primitive
then the
number of vertices to read can also be phrased as the number
of indices to read.
Since: 1.8
Stability Level: Unstable
cogl_primitive_set_n_vertices ()
void cogl_primitive_set_n_vertices (CoglPrimitive *primitive
,int n_vertices
);
Specifies how many vertices should be read when drawing the given
primitive
.
Usually this value is set implicitly when associating vertex data or indices with a CoglPrimitive.
Since: 1.8
Stability Level: Unstable
cogl_primitive_set_mode ()
void cogl_primitive_set_mode (CoglPrimitive *primitive
,CoglVerticesMode mode
);
cogl_primitive_set_attributes ()
void cogl_primitive_set_attributes (CoglPrimitive *primitive
,CoglAttribute **attributes
,int n_attributes
);
Replaces all the attributes of the given CoglPrimitive object.
Parameters
primitive 
A CoglPrimitive object 

attributes 
an array of CoglAttribute pointers 

n_attributes 
the number of elements in 
Since: 1.6
Stability Level: Unstable
cogl_primitive_get_indices ()
CoglIndices *
cogl_primitive_get_indices (CoglPrimitive *primitive
);
Returns
the indices that were set with
cogl_primitive_set_indices()
or NULL
if no indices were set.
[transfer none]
Since: 1.10
Stability Level: Unstable
cogl_primitive_set_indices ()
void cogl_primitive_set_indices (CoglPrimitive *primitive
,CoglIndices *indices
,int n_indices
);
Associates a sequence of CoglIndices with the given primitive
.
CoglIndices provide a way to virtualize your real vertex data by providing a sequence of indices that index into your real vertex data. The GPU will walk though the index values to indirectly lookup the data for each vertex instead of sequentially walking through the data directly. This lets you save memory by indexing shared data multiple times instead of duplicating the data.
The value passed as n_indices
will simply update the
CoglPrimitive n_vertices
property as if
cogl_primitive_set_n_vertices()
were called. This property defines
the number of vertices to draw or, put another way, how many
indices should be read from indices
when drawing.
first_vertex
property
also affects drawing with indices by defining the first entry of the
indices to start drawing from.Parameters
primitive 

indices 
A CoglIndices array 

n_indices 
The number of indices to reference when drawing 
Since: 1.10
Stability Level: Unstable
cogl_primitive_copy ()
CoglPrimitive *
cogl_primitive_copy (CoglPrimitive *primitive
);
Makes a copy of an existing CoglPrimitive. Note that the primitive is a shallow copy which means it will use the same attributes and attribute buffers as the original primitive.
Since: 1.10
Stability Level: Unstable
CoglPrimitiveAttributeCallback ()
CoglBool (*CoglPrimitiveAttributeCallback) (CoglPrimitive *primitive
,CoglAttribute *attribute
,void *user_data
);
The callback prototype used with cogl_primitive_foreach_attribute()
for iterating all the attributes of a CoglPrimitive.
The function should return TRUE to continue iteration or FALSE to stop.
Parameters
primitive 
The CoglPrimitive whose attributes are being iterated 

attribute 
The CoglAttribute 

user_data 
The private data passed to 
Since: 1.10
Stability Level: Unstable
cogl_primitive_foreach_attribute ()
void cogl_primitive_foreach_attribute (CoglPrimitive *primitive
,CoglPrimitiveAttributeCallback callback
,void *user_data
);
Iterates all the attributes of the given CoglPrimitive.
Parameters
primitive 
A CoglPrimitive object 

callback 
A CoglPrimitiveAttributeCallback to be called for each attribute. 
[scope call] 
user_data 
Private data that will be passed to the callback. 
[closure] 
Since: 1.10
Stability Level: Unstable
cogl_primitive_draw ()
void cogl_primitive_draw (CoglPrimitive *primitive
,CoglFramebuffer *framebuffer
,CoglPipeline *pipeline
);
Draws the given primitive
geometry to the specified destination
framebuffer
using the graphics processing state described by pipeline
.
This drawing api doesn't support highlevel meta texture types such
as CoglTexture2DSliced so it is the user's responsibility to
ensure that only lowlevel textures that can be directly sampled by
a GPU such as CoglTexture2D, CoglTextureRectangle or CoglTexture3D
are associated with layers of the given pipeline
.
Parameters
primitive 
A CoglPrimitive geometry object 

framebuffer 
A destination CoglFramebuffer 

pipeline 
A CoglPipeline state object 
Since: 1.16
Stability Level: Unstable