clutter 2.0.0-x86-mingw32

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

@@ -0,0 +1,314 @@
+/*
+ * 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_BITMAP_H__
+#define __COGL_BITMAP_H__
+
+#include <cogl/cogl-types.h>
+#include <cogl/cogl-buffer.h>
+#include <cogl/cogl-context.h>
+#include <cogl/cogl-pixel-buffer.h>
+
+#ifdef COGL_HAS_ANDROID_SUPPORT
+#include <android/asset_manager.h>
+#endif
+
+COGL_BEGIN_DECLS
+
+typedef struct _CoglBitmap CoglBitmap;
+
+/**
+ * SECTION:cogl-bitmap
+ * @short_description: Functions for loading images
+ *
+ * Cogl allows loading image data into memory as CoglBitmaps without
+ * loading them immediately into GPU textures.
+ *
+ * #CoglBitmap is available since Cogl 1.0
+ */
+
+
+/**
+ * cogl_bitmap_new_from_file:
+ * @filename: the file to load.
+ * @error: a #CoglError or %NULL.
+ *
+ * Loads an image file from disk. This function can be safely called from
+ * within a thread.
+ *
+ * Return value: a #CoglBitmap to the new loaded image data, or
+ *   %NULL if loading the image failed.
+ *
+ * Since: 1.0
+ */
+CoglBitmap *
+cogl_bitmap_new_from_file (const char *filename,
+                           CoglError **error);
+
+#ifdef COGL_HAS_ANDROID_SUPPORT
+/**
+ * cogl_android_bitmap_new_from_asset:
+ * @context: A #CoglContext
+ * @manager: An Android Asset Manager.
+ * @filename: The file name for the asset
+ * @error: A return location for a CoglError exception.
+ *
+ * Loads an Android asset into a newly allocated #CoglBitmap.
+ *
+ * Return value: A newly allocated #CoglBitmap holding the image data of the
+ *               specified asset.
+ *
+ * Since: 2.0
+ */
+CoglBitmap *
+cogl_android_bitmap_new_from_asset (CoglContext *context,
+                                    AAssetManager *manager,
+                                    const char *filename,
+                                    CoglError **error);
+#endif
+
+#if defined (COGL_ENABLE_EXPERIMENTAL_API)
+
+/**
+ * cogl_bitmap_new_from_buffer:
+ * @buffer: A #CoglBuffer containing image data
+ * @format: The #CoglPixelFormat defining the format of the image data
+ *          in the given @buffer.
+ * @width: The width of the image data in the given @buffer.
+ * @height: The height of the image data in the given @buffer.
+ * @rowstride: The rowstride in bytes of the image data in the given @buffer.
+ * @offset: The offset into the given @buffer to the first pixel that
+ *          should be considered part of the #CoglBitmap.
+ *
+ * Wraps some image data that has been uploaded into a #CoglBuffer as
+ * a #CoglBitmap. The data is not copied in this process.
+ *
+ * Return value: a #CoglBitmap encapsulating the given @buffer.
+ *
+ * Since: 1.8
+ * Stability: unstable
+ */
+CoglBitmap *
+cogl_bitmap_new_from_buffer (CoglBuffer *buffer,
+                             CoglPixelFormat format,
+                             int width,
+                             int height,
+                             int rowstride,
+                             int offset);
+
+/**
+ * cogl_bitmap_new_with_size:
+ * @context: A #CoglContext
+ * @width: width of the bitmap in pixels
+ * @height: height of the bitmap in pixels
+ * @format: the format of the pixels the array will store
+ *
+ * Creates a new #CoglBitmap with the given width, height and format.
+ * The initial contents of the bitmap are undefined.
+ *
+ * The data for the bitmap will be stored in a newly created
+ * #CoglPixelBuffer. You can get a pointer to the pixel buffer using
+ * cogl_bitmap_get_buffer(). The #CoglBuffer API can then be
+ * used to fill the bitmap with data.
+ *
+ * <note>Cogl will try its best to provide a hardware array you can
+ * map, write into and effectively do a zero copy upload when creating
+ * a texture from it with cogl_texture_new_from_bitmap(). For various
+ * reasons, such arrays are likely to have a stride larger than width
+ * * bytes_per_pixel. The user must take the stride into account when
+ * writing into it. The stride can be retrieved with
+ * cogl_bitmap_get_rowstride().</note>
+ *
+ * Return value: a #CoglPixelBuffer representing the newly created array or
+ *               %NULL on failure
+ *
+ * Since: 1.10
+ * Stability: Unstable
+ */
+CoglBitmap *
+cogl_bitmap_new_with_size (CoglContext *context,
+                           unsigned int width,
+                           unsigned int height,
+                           CoglPixelFormat format);
+
+/**
+ * cogl_bitmap_new_for_data:
+ * @context: A #CoglContext
+ * @width: The width of the bitmap.
+ * @height: The height of the bitmap.
+ * @format: The format of the pixel data.
+ * @rowstride: The rowstride of the bitmap (the number of bytes from
+ *   the start of one row of the bitmap to the next).
+ * @data: A pointer to the data. The bitmap will take ownership of this data.
+ *
+ * Creates a bitmap using some existing data. The data is not copied
+ * so the application must keep the buffer alive for the lifetime of
+ * the #CoglBitmap. This can be used for example with
+ * cogl_framebuffer_read_pixels_into_bitmap() to read data directly
+ * into an application buffer with the specified rowstride.
+ *
+ * Return value: A new #CoglBitmap.
+ * Since: 1.10
+ * Stability: unstable
+ */
+CoglBitmap *
+cogl_bitmap_new_for_data (CoglContext *context,
+                          int width,
+                          int height,
+                          CoglPixelFormat format,
+                          int rowstride,
+                          uint8_t *data);
+
+/**
+ * cogl_bitmap_get_format:
+ * @bitmap: A #CoglBitmap
+ *
+ * Return value: the #CoglPixelFormat that the data for the bitmap is in.
+ * Since: 1.10
+ * Stability: unstable
+ */
+CoglPixelFormat
+cogl_bitmap_get_format (CoglBitmap *bitmap);
+
+/**
+ * cogl_bitmap_get_width:
+ * @bitmap: A #CoglBitmap
+ *
+ * Return value: the width of the bitmap
+ * Since: 1.10
+ * Stability: unstable
+ */
+int
+cogl_bitmap_get_width (CoglBitmap *bitmap);
+
+/**
+ * cogl_bitmap_get_height:
+ * @bitmap: A #CoglBitmap
+ *
+ * Return value: the height of the bitmap
+ * Since: 1.10
+ * Stability: unstable
+ */
+int
+cogl_bitmap_get_height (CoglBitmap *bitmap);
+
+/**
+ * cogl_bitmap_get_rowstride:
+ * @bitmap: A #CoglBitmap
+ *
+ * Return value: the rowstride of the bitmap. This is the number of
+ *   bytes between the address of start of one row to the address of the
+ *   next row in the image.
+ * Since: 1.10
+ * Stability: unstable
+ */
+int
+cogl_bitmap_get_rowstride (CoglBitmap *bitmap);
+
+/**
+ * cogl_bitmap_get_buffer:
+ * @bitmap: A #CoglBitmap
+ *
+ * Return value: the #CoglPixelBuffer that this buffer uses for
+ *   storage. Note that if the bitmap was created with
+ *   cogl_bitmap_new_from_file() then it will not actually be using a
+ *   pixel buffer and this function will return %NULL.
+ * Stability: unstable
+ * Since: 1.10
+ */
+CoglPixelBuffer *
+cogl_bitmap_get_buffer (CoglBitmap *bitmap);
+
+#endif /* COGL_ENABLE_EXPERIMENTAL_API */
+
+/**
+ * cogl_bitmap_get_size_from_file:
+ * @filename: the file to check
+ * @width: (out): return location for the bitmap width, or %NULL
+ * @height: (out): return location for the bitmap height, or %NULL
+ *
+ * Parses an image file enough to extract the width and height
+ * of the bitmap.
+ *
+ * Return value: %TRUE if the image was successfully parsed
+ *
+ * Since: 1.0
+ */
+CoglBool
+cogl_bitmap_get_size_from_file (const char *filename,
+                                int *width,
+                                int *height);
+
+/**
+ * cogl_is_bitmap:
+ * @object: a #CoglObject pointer
+ *
+ * Checks whether @object is a #CoglBitmap
+ *
+ * Return value: %TRUE if the passed @object represents a bitmap,
+ *   and %FALSE otherwise
+ *
+ * Since: 1.0
+ */
+CoglBool
+cogl_is_bitmap (void *object);
+
+/**
+ * COGL_BITMAP_ERROR:
+ *
+ * #CoglError domain for bitmap errors.
+ *
+ * Since: 1.4
+ */
+#define COGL_BITMAP_ERROR (cogl_bitmap_error_quark ())
+
+/**
+ * CoglBitmapError:
+ * @COGL_BITMAP_ERROR_FAILED: Generic failure code, something went
+ *   wrong.
+ * @COGL_BITMAP_ERROR_UNKNOWN_TYPE: Unknown image type.
+ * @COGL_BITMAP_ERROR_CORRUPT_IMAGE: An image file was broken somehow.
+ *
+ * Error codes that can be thrown when performing bitmap
+ * operations. Note that gdk_pixbuf_new_from_file() can also throw
+ * errors directly from the underlying image loading library. For
+ * example, if GdkPixbuf is used then errors #GdkPixbufError<!-- -->s
+ * will be used directly.
+ *
+ * Since: 1.4
+ */
+typedef enum {
+  COGL_BITMAP_ERROR_FAILED,
+  COGL_BITMAP_ERROR_UNKNOWN_TYPE,
+  COGL_BITMAP_ERROR_CORRUPT_IMAGE
+} CoglBitmapError;
+
+uint32_t cogl_bitmap_error_quark (void);
+
+COGL_END_DECLS
+
+#endif /* __COGL_BITMAP_H__ */

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

@@ -0,0 +1,309 @@
+/*
+ * Cogl
+ *
+ * An object oriented GL/GLES Abstraction/Utility Layer
+ *
+ * Copyright (C)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_BUFFER_H__
+#define __COGL_BUFFER_H__
+
+#include <cogl/cogl-types.h>
+#include <cogl/cogl-error.h>
+
+COGL_BEGIN_DECLS
+
+/**
+ * SECTION:cogl-buffer
+ * @short_description: Common buffer functions, including data upload APIs
+ * @stability: unstable
+ *
+ * The CoglBuffer API provides a common interface to manipulate
+ * buffers that have been allocated either via cogl_pixel_buffer_new()
+ * or cogl_attribute_buffer_new(). The API allows you to upload data
+ * to these buffers and define usage hints that help Cogl manage your
+ * buffer optimally.
+ *
+ * Data can either be uploaded by supplying a pointer and size so Cogl
+ * can copy your data, or you can mmap() a CoglBuffer and then you can
+ * copy data to the buffer directly.
+ *
+ * One of the most common uses for CoglBuffers is to upload texture
+ * data asynchronously since the ability to mmap the buffers into
+ * the CPU makes it possible for another thread to handle the IO
+ * of loading an image file and unpacking it into the mapped buffer
+ * without blocking other Cogl operations.
+ */
+
+#define COGL_BUFFER(buffer)     ((CoglBuffer *)(buffer))
+
+typedef struct _CoglBuffer CoglBuffer;
+
+#define COGL_BUFFER_ERROR (_cogl_buffer_error_domain ())
+
+/**
+ * CoglBufferError:
+ * @COGL_BUFFER_ERROR_MAP: A buffer could not be mapped either
+ *    because the feature isn't supported or because a system
+ *    limitation was hit.
+ *
+ * Error enumeration for #CoglBuffer
+ *
+ * Stability: unstable
+ */
+typedef enum { /*< prefix=COGL_BUFFER_ERROR >*/
+  COGL_BUFFER_ERROR_MAP,
+} CoglBufferError;
+
+uint32_t
+_cogl_buffer_error_domain (void);
+
+/**
+ * cogl_is_buffer:
+ * @object: a buffer object
+ *
+ * Checks whether @buffer is a buffer object.
+ *
+ * Return value: %TRUE if the handle is a CoglBuffer, and %FALSE otherwise
+ *
+ * Since: 1.2
+ * Stability: unstable
+ */
+CoglBool
+cogl_is_buffer (void *object);
+
+/**
+ * cogl_buffer_get_size:
+ * @buffer: a buffer object
+ *
+ * Retrieves the size of buffer
+ *
+ * Return value: the size of the buffer in bytes
+ *
+ * Since: 1.2
+ * Stability: unstable
+ */
+unsigned int
+cogl_buffer_get_size (CoglBuffer *buffer);
+
+/**
+ * CoglBufferUpdateHint:
+ * @COGL_BUFFER_UPDATE_HINT_STATIC: the buffer will not change over time
+ * @COGL_BUFFER_UPDATE_HINT_DYNAMIC: the buffer will change from time to time
+ * @COGL_BUFFER_UPDATE_HINT_STREAM: the buffer will be used once or a couple of
+ *   times
+ *
+ * The update hint on a buffer allows the user to give some detail on how often
+ * the buffer data is going to be updated.
+ *
+ * Since: 1.2
+ * Stability: unstable
+ */
+typedef enum { /*< prefix=COGL_BUFFER_UPDATE_HINT >*/
+  COGL_BUFFER_UPDATE_HINT_STATIC,
+  COGL_BUFFER_UPDATE_HINT_DYNAMIC,
+  COGL_BUFFER_UPDATE_HINT_STREAM
+} CoglBufferUpdateHint;
+
+/**
+ * cogl_buffer_set_update_hint:
+ * @buffer: a buffer object
+ * @hint: the new hint
+ *
+ * Sets the update hint on a buffer. See #CoglBufferUpdateHint for a description
+ * of the available hints.
+ *
+ * Since: 1.2
+ * Stability: unstable
+ */
+void
+cogl_buffer_set_update_hint (CoglBuffer          *buffer,
+                             CoglBufferUpdateHint hint);
+
+/**
+ * cogl_buffer_get_update_hint:
+ * @buffer: a buffer object
+ *
+ * Retrieves the update hints set using cogl_buffer_set_update_hint()
+ *
+ * Return value: the #CoglBufferUpdateHint currently used by the buffer
+ *
+ * Since: 1.2
+ * Stability: unstable
+ */
+CoglBufferUpdateHint
+cogl_buffer_get_update_hint (CoglBuffer *buffer);
+
+/**
+ * CoglBufferAccess:
+ * @COGL_BUFFER_ACCESS_READ: the buffer will be read
+ * @COGL_BUFFER_ACCESS_WRITE: the buffer will written to
+ * @COGL_BUFFER_ACCESS_READ_WRITE: the buffer will be used for both reading and
+ *   writing
+ *
+ * The access hints for cogl_buffer_set_update_hint()
+ *
+ * Since: 1.2
+ * Stability: unstable
+ */
+typedef enum { /*< prefix=COGL_BUFFER_ACCESS >*/
+ COGL_BUFFER_ACCESS_READ       = 1 << 0,
+ COGL_BUFFER_ACCESS_WRITE      = 1 << 1,
+ COGL_BUFFER_ACCESS_READ_WRITE = COGL_BUFFER_ACCESS_READ | COGL_BUFFER_ACCESS_WRITE
+} CoglBufferAccess;
+
+
+/**
+ * CoglBufferMapHint:
+ * @COGL_BUFFER_MAP_HINT_DISCARD: Tells Cogl that you plan to replace
+ *    all the buffer's contents. When this flag is used to map a
+ *    buffer, the entire contents of the buffer become undefined, even
+ *    if only a subregion of the buffer is mapped.
+ * @COGL_BUFFER_MAP_HINT_DISCARD_RANGE: Tells Cogl that you plan to
+ *    replace all the contents of the mapped region. The contents of
+ *    the region specified are undefined after this flag is used to
+ *    map a buffer.
+ *
+ * Hints to Cogl about how you are planning to modify the data once it
+ * is mapped.
+ *
+ * Since: 1.4
+ * Stability: unstable
+ */
+typedef enum { /*< prefix=COGL_BUFFER_MAP_HINT >*/
+  COGL_BUFFER_MAP_HINT_DISCARD = 1 << 0,
+  COGL_BUFFER_MAP_HINT_DISCARD_RANGE = 1 << 1
+} CoglBufferMapHint;
+
+/**
+ * cogl_buffer_map:
+ * @buffer: a buffer object
+ * @access: how the mapped buffer will be used by the application
+ * @hints: A mask of #CoglBufferMapHint<!-- -->s that tell Cogl how
+ *   the data will be modified once mapped.
+ *
+ * Maps the buffer into the application address space for direct
+ * access. This is equivalent to calling cogl_buffer_map_range() with
+ * zero as the offset and the size of the entire buffer as the size.
+ *
+ * It is strongly recommended that you pass
+ * %COGL_BUFFER_MAP_HINT_DISCARD as a hint if you are going to replace
+ * all the buffer's data. This way if the buffer is currently being
+ * used by the GPU then the driver won't have to stall the CPU and
+ * wait for the hardware to finish because it can instead allocate a
+ * new buffer to map.
+ *
+ * The behaviour is undefined if you access the buffer in a way
+ * conflicting with the @access mask you pass. It is also an error to
+ * release your last reference while the buffer is mapped.
+ *
+ * Return value: A pointer to the mapped memory or %NULL is the call fails
+ *
+ * Since: 1.2
+ * Stability: unstable
+ */
+void *
+cogl_buffer_map (CoglBuffer *buffer,
+                 CoglBufferAccess access,
+                 CoglBufferMapHint hints);
+
+/**
+ * cogl_buffer_map_range:
+ * @buffer: a buffer object
+ * @offset: Offset within the buffer to start the mapping
+ * @size: The size of data to map
+ * @access: how the mapped buffer will be used by the application
+ * @hints: A mask of #CoglBufferMapHint<!-- -->s that tell Cogl how
+ *   the data will be modified once mapped.
+ * @error: A #CoglError for catching exceptional errors
+ *
+ * Maps a sub-region of the buffer into the application's address space
+ * for direct access.
+ *
+ * It is strongly recommended that you pass
+ * %COGL_BUFFER_MAP_HINT_DISCARD as a hint if you are going to replace
+ * all the buffer's data. This way if the buffer is currently being
+ * used by the GPU then the driver won't have to stall the CPU and
+ * wait for the hardware to finish because it can instead allocate a
+ * new buffer to map. You can pass
+ * %COGL_BUFFER_MAP_HINT_DISCARD_RANGE instead if you want the
+ * regions outside of the mapping to be retained.
+ *
+ * The behaviour is undefined if you access the buffer in a way
+ * conflicting with the @access mask you pass. It is also an error to
+ * release your last reference while the buffer is mapped.
+ *
+ * Return value: A pointer to the mapped memory or %NULL is the call fails
+ *
+ * Since: 2.0
+ * Stability: unstable
+ */
+void *
+cogl_buffer_map_range (CoglBuffer *buffer,
+                       size_t offset,
+                       size_t size,
+                       CoglBufferAccess access,
+                       CoglBufferMapHint hints,
+                       CoglError **error);
+
+/**
+ * cogl_buffer_unmap:
+ * @buffer: a buffer object
+ *
+ * Unmaps a buffer previously mapped by cogl_buffer_map().
+ *
+ * Since: 1.2
+ * Stability: unstable
+ */
+void
+cogl_buffer_unmap (CoglBuffer *buffer);
+
+/**
+ * cogl_buffer_set_data:
+ * @buffer: a buffer object
+ * @offset: destination offset (in bytes) in the buffer
+ * @data: a pointer to the data to be copied into the buffer
+ * @size: number of bytes to copy
+ *
+ * Updates part of the buffer with new data from @data. Where to put this new
+ * data is controlled by @offset and @offset + @data should be less than the
+ * buffer size.
+ *
+ * Return value: %TRUE is the operation succeeded, %FALSE otherwise
+ *
+ * Since: 1.2
+ * Stability: unstable
+ */
+CoglBool
+cogl_buffer_set_data (CoglBuffer *buffer,
+                      size_t offset,
+                      const void *data,
+                      size_t size);
+
+COGL_END_DECLS
+
+#endif /* __COGL_BUFFER_H__ */