CoglBuffer: The Buffer Interface

CoglBuffer: The Buffer Interface — Common buffer functions, including data upload APIs

Stability Level

Unstable, unless otherwise indicated

Synopsis

                    CoglBuffer;
CoglBool            cogl_is_buffer                      (void *object);
unsigned int        cogl_buffer_get_size                (CoglBuffer *buffer);
enum                CoglBufferUpdateHint;
void                cogl_buffer_set_update_hint         (CoglBuffer *buffer,
                                                         CoglBufferUpdateHint hint);
CoglBufferUpdateHint cogl_buffer_get_update_hint        (CoglBuffer *buffer);
enum                CoglBufferAccess;
enum                CoglBufferMapHint;
void *              cogl_buffer_map                     (CoglBuffer *buffer,
                                                         CoglBufferAccess access,
                                                         CoglBufferMapHint hints,
                                                         CoglError **error);
void *              cogl_buffer_map_range               (CoglBuffer *buffer,
                                                         size_t offset,
                                                         size_t size,
                                                         CoglBufferAccess access,
                                                         CoglBufferMapHint hints,
                                                         CoglError **error);
void                cogl_buffer_unmap                   (CoglBuffer *buffer);
CoglBool            cogl_buffer_set_data                (CoglBuffer *buffer,
                                                         size_t offset,
                                                         const void *data,
                                                         size_t size,
                                                         CoglError **error);

                    CoglPixelBuffer;
CoglPixelBuffer *   cogl_pixel_buffer_new               (CoglContext *context,
                                                         size_t size,
                                                         const void *data,
                                                         CoglError **error);
CoglBool            cogl_is_pixel_buffer                (void *object);

Description

The CoglBuffer API provides a common interface to manipulate buffers that have been allocated either via cogl_pixel_buffer_new() or cogl_attribute_buffer_new(). The API allows you to upload data to these buffers and define usage hints that help Cogl manage your buffer optimally.

Data can either be uploaded by supplying a pointer and size so Cogl can copy your data, or you can mmap() a CoglBuffer and then you can copy data to the buffer directly.

One of the most common uses for CoglBuffers is to upload texture data asynchronously since the ability to mmap the buffers into the CPU makes it possible for another thread to handle the IO of loading an image file and unpacking it into the mapped buffer without blocking other Cogl operations.

Details

CoglBuffer

typedef struct _CoglBuffer CoglBuffer;

cogl_is_buffer ()

CoglBool            cogl_is_buffer                      (void *object);

Checks whether buffer is a buffer object.

object :

a buffer object

Returns :

TRUE if the handle is a CoglBuffer, and FALSE otherwise

Since 1.2

Stability Level: Unstable


cogl_buffer_get_size ()

unsigned int        cogl_buffer_get_size                (CoglBuffer *buffer);

Retrieves the size of buffer

buffer :

a buffer object

Returns :

the size of the buffer in bytes

Since 1.2

Stability Level: Unstable


enum CoglBufferUpdateHint

typedef enum {
 /*< prefix=COGL_BUFFER_UPDATE_HINT >*/
  COGL_BUFFER_UPDATE_HINT_STATIC,
  COGL_BUFFER_UPDATE_HINT_DYNAMIC,
  COGL_BUFFER_UPDATE_HINT_STREAM
} CoglBufferUpdateHint;

The update hint on a buffer allows the user to give some detail on how often the buffer data is going to be updated.

COGL_BUFFER_UPDATE_HINT_STATIC

the buffer will not change over time

COGL_BUFFER_UPDATE_HINT_DYNAMIC

the buffer will change from time to time

COGL_BUFFER_UPDATE_HINT_STREAM

the buffer will be used once or a couple of times

Since 1.2

Stability Level: Unstable


cogl_buffer_set_update_hint ()

void                cogl_buffer_set_update_hint         (CoglBuffer *buffer,
                                                         CoglBufferUpdateHint hint);

Sets the update hint on a buffer. See CoglBufferUpdateHint for a description of the available hints.

buffer :

a buffer object

hint :

the new hint

Since 1.2

Stability Level: Unstable


cogl_buffer_get_update_hint ()

CoglBufferUpdateHint cogl_buffer_get_update_hint        (CoglBuffer *buffer);

Retrieves the update hints set using cogl_buffer_set_update_hint()

buffer :

a buffer object

Returns :

the CoglBufferUpdateHint currently used by the buffer

Since 1.2

Stability Level: Unstable


enum CoglBufferAccess

typedef enum {
 /*< prefix=COGL_BUFFER_ACCESS >*/
 COGL_BUFFER_ACCESS_READ       = 1 << 0,
 COGL_BUFFER_ACCESS_WRITE      = 1 << 1,
 COGL_BUFFER_ACCESS_READ_WRITE = COGL_BUFFER_ACCESS_READ | COGL_BUFFER_ACCESS_WRITE
} CoglBufferAccess;

The access hints for cogl_buffer_set_update_hint()

COGL_BUFFER_ACCESS_READ

the buffer will be read

COGL_BUFFER_ACCESS_WRITE

the buffer will written to

COGL_BUFFER_ACCESS_READ_WRITE

the buffer will be used for both reading and writing

Since 1.2

Stability Level: Unstable


enum CoglBufferMapHint

typedef enum {
 /*< prefix=COGL_BUFFER_MAP_HINT >*/
  COGL_BUFFER_MAP_HINT_DISCARD = 1 << 0,
  COGL_BUFFER_MAP_HINT_DISCARD_RANGE = 1 << 1
} CoglBufferMapHint;

Hints to Cogl about how you are planning to modify the data once it is mapped.

COGL_BUFFER_MAP_HINT_DISCARD

Tells Cogl that you plan to replace all the buffer's contents. When this flag is used to map a buffer, the entire contents of the buffer become undefined, even if only a subregion of the buffer is mapped.

COGL_BUFFER_MAP_HINT_DISCARD_RANGE

Tells Cogl that you plan to replace all the contents of the mapped region. The contents of the region specified are undefined after this flag is used to map a buffer.

Since 1.4

Stability Level: Unstable


cogl_buffer_map ()

void *              cogl_buffer_map                     (CoglBuffer *buffer,
                                                         CoglBufferAccess access,
                                                         CoglBufferMapHint hints,
                                                         CoglError **error);

Maps the buffer into the application address space for direct access. This is equivalent to calling cogl_buffer_map_range() with zero as the offset and the size of the entire buffer as the size.

It is strongly recommended that you pass COGL_BUFFER_MAP_HINT_DISCARD as a hint if you are going to replace all the buffer's data. This way if the buffer is currently being used by the GPU then the driver won't have to stall the CPU and wait for the hardware to finish because it can instead allocate a new buffer to map.

The behaviour is undefined if you access the buffer in a way conflicting with the access mask you pass. It is also an error to release your last reference while the buffer is mapped.

buffer :

a buffer object

access :

how the mapped buffer will be used by the application

hints :

A mask of CoglBufferMapHints that tell Cogl how the data will be modified once mapped.

error :

A CoglError for catching exceptional errors

Returns :

A pointer to the mapped memory or NULL is the call fails

Since 1.2

Stability Level: Unstable


cogl_buffer_map_range ()

void *              cogl_buffer_map_range               (CoglBuffer *buffer,
                                                         size_t offset,
                                                         size_t size,
                                                         CoglBufferAccess access,
                                                         CoglBufferMapHint hints,
                                                         CoglError **error);

Maps a sub-region of the buffer into the application's address space for direct access.

It is strongly recommended that you pass COGL_BUFFER_MAP_HINT_DISCARD as a hint if you are going to replace all the buffer's data. This way if the buffer is currently being used by the GPU then the driver won't have to stall the CPU and wait for the hardware to finish because it can instead allocate a new buffer to map. You can pass COGL_BUFFER_MAP_HINT_DISCARD_RANGE instead if you want the regions outside of the mapping to be retained.

The behaviour is undefined if you access the buffer in a way conflicting with the access mask you pass. It is also an error to release your last reference while the buffer is mapped.

buffer :

a buffer object

offset :

Offset within the buffer to start the mapping

size :

The size of data to map

access :

how the mapped buffer will be used by the application

hints :

A mask of CoglBufferMapHints that tell Cogl how the data will be modified once mapped.

error :

A CoglError for catching exceptional errors

Returns :

A pointer to the mapped memory or NULL is the call fails

Since 2.0

Stability Level: Unstable


cogl_buffer_unmap ()

void                cogl_buffer_unmap                   (CoglBuffer *buffer);

Unmaps a buffer previously mapped by cogl_buffer_map().

buffer :

a buffer object

Since 1.2

Stability Level: Unstable


cogl_buffer_set_data ()

CoglBool            cogl_buffer_set_data                (CoglBuffer *buffer,
                                                         size_t offset,
                                                         const void *data,
                                                         size_t size,
                                                         CoglError **error);

Updates part of the buffer with new data from data. Where to put this new data is controlled by offset and offset + data should be less than the buffer size.

buffer :

a buffer object

offset :

destination offset (in bytes) in the buffer

data :

a pointer to the data to be copied into the buffer

size :

number of bytes to copy

error :

A CoglError for catching exceptional errors

Returns :

TRUE is the operation succeeded, FALSE otherwise

Since 1.2

Stability Level: Unstable


CoglPixelBuffer

typedef struct _CoglPixelBuffer CoglPixelBuffer;

cogl_pixel_buffer_new ()

CoglPixelBuffer *   cogl_pixel_buffer_new               (CoglContext *context,
                                                         size_t size,
                                                         const void *data,
                                                         CoglError **error);

Declares a new CoglPixelBuffer of size bytes to contain arrays of pixels. Once declared, data can be set using cogl_buffer_set_data() or by mapping it into the application's address space using cogl_buffer_map().

If data isn't NULL then size bytes will be read from data and immediately copied into the new buffer.

context :

A CoglContext

size :

The number of bytes to allocate for the pixel data.

data :

An optional pointer to vertex data to upload immediately

error :

A CoglError for catching exceptional errors

Since 1.10

Stability Level: Unstable


cogl_is_pixel_buffer ()

CoglBool            cogl_is_pixel_buffer                (void *object);

Checks whether object is a pixel buffer.

object :

a CoglObject to test

Returns :

TRUE if the object is a pixel buffer, and FALSE otherwise

Since 1.2

Stability Level: Unstable