clutter 2.0.0-x86-mingw32

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

@@ -0,0 +1,173 @@
+/*
+ * Cogl
+ *
+ * An object oriented GL/GLES Abstraction/Utility Layer
+ *
+ * Copyright (C) 2007,2008,2009 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 <http://www.gnu.org/licenses/>.
+ *
+ *
+ */
+
+#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>
+
+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)
+
+/**
+ * cogl_pipeline_new:
+ * @context: a #CoglContext
+ *
+ * Allocates and initializes a default simple pipeline that will color
+ * a primitive white.
+ *
+ * Return value: 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.
+ *
+ * Returns: 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: A #CoglPipelineLayerCallback to be called for each layer
+ *            index
+ * @user_data: 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,114 @@
+/*
+ * Cogl
+ *
+ * An object oriented GL/GLES Abstraction/Utility Layer
+ *
+ * Copyright (C) 2008,2009,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 <http://www.gnu.org/licenses/>.
+ *
+ *
+ *
+ * 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__
+
+#include <cogl/cogl-types.h>
+#include <cogl/cogl-context.h>
+
+COGL_BEGIN_DECLS
+
+#define COGL_PIXEL_BUFFER(buffer) ((CoglPixelBuffer *)(buffer))
+
+typedef struct _CoglPixelBuffer CoglPixelBuffer;
+
+/**
+ * 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.
+ *
+ * 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,174 @@
+/*
+ * Cogl
+ *
+ * An object oriented GL/GLES Abstraction/Utility Layer
+ *
+ * Copyright (C) 2012 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
+ * <http://www.gnu.org/licenses/>.
+ *
+ *
+ * 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_get_info:
+ * @context: A #CoglContext
+ * @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.
+ *
+ * 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. Either way it should pass a pointer to either array back to
+ * Cogl when calling cogl_poll_dispatch().
+ *
+ * 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 zero if
+ * Cogl needs to be woken up immediately.
+ *
+ * Stability: unstable
+ * Since: 1.10
+ */
+void
+cogl_poll_get_info (CoglContext *context,
+                    CoglPollFD **poll_fds,
+                    int *n_poll_fds,
+                    int64_t *timeout);
+
+/**
+ * cogl_poll_dispatch:
+ * @context: A #CoglContext
+ * @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 from
+ * cogl_context_begin_idle() or a shorter array missing some file
+ * descriptors that Cogl requested.
+ *
+ * Stability: unstable
+ * Since: 1.10
+ */
+void
+cogl_poll_dispatch (CoglContext *context,
+                    const CoglPollFD *poll_fds,
+                    int n_poll_fds);
+
+COGL_END_DECLS
+
+#endif /* __COGL_POLL_H__ */