clutter 2.2.4-x64-mingw32

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

@@ -0,0 +1,194 @@
+/*
+ * Cogl
+ *
+ * A Low Level GPU Graphics and Utilities API
+ *
+ * Copyright (C) 2007,2008,2009 Intel Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy,
+ * modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ *
+ */
+
+#if !defined(__COGL_H_INSIDE__) && !defined(COGL_COMPILATION)
+#error "Only <cogl/cogl.h> can be included directly."
+#endif
+
+#ifndef __COGL_PIPELINE_H__
+#define __COGL_PIPELINE_H__
+
+/* We forward declare the CoglPipeline type here to avoid some circular
+ * dependency issues with the following headers.
+ */
+typedef struct _CoglPipeline CoglPipeline;
+
+#include <cogl/cogl-types.h>
+#include <cogl/cogl-context.h>
+#include <cogl/cogl-snippet.h>
+
+#ifdef COGL_HAS_GTYPE_SUPPORT
+#include <glib-object.h>
+#endif
+
+COGL_BEGIN_DECLS
+
+#ifdef COGL_ENABLE_EXPERIMENTAL_API
+
+/**
+ * SECTION:cogl-pipeline
+ * @short_description: Functions for creating and manipulating the GPU
+ *                     pipeline
+ *
+ * Cogl allows creating and manipulating objects representing the full
+ * configuration of the GPU pipeline. In simplified terms the GPU
+ * pipeline takes primitive geometry as the input, it first performs
+ * vertex processing, allowing you to deform your geometry, then
+ * rasterizes that (turning it from pure geometry into fragments) then
+ * performs fragment processing including depth testing and texture
+ * mapping. Finally it blends the result with the framebuffer.
+ */
+
+#define COGL_PIPELINE(OBJECT) ((CoglPipeline *)OBJECT)
+
+#ifdef COGL_HAS_GTYPE_SUPPORT
+/**
+ * cogl_pipeline_get_gtype:
+ *
+ * Returns: a #GType that can be used with the GLib type system.
+ */
+GType cogl_pipeline_get_gtype (void);
+#endif
+
+/**
+ * cogl_pipeline_new:
+ * @context: a #CoglContext
+ *
+ * Allocates and initializes a default simple pipeline that will color
+ * a primitive white.
+ *
+ * Return value: (transfer full): a pointer to a new #CoglPipeline
+ *
+ * Since: 2.0
+ * Stability: Unstable
+ */
+CoglPipeline *
+cogl_pipeline_new (CoglContext *context);
+
+/**
+ * cogl_pipeline_copy:
+ * @source: a #CoglPipeline object to copy
+ *
+ * Creates a new pipeline with the configuration copied from the
+ * source pipeline.
+ *
+ * We would strongly advise developers to always aim to use
+ * cogl_pipeline_copy() instead of cogl_pipeline_new() whenever there will
+ * be any similarity between two pipelines. Copying a pipeline helps Cogl
+ * keep track of a pipelines ancestry which we may use to help minimize GPU
+ * state changes.
+ *
+ * Return value: (transfer full): a pointer to the newly allocated #CoglPipeline
+ *
+ * Since: 2.0
+ * Stability: Unstable
+ */
+CoglPipeline *
+cogl_pipeline_copy (CoglPipeline *source);
+
+/**
+ * cogl_is_pipeline:
+ * @object: A #CoglObject
+ *
+ * Gets whether the given @object references an existing pipeline object.
+ *
+ * Return value: %TRUE if the @object references a #CoglPipeline,
+ *   %FALSE otherwise
+ *
+ * Since: 2.0
+ * Stability: Unstable
+ */
+CoglBool
+cogl_is_pipeline (void *object);
+
+/**
+ * CoglPipelineLayerCallback:
+ * @pipeline: The #CoglPipeline whos layers are being iterated
+ * @layer_index: The current layer index
+ * @user_data: The private data passed to cogl_pipeline_foreach_layer()
+ *
+ * The callback prototype used with cogl_pipeline_foreach_layer() for
+ * iterating all the layers of a @pipeline.
+ *
+ * Since: 2.0
+ * Stability: Unstable
+ */
+typedef CoglBool (*CoglPipelineLayerCallback) (CoglPipeline *pipeline,
+                                               int layer_index,
+                                               void *user_data);
+
+/**
+ * cogl_pipeline_foreach_layer:
+ * @pipeline: A #CoglPipeline object
+ * @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.
+ *
+ * Since: 2.0
+ * Stability: Unstable
+ */
+void
+cogl_pipeline_foreach_layer (CoglPipeline *pipeline,
+                             CoglPipelineLayerCallback callback,
+                             void *user_data);
+
+/**
+ * cogl_pipeline_get_uniform_location:
+ * @pipeline: A #CoglPipeline object
+ * @uniform_name: The name of a uniform
+ *
+ * This is used to get an integer representing the uniform with the
+ * name @uniform_name. The integer can be passed to functions such as
+ * cogl_pipeline_set_uniform_1f() to set the value of a uniform.
+ *
+ * This function will always return a valid integer. Ie, unlike
+ * OpenGL, it does not return -1 if the uniform is not available in
+ * this pipeline so it can not be used to test whether uniforms are
+ * present. It is not necessary to set the program on the pipeline
+ * before calling this function.
+ *
+ * Return value: A integer representing the location of the given uniform.
+ *
+ * Since: 2.0
+ * Stability: Unstable
+ */
+int
+cogl_pipeline_get_uniform_location (CoglPipeline *pipeline,
+                                    const char *uniform_name);
+
+
+#endif /* COGL_ENABLE_EXPERIMENTAL_API */
+
+COGL_END_DECLS
+
+#endif /* __COGL_PIPELINE_H__ */

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

@@ -0,0 +1,138 @@
+/*
+ * Cogl
+ *
+ * A Low Level GPU Graphics and Utilities API
+ *
+ * Copyright (C) 2008,2009,2010 Intel Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy,
+ * modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ *
+ *
+ * Authors:
+ *   Damien Lespiau <damien.lespiau@intel.com>
+ *   Robert Bragg <robert@linux.intel.com>
+ */
+
+#if !defined(__COGL_H_INSIDE__) && !defined(COGL_COMPILATION)
+#error "Only <cogl/cogl.h> can be included directly."
+#endif
+
+#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>
+
+#ifdef COGL_HAS_GTYPE_SUPPORT
+#include <glib-object.h>
+#endif
+
+COGL_BEGIN_DECLS
+
+#define COGL_PIXEL_BUFFER(buffer) ((CoglPixelBuffer *)(buffer))
+
+#ifdef COGL_HAS_GTYPE_SUPPORT
+/**
+ * cogl_pixel_buffer_get_gtype:
+ *
+ * Returns: a #GType that can be used with the GLib type system.
+ */
+GType cogl_pixel_buffer_get_gtype (void);
+#endif
+
+/**
+ * cogl_pixel_buffer_new:
+ * @context: A #CoglContext
+ * @size: The number of bytes to allocate for the pixel data.
+ * @data: An optional pointer to vertex data to upload immediately
+ *
+ * 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.
+ *
+ * Return value: (transfer full): a newly allocated #CoglPixelBuffer
+ *
+ * Since: 1.10
+ * Stability: unstable
+ */
+CoglPixelBuffer *
+cogl_pixel_buffer_new (CoglContext *context,
+                       size_t size,
+                       const void *data);
+
+/**
+ * cogl_is_pixel_buffer:
+ * @object: a #CoglObject to test
+ *
+ * Checks whether @object is a pixel buffer.
+ *
+ * Return value: %TRUE if the @object is a pixel buffer, and %FALSE
+ *   otherwise
+ *
+ * Since: 1.2
+ * Stability: Unstable
+ */
+CoglBool
+cogl_is_pixel_buffer (void *object);
+
+#if 0
+/*
+ * cogl_pixel_buffer_set_region:
+ * @buffer: A #CoglPixelBuffer object
+ * @data: pixel data to upload to @array
+ * @src_width: width in pixels of the region to update
+ * @src_height: height in pixels of the region to update
+ * @src_rowstride: row stride in bytes of the source array
+ * @dst_x: upper left destination horizontal coordinate
+ * @dst_y: upper left destination vertical coordinate
+ *
+ * Uploads new data into a pixel array. The source data pointed by @data can
+ * have a different stride than @array in which case the function will do the
+ * right thing for you. For performance reasons, it is recommended for the
+ * source data to have the same stride than @array.
+ *
+ * Return value: %TRUE if the upload succeeded, %FALSE otherwise
+ *
+ * Since: 1.2
+ * Stability: Unstable
+ */
+CoglBool
+cogl_pixel_buffer_set_region (CoglPixelBuffer *buffer,
+                              uint8_t *data,
+                              unsigned int src_width,
+                              unsigned int src_height,
+                              unsigned int src_rowstride,
+                              unsigned int dst_x,
+                              unsigned int dst_y);
+#endif
+
+COGL_END_DECLS
+
+#endif /* __COGL_PIXEL_BUFFER_H__ */

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

@@ -0,0 +1,200 @@
+/*
+ * Cogl
+ *
+ * A Low Level GPU Graphics and Utilities API
+ *
+ * Copyright (C) 2012 Intel Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy,
+ * modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ *
+ * Authors:
+ *  Neil Roberts <neil@linux.intel.com>
+ */
+
+#if !defined(__COGL_H_INSIDE__) && !defined(COGL_COMPILATION)
+#error "Only <cogl/cogl.h> can be included directly."
+#endif
+
+#ifndef __COGL_POLL_H__
+#define __COGL_POLL_H__
+
+#include <cogl/cogl-defines.h>
+#include <cogl/cogl-context.h>
+
+COGL_BEGIN_DECLS
+
+/**
+ * SECTION:cogl-poll
+ * @short_description: Functions for integrating Cogl with an
+ *   application's main loop
+ *
+ * Cogl needs to integrate with the application's main loop so that it
+ * can internally handle some events from the driver. All Cogl
+ * applications must use these functions. They provide enough
+ * information to describe the state that Cogl will need to wake up
+ * on. An application using the GLib main loop can instead use
+ * cogl_glib_source_new() which provides a #GSource ready to be added
+ * to the main loop.
+ */
+
+/**
+ * CoglPollFDEvent:
+ * @COGL_POLL_FD_EVENT_IN: there is data to read
+ * @COGL_POLL_FD_EVENT_PRI: data can be written (without blocking)
+ * @COGL_POLL_FD_EVENT_OUT: there is urgent data to read.
+ * @COGL_POLL_FD_EVENT_ERR: error condition
+ * @COGL_POLL_FD_EVENT_HUP: hung up (the connection has been broken, usually
+ *                          for pipes and sockets).
+ * @COGL_POLL_FD_EVENT_NVAL: invalid request. The file descriptor is not open.
+ *
+ * A bitmask of events that Cogl may need to wake on for a file
+ * descriptor. Note that these all have the same values as the
+ * corresponding defines for the poll function call on Unix so they
+ * may be directly passed to poll.
+ *
+ * Since: 1.10
+ * Stability: unstable
+ */
+typedef enum
+{
+  COGL_POLL_FD_EVENT_IN = COGL_SYSDEF_POLLIN,
+  COGL_POLL_FD_EVENT_PRI = COGL_SYSDEF_POLLPRI,
+  COGL_POLL_FD_EVENT_OUT = COGL_SYSDEF_POLLOUT,
+  COGL_POLL_FD_EVENT_ERR = COGL_SYSDEF_POLLERR,
+  COGL_POLL_FD_EVENT_HUP = COGL_SYSDEF_POLLHUP,
+  COGL_POLL_FD_EVENT_NVAL = COGL_SYSDEF_POLLNVAL
+} CoglPollFDEvent;
+
+/**
+ * CoglPollFD:
+ * @fd: The file descriptor to block on
+ * @events: A bitmask of events to block on
+ * @revents: A bitmask of returned events
+ *
+ * A struct for describing the state of a file descriptor that Cogl
+ * needs to block on. The @events field contains a bitmask of
+ * #CoglPollFDEvent<!-- -->s that should cause the application to wake
+ * up. After the application is woken up from idle it should pass back
+ * an array of #CoglPollFD<!-- -->s to Cogl and update the @revents
+ * mask to the actual events that occurred on the file descriptor.
+ *
+ * Note that CoglPollFD is deliberately exactly the same as struct
+ * pollfd on Unix so that it can simply be cast when calling poll.
+ *
+ * Since: 1.10
+ * Stability: unstable
+ */
+typedef struct {
+  int fd;
+  short int events;
+  short int revents;
+} CoglPollFD;
+
+/**
+ * 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.
+ *
+ * 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
+ * that Cogl expects. The fd and events members will be updated
+ * 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.
+ *
+ * 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
+ * handling functions of SDL don't allow blocking on a file
+ * descriptor) *n_poll_fds is guaranteed to be zero.
+ *
+ * @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 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.16
+ */
+int
+cogl_poll_renderer_get_info (CoglRenderer *renderer,
+                             CoglPollFD **poll_fds,
+                             int *n_poll_fds,
+                             int64_t *timeout);
+
+/**
+ * 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.
+ *
+ * This should be called whenever an application is woken up from
+ * 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 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.16
+ */
+void
+cogl_poll_renderer_dispatch (CoglRenderer *renderer,
+                             const CoglPollFD *poll_fds,
+                             int n_poll_fds);
+
+COGL_END_DECLS
+
+#endif /* __COGL_POLL_H__ */