clutter 2.2.4-x64-mingw32

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

@@ -0,0 +1,107 @@
+/*
+ * Cogl
+ *
+ * A Low Level GPU Graphics and Utilities API
+ *
+ * Copyright (C) 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:
+ *   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_INDEX_BUFFER_H__
+#define __COGL_INDEX_BUFFER_H__
+
+#include <cogl/cogl-context.h>
+
+#ifdef COGL_HAS_GTYPE_SUPPORT
+#include <glib-object.h>
+#endif
+
+COGL_BEGIN_DECLS
+
+/**
+ * SECTION:cogl-index-buffer
+ * @short_description: Functions for creating and manipulating vertex
+ * indices.
+ *
+ * FIXME
+ */
+
+#define COGL_INDEX_BUFFER(buffer) ((CoglIndexBuffer*) buffer)
+
+typedef struct _CoglIndexBuffer	      CoglIndexBuffer;
+
+#ifdef COGL_HAS_GTYPE_SUPPORT
+/**
+ * cogl_index_buffer_get_gtype:
+ *
+ * Returns: a #GType that can be used with the GLib type system.
+ */
+GType cogl_index_buffer_get_gtype (void);
+#endif
+
+/**
+ * cogl_index_buffer_new:
+ * @context: A #CoglContext
+ * @bytes: The number of bytes to allocate for vertex attribute data.
+ *
+ * Declares a new #CoglIndexBuffer of @size bytes to contain vertex
+ * indices. 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().
+ *
+ * Return value: (transfer full): A newly allocated #CoglIndexBuffer
+ *
+ * Since: 1.4
+ * Stability: Unstable
+ */
+CoglIndexBuffer *
+cogl_index_buffer_new (CoglContext *context,
+                       size_t bytes);
+
+/**
+ * cogl_is_index_buffer:
+ * @object: A #CoglObject
+ *
+ * Gets whether the given object references a #CoglIndexBuffer.
+ *
+ * Returns: %TRUE if the @object references a #CoglIndexBuffer,
+ *   %FALSE otherwise
+ *
+ * Since: 1.4
+ * Stability: Unstable
+ */
+CoglBool
+cogl_is_index_buffer (void *object);
+
+COGL_END_DECLS
+
+#endif /* __COGL_INDEX_BUFFER_H__ */
+

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

@@ -0,0 +1,165 @@
+/*
+ * Cogl
+ *
+ * A Low Level GPU Graphics and Utilities API
+ *
+ * Copyright (C) 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:
+ *   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_INDICES_H__
+#define __COGL_INDICES_H__
+
+/* We forward declare the CoglIndices type here to avoid some circular
+ * dependency issues with the following headers.
+ */
+typedef struct _CoglIndices CoglIndices;
+
+#include <cogl/cogl-index-buffer.h>
+
+#ifdef COGL_HAS_GTYPE_SUPPORT
+#include <glib-object.h>
+#endif
+
+COGL_BEGIN_DECLS
+
+/**
+ * SECTION:cogl-indices
+ * @short_description: Describe vertex indices stored in a #CoglIndexBuffer.
+ *
+ * Indices allow you to avoid duplicating vertices in your vertex data
+ * by virtualizing your data and instead providing a sequence of index
+ * values that tell the GPU which data should be used for each vertex.
+ *
+ * If the GPU is given a sequence of indices it doesn't simply walk
+ * through each vertex of your data in order it will instead walk
+ * through the indices which can provide random access to the
+ * underlying data.
+ *
+ * Since it's very common to have duplicate vertices when describing a
+ * shape as a list of triangles it can often be a significant space
+ * saving to describe geometry using indices. Reducing the size of
+ * your models can make it cheaper to map them into the GPU by
+ * reducing the demand on memory bandwidth and may help to make better
+ * use of your GPUs internal vertex caching.
+ *
+ * For example, to describe a quadrilateral as 2 triangles for the GPU
+ * you could either provide data with 6 vertices or instead with
+ * indices you can provide vertex data for just 4 vertices and an
+ * index buffer that specfies the 6 vertices by indexing the shared
+ * vertices multiple times.
+ *
+ * |[
+ *   CoglVertex2f quad_vertices[] = {
+ *     {x0, y0}, //0 = top left
+ *     {x1, y1}, //1 = bottom left
+ *     {x2, y2}, //2 = bottom right
+ *     {x3, y3}, //3 = top right
+ *   };
+ *   //tell the gpu how to interpret the quad as 2 triangles...
+ *   unsigned char indices[] = {0, 1, 2, 0, 2, 3};
+ * ]|
+ *
+ * Even in the above illustration we see a saving of 10bytes for one
+ * quad compared to having data for 6 vertices and no indices but if
+ * you need to draw 100s or 1000s of quads then its really quite
+ * significant.
+ *
+ * Something else to consider is that often indices can be defined
+ * once and remain static while the vertex data may change for
+ * animations perhaps. That means you may be able to ignore the
+ * negligable cost of mapping your indices into the GPU if they don't
+ * ever change.
+ *
+ * The above illustration is actually a good example of static indices
+ * because it's really common that developers have quad mesh data that
+ * they need to display and we know exactly what that indices array
+ * needs to look like depending on the number of quads that need to be
+ * drawn. It doesn't matter how the quads might be animated and
+ * changed the indices will remain the same. Cogl even has a utility
+ * (cogl_get_rectangle_indices()) to get access to re-useable indices
+ * for drawing quads as above.
+ */
+
+#ifdef COGL_HAS_GTYPE_SUPPORT
+/**
+ * cogl_indices_get_gtype:
+ *
+ * Returns: a #GType that can be used with the GLib type system.
+ */
+GType cogl_indices_get_gtype (void);
+#endif
+
+CoglIndices *
+cogl_indices_new (CoglContext *context,
+                  CoglIndicesType type,
+                  const void *indices_data,
+                  int n_indices);
+
+CoglIndices *
+cogl_indices_new_for_buffer (CoglIndicesType type,
+                             CoglIndexBuffer *buffer,
+                             size_t offset);
+
+CoglIndexBuffer *
+cogl_indices_get_buffer (CoglIndices *indices);
+
+CoglIndicesType
+cogl_indices_get_type (CoglIndices *indices);
+
+size_t
+cogl_indices_get_offset (CoglIndices *indices);
+
+void
+cogl_indices_set_offset (CoglIndices *indices,
+                         size_t offset);
+
+CoglIndices *
+cogl_get_rectangle_indices (CoglContext *context, int n_rectangles);
+
+/**
+ * cogl_is_indices:
+ * @object: A #CoglObject pointer
+ *
+ * Gets whether the given object references a #CoglIndices.
+ *
+ * Return value: %TRUE if the object references a #CoglIndices
+ *   and %FALSE otherwise.
+ * Since: 1.10
+ * Stability: unstable
+ */
+CoglBool
+cogl_is_indices (void *object);
+
+COGL_END_DECLS
+
+#endif /* __COGL_INDICES_H__ */
+

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

@@ -0,0 +1,273 @@
+/*
+ * 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.
+ */
+
+#if !defined(__COGL_H_INSIDE__) && !defined(COGL_COMPILATION)
+#error "Only <cogl/cogl.h> can be included directly."
+#endif
+
+#ifndef __COGL_MACROS_H__
+#define __COGL_MACROS_H__
+
+#include <cogl/cogl-version.h>
+
+/* These macros are used to mark deprecated functions, and thus have
+ * to be exposed in a public header.
+ *
+ * They are only intended for internal use and should not be used by
+ * other projects.
+ */
+#if defined(COGL_DISABLE_DEPRECATION_WARNINGS) || defined(COGL_COMPILATION)
+
+#define COGL_DEPRECATED
+#define COGL_DEPRECATED_FOR(f)
+#define COGL_UNAVAILABLE(maj,min)
+
+#else /* COGL_DISABLE_DEPRECATION_WARNINGS */
+
+#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1)
+#define COGL_DEPRECATED __attribute__((__deprecated__))
+#elif defined(_MSC_VER) && (_MSC_VER >= 1300)
+#define COGL_DEPRECATED __declspec(deprecated)
+#else
+#define COGL_DEPRECATED
+#endif
+
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
+#define COGL_DEPRECATED_FOR(f) __attribute__((__deprecated__("Use '" #f "' instead")))
+#elif defined(_MSC_FULL_VER) && (_MSC_FULL_VER > 140050320)
+#define COGL_DEPRECATED_FOR(f) __declspec(deprecated("is deprecated. Use '" #f "' instead"))
+#else
+#define COGL_DEPRECATED_FOR(f) G_DEPRECATED
+#endif
+
+#if    __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
+#define COGL_UNAVAILABLE(maj,min) __attribute__((deprecated("Not available before " #maj "." #min)))
+#elif defined(_MSC_FULL_VER) && (_MSC_FULL_VER > 140050320)
+#define COGL_UNAVAILABLE(maj,min) __declspec(deprecated("is not available before " #maj "." #min))
+#else
+#define COGL_UNAVAILABLE(maj,min)
+#endif
+
+#endif /* COGL_DISABLE_DEPRECATION_WARNINGS */
+
+/**
+ * COGL_VERSION_MIN_REQUIRED:
+ *
+ * A macro that should be defined by the user prior to including the
+ * cogl.h header.
+ *
+ * The definition should be one of the predefined Cogl version macros,
+ * such as: %COGL_VERSION_1_8, %COGL_VERSION_1_10, ...
+ *
+ * This macro defines the lower bound for the Cogl API to be used.
+ *
+ * If a function has been deprecated in a newer version of Cogl, it
+ * is possible to use this symbol to avoid the compiler warnings without
+ * disabling warnings for every deprecated function.
+ *
+ * Since: 1.16
+ */
+#ifndef COGL_VERSION_MIN_REQUIRED
+# define COGL_VERSION_MIN_REQUIRED (COGL_VERSION_CURRENT_STABLE)
+#endif
+
+/**
+ * COGL_VERSION_MAX_ALLOWED:
+ *
+ * A macro that should be define by the user prior to including the
+ * cogl.h header.
+ *
+ * The definition should be one of the predefined Cogl version macros,
+ * such as: %COGL_VERSION_1_0, %COGL_VERSION_1_2, ...
+ *
+ * This macro defines the upper bound for the Cogl API to be used.
+ *
+ * If a function has been introduced in a newer version of Cogl, it
+ * is possible to use this symbol to get compiler warnings when trying
+ * to use that function.
+ *
+ * Since: 1.16
+ */
+#ifndef COGL_VERSION_MAX_ALLOWED
+# if COGL_VERSION_MIN_REQUIRED > COGL_VERSION_PREVIOUS_STABLE
+#  define COGL_VERSION_MAX_ALLOWED COGL_VERSION_MIN_REQUIRED
+# else
+#  define COGL_VERSION_MAX_ALLOWED COGL_VERSION_CURRENT_STABLE
+# endif
+#endif
+
+/* sanity checks */
+#if COGL_VERSION_MAX_ALLOWED < COGL_VERSION_MIN_REQUIRED
+# error "COGL_VERSION_MAX_ALLOWED must be >= COGL_VERSION_MIN_REQUIRED"
+#endif
+#if COGL_VERSION_MIN_REQUIRED < COGL_VERSION_1_0
+# error "COGL_VERSION_MIN_REQUIRED must be >= COGL_VERSION_1_0"
+#endif
+
+/* XXX: Every new stable minor release should add a set of macros here */
+#if COGL_VERSION_MIN_REQUIRED >= COGL_VERSION_1_0
+# define COGL_DEPRECATED_IN_1_0              COGL_DEPRECATED
+# define COGL_DEPRECATED_IN_1_0_FOR(f)       COGL_DEPRECATED_FOR(f)
+#else
+# define COGL_DEPRECATED_IN_1_0
+# define COGL_DEPRECATED_IN_1_0_FOR(f)
+#endif
+
+#if COGL_VERSION_MAX_ALLOWED < COGL_VERSION_1_0
+# define COGL_AVAILABLE_IN_1_0               COGL_UNAVAILABLE(1, 0)
+#else
+# define COGL_AVAILABLE_IN_1_0
+#endif
+
+#if COGL_VERSION_MIN_REQUIRED >= COGL_VERSION_1_2
+# define COGL_DEPRECATED_IN_1_2              COGL_DEPRECATED
+# define COGL_DEPRECATED_IN_1_2_FOR(f)       COGL_DEPRECATED_FOR(f)
+#else
+# define COGL_DEPRECATED_IN_1_2
+# define COGL_DEPRECATED_IN_1_2_FOR(f)
+#endif
+
+#if COGL_VERSION_MAX_ALLOWED < COGL_VERSION_1_2
+# define COGL_AVAILABLE_IN_1_2               COGL_UNAVAILABLE(1, 2)
+#else
+# define COGL_AVAILABLE_IN_1_2
+#endif
+
+#if COGL_VERSION_MIN_REQUIRED >= COGL_VERSION_1_4
+# define COGL_DEPRECATED_IN_1_4              COGL_DEPRECATED
+# define COGL_DEPRECATED_IN_1_4_FOR(f)       COGL_DEPRECATED_FOR(f)
+#else
+# define COGL_DEPRECATED_IN_1_4
+# define COGL_DEPRECATED_IN_1_4_FOR(f)
+#endif
+
+#if COGL_VERSION_MAX_ALLOWED < COGL_VERSION_1_4
+# define COGL_AVAILABLE_IN_1_4               COGL_UNAVAILABLE(1, 4)
+#else
+# define COGL_AVAILABLE_IN_1_4
+#endif
+
+#if COGL_VERSION_MIN_REQUIRED >= COGL_VERSION_1_6
+# define COGL_DEPRECATED_IN_1_6              COGL_DEPRECATED
+# define COGL_DEPRECATED_IN_1_6_FOR(f)       COGL_DEPRECATED_FOR(f)
+#else
+# define COGL_DEPRECATED_IN_1_6
+# define COGL_DEPRECATED_IN_1_6_FOR(f)
+#endif
+
+#if COGL_VERSION_MAX_ALLOWED < COGL_VERSION_1_6
+# define COGL_AVAILABLE_IN_1_6               COGL_UNAVAILABLE(1, 6)
+#else
+# define COGL_AVAILABLE_IN_1_6
+#endif
+
+#if COGL_VERSION_MIN_REQUIRED >= COGL_VERSION_1_8
+# define COGL_DEPRECATED_IN_1_8              COGL_DEPRECATED
+# define COGL_DEPRECATED_IN_1_8_FOR(f)       COGL_DEPRECATED_FOR(f)
+#else
+# define COGL_DEPRECATED_IN_1_8
+# define COGL_DEPRECATED_IN_1_8_FOR(f)
+#endif
+
+#if COGL_VERSION_MAX_ALLOWED < COGL_VERSION_1_8
+# define COGL_AVAILABLE_IN_1_8               COGL_UNAVAILABLE(1, 8)
+#else
+# define COGL_AVAILABLE_IN_1_8
+#endif
+
+#if COGL_VERSION_MIN_REQUIRED >= COGL_VERSION_1_10
+# define COGL_DEPRECATED_IN_1_10             COGL_DEPRECATED
+# define COGL_DEPRECATED_IN_1_10_FOR(f)      COGL_DEPRECATED_FOR(f)
+#else
+# define COGL_DEPRECATED_IN_1_10
+# define COGL_DEPRECATED_IN_1_10_FOR(f)
+#endif
+
+#if COGL_VERSION_MAX_ALLOWED < COGL_VERSION_1_10
+# define COGL_AVAILABLE_IN_1_10              COGL_UNAVAILABLE(1, 10)
+#else
+# define COGL_AVAILABLE_IN_1_10
+#endif
+
+#if COGL_VERSION_MIN_REQUIRED >= COGL_VERSION_1_12
+# define COGL_DEPRECATED_IN_1_12             COGL_DEPRECATED
+# define COGL_DEPRECATED_IN_1_12_FOR(f)      COGL_DEPRECATED_FOR(f)
+#else
+# define COGL_DEPRECATED_IN_1_12
+# define COGL_DEPRECATED_IN_1_12_FOR(f)
+#endif
+
+#if COGL_VERSION_MAX_ALLOWED < COGL_VERSION_1_12
+# define COGL_AVAILABLE_IN_1_12              COGL_UNAVAILABLE(1, 12)
+#else
+# define COGL_AVAILABLE_IN_1_12
+#endif
+
+#if COGL_VERSION_MIN_REQUIRED >= COGL_VERSION_1_14
+# define COGL_DEPRECATED_IN_1_14             COGL_DEPRECATED
+# define COGL_DEPRECATED_IN_1_14_FOR(f)      COGL_DEPRECATED_FOR(f)
+#else
+# define COGL_DEPRECATED_IN_1_14
+# define COGL_DEPRECATED_IN_1_14_FOR(f)
+#endif
+
+#if COGL_VERSION_MAX_ALLOWED < COGL_VERSION_1_14
+# define COGL_AVAILABLE_IN_1_14              COGL_UNAVAILABLE(1, 14)
+#else
+# define COGL_AVAILABLE_IN_1_14
+#endif
+
+#if COGL_VERSION_MIN_REQUIRED >= COGL_VERSION_1_16
+# define COGL_DEPRECATED_IN_1_16             COGL_DEPRECATED
+# define COGL_DEPRECATED_IN_1_16_FOR(f)      COGL_DEPRECATED_FOR(f)
+#else
+# define COGL_DEPRECATED_IN_1_16
+# define COGL_DEPRECATED_IN_1_16_FOR(f)
+#endif
+
+#if COGL_VERSION_MAX_ALLOWED < COGL_VERSION_1_16
+# define COGL_AVAILABLE_IN_1_16              COGL_UNAVAILABLE(1, 16)
+#else
+# define COGL_AVAILABLE_IN_1_16
+#endif
+
+#if COGL_VERSION_MIN_REQUIRED >= COGL_VERSION_1_18
+# define COGL_DEPRECATED_IN_1_18             COGL_DEPRECATED
+# define COGL_DEPRECATED_IN_1_18_FOR(f)      COGL_DEPRECATED_FOR(f)
+#else
+# define COGL_DEPRECATED_IN_1_18
+# define COGL_DEPRECATED_IN_1_18_FOR(f)
+#endif
+
+#if COGL_VERSION_MAX_ALLOWED < COGL_VERSION_1_18
+# define COGL_AVAILABLE_IN_1_18              COGL_UNAVAILABLE(1, 18)
+#else
+# define COGL_AVAILABLE_IN_1_18
+#endif
+
+#endif /* __COGL_MACROS_H__ */