cogl_vertex_buffer_new ()

CoglHandle
cogl_vertex_buffer_new (unsigned int n_vertices);

Creates a new vertex buffer that you can use to add attributes.

cogl_vertex_buffer_get_n_vertices ()

unsigned int
cogl_vertex_buffer_get_n_vertices (CoglHandle handle);

Retrieves the number of vertices that handle represents

cogl_vertex_buffer_add ()

void
cogl_vertex_buffer_add (CoglHandle handle,
                        const char *attribute_name,
                        uint8_t n_components,
                        CoglAttributeType type,
                        CoglBool normalized,
                        uint16_t stride,
                        const void *pointer);

Adds an attribute to a buffer, or replaces a previously added attribute with the same name.

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

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.

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

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

cogl_vertex_buffer_delete ()

void
cogl_vertex_buffer_delete (CoglHandle handle,
                           const char *attribute_name);

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.

cogl_vertex_buffer_submit ()

void
cogl_vertex_buffer_submit (CoglHandle handle);

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.

cogl_vertex_buffer_disable ()

void
cogl_vertex_buffer_disable (CoglHandle handle,
                            const char *attribute_name);

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.

cogl_vertex_buffer_enable ()

void
cogl_vertex_buffer_enable (CoglHandle handle,
                           const char *attribute_name);

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

cogl_vertex_buffer_draw ()

void
cogl_vertex_buffer_draw (CoglHandle handle,
                         CoglVerticesMode mode,
                         int first,
                         int count);

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.

cogl_is_vertex_buffer ()

CoglBool
cogl_is_vertex_buffer (CoglHandle handle);

Checks whether handle is a Vertex Buffer Object

Since: 1.0

cogl_vertex_buffer_indices_new ()

CoglHandle
cogl_vertex_buffer_indices_new (CoglIndicesType indices_type,
                                const void *indices_array,
                                int indices_len);

Depending on how much geometry you are submitting it can be worthwhile optimizing the number of redundant vertices you submit. Using an index array allows you to reference vertices multiple times, for example during triangle strips.

cogl_vertex_buffer_draw_elements ()

void
cogl_vertex_buffer_draw_elements (CoglHandle handle,
                                  CoglVerticesMode mode,
                                  CoglHandle indices,
                                  int min_index,
                                  int max_index,
                                  int indices_offset,
                                  int count);

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.

cogl_vertex_buffer_indices_get_for_quads ()

CoglHandle
cogl_vertex_buffer_indices_get_for_quads
                               (unsigned int n_indices);

Creates a vertex buffer containing the indices needed to draw pairs of triangles from a list of vertices grouped as quads. There will be at least n_indices entries in the buffer (but there may be more).

The indices will follow this pattern:

0, 1, 2, 0, 2, 3, 4, 5, 6, 4, 6, 7 ... etc

For example, if you submit vertices for a quad like like that shown in Figure 2, “Example of vertices submitted to form a quad” then you can request 6 indices to render two triangles like those shown in Figure 3, “Illustration of the triangle indices that will be generated”.

Figure 2. Example of vertices submitted to form a quad

Figure 3. Illustration of the triangle indices that will be generated

cogl_is_vertex_buffer_indices ()

CoglBool
cogl_is_vertex_buffer_indices (CoglHandle handle);

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

Since: 1.4

enum CoglVerticesMode

Different ways of interpreting vertices when drawing.

Since: 1.0

enum CoglIndicesType

You should aim to use the smallest data type that gives you enough range, since it reduces the size of your index array and can help reduce the demand on memory bandwidth.

Note that COGL_INDICES_TYPE_UNSIGNED_INT is only supported if the COGL_FEATURE_ID_UNSIGNED_INT_INDICES feature is available. This should always be available on OpenGL but on OpenGL ES it will only be available if the GL_OES_element_index_uint extension is advertized.