clutter 2.2.4-x64-mingw32

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

@@ -0,0 +1,194 @@
+/*
+ * Cogl
+ *
+ * A Low Level GPU Graphics and Utilities API
+ *
+ * Copyright (C) 2011 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_META_TEXTURE_H__
+#define __COGL_META_TEXTURE_H__
+
+#include <cogl/cogl-pipeline-layer-state.h>
+
+COGL_BEGIN_DECLS
+
+/**
+ * SECTION:cogl-meta-texture
+ * @short_description: Interface for high-level textures built from
+ *                     low-level textures like #CoglTexture2D and
+ *                     #CoglTexture3D.
+ *
+ * Cogl helps to make it easy to deal with high level textures such
+ * as #CoglAtlasTexture<!-- -->s, #CoglSubTexture<!-- -->s,
+ * #CoglTexturePixmapX11 textures and #CoglTexture2DSliced textures
+ * consistently.
+ *
+ * A #CoglMetaTexture is a texture that might internally be
+ * represented by one or more low-level #CoglTexture<!-- -->s
+ * such as #CoglTexture2D or #CoglTexture3D. These low-level textures
+ * are the only ones that a GPU really understands but because
+ * applications often want more high-level texture abstractions
+ * (such as storing multiple textures inside one larger "atlas"
+ * texture) it's desirable to be able to deal with these
+ * using a common interface.
+ *
+ * For example the GPU is not able to automatically handle repeating a
+ * texture that is part of a larger atlas texture but if you use
+ * %COGL_PIPELINE_WRAP_MODE_REPEAT with an atlas texture when drawing
+ * with cogl_rectangle() you should see that it "Just Works™" - at
+ * least if you don't use multi-texturing. The reason this works is
+ * because cogl_rectangle() internally understands the #CoglMetaTexture
+ * interface and is able to manually resolve the low-level textures
+ * using this interface and by making multiple draw calls it can
+ * emulate the texture repeat modes.
+ *
+ * Cogl doesn't aim to pretend that meta-textures are just like real
+ * textures because it would get extremely complex to try and emulate
+ * low-level GPU semantics transparently for these textures.  The low
+ * level drawing APIs of Cogl, such as cogl_primitive_draw() don't
+ * actually know anything about the #CoglMetaTexture interface and its
+ * the developer's responsibility to resolve all textures referenced
+ * by a #CoglPipeline to low-level textures before drawing.
+ *
+ * If you want to develop custom primitive APIs like
+ * cogl_framebuffer_draw_rectangle() and you want to support drawing
+ * with #CoglAtlasTexture<!-- -->s or #CoglSubTexture<!-- -->s for
+ * example, then you will need to use this #CoglMetaTexture interface
+ * to be able to resolve high-level textures into low-level textures
+ * before drawing with Cogl's low-level drawing APIs such as
+ * cogl_primitive_draw().
+ *
+ * <note>Most developers won't need to use this interface directly
+ * but still it is worth understanding the distinction between
+ * low-level and meta textures because you may find other references
+ * in the documentation that detail limitations of using
+ * meta-textures.</note>
+ */
+
+#ifdef __COGL_H_INSIDE__
+/* For the public C api we typedef interface types as void to avoid needing
+ * lots of casting in code and instead we will rely on runtime type checking
+ * for these objects. */
+typedef void CoglMetaTexture;
+#else
+typedef struct _CoglMetaTexture CoglMetaTexture;
+#define COGL_META_TEXTURE(X) ((CoglMetaTexture *)X)
+#endif
+
+/**
+ * CoglMetaTextureCallback:
+ * @sub_texture: A low-level #CoglTexture making up part of a
+ *               #CoglMetaTexture.
+ * @sub_texture_coords: A float 4-tuple ordered like
+ *                      (tx1,ty1,tx2,ty2) defining what region of the
+ *                      current @sub_texture maps to a sub-region of a
+ *                      #CoglMetaTexture. (tx1,ty1) is the top-left
+ *                      sub-region coordinate and (tx2,ty2) is the
+ *                      bottom-right. These are low-level texture
+ *                      coordinates.
+ * @meta_coords: A float 4-tuple ordered like (tx1,ty1,tx2,ty2)
+ *               defining what sub-region of a #CoglMetaTexture this
+ *               low-level @sub_texture maps too. (tx1,ty1) is
+ *               the top-left sub-region coordinate and (tx2,ty2) is
+ *               the bottom-right. These are high-level meta-texture
+ *               coordinates.
+ * @user_data: A private pointer passed to
+ *             cogl_meta_texture_foreach_in_region().
+ *
+ * A callback used with cogl_meta_texture_foreach_in_region() to
+ * retrieve details of all the low-level #CoglTexture<!-- -->s that
+ * make up a given #CoglMetaTexture.
+ *
+ * Since: 1.10
+ * Stability: unstable
+ */
+typedef void (*CoglMetaTextureCallback) (CoglTexture *sub_texture,
+                                         const float *sub_texture_coords,
+                                         const float *meta_coords,
+                                         void *user_data);
+
+/**
+ * cogl_meta_texture_foreach_in_region:
+ * @meta_texture: An object implementing the #CoglMetaTexture
+ *                interface.
+ * @tx_1: The top-left x coordinate of the region to iterate
+ * @ty_1: The top-left y coordinate of the region to iterate
+ * @tx_2: The bottom-right x coordinate of the region to iterate
+ * @ty_2: The bottom-right y coordinate of the region to iterate
+ * @wrap_s: The wrap mode for the x-axis
+ * @wrap_t: The wrap mode for the y-axis
+ * @callback: A #CoglMetaTextureCallback pointer to be called
+ *            for each low-level texture within the specified region.
+ * @user_data: A private pointer that is passed to @callback.
+ *
+ * Allows you to manually iterate the low-level textures that define a
+ * given region of a high-level #CoglMetaTexture.
+ *
+ * For example cogl_texture_2d_sliced_new_with_size() can be used to
+ * create a meta texture that may slice a large image into multiple,
+ * smaller power-of-two sized textures. These high level textures are
+ * not directly understood by a GPU and so this API must be used to
+ * manually resolve the underlying textures for drawing.
+ *
+ * All high level textures (#CoglAtlasTexture, #CoglSubTexture,
+ * #CoglTexturePixmapX11, and #CoglTexture2DSliced) can be handled
+ * consistently using this interface which greately simplifies
+ * implementing primitives that support all texture types.
+ *
+ * For example if you use the cogl_rectangle() API then Cogl will
+ * internally use this API to resolve the low level textures of any
+ * meta textures you have associated with CoglPipeline layers.
+ *
+ * <note>The low level drawing APIs such as cogl_primitive_draw()
+ * don't understand the #CoglMetaTexture interface and so it is your
+ * responsibility to use this API to resolve all CoglPipeline textures
+ * into low-level textures before drawing.</note>
+ *
+ * For each low-level texture that makes up part of the given region
+ * of the @meta_texture, @callback is called specifying how the
+ * low-level texture maps to the original region.
+ *
+ * Since: 1.10
+ * Stability: unstable
+ */
+void
+cogl_meta_texture_foreach_in_region (CoglMetaTexture *meta_texture,
+                                     float tx_1,
+                                     float ty_1,
+                                     float tx_2,
+                                     float ty_2,
+                                     CoglPipelineWrapMode wrap_s,
+                                     CoglPipelineWrapMode wrap_t,
+                                     CoglMetaTextureCallback callback,
+                                     void *user_data);
+
+COGL_END_DECLS
+
+#endif /* __COGL_META_TEXTURE_H__ */

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

@@ -0,0 +1,251 @@
+/*
+ * Cogl
+ *
+ * A Low Level GPU Graphics and Utilities API
+ *
+ * Copyright (C) 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.
+ *
+ *
+ */
+
+#ifndef __COGL_OBJECT_H
+#define __COGL_OBJECT_H
+
+#include <cogl/cogl-types.h>
+
+#ifdef COGL_HAS_GTYPE_SUPPORT
+#include <glib-object.h>
+#endif
+
+COGL_BEGIN_DECLS
+
+typedef struct _CoglObject      CoglObject;
+
+#define COGL_OBJECT(X)          ((CoglObject *)X)
+
+/**
+ * CoglObject:
+ *
+ * Ref Func: cogl_object_ref
+ * Unref Func: cogl_object_unref
+ * Set Value Func: cogl_object_value_set_object
+ * Get Value Func: cogl_object_value_get_object
+ */
+
+#ifdef COGL_HAS_GTYPE_SUPPORT
+/**
+ * cogl_object_get_gtype:
+ *
+ * Returns: a #GType that can be used with the GLib type system.
+ */
+GType cogl_object_get_gtype (void);
+#endif
+
+/**
+ * cogl_object_ref: (skip)
+ * @object: a #CoglObject
+ *
+ * Increases the reference count of @object by 1
+ *
+ * Returns: the @object, with its reference count increased
+ */
+void *
+cogl_object_ref (void *object);
+
+/**
+ * cogl_object_unref: (skip)
+ * @object: a #CoglObject
+ *
+ * Drecreases the reference count of @object by 1; if the reference
+ * count reaches 0, the resources allocated by @object will be freed
+ */
+void
+cogl_object_unref (void *object);
+
+/**
+ * CoglUserDataKey:
+ * @unused: ignored.
+ *
+ * A #CoglUserDataKey is used to declare a key for attaching data to a
+ * #CoglObject using cogl_object_set_user_data. The typedef only exists as a
+ * formality to make code self documenting since only the unique address of a
+ * #CoglUserDataKey is used.
+ *
+ * Typically you would declare a static #CoglUserDataKey and set private data
+ * on an object something like this:
+ *
+ * |[
+ * static CoglUserDataKey path_private_key;
+ *
+ * static void
+ * destroy_path_private_cb (void *data)
+ * {
+ *   g_free (data);
+ * }
+ *
+ * static void
+ * my_path_set_data (CoglPath *path, void *data)
+ * {
+ *   cogl_object_set_user_data (COGL_OBJECT (path),
+ *                              &private_key,
+ *                              data,
+ *                              destroy_path_private_cb);
+ * }
+ * ]|
+ *
+ * Since: 1.4
+ */
+typedef struct {
+  int unused;
+} CoglUserDataKey;
+
+/**
+ * CoglUserDataDestroyCallback:
+ * @user_data: The data whos association with a #CoglObject has been
+ *             destoyed.
+ *
+ * When associating private data with a #CoglObject a callback can be
+ * given which will be called either if the object is destroyed or if
+ * cogl_object_set_user_data() is called with NULL user_data for the
+ * same key.
+ *
+ * Since: 1.4
+ */
+#ifdef COGL_HAS_GTYPE_SUPPORT
+typedef GDestroyNotify CoglUserDataDestroyCallback;
+#else
+typedef void (*CoglUserDataDestroyCallback) (void *user_data);
+#endif
+
+/**
+ * CoglDebugObjectTypeInfo:
+ * @name: A human readable name for the type.
+ * @instance_count: The number of objects of this type that are
+ *   currently in use
+ *
+ * This struct is used to pass information to the callback when
+ * cogl_debug_object_foreach_type() is called.
+ *
+ * Since: 1.8
+ * Stability: unstable
+ */
+typedef struct {
+  const char *name;
+  unsigned long instance_count;
+} CoglDebugObjectTypeInfo;
+
+/**
+ * CoglDebugObjectForeachTypeCallback:
+ * @info: A pointer to a struct containing information about the type.
+ *
+ * A callback function to use for cogl_debug_object_foreach_type().
+ *
+ * Since: 1.8
+ * Stability: unstable
+ */
+typedef void
+(* CoglDebugObjectForeachTypeCallback) (const CoglDebugObjectTypeInfo *info,
+                                        void *user_data);
+
+/**
+ * cogl_object_set_user_data: (skip)
+ * @object: The object to associate private data with
+ * @key: The address of a #CoglUserDataKey which provides a unique value
+ *   with which to index the private data.
+ * @user_data: The data to associate with the given object,
+ *   or %NULL to remove a previous association.
+ * @destroy: A #CoglUserDataDestroyCallback to call if the object is
+ *   destroyed or if the association is removed by later setting
+ *   %NULL data for the same key.
+ *
+ * Associates some private @user_data with a given #CoglObject. To
+ * later remove the association call cogl_object_set_user_data() with
+ * the same @key but NULL for the @user_data.
+ *
+ * Since: 1.4
+ */
+void
+cogl_object_set_user_data (CoglObject *object,
+                           CoglUserDataKey *key,
+                           void *user_data,
+                           CoglUserDataDestroyCallback destroy);
+
+/**
+ * cogl_object_get_user_data: (skip)
+ * @object: The object with associated private data to query
+ * @key: The address of a #CoglUserDataKey which provides a unique value
+ *       with which to index the private data.
+ *
+ * Finds the user data previously associated with @object using
+ * the given @key. If no user data has been associated with @object
+ * for the given @key this function returns NULL.
+ *
+ * Returns: (transfer none): The user data previously associated
+ *   with @object using the given @key; or %NULL if no associated
+ *   data is found.
+ *
+ * Since: 1.4
+ */
+void *
+cogl_object_get_user_data (CoglObject *object,
+                           CoglUserDataKey *key);
+
+#ifdef COGL_ENABLE_EXPERIMENTAL_API
+
+/**
+ * cogl_debug_object_foreach_type:
+ * @func: (scope call): A callback function for each type
+ * @user_data: (closure): A pointer to pass to @func
+ *
+ * Invokes @func once for each type of object that Cogl uses and
+ * passes a count of the number of objects for that type. This is
+ * intended to be used solely for debugging purposes to track down
+ * issues with objects leaking.
+ *
+ * Since: 1.8
+ * Stability: unstable
+ */
+void
+cogl_debug_object_foreach_type (CoglDebugObjectForeachTypeCallback func,
+                                void *user_data);
+
+/**
+ * cogl_debug_object_print_instances:
+ *
+ * Prints a list of all the object types that Cogl uses along with the
+ * number of objects of that type that are currently in use. This is
+ * intended to be used solely for debugging purposes to track down
+ * issues with objects leaking.
+ *
+ * Since: 1.8
+ * Stability: unstable
+ */
+void
+cogl_debug_object_print_instances (void);
+
+#endif /* COGL_ENABLE_EXPERIMENTAL_API */
+
+COGL_END_DECLS
+
+#endif /* __COGL_OBJECT_H */
+

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

@@ -0,0 +1,172 @@
+/*
+ * Cogl
+ *
+ * A Low Level GPU Graphics and Utilities API
+ *
+ * Copyright (C) 2007,2008,2009,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_OFFSCREEN_H__
+#define __COGL_OFFSCREEN_H__
+
+#include <cogl/cogl-types.h>
+#include <cogl/cogl-texture.h>
+
+#ifdef COGL_HAS_GTYPE_SUPPORT
+#include <glib-object.h>
+#endif
+
+COGL_BEGIN_DECLS
+
+/**
+ * SECTION:cogl-offscreen
+ * @short_description: Functions for creating and manipulating offscreen
+ *                     framebuffers.
+ *
+ * Cogl allows creating and operating on offscreen framebuffers.
+ */
+
+typedef struct _CoglOffscreen CoglOffscreen;
+
+#define COGL_OFFSCREEN(X) ((CoglOffscreen *)X)
+
+#ifdef COGL_HAS_GTYPE_SUPPORT
+/**
+ * cogl_offscreen_get_gtype:
+ *
+ * Returns: a #GType that can be used with the GLib type system.
+ */
+GType cogl_offscreen_get_gtype (void);
+#endif
+
+/* Offscreen api */
+
+/**
+ * cogl_offscreen_new_with_texture:
+ * @texture: A #CoglTexture pointer
+ *
+ * This creates an offscreen framebuffer object using the given
+ * @texture as the primary color buffer. It doesn't just initialize
+ * the contents of the offscreen buffer with the @texture; they are
+ * tightly bound so that drawing to the offscreen buffer effectively
+ * updates the contents of the given texture. You don't need to
+ * destroy the offscreen buffer before you can use the @texture again.
+ *
+ * <note>This api only works with low-level #CoglTexture types such as
+ * #CoglTexture2D, #CoglTexture3D and #CoglTextureRectangle, and not
+ * with meta-texture types such as #CoglTexture2DSliced.</note>
+ *
+ * The storage for the framebuffer is actually allocated lazily
+ * so this function will never return %NULL to indicate a runtime
+ * error. This means it is still possible to configure the framebuffer
+ * before it is really allocated.
+ *
+ * Simple applications without full error handling can simply rely on
+ * Cogl to lazily allocate the storage of framebuffers but you should
+ * be aware that if Cogl encounters an error (such as running out of
+ * GPU memory) then your application will simply abort with an error
+ * message. If you need to be able to catch such exceptions at runtime
+ * then you can explicitly allocate your framebuffer when you have
+ * finished configuring it by calling cogl_framebuffer_allocate() and
+ * passing in a #CoglError argument to catch any exceptions.
+ *
+ * Return value: (transfer full): a newly instantiated #CoglOffscreen
+ *   framebuffer.
+ */
+CoglOffscreen *
+cogl_offscreen_new_with_texture (CoglTexture *texture);
+
+/**
+ * cogl_offscreen_new_to_texture:
+ * @texture: A #CoglTexture pointer
+ *
+ * This creates an offscreen buffer object using the given @texture as the
+ * primary color buffer. It doesn't just initialize the contents of the
+ * offscreen buffer with the @texture; they are tightly bound so that
+ * drawing to the offscreen buffer effectivly updates the contents of the
+ * given texture. You don't need to destroy the offscreen buffer before
+ * you can use the @texture again.
+ *
+ * <note>This only works with low-level #CoglTexture types such as
+ * #CoglTexture2D, #CoglTexture3D and #CoglTextureRectangle, and not
+ * with meta-texture types such as #CoglTexture2DSliced.</note>
+ *
+ * Return value: (transfer full): a newly instantiated #CoglOffscreen
+ *   framebuffer or %NULL if it wasn't possible to create the
+ *   buffer.
+ * Deprecated: 1.16: Use cogl_offscreen_new_with_texture instead.
+ */
+COGL_DEPRECATED_IN_1_16_FOR (cogl_offscreen_new_with_texture)
+CoglOffscreen *
+cogl_offscreen_new_to_texture (CoglTexture *texture);
+
+/**
+ * cogl_is_offscreen:
+ * @object: A pointer to a #CoglObject
+ *
+ * Determines whether the given #CoglObject references an offscreen
+ * framebuffer object.
+ *
+ * Returns: %TRUE if @object is a #CoglOffscreen framebuffer,
+ *          %FALSE otherwise
+ */
+CoglBool
+cogl_is_offscreen (void *object);
+
+/**
+ * cogl_offscreen_ref:
+ * @offscreen: A pointer to a #CoglOffscreen framebuffer
+ *
+ * Increments the reference count on the @offscreen framebuffer.
+ *
+ * Return value: (transfer none): For convenience it returns the
+ *                                given @offscreen
+ *
+ * Deprecated: 1.2: cogl_object_ref() should be used in new code.
+ */
+COGL_DEPRECATED_FOR (cogl_object_ref)
+void *
+cogl_offscreen_ref (void *offscreen);
+
+/**
+ * cogl_offscreen_unref:
+ * @offscreen: A pointer to a #CoglOffscreen framebuffer
+ *
+ * Decreases the reference count for the @offscreen buffer and frees it when
+ * the count reaches 0.
+ *
+ * Deprecated: 1.2: cogl_object_unref() should be used in new code.
+ */
+COGL_DEPRECATED_FOR (cogl_object_unref)
+void
+cogl_offscreen_unref (void *offscreen);
+
+COGL_END_DECLS
+
+#endif /* __COGL_OFFSCREEN_H__ */