clutter 2.0.2-x86-mingw32 → 2.0.3-x86-mingw32

data/vendor/local/include/cogl/cogl/cogl-output.h

@@ -61,7 +61,7 @@ typedef struct _CoglOutput CoglOutput;
 #define COGL_OUTPUT(X) ((CoglOutput *)(X))
 
 /**
- * CoglSubpixelOrder
+ * CoglSubpixelOrder:
  * @COGL_SUBPIXEL_ORDER_UNKNOWN: the layout of subpixel
  *   components for the device is unknown.
  * @COGL_SUBPIXEL_ORDER_NONE: the device displays colors

data/vendor/local/include/cogl/cogl/cogl-pipeline-layer-state.h

@@ -179,8 +179,8 @@ cogl_pipeline_set_layer_null_texture (CoglPipeline *pipeline,
  * @pipeline: A #CoglPipeline object
  * @layer_index: the index of the layer
  *
- * Return value: the texture that was set for the given layer of the
- *   pipeline or %NULL if no texture was set.
+ * Return value: (transfer none): the texture that was set for the
+ *   given layer of the pipeline or %NULL if no texture was set.
  * Stability: unstable
  * Since: 1.10
  */

data/vendor/local/include/cogl/cogl/cogl-pipeline-state.h

@@ -487,12 +487,17 @@ cogl_pipeline_set_blend_constant (CoglPipeline *pipeline,
  * @point_size: the new point size.
  *
  * Changes the size of points drawn when %COGL_VERTICES_MODE_POINTS is
- * used with the vertex buffer API. Note that typically the GPU will
- * only support a limited minimum and maximum range of point sizes. If
- * the chosen point size is outside that range then the nearest value
- * within that range will be used instead. The size of a point is in
- * screen space so it will be the same regardless of any
- * transformations. The default point size is 1.0.
+ * used with the attribute buffer API. Note that typically the GPU
+ * will only support a limited minimum and maximum range of point
+ * sizes. If the chosen point size is outside that range then the
+ * nearest value within that range will be used instead. The size of a
+ * point is in screen space so it will be the same regardless of any
+ * transformations.
+ *
+ * If the point size is set to 0.0 then drawing points with the
+ * pipeline will have undefined results. This is the default value so
+ * if an application wants to draw points it must make sure to use a
+ * pipeline that has an explicit point size set on it.
  *
  * Since: 2.0
  * Stability: Unstable
@@ -516,6 +521,50 @@ cogl_pipeline_set_point_size (CoglPipeline *pipeline,
 float
 cogl_pipeline_get_point_size (CoglPipeline *pipeline);
 
+/**
+ * cogl_pipeline_set_per_vertex_point_size:
+ * @pipeline: a #CoglPipeline pointer
+ * @enable: whether to enable per-vertex point size
+ * @error: a location to store a #CoglError if the change failed
+ *
+ * Sets whether to use a per-vertex point size or to use the value set
+ * by cogl_pipeline_set_point_size(). If per-vertex point size is
+ * enabled then the point size can be set for an individual point
+ * either by drawing with a #CoglAttribute with the name
+ * ‘cogl_point_size_in’ or by writing to the GLSL builtin
+ * ‘cogl_point_size_out’ from a vertex shader snippet.
+ *
+ * If per-vertex point size is enabled and this attribute is not used
+ * and cogl_point_size_out is not written to then the results are
+ * undefined.
+ *
+ * Note that enabling this will only work if the
+ * %COGL_FEATURE_ID_PER_VERTEX_POINT_SIZE feature is available. If
+ * this is not available then the function will return %FALSE and set
+ * a #CoglError.
+ *
+ * Since: 2.0
+ * Stability: Unstable
+ * Return value: %TRUE if the change suceeded or %FALSE otherwise
+ */
+CoglBool
+cogl_pipeline_set_per_vertex_point_size (CoglPipeline *pipeline,
+                                         CoglBool enable,
+                                         CoglError **error);
+
+/**
+ * cogl_pipeline_get_per_vertex_point_size:
+ * @pipeline: a #CoglPipeline pointer
+ *
+ * Since: 2.0
+ * Stability: Unstable
+ * Return value: %TRUE if the pipeline has per-vertex point size
+ *   enabled or %FALSE otherwise. The per-vertex point size can be
+ *   enabled with cogl_pipeline_set_per_vertex_point_size().
+ */
+CoglBool
+cogl_pipeline_get_per_vertex_point_size (CoglPipeline *pipeline);
+
 /**
  * cogl_pipeline_get_color_mask:
  * @pipeline: a #CoglPipeline object.
@@ -555,7 +604,7 @@ cogl_pipeline_set_color_mask (CoglPipeline *pipeline,
  * Queries what user program has been associated with the given
  * @pipeline using cogl_pipeline_set_user_program().
  *
- * Return value: The current user program or %COGL_INVALID_HANDLE.
+ * Return value: (transfer none): The current user program or %COGL_INVALID_HANDLE.
  *
  * Since: 2.0
  * Stability: Unstable
@@ -640,7 +689,7 @@ cogl_pipeline_set_depth_state (CoglPipeline *pipeline,
                                CoglError **error);
 
 /**
- * cogl_pipeline_get_depth_state
+ * cogl_pipeline_get_depth_state:
  * @pipeline: A #CoglPipeline object
  * @state_out: (out): A destination #CoglDepthState struct
  *

data/vendor/local/include/cogl/cogl/cogl-pipeline.h

@@ -64,7 +64,7 @@ COGL_BEGIN_DECLS
  * Allocates and initializes a default simple pipeline that will color
  * a primitive white.
  *
- * Return value: a pointer to a new #CoglPipeline
+ * Return value: (transfer full): a pointer to a new #CoglPipeline
  *
  * Since: 2.0
  * Stability: Unstable
@@ -85,7 +85,7 @@ cogl_pipeline_new (CoglContext *context);
  * keep track of a pipelines ancestry which we may use to help minimize GPU
  * state changes.
  *
- * Returns: a pointer to the newly allocated #CoglPipeline
+ * Return value: (transfer full): a pointer to the newly allocated #CoglPipeline
  *
  * Since: 2.0
  * Stability: Unstable
@@ -127,9 +127,10 @@ typedef CoglBool (*CoglPipelineLayerCallback) (CoglPipeline *pipeline,
 /**
  * cogl_pipeline_foreach_layer:
  * @pipeline: A #CoglPipeline object
- * @callback: A #CoglPipelineLayerCallback to be called for each layer
- *            index
- * @user_data: Private data that will be passed to the callback
+ * @callback: (scope call): A #CoglPipelineLayerCallback to be
+ *            called for each layer index
+ * @user_data: (closure): Private data that will be passed to the
+ *             callback
  *
  * Iterates all the layer indices of the given @pipeline.
  *

data/vendor/local/include/cogl/cogl/cogl-pixel-buffer.h

@@ -32,6 +32,10 @@
 #ifndef __COGL_PIXEL_BUFFER_H__
 #define __COGL_PIXEL_BUFFER_H__
 
+/* XXX: We forward declare CoglPixelBuffer here to allow for circular
+ * dependencies between some headers */
+typedef struct _CoglPixelBuffer CoglPixelBuffer;
+
 #include <cogl/cogl-types.h>
 #include <cogl/cogl-context.h>
 
@@ -39,8 +43,6 @@ COGL_BEGIN_DECLS
 
 #define COGL_PIXEL_BUFFER(buffer) ((CoglPixelBuffer *)(buffer))
 
-typedef struct _CoglPixelBuffer CoglPixelBuffer;
-
 /**
  * cogl_pixel_buffer_new:
  * @context: A #CoglContext
@@ -55,6 +57,8 @@ typedef struct _CoglPixelBuffer CoglPixelBuffer;
  * If @data isn't %NULL then @size bytes will be read from @data and
  * immediately copied into the new buffer.
  *
+ * Return value: (transfer full): a newly allocated #CoglPixelBuffer
+ *
  * Since: 1.10
  * Stability: unstable
  */

data/vendor/local/include/cogl/cogl/cogl-poll.h

@@ -104,19 +104,23 @@ typedef struct {
 } CoglPollFD;
 
 /**
- * cogl_poll_get_info:
- * @context: A #CoglContext
+ * cogl_poll_renderer_get_info:
+ * @renderer: A #CoglRenderer
  * @poll_fds: A return location for a pointer to an array
  *            of #CoglPollFD<!-- -->s
  * @n_poll_fds: A return location for the number of entries in *@poll_fds
  * @timeout: A return location for the maximum length of time to wait
  *           in microseconds, or -1 to wait indefinitely.
  *
- * This should be called whenever an application is about to go idle
- * so that Cogl has a chance to describe what state it needs to be
- * woken up on. The assumption is that the application is using a main
- * loop with something like the poll function call on Unix or the GLib
- * main loop.
+ * Is used to integrate Cogl with an application mainloop that is based
+ * on the unix poll(2) api (or select() or something equivalent). This
+ * api should be called whenever an application is about to go idle so
+ * that Cogl has a chance to describe what file descriptor events it
+ * needs to be woken up for.
+ *
+ * <note>If your application is using the Glib mainloop then you
+ * should jump to the cogl_glib_source_new() api as a more convenient
+ * way of integrating Cogl with the mainloop.</note>
  *
  * After the function is called *@poll_fds will contain a pointer to
  * an array of #CoglPollFD structs describing the file descriptors
@@ -124,8 +128,12 @@ typedef struct {
  * accordingly. After the application has completed its idle it is
  * expected to either update the revents members directly in this
  * array or to create a copy of the array and update them
- * there. Either way it should pass a pointer to either array back to
- * Cogl when calling cogl_poll_dispatch().
+ * there.
+ *
+ * When the application mainloop returns from calling poll(2) (or its
+ * equivalent) then it should call cogl_poll_renderer_dispatch()
+ * passing a pointer the array of CoglPollFD<!-- -->s with updated
+ * revent values.
  *
  * When using the %COGL_WINSYS_ID_WGL winsys (where file descriptors
  * don't make any sense) or %COGL_WINSYS_ID_SDL (where the event
@@ -134,21 +142,29 @@ typedef struct {
  *
  * @timeout will contain a maximum amount of time to wait in
  * microseconds before the application should wake up or -1 if the
- * application should wait indefinitely. This can also be 0 zero if
+ * application should wait indefinitely. This can also be 0 if
  * Cogl needs to be woken up immediately.
  *
+ * Return value: A "poll fd state age" that changes whenever the set
+ *               of poll_fds has changed. If this API is being used to
+ *               integrate with another system mainloop api then
+ *               knowing if the set of file descriptors and events has
+ *               really changed can help avoid redundant work
+ *               depending the api. The age isn't guaranteed to change
+ *               when the timeout changes.
+ *
  * Stability: unstable
- * Since: 1.10
+ * Since: 1.16
  */
-void
-cogl_poll_get_info (CoglContext *context,
-                    CoglPollFD **poll_fds,
-                    int *n_poll_fds,
-                    int64_t *timeout);
+int
+cogl_poll_renderer_get_info (CoglRenderer *renderer,
+                             CoglPollFD **poll_fds,
+                             int *n_poll_fds,
+                             int64_t *timeout);
 
 /**
- * cogl_poll_dispatch:
- * @context: A #CoglContext
+ * cogl_poll_renderer_dispatch:
+ * @renderer: A #CoglRenderer
  * @poll_fds: An array of #CoglPollFD<!-- -->s describing the events
  *            that have occurred since the application went idle.
  * @n_poll_fds: The length of the @poll_fds array.
@@ -157,17 +173,21 @@ cogl_poll_get_info (CoglContext *context,
  * going idle in its main loop. The @poll_fds array should contain a
  * list of file descriptors matched with the events that occurred in
  * revents. The events field is ignored. It is safe to pass in extra
- * file descriptors that Cogl didn't request from
- * cogl_context_begin_idle() or a shorter array missing some file
+ * file descriptors that Cogl didn't request when calling
+ * cogl_poll_renderer_get_info() or a shorter array missing some file
  * descriptors that Cogl requested.
  *
+ * <note>If your application didn't originally create a #CoglRenderer
+ * manually then you can easily get a #CoglRenderer pointer by calling
+ * cogl_get_renderer().</note>
+ *
  * Stability: unstable
- * Since: 1.10
+ * Since: 1.16
  */
 void
-cogl_poll_dispatch (CoglContext *context,
-                    const CoglPollFD *poll_fds,
-                    int n_poll_fds);
+cogl_poll_renderer_dispatch (CoglRenderer *renderer,
+                             const CoglPollFD *poll_fds,
+                             int n_poll_fds);
 
 COGL_END_DECLS
 

data/vendor/local/include/cogl/cogl/cogl-primitive-texture.h

@@ -46,9 +46,9 @@ COGL_BEGIN_DECLS
  * as #CoglAtlasTexture and #CoglTexture2DSliced.
  *
  * A texture that implements this interface can be directly used with
- * the attributes API such as cogl_framebuffer_draw_attributes().
- * Other types of textures need to be first resolved to primitive
- * textures using the #CoglMetaTexture interface.
+ * the low level cogl_primitive_draw() API. Other types of textures
+ * need to be first resolved to primitive textures using the
+ * #CoglMetaTexture interface.
  *
  * <note>Most developers won't need to use this interface directly but
  * still it is worth understanding the distinction between high-level

data/vendor/local/include/cogl/cogl/cogl-primitive.h

@@ -38,6 +38,7 @@ typedef struct _CoglPrimitive CoglPrimitive;
 
 #include <cogl/cogl-vertex-buffer.h> /* for CoglVerticesMode */
 #include <cogl/cogl-attribute.h>
+#include <cogl/cogl-framebuffer.h>
 
 COGL_BEGIN_DECLS
 
@@ -221,7 +222,7 @@ typedef struct {
  * cogl_primitive_set_n_vertices() were called. This property defines
  * the number of vertices to read when drawing.
  *
- * Returns: A newly allocated #CoglPrimitive object
+ * Return value: (transfer full): A newly allocated #CoglPrimitive object
  *
  * Since: 1.6
  * Stability: Unstable
@@ -231,6 +232,27 @@ cogl_primitive_new (CoglVerticesMode mode,
                     int n_vertices,
                     ...);
 
+/**
+ * cogl_primitive_new_with_attributes:
+ * @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
+ *
+ * Combines a set of #CoglAttribute<!-- -->s 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 <structfield>n_vertices</structfield> property as if
+ * cogl_primitive_set_n_vertices() were called. This property defines
+ * the number of vertices to read when drawing.
+ *
+ * Return value: (transfer full): A newly allocated #CoglPrimitive object
+ *
+ * Since: 1.6
+ * Stability: Unstable
+ */
 CoglPrimitive *
 cogl_primitive_new_with_attributes (CoglVerticesMode mode,
                                     int n_vertices,
@@ -243,7 +265,9 @@ cogl_primitive_new_with_attributes (CoglVerticesMode mode,
  * @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
+
+ * @data: (array length=n_vertices): (type Cogl.VertexP2): 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
@@ -278,8 +302,8 @@ cogl_primitive_new_with_attributes (CoglVerticesMode mode,
  * 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)</note>
  *
- * Return value: A newly allocated #CoglPrimitive with a reference of
- * 1. This can be freed using cogl_object_unref().
+ * Return value: (transfer full): A newly allocated #CoglPrimitive
+ * with a reference of 1. This can be freed using cogl_object_unref().
  *
  * Since: 1.6
  * Stability: Unstable
@@ -296,7 +320,8 @@ cogl_primitive_new_p2 (CoglContext *context,
  * @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
+ * @data: (array length=n_vertices): (type Cogl.VertexP3): 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
@@ -331,8 +356,8 @@ cogl_primitive_new_p2 (CoglContext *context,
  * 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)</note>
  *
- * Return value: A newly allocated #CoglPrimitive with a reference of
- * 1. This can be freed using cogl_object_unref().
+ * Return value: (transfer full): A newly allocated #CoglPrimitive
+ * with a reference of 1. This can be freed using cogl_object_unref().
  *
  * Since: 1.6
  * Stability: Unstable
@@ -349,7 +374,8 @@ cogl_primitive_new_p3 (CoglContext *context,
  * @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
+ * @data: (array length=n_vertices): (type Cogl.VertexP2C4): 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
@@ -386,8 +412,8 @@ cogl_primitive_new_p3 (CoglContext *context,
  * 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)</note>
  *
- * Return value: A newly allocated #CoglPrimitive with a reference of
- * 1. This can be freed using cogl_object_unref().
+ * Return value: (transfer full): A newly allocated #CoglPrimitive
+ * with a reference of 1. This can be freed using cogl_object_unref().
  *
  * Since: 1.6
  * Stability: Unstable
@@ -404,7 +430,8 @@ cogl_primitive_new_p2c4 (CoglContext *context,
  * @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
+ * @data: (array length=n_vertices): (type Cogl.VertexP3C4): 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
@@ -441,8 +468,8 @@ cogl_primitive_new_p2c4 (CoglContext *context,
  * 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)</note>
  *
- * Return value: A newly allocated #CoglPrimitive with a reference of
- * 1. This can be freed using cogl_object_unref().
+ * Return value: (transfer full): A newly allocated #CoglPrimitive
+ * with a reference of 1. This can be freed using cogl_object_unref().
  *
  * Since: 1.6
  * Stability: Unstable
@@ -459,7 +486,8 @@ cogl_primitive_new_p3c4 (CoglContext *context,
  * @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
+ * @data: (array length=n_vertices): (type Cogl.VertexP2T2): 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
@@ -496,8 +524,8 @@ cogl_primitive_new_p3c4 (CoglContext *context,
  * 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)</note>
  *
- * Return value: A newly allocated #CoglPrimitive with a reference of
- * 1. This can be freed using cogl_object_unref().
+ * Return value: (transfer full): A newly allocated #CoglPrimitive
+ * with a reference of 1. This can be freed using cogl_object_unref().
  *
  * Since: 1.6
  * Stability: Unstable
@@ -514,7 +542,8 @@ cogl_primitive_new_p2t2 (CoglContext *context,
  * @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
+ * @data: (array length=n_vertices): (type Cogl.VertexP3T2): 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
@@ -551,8 +580,8 @@ cogl_primitive_new_p2t2 (CoglContext *context,
  * 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)</note>
  *
- * Return value: A newly allocated #CoglPrimitive with a reference of
- * 1. This can be freed using cogl_object_unref().
+ * Return value: (transfer full): A newly allocated #CoglPrimitive
+ * with a reference of 1. This can be freed using cogl_object_unref().
  *
  * Since: 1.6
  * Stability: Unstable
@@ -569,7 +598,8 @@ cogl_primitive_new_p3t2 (CoglContext *context,
  * @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
+ * @data: (array length=n_vertices): (type Cogl.VertexP2T2C4): 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
@@ -606,8 +636,8 @@ cogl_primitive_new_p3t2 (CoglContext *context,
  * 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)</note>
  *
- * Return value: A newly allocated #CoglPrimitive with a reference of
- * 1. This can be freed using cogl_object_unref().
+ * Return value: (transfer full): A newly allocated #CoglPrimitive
+ * with a reference of 1. This can be freed using cogl_object_unref().
  *
  * Since: 1.6
  * Stability: Unstable
@@ -624,7 +654,8 @@ cogl_primitive_new_p2t2c4 (CoglContext *context,
  * @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
+ * @data: (array length=n_vertices): (type Cogl.VertexP3T2C4): 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
@@ -661,8 +692,8 @@ cogl_primitive_new_p2t2c4 (CoglContext *context,
  * 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)</note>
  *
- * Return value: A newly allocated #CoglPrimitive with a reference of
- * 1. This can be freed using cogl_object_unref().
+ * Return value: (transfer full): A newly allocated #CoglPrimitive
+ * with a reference of 1. This can be freed using cogl_object_unref().
  *
  * Since: 1.6
  * Stability: Unstable
@@ -786,7 +817,7 @@ cogl_primitive_set_indices (CoglPrimitive *primitive,
  * cogl_primitive_get_indices:
  * @primitive: A #CoglPrimitive
  *
- * Return value: the indices that were set with
+ * Return value: (transfer none): the indices that were set with
  * cogl_primitive_set_indices() or %NULL if no indices were set.
  *
  * Since: 1.10
@@ -803,7 +834,7 @@ cogl_primitive_get_indices (CoglPrimitive *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
+ * Return value: (transfer full): the new primitive
  * Since: 1.10
  * Stability: unstable
  */
@@ -847,8 +878,10 @@ typedef CoglBool (* CoglPrimitiveAttributeCallback) (CoglPrimitive *primitive,
 /**
  * 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
+ * @callback: (scope call): A #CoglPrimitiveAttributeCallback to be
+ *            called for each attribute
+ * @user_data: (closure): Private data that will be passed to the
+ *             callback
  *
  * Iterates all the attributes of the given #CoglPrimitive.
  *
@@ -860,6 +893,30 @@ cogl_primitive_foreach_attribute (CoglPrimitive *primitive,
                                   CoglPrimitiveAttributeCallback callback,
                                   void *user_data);
 
+/**
+ * cogl_primitive_draw:
+ * @primitive: A #CoglPrimitive geometry object
+ * @framebuffer: A destination #CoglFramebuffer
+ * @pipeline: A #CoglPipeline state object
+ *
+ * Draws the given @primitive geometry to the specified destination
+ * @framebuffer using the graphics processing state described by @pipeline.
+ *
+ * This drawing api doesn't support high-level meta texture types such
+ * as #CoglTexture2DSliced so it is the user's responsibility to
+ * ensure that only low-level textures that can be directly sampled by
+ * a GPU such as #CoglTexture2D, #CoglTextureRectangle or #CoglTexture3D
+ * are associated with layers of the given @pipeline.
+ *
+ * Stability: unstable
+ * Since: 1.16
+ */
+void
+cogl_primitive_draw (CoglPrimitive *primitive,
+                     CoglFramebuffer *framebuffer,
+                     CoglPipeline *pipeline);
+
+
 COGL_END_DECLS
 
 #endif /* __COGL_PRIMITIVE_H__ */