/*
* Cogl
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
* Copyright (C) 2010 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this library. If not, see .
*
*
*
* Authors:
* Robert Bragg
*/
#if !defined(__COGL_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#ifndef __COGL_PRIMITIVE_H__
#define __COGL_PRIMITIVE_H__
#include /* for CoglVerticesMode */
#include
G_BEGIN_DECLS
/**
* SECTION:cogl-primitive
* @short_description: Functions for creating, manipulating and drawing
* primitives
*
* FIXME
*/
typedef struct _CoglPrimitive CoglPrimitive;
/**
* CoglVertexP2:
* @x: The x component of a position attribute
* @y: The y component of a position attribute
*
* A convenience vertex definition that can be used with
* cogl_primitive_new_with_v2_attributes().
*
* Since: 1.6
* Stability: Unstable
*/
typedef struct
{
float x, y;
} CoglVertexP2;
/**
* CoglVertexP3:
* @x: The x component of a position attribute
* @y: The y component of a position attribute
* @z: The z component of a position attribute
*
* A convenience vertex definition that can be used with
* cogl_primitive_new_with_v3_attributes().
*
* Since: 1.6
* Stability: Unstable
*/
typedef struct
{
float x, y, z;
} CoglVertexP3;
/**
* CoglVertexP2C4:
* @x: The x component of a position attribute
* @y: The y component of a position attribute
* @r: The red component of a color attribute
* @b: The green component of a color attribute
* @g: The blue component of a color attribute
* @a: The alpha component of a color attribute
*
* A convenience vertex definition that can be used with
* cogl_primitive_new_with_v2c4_attributes().
*
* Since: 1.6
* Stability: Unstable
*/
typedef struct
{
float x, y;
guint8 r, g, b, a;
} CoglVertexP2C4;
/**
* CoglVertexP3C4:
* @x: The x component of a position attribute
* @y: The y component of a position attribute
* @z: The z component of a position attribute
* @r: The red component of a color attribute
* @b: The green component of a color attribute
* @g: The blue component of a color attribute
* @a: The alpha component of a color attribute
*
* A convenience vertex definition that can be used with
* cogl_primitive_new_with_v3c4_attributes().
*
* Since: 1.6
* Stability: Unstable
*/
typedef struct
{
float x, y, z;
guint8 r, g, b, a;
} CoglVertexP3C4;
/**
* CoglVertexP2T2:
* @x: The x component of a position attribute
* @y: The y component of a position attribute
* @s: The s component of a texture coordinate attribute
* @t: The t component of a texture coordinate attribute
*
* A convenience vertex definition that can be used with
* cogl_primitive_new_with_v2t2_attributes().
*
* Since: 1.6
* Stability: Unstable
*/
typedef struct
{
float x, y;
float s, t;
} CoglVertexP2T2;
/**
* CoglVertexP3T2:
* @x: The x component of a position attribute
* @y: The y component of a position attribute
* @z: The z component of a position attribute
* @s: The s component of a texture coordinate attribute
* @t: The t component of a texture coordinate attribute
*
* A convenience vertex definition that can be used with
* cogl_primitive_new_with_v3t2_attributes().
*
* Since: 1.6
* Stability: Unstable
*/
typedef struct
{
float x, y, z;
float s, t;
} CoglVertexP3T2;
/**
* CoglVertexP2T2C4:
* @x: The x component of a position attribute
* @y: The y component of a position attribute
* @s: The s component of a texture coordinate attribute
* @t: The t component of a texture coordinate attribute
* @r: The red component of a color attribute
* @b: The green component of a color attribute
* @g: The blue component of a color attribute
* @a: The alpha component of a color attribute
*
* A convenience vertex definition that can be used with
* cogl_primitive_new_with_v3t2c4_attributes().
*
* Since: 1.6
* Stability: Unstable
*/
typedef struct
{
float x, y;
float s, t;
guint8 r, g, b, a;
} CoglVertexP2T2C4;
/**
* CoglVertexP3T2C4:
* @x: The x component of a position attribute
* @y: The y component of a position attribute
* @z: The z component of a position attribute
* @s: The s component of a texture coordinate attribute
* @t: The t component of a texture coordinate attribute
* @r: The red component of a color attribute
* @b: The green component of a color attribute
* @g: The blue component of a color attribute
* @a: The alpha component of a color attribute
*
* A convenience vertex definition that can be used with
* cogl_primitive_new_with_v3t2c4_attributes().
*
* Since: 1.6
* Stability: Unstable
*/
typedef struct
{
float x, y, z;
float s, t;
guint8 r, g, b, a;
} CoglVertexP3T2C4;
/**
* cogl_primitive_new:
* @mode: A #CoglVerticesMode defining how to draw the vertices
* @n_vertices: The number of vertices to process when drawing
* @Varargs: A %NULL terminated list of 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.
*
* Returns: A newly allocated #CoglPrimitive object
*
* Since: 1.6
* Stability: Unstable
*/
CoglPrimitive *
cogl_primitive_new (CoglVerticesMode mode,
int n_vertices,
...);
CoglPrimitive *
cogl_primitive_new_with_attributes (CoglVerticesMode mode,
int n_vertices,
CoglAttribute **attributes,
int n_attributes);
/**
* cogl_primitive_new_p2:
* @mode: A #CoglVerticesMode defining how to draw the vertices
* @n_vertices: The number of vertices to read from @data and also
* the number of vertices to read when later drawing.
* @data: An array of #CoglVertexP2 vertices
*
* 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:
* |[
* 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.
* The primitive API doesn't support drawing with sliced
* textures (since switching between slices implies changing state and
* so that implies multiple primitives need to be submitted). You
* should pass the %COGL_TEXTURE_NO_SLICING flag to all textures that
* might be used while drawing with this API. If your hardware doesn't
* support non-power of two textures (For example you are using GLES
* 1.1) then you will need to make sure your assets are resized to a
* power-of-two size (though they don't have to be square)
*
* Return value: A newly allocated #CoglPrimitive with a reference of
* 1. This can be freed using cogl_object_unref().
*
* Since: 1.6
* Stability: Unstable
*/
CoglPrimitive *
cogl_primitive_new_p2 (CoglVerticesMode mode,
int n_vertices,
const CoglVertexP2 *data);
/**
* cogl_primitive_new_p3:
* @mode: A #CoglVerticesMode defining how to draw the vertices
* @n_vertices: The number of vertices to read from @data and also
* the number of vertices to read when later drawing.
* @data: An array of #CoglVertexP3 vertices
*
* 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:
* |[
* 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.
* The primitive API doesn't support drawing with sliced
* textures (since switching between slices implies changing state and
* so that implies multiple primitives need to be submitted). You
* should pass the %COGL_TEXTURE_NO_SLICING flag to all textures that
* might be used while drawing with this API. If your hardware doesn't
* support non-power of two textures (For example you are using GLES
* 1.1) then you will need to make sure your assets are resized to a
* power-of-two size (though they don't have to be square)
*
* Return value: A newly allocated #CoglPrimitive with a reference of
* 1. This can be freed using cogl_object_unref().
*
* Since: 1.6
* Stability: Unstable
*/
CoglPrimitive *
cogl_primitive_new_p3 (CoglVerticesMode mode,
int n_vertices,
const CoglVertexP3 *data);
/**
* cogl_primitive_new_p2c4:
* @mode: A #CoglVerticesMode defining how to draw the vertices
* @n_vertices: The number of vertices to read from @data and also
* the number of vertices to read when later drawing.
* @data: An array of #CoglVertexP2C4 vertices
*
* 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:
* |[
* 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.
* The primitive API doesn't support drawing with sliced
* textures (since switching between slices implies changing state and
* so that implies multiple primitives need to be submitted). You
* should pass the %COGL_TEXTURE_NO_SLICING flag to all textures that
* might be used while drawing with this API. If your hardware doesn't
* support non-power of two textures (For example you are using GLES
* 1.1) then you will need to make sure your assets are resized to a
* power-of-two size (though they don't have to be square)
*
* Return value: A newly allocated #CoglPrimitive with a reference of
* 1. This can be freed using cogl_object_unref().
*
* Since: 1.6
* Stability: Unstable
*/
CoglPrimitive *
cogl_primitive_new_p2c4 (CoglVerticesMode mode,
int n_vertices,
const CoglVertexP2C4 *data);
/**
* cogl_primitive_new_p3c4:
* @mode: A #CoglVerticesMode defining how to draw the vertices
* @n_vertices: The number of vertices to read from @data and also
* the number of vertices to read when later drawing.
* @data: An array of #CoglVertexP3C4 vertices
*
* 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:
* |[
* 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.
* The primitive API doesn't support drawing with sliced
* textures (since switching between slices implies changing state and
* so that implies multiple primitives need to be submitted). You
* should pass the %COGL_TEXTURE_NO_SLICING flag to all textures that
* might be used while drawing with this API. If your hardware doesn't
* support non-power of two textures (For example you are using GLES
* 1.1) then you will need to make sure your assets are resized to a
* power-of-two size (though they don't have to be square)
*
* Return value: A newly allocated #CoglPrimitive with a reference of
* 1. This can be freed using cogl_object_unref().
*
* Since: 1.6
* Stability: Unstable
*/
CoglPrimitive *
cogl_primitive_new_p3c4 (CoglVerticesMode mode,
int n_vertices,
const CoglVertexP3C4 *data);
/**
* cogl_primitive_new_p2t2:
* @mode: A #CoglVerticesMode defining how to draw the vertices
* @n_vertices: The number of vertices to read from @data and also
* the number of vertices to read when later drawing.
* @data: An array of #CoglVertexP2T2 vertices
*
* 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:
* |[
* 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.
* The primitive API doesn't support drawing with sliced
* textures (since switching between slices implies changing state and
* so that implies multiple primitives need to be submitted). You
* should pass the %COGL_TEXTURE_NO_SLICING flag to all textures that
* might be used while drawing with this API. If your hardware doesn't
* support non-power of two textures (For example you are using GLES
* 1.1) then you will need to make sure your assets are resized to a
* power-of-two size (though they don't have to be square)
*
* Return value: A newly allocated #CoglPrimitive with a reference of
* 1. This can be freed using cogl_object_unref().
*
* Since: 1.6
* Stability: Unstable
*/
CoglPrimitive *
cogl_primitive_new_p2t2 (CoglVerticesMode mode,
int n_vertices,
const CoglVertexP2T2 *data);
/**
* cogl_primitive_new_p3t2:
* @mode: A #CoglVerticesMode defining how to draw the vertices
* @n_vertices: The number of vertices to read from @data and also
* the number of vertices to read when later drawing.
* @data: An array of #CoglVertexP3T2 vertices
*
* 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:
* |[
* 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.
* The primitive API doesn't support drawing with sliced
* textures (since switching between slices implies changing state and
* so that implies multiple primitives need to be submitted). You
* should pass the %COGL_TEXTURE_NO_SLICING flag to all textures that
* might be used while drawing with this API. If your hardware doesn't
* support non-power of two textures (For example you are using GLES
* 1.1) then you will need to make sure your assets are resized to a
* power-of-two size (though they don't have to be square)
*
* Return value: A newly allocated #CoglPrimitive with a reference of
* 1. This can be freed using cogl_object_unref().
*
* Since: 1.6
* Stability: Unstable
*/
CoglPrimitive *
cogl_primitive_new_p3t2 (CoglVerticesMode mode,
int n_vertices,
const CoglVertexP3T2 *data);
/**
* cogl_primitive_new_p2t2c4:
* @mode: A #CoglVerticesMode defining how to draw the vertices
* @n_vertices: The number of vertices to read from @data and also
* the number of vertices to read when later drawing.
* @data: An array of #CoglVertexP2T2C4 vertices
*
* 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:
* |[
* 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.
* The primitive API doesn't support drawing with sliced
* textures (since switching between slices implies changing state and
* so that implies multiple primitives need to be submitted). You
* should pass the %COGL_TEXTURE_NO_SLICING flag to all textures that
* might be used while drawing with this API. If your hardware doesn't
* support non-power of two textures (For example you are using GLES
* 1.1) then you will need to make sure your assets are resized to a
* power-of-two size (though they don't have to be square)
*
* Return value: A newly allocated #CoglPrimitive with a reference of
* 1. This can be freed using cogl_object_unref().
*
* Since: 1.6
* Stability: Unstable
*/
CoglPrimitive *
cogl_primitive_new_p2t2c4 (CoglVerticesMode mode,
int n_vertices,
const CoglVertexP2T2C4 *data);
/**
* cogl_primitive_new_p3t2c4:
* @mode: A #CoglVerticesMode defining how to draw the vertices
* @n_vertices: The number of vertices to read from @data and also
* the number of vertices to read when later drawing.
* @data: An array of #CoglVertexP3T2C4 vertices
*
* 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:
* |[
* 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.
* The primitive API doesn't support drawing with sliced
* textures (since switching between slices implies changing state and
* so that implies multiple primitives need to be submitted). You
* should pass the %COGL_TEXTURE_NO_SLICING flag to all textures that
* might be used while drawing with this API. If your hardware doesn't
* support non-power of two textures (For example you are using GLES
* 1.1) then you will need to make sure your assets are resized to a
* power-of-two size (though they don't have to be square)
*
* Return value: A newly allocated #CoglPrimitive with a reference of
* 1. This can be freed using cogl_object_unref().
*
* Since: 1.6
* Stability: Unstable
*/
CoglPrimitive *
cogl_primitive_new_p3t2c4 (CoglVerticesMode mode,
int n_vertices,
const CoglVertexP3T2C4 *data);
int
cogl_primitive_get_first_vertex (CoglPrimitive *primitive);
void
cogl_primitive_set_first_vertex (CoglPrimitive *primitive,
int first_vertex);
#define cogl_primitive_get_n_vertices cogl_primitive_get_n_vertices_EXP
/**
* cogl_primitive_get_n_vertices:
* @primitive: A #CoglPrimitive object
*
* 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.
*
* To be clear; it doesn't refer to the number of vertices - in
* terms of data - associated with the primitive it's just the number
* of vertices to read and draw.
*
* Returns: The number of vertices to read when drawing.
*
* Since: 1.8
* Stability: unstable
*/
int
cogl_primitive_get_n_vertices (CoglPrimitive *primitive);
#define cogl_primitive_set_n_vertices cogl_primitive_set_n_vertices_EXP
/**
* cogl_primitive_set_n_vertices:
* @primitive: A #CoglPrimitive object
* @n_vertices: The number of vertices to read when drawing.
*
* 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.
*
* To be clear; it doesn't refer to the number of vertices - in
* terms of data - associated with the primitive it's just the number
* of vertices to read and draw.
*
* Since: 1.8
* Stability: unstable
*/
void
cogl_primitive_set_n_vertices (CoglPrimitive *primitive,
int n_vertices);
CoglVerticesMode
cogl_primitive_get_mode (CoglPrimitive *primitive);
void
cogl_primitive_set_mode (CoglPrimitive *primitive,
CoglVerticesMode mode);
/**
* cogl_primitive_set_attributes:
* @primitive: A #CoglPrimitive object
* @attributes: A %NULL terminated array of #CoglAttribute
* pointers
*
* Replaces all the attributes of the given #CoglPrimitive object.
*
* Since: 1.6
* Stability: Unstable
*/
void
cogl_primitive_set_attributes (CoglPrimitive *primitive,
CoglAttribute **attributes,
int n_attributes);
#define cogl_primitive_set_indices cogl_primitive_set_indices_EXP
/**
* cogl_primitive_set_indices:
* @primitive: A #CoglPrimitive
* @indices: A #CoglIndices array
* @n_indices: The number of indices to reference when drawing
*
* 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.
*
* The #CoglPrimitive::first_vertex property also affects
* drawing with indices by defining the first entry of the indices to
* start drawing from.
*
* Since: 1.10
* Stability: unstable
*/
void
cogl_primitive_set_indices (CoglPrimitive *primitive,
CoglIndices *indices,
int n_indices);
/**
* cogl_primitive_get_indices:
* @primitive: A #CoglPrimitive
*
* Return value: the indices that were set with
* cogl_primitive_set_indices() or %NULL if no indices were set.
*
* Since: 1.10
* Stability: unstable
*/
CoglIndices *
cogl_primitive_get_indices (CoglPrimitive *primitive);
/**
* cogl_primitive_copy:
* @primitive: A primitive copy
*
* 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.
*
* Return value: the new primitive
* Since: 1.10
* Stability: unstable
*/
CoglPrimitive *
cogl_primitive_copy (CoglPrimitive *primitive);
/**
* cogl_is_primitive:
* @object: A #CoglObject
*
* Gets whether the given object references a #CoglPrimitive.
*
* Returns: %TRUE if the handle references a #CoglPrimitive,
* %FALSE otherwise
*
* Since: 1.6
* Stability: Unstable
*/
gboolean
cogl_is_primitive (void *object);
/**
* CoglPrimitiveAttributeCallback:
* @primitive: The #CoglPrimitive whose attributes are being iterated
* @attribute: The #CoglAttribute
* @user_data: The private data passed to cogl_primitive_foreach_attribute()
*
* 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.
*
* Since: 1.10
* Stability: Unstable
*/
typedef gboolean (* CoglPrimitiveAttributeCallback) (CoglPrimitive *primitive,
CoglAttribute *attribute,
void *user_data);
/**
* cogl_primitive_foreach_attribute:
* @primitive: A #CoglPrimitive object
* @callback: A #CoglPrimitiveAttributeCallback to be called for each attribute
* @user_data: Private data that will be passed to the callback
*
* Iterates all the attributes of the given #CoglPrimitive.
*
* Since: 1.10
* Stability: Unstable
*/
void
cogl_primitive_foreach_attribute (CoglPrimitive *primitive,
CoglPrimitiveAttributeCallback callback,
void *user_data);
G_END_DECLS
#endif /* __COGL_PRIMITIVE_H__ */