clutter 2.2.0-x86-mingw32 → 2.2.1-x86-mingw32

data/vendor/local/include/cogl/cogl/cogl-texture-2d.h

@@ -1,23 +1,29 @@
 /*
  * Cogl
  *
- * An object oriented GL/GLES Abstraction/Utility Layer
+ * A Low Level GPU Graphics and Utilities API
  *
- * Copyright (C) 2011 Intel Corporation.
+ * Copyright (C) 2011,2013 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.
+ * 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:
  *
- * 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.
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
  *
- * 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/>.
+ * 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:
@@ -55,6 +61,15 @@ COGL_BEGIN_DECLS
 typedef struct _CoglTexture2D CoglTexture2D;
 #define COGL_TEXTURE_2D(X) ((CoglTexture2D *)X)
 
+#ifdef COGL_HAS_GTYPE_SUPPORT
+/**
+ * cogl_texture_2d_get_gtype:
+ *
+ * Returns: a #GType that can be used with the GLib type system.
+ */
+GType cogl_texture_2d_get_gtype (void);
+#endif
+
 /**
  * cogl_is_texture_2d:
  * @object: A #CoglObject
@@ -73,13 +88,9 @@ cogl_is_texture_2d (void *object);
  * @ctx: A #CoglContext
  * @width: Width of the texture to allocate
  * @height: Height of the texture to allocate
- * @internal_format: The format of the texture
  *
- * Allocates a low-level #CoglTexture2D texture that your GPU can
- * texture from directly. This is unlike sliced textures for example
- * which may be comprised of multiple internal textures, or atlas
- * textures where Cogl has to modify texture coordinates before they
- * may be used by the GPU.
+ * Creates a low-level #CoglTexture2D texture with a given @width and
+ * @height that your GPU can texture from directly.
  *
  * The storage for the texture is not allocated before this function
  * returns. You can call cogl_texture_allocate() to explicitly
@@ -87,6 +98,11 @@ cogl_is_texture_2d (void *object);
  * automatically allocate storage lazily when it may know more about
  * how the texture is being used and can optimize how it is allocated.
  *
+ * The texture is still configurable until it has been allocated so
+ * for example you can influence the internal format of the texture
+ * using cogl_texture_set_components() and
+ * cogl_texture_set_premultiplied().
+ *
  * <note>Many GPUs only support power of two sizes for #CoglTexture2D
  * textures. You can check support for non power of two textures by
  * checking for the %COGL_FEATURE_ID_TEXTURE_NPOT feature via
@@ -99,24 +115,31 @@ cogl_is_texture_2d (void *object);
 CoglTexture2D *
 cogl_texture_2d_new_with_size (CoglContext *ctx,
                                int width,
-                               int height,
-                               CoglPixelFormat internal_format);
+                               int height);
 
 /**
  * cogl_texture_2d_new_from_file:
  * @ctx: A #CoglContext
  * @filename: the file to load
- * @internal_format: the #CoglPixelFormat to use for the GPU storage of the
- *    texture. If %COGL_PIXEL_FORMAT_ANY is given then a premultiplied
- *    format similar to the format of the source data will be used. The
- *    default blending equations of Cogl expect premultiplied color data;
- *    the main use of passing a non-premultiplied format here is if you
- *    have non-premultiplied source data and are going to adjust the blend
- *    mode (see cogl_material_set_blend()) or use the data for something
- *    other than straight blending.
  * @error: A #CoglError to catch exceptional errors or %NULL
  *
- * Creates a #CoglTexture2D from an image file.
+ * Creates a low-level #CoglTexture2D texture from an image file.
+ *
+ * The storage for the texture is not allocated before this function
+ * returns. You can call cogl_texture_allocate() to explicitly
+ * allocate the underlying storage or preferably let Cogl
+ * automatically allocate storage lazily when it may know more about
+ * how the texture is being used and can optimize how it is allocated.
+ *
+ * The texture is still configurable until it has been allocated so
+ * for example you can influence the internal format of the texture
+ * using cogl_texture_set_components() and
+ * cogl_texture_set_premultiplied().
+ *
+ * <note>Many GPUs only support power of two sizes for #CoglTexture2D
+ * textures. You can check support for non power of two textures by
+ * checking for the %COGL_FEATURE_ID_TEXTURE_NPOT feature via
+ * cogl_has_feature().</note>
  *
  * Return value: (transfer full): A newly created #CoglTexture2D or %NULL on failure
  *               and @error will be updated.
@@ -126,7 +149,6 @@ cogl_texture_2d_new_with_size (CoglContext *ctx,
 CoglTexture2D *
 cogl_texture_2d_new_from_file (CoglContext *ctx,
                                const char *filename,
-                               CoglPixelFormat internal_format,
                                CoglError **error);
 
 /**
@@ -135,24 +157,25 @@ cogl_texture_2d_new_from_file (CoglContext *ctx,
  * @width: width of texture in pixels
  * @height: height of texture in pixels
  * @format: the #CoglPixelFormat the buffer is stored in in RAM
- * @internal_format: the #CoglPixelFormat that will be used for storing
- *    the buffer on the GPU. If %COGL_PIXEL_FORMAT_ANY is given then a
- *    premultiplied format similar to the format of the source data will
- *    be used. The default blending equations of Cogl expect premultiplied
- *    color data; the main use of passing a non-premultiplied format here
- *    is if you have non-premultiplied source data and are going to adjust
- *    the blend mode (see cogl_pipeline_set_blend()) or use the data for
- *    something other than straight blending.
  * @rowstride: the memory offset in bytes between the starts of
  *    scanlines in @data. A value of 0 will make Cogl automatically
  *    calculate @rowstride from @width and @format.
  * @data: pointer the memory region where the source buffer resides
  * @error: A #CoglError for exceptions
  *
- * Creates a new #CoglTexture2D texture based on data residing in memory.
- * These are unlike sliced textures for example which may be comprised
- * of multiple internal textures, or atlas textures where Cogl has to
- * modify texture coordinates before they may be used by the GPU.
+ * Creates a low-level #CoglTexture2D texture based on data residing
+ * in memory.
+ *
+ * <note>This api will always immediately allocate GPU memory for the
+ * texture and upload the given data so that the @data pointer does
+ * not need to remain valid once this function returns. This means it
+ * is not possible to configure the texture before it is allocated. If
+ * you do need to configure the texture before allocation (to specify
+ * constraints on the internal format for example) then you can
+ * instead create a #CoglBitmap for your data and use
+ * cogl_texture_2d_new_from_bitmap() or use
+ * cogl_texture_2d_new_with_size() and then upload data using
+ * cogl_texture_set_data()</note>
  *
  * <note>Many GPUs only support power of two sizes for #CoglTexture2D
  * textures. You can check support for non power of two textures by
@@ -171,7 +194,6 @@ cogl_texture_2d_new_from_data (CoglContext *ctx,
                                int width,
                                int height,
                                CoglPixelFormat format,
-                               CoglPixelFormat internal_format,
                                int rowstride,
                                const uint8_t *data,
                                CoglError **error);
@@ -179,39 +201,33 @@ cogl_texture_2d_new_from_data (CoglContext *ctx,
 /**
  * cogl_texture_2d_new_from_bitmap:
  * @bitmap: A #CoglBitmap
- * @internal_format: the #CoglPixelFormat that will be used for storing
- *    the buffer on the GPU. If %COGL_PIXEL_FORMAT_ANY is given then a
- *    premultiplied format similar to the format of the source data will
- *    be used. The default blending equations of Cogl expect premultiplied
- *    color data; the main use of passing a non-premultiplied format here
- *    is if you have non-premultiplied source data and are going to adjust
- *    the blend mode (see cogl_pipeline_set_blend()) or use the data for
- *    something other than straight blending.
- * @error: A #CoglError for exceptions
  *
- * Creates a new #CoglTexture2D texture based on data residing in a
- * bitmap. These are unlike sliced textures for example which may be
- * comprised of multiple internal textures, or atlas textures where
- * Cogl has to modify texture coordinates before they may be used by
- * the GPU.
+ * Creates a low-level #CoglTexture2D texture based on data residing
+ * in a #CoglBitmap.
+ *
+ * The storage for the texture is not allocated before this function
+ * returns. You can call cogl_texture_allocate() to explicitly
+ * allocate the underlying storage or preferably let Cogl
+ * automatically allocate storage lazily when it may know more about
+ * how the texture is being used and can optimize how it is allocated.
+ *
+ * The texture is still configurable until it has been allocated so
+ * for example you can influence the internal format of the texture
+ * using cogl_texture_set_components() and
+ * cogl_texture_set_premultiplied().
  *
  * <note>Many GPUs only support power of two sizes for #CoglTexture2D
  * textures. You can check support for non power of two textures by
  * checking for the %COGL_FEATURE_ID_TEXTURE_NPOT feature via
  * cogl_has_feature().</note>
  *
- * Returns: (transfer full): A newly allocated #CoglTexture2D, or if
- *          the size is not supported (because it is too large or a
- *          non-power-of-two size that the hardware doesn't support)
- *          it will return %NULL and set @error.
+ * Returns: (transfer full): A newly allocated #CoglTexture2D
  *
  * Since: 2.0
  * Stability: unstable
  */
 CoglTexture2D *
-cogl_texture_2d_new_from_bitmap (CoglBitmap *bitmap,
-                                 CoglPixelFormat internal_format,
-                                 CoglError **error);
+cogl_texture_2d_new_from_bitmap (CoglBitmap *bitmap);
 
 COGL_END_DECLS
 

data/vendor/local/include/cogl/cogl/cogl-texture-3d.h

@@ -1,24 +1,29 @@
 /*
  * Cogl
  *
- * An object oriented GL/GLES Abstraction/Utility Layer
+ * A Low Level GPU Graphics and Utilities API
  *
  * 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, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
+ * 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>
@@ -47,17 +52,24 @@ typedef struct _CoglTexture3D CoglTexture3D;
 
 #define COGL_TEXTURE_3D(X) ((CoglTexture3D *)X)
 
+#ifdef COGL_HAS_GTYPE_SUPPORT
+/**
+ * cogl_texture_3d_get_gtype:
+ *
+ * Returns: a #GType that can be used with the GLib type system.
+ */
+GType cogl_texture_3d_get_gtype (void);
+#endif
+
 /**
  * cogl_texture_3d_new_with_size:
  * @context: a #CoglContext
  * @width: width of the texture in pixels.
  * @height: height of the texture in pixels.
  * @depth: depth of the texture in pixels.
- * @internal_format: the #CoglPixelFormat to use for the GPU
- *    storage of the texture.
  *
- * Creates a new #CoglTexture3D texture with the specified dimensions
- * and pixel format.
+ * Creates a low-level #CoglTexture3D texture with the specified
+ * dimensions and pixel format.
  *
  * The storage for the texture is not allocated before this function
  * returns. You can call cogl_texture_allocate() to explicitly
@@ -66,6 +78,11 @@ typedef struct _CoglTexture3D CoglTexture3D;
  * how the texture is going to be used and can optimize how it is
  * allocated.
  *
+ * The texture is still configurable until it has been allocated so
+ * for example you can influence the internal format of the texture
+ * using cogl_texture_set_components() and
+ * cogl_texture_set_premultiplied().
+ *
  * <note>This texture will fail to allocate later if
  * %COGL_FEATURE_ID_TEXTURE_3D is not advertised. Allocation can also
  * fail if the requested dimensions are not supported by the
@@ -79,8 +96,7 @@ CoglTexture3D *
 cogl_texture_3d_new_with_size (CoglContext *context,
                                int width,
                                int height,
-                               int depth,
-                               CoglPixelFormat internal_format);
+                               int depth);
 
 /**
  * cogl_texture_3d_new_from_data:
@@ -89,14 +105,6 @@ cogl_texture_3d_new_with_size (CoglContext *context,
  * @height: height of the texture in pixels.
  * @depth: depth of the texture in pixels.
  * @format: the #CoglPixelFormat the buffer is stored in in RAM
- * @internal_format: the #CoglPixelFormat that will be used for storing
- *    the buffer on the GPU. If %COGL_PIXEL_FORMAT_ANY is given then a
- *    premultiplied format similar to the format of the source data will
- *    be used. The default blending equations of Cogl expect premultiplied
- *    color data; the main use of passing a non-premultiplied format here
- *    is if you have non-premultiplied source data and are going to adjust
- *    the blend mode (see cogl_pipeline_set_blend()) or use the data for
- *    something other than straight blending.
  * @rowstride: the memory offset in bytes between the starts of
  *    scanlines in @data or 0 to infer it from the width and format
  * @image_stride: the number of bytes from one image to the next. This
@@ -107,16 +115,21 @@ cogl_texture_3d_new_with_size (CoglContext *context,
  * @data: pointer the memory region where the source buffer resides
  * @error: A CoglError return location.
  *
- * Creates a new 3D texture and initializes it with @data. The data is
- * assumed to be packed array of @depth images. There can be padding
- * between the images using @image_stride.
+ * Creates a low-level 3D texture and initializes it with @data. The
+ * data is assumed to be packed array of @depth images. There can be
+ * padding between the images using @image_stride.
  *
- * Note that this function will throw a #CoglError if
- * %COGL_FEATURE_ID_TEXTURE_3D is not advertised. It can also fail if the
- * requested dimensions are not supported by the GPU.
+ * <note>This api will always immediately allocate GPU memory for the
+ * texture and upload the given data so that the @data pointer does
+ * not need to remain valid once this function returns. This means it
+ * is not possible to configure the texture before it is allocated. If
+ * you do need to configure the texture before allocation (to specify
+ * constraints on the internal format for example) then you can
+ * instead create a #CoglBitmap for your data and use
+ * cogl_texture_3d_new_from_bitmap().</note>
  *
  * Return value: (transfer full): the newly created #CoglTexture3D or
- *               %NULL if there was an error an an exception will be
+ *               %NULL if there was an error and an exception will be
  *               returned through @error.
  * Since: 1.10
  * Stability: Unstable
@@ -127,7 +140,6 @@ cogl_texture_3d_new_from_data (CoglContext *context,
                                int height,
                                int depth,
                                CoglPixelFormat format,
-                               CoglPixelFormat internal_format,
                                int rowstride,
                                int image_stride,
                                const uint8_t *data,
@@ -138,34 +150,39 @@ cogl_texture_3d_new_from_data (CoglContext *context,
  * @bitmap: A #CoglBitmap object.
  * @height: height of the texture in pixels.
  * @depth: depth of the texture in pixels.
- * @internal_format: the #CoglPixelFormat that will be used for storing
- *    the buffer on the GPU. If %COGL_PIXEL_FORMAT_ANY is given then a
- *    premultiplied format similar to the format of the source data will
- *    be used. The default blending equations of Cogl expect premultiplied
- *    color data; the main use of passing a non-premultiplied format here
- *    is if you have non-premultiplied source data and are going to adjust
- *    the blend mode (see cogl_pipeline_set_blend()) or use the data for
- *    something other than straight blending.
- * @error: A CoglError return location.
  *
- * Creates a new 3D texture and initializes it with the images in
- * @bitmap. The images are assumed to be packed together after one
+ * Creates a low-level 3D texture and initializes it with the images
+ * in @bitmap. The images are assumed to be packed together after one
  * another in the increasing y axis. The height of individual image is
  * given as @height and the number of images is given in @depth. The
  * actual height of the bitmap can be larger than @height × @depth. In
  * this case it assumes there is padding between the images.
  *
- * Return value: (transfer full): the newly created texture or %NULL
- *   if there was an error.
+ * The storage for the texture is not allocated before this function
+ * returns. You can call cogl_texture_allocate() to explicitly
+ * allocate the underlying storage or preferably let Cogl
+ * automatically allocate storage lazily when it may know more about
+ * how the texture is going to be used and can optimize how it is
+ * allocated.
+ *
+ * The texture is still configurable until it has been allocated so
+ * for example you can influence the internal format of the texture
+ * using cogl_texture_set_components() and
+ * cogl_texture_set_premultiplied().
+ *
+ * <note>This texture will fail to allocate later if
+ * %COGL_FEATURE_ID_TEXTURE_3D is not advertised. Allocation can also
+ * fail if the requested dimensions are not supported by the
+ * GPU.</note>
+ *
+ * Return value: (transfer full): a newly created #CoglTexture3D
  * Since: 2.0
  * Stability: unstable
  */
 CoglTexture3D *
 cogl_texture_3d_new_from_bitmap (CoglBitmap *bitmap,
-                                 unsigned int height,
-                                 unsigned int depth,
-                                 CoglPixelFormat internal_format,
-                                 CoglError **error);
+                                 int height,
+                                 int depth);
 
 /**
  * cogl_is_texture_3d:

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

@@ -0,0 +1,105 @@
+/*
+ * Cogl
+ *
+ * A Low Level GPU Graphics and Utilities API
+ *
+ * Copyright (C) 2014 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_TEXTURE_DEPRECATED_H__
+#define __COGL_TEXTURE_DEPRECATED_H__
+
+/**
+ * cogl_texture_get_format:
+ * @texture: a #CoglTexture pointer.
+ *
+ * Queries the #CoglPixelFormat of a cogl texture.
+ *
+ * Return value: the #CoglPixelFormat of the GPU side texture
+ * Deprecated: 1.18: This api is misleading
+ */
+COGL_DEPRECATED_IN_1_18
+CoglPixelFormat
+cogl_texture_get_format (CoglTexture *texture);
+
+/**
+ * cogl_texture_get_rowstride:
+ * @texture a #CoglTexture pointer.
+ *
+ * Determines the bytes-per-pixel for the #CoglPixelFormat retrieved
+ * from cogl_texture_get_format() and multiplies that by the texture's
+ * width.
+ *
+ * <note>It's very unlikely that anyone would need to use this API to
+ * query the internal rowstride of a #CoglTexture which can just be
+ * considered an implementation detail. Actually it's not even useful
+ * internally since underlying drivers are free to use a different
+ * format</note>
+ *
+ * <note>This API is only here for backwards compatibility and
+ * shouldn't be used in new code. In particular please don't be
+ * mislead to pass the returned value to cogl_texture_get_data() for
+ * the rowstride, since you should be passing the rowstride you desire
+ * for your destination buffer not the rowstride of the source
+ * texture.</note>
+ *
+ * Return value: The bytes-per-pixel for the current format
+ *               multiplied by the texture's width
+ *
+ * Deprecated: 1.10: There's no replacement for the API but there's
+ *                   also no known need for API either. It was just
+ *                   a mistake that it was ever published.
+ */
+COGL_DEPRECATED_IN_1_10
+unsigned int
+cogl_texture_get_rowstride (CoglTexture *texture);
+
+/**
+ * cogl_texture_ref: (skip)
+ * @texture: a #CoglTexture.
+ *
+ * Increment the reference count for a cogl texture.
+ *
+ * Deprecated: 1.2: Use cogl_object_ref() instead
+ *
+ * Return value: the @texture pointer.
+ */
+COGL_DEPRECATED_FOR (cogl_object_ref)
+void *
+cogl_texture_ref (void *texture);
+
+/**
+ * cogl_texture_unref: (skip)
+ * @texture: a #CoglTexture.
+ *
+ * Decrement the reference count for a cogl texture.
+ *
+ * Deprecated: 1.2: Use cogl_object_unref() instead
+ */
+COGL_DEPRECATED_FOR (cogl_object_unref)
+void
+cogl_texture_unref (void *texture);
+
+#endif /* __COGL_TEXTURE_DEPRECATED_H__ */