[cogl/wip/rib/master-next: 35/44] texture: Make CoglTextureRectangle experimentally public
- From: Robert Bragg <rbragg src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [cogl/wip/rib/master-next: 35/44] texture: Make CoglTextureRectangle experimentally public
- Date: Fri, 28 Oct 2011 15:45:26 +0000 (UTC)
commit f286202aa23b9d17b7b4fd7aad22deb8a5f0d998
Author: Robert Bragg <robert linux intel com>
Date: Fri Oct 14 09:25:12 2011 +0100
texture: Make CoglTextureRectangle experimentally public
This exposes CoglTextureRectangle in the experimental cogl 2.0 api. For
now we just expose a single constructor;
cogl_texture_rectangle_new_with_size() but we can add more later.
This is part of going work to improve our texture apis with more
emphasis on providing low-level access to the varying semantics of
different texture types understood by the gpu instead of only trying to
present a lowest common denominator api.
CoglTextureRectangle is notably useful for never being restricted to
power of two sizes and for being sampled with non-normalized texture
coordinates which can be convenient for use a lookup tables in glsl due
to not needing separate uniforms for mapping normalized coordinates to
texels. Unlike CoglTexture2D though rectangle textures can't have a
mipmap and they only support the _CLAMP_TO_EDGE wrap mode.
Applications wanting to use CoglTextureRectangle should first check
cogl_has_feature (COGL_FEATURE_ID_TEXTURE_RECTANGLE).
cogl/Makefile.am | 1 +
cogl/cogl-meta-texture.c | 4 +-
cogl/cogl-sub-texture.c | 4 +-
cogl/cogl-texture-rectangle-private.h | 18 +---
cogl/cogl-texture-rectangle.c | 80 ++++++++------
cogl/cogl-texture-rectangle.h | 118 ++++++++++++++++++++
cogl/cogl-texture.h | 3 +-
cogl/cogl.h | 1 +
cogl/winsys/cogl-texture-pixmap-x11.c | 2 +-
cogl/winsys/cogl-winsys-glx.c | 15 ++-
.../cogl-2.0-experimental-sections.txt | 7 +
11 files changed, 190 insertions(+), 63 deletions(-)
---
diff --git a/cogl/Makefile.am b/cogl/Makefile.am
index 2d844cf..ca7d4b6 100644
--- a/cogl/Makefile.am
+++ b/cogl/Makefile.am
@@ -77,6 +77,7 @@ cogl_public_h = \
$(srcdir)/cogl-texture.h \
$(srcdir)/cogl-texture-3d.h \
$(srcdir)/cogl-texture-2d.h \
+ $(srcdir)/cogl-texture-rectangle.h \
$(srcdir)/cogl-texture-2d-sliced.h \
$(srcdir)/cogl-meta-texture.h \
$(srcdir)/cogl-types.h \
diff --git a/cogl/cogl-meta-texture.c b/cogl/cogl-meta-texture.c
index 7fc21bf..7c142d0 100644
--- a/cogl/cogl-meta-texture.c
+++ b/cogl/cogl-meta-texture.c
@@ -291,7 +291,7 @@ cogl_meta_texture_foreach_in_region (CoglMetaTexture *meta_texture,
* coordinates beyond this point and only re-normalize just before
* calling the user's callback... */
- if (!_cogl_is_texture_rectangle (COGL_TEXTURE (meta_texture)))
+ if (!cogl_is_texture_rectangle (COGL_TEXTURE (meta_texture)))
{
normalize_data.callback = callback;
normalize_data.user_data = user_data;
@@ -367,7 +367,7 @@ cogl_meta_texture_foreach_in_region (CoglMetaTexture *meta_texture,
* callback that un_normalizes the slice coordinates we get from
* _cogl_texture_spans_foreach_in_region before passing them to
* the user's callback. */
- if (_cogl_is_texture_rectangle (meta_texture))
+ if (cogl_is_texture_rectangle (meta_texture))
{
un_normalize_data.callback = callback;
un_normalize_data.user_data = user_data;
diff --git a/cogl/cogl-sub-texture.c b/cogl/cogl-sub-texture.c
index 9926376..0739782 100644
--- a/cogl/cogl-sub-texture.c
+++ b/cogl/cogl-sub-texture.c
@@ -58,7 +58,7 @@ _cogl_sub_texture_unmap_quad (CoglSubTexture *sub_tex,
* NB: sub_tex->sub_x/y/width/height are in non-normalized
* coordinates.
*/
- if (_cogl_is_texture_rectangle (sub_tex->full_texture))
+ if (cogl_is_texture_rectangle (sub_tex->full_texture))
{
coords[0] = (coords[0] - sub_tex->sub_x) / sub_tex->sub_width;
coords[1] = (coords[1] - sub_tex->sub_y) / sub_tex->sub_height;
@@ -88,7 +88,7 @@ _cogl_sub_texture_map_quad (CoglSubTexture *sub_tex,
* coordinates.
*/
- if (_cogl_is_texture_rectangle (sub_tex->full_texture))
+ if (cogl_is_texture_rectangle (sub_tex->full_texture))
{
coords[0] = coords[0] * sub_tex->sub_width + sub_tex->sub_x;
coords[1] = coords[1] * sub_tex->sub_height + sub_tex->sub_y;
diff --git a/cogl/cogl-texture-rectangle-private.h b/cogl/cogl-texture-rectangle-private.h
index 07eca5e..dde9109 100644
--- a/cogl/cogl-texture-rectangle-private.h
+++ b/cogl/cogl-texture-rectangle-private.h
@@ -24,14 +24,9 @@
#ifndef __COGL_TEXTURE_RECTANGLE_H
#define __COGL_TEXTURE_RECTANGLE_H
-#include "cogl-handle.h"
#include "cogl-pipeline-private.h"
#include "cogl-texture-private.h"
-#define COGL_TEXTURE_RECTANGLE(tex) ((CoglTextureRectangle *) tex)
-
-typedef struct _CoglTextureRectangle CoglTextureRectangle;
-
struct _CoglTextureRectangle
{
CoglTexture _parent;
@@ -52,24 +47,15 @@ struct _CoglTextureRectangle
gboolean is_foreign;
};
-gboolean
-_cogl_is_texture_rectangle (void *object);
-
GQuark
_cogl_handle_texture_rectangle_get_type (void);
-CoglHandle
-_cogl_texture_rectangle_new_with_size (unsigned int width,
- unsigned int height,
- CoglTextureFlags flags,
- CoglPixelFormat internal_format);
-
-CoglHandle
+CoglTextureRectangle *
_cogl_texture_rectangle_new_from_bitmap (CoglBitmap *bmp,
CoglTextureFlags flags,
CoglPixelFormat internal_format);
-CoglHandle
+CoglTextureRectangle *
_cogl_texture_rectangle_new_from_foreign (GLuint gl_handle,
GLuint width,
GLuint height,
diff --git a/cogl/cogl-texture-rectangle.c b/cogl/cogl-texture-rectangle.c
index 9ea9392..c43779b 100644
--- a/cogl/cogl-texture-rectangle.c
+++ b/cogl/cogl-texture-rectangle.c
@@ -55,7 +55,7 @@
static void _cogl_texture_rectangle_free (CoglTextureRectangle *tex_rect);
-COGL_TEXTURE_INTERNAL_DEFINE (TextureRectangle, texture_rectangle);
+COGL_TEXTURE_DEFINE (TextureRectangle, texture_rectangle);
static const CoglTextureVtable cogl_texture_rectangle_vtable;
@@ -112,7 +112,8 @@ _cogl_texture_rectangle_free (CoglTextureRectangle *tex_rect)
static gboolean
_cogl_texture_rectangle_can_create (unsigned int width,
unsigned int height,
- CoglPixelFormat internal_format)
+ CoglPixelFormat internal_format,
+ GError **error)
{
GLenum gl_intformat;
GLenum gl_type;
@@ -120,7 +121,13 @@ _cogl_texture_rectangle_can_create (unsigned int width,
_COGL_GET_CONTEXT (ctx, FALSE);
if (!cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_RECTANGLE))
- return FALSE;
+ {
+ g_set_error (error,
+ COGL_TEXTURE_ERROR,
+ COGL_TEXTURE_ERROR_TYPE,
+ "The CoglTextureRectangle feature isn't available");
+ return FALSE;
+ }
ctx->texture_driver->pixel_format_to_gl (internal_format,
&gl_intformat,
@@ -133,7 +140,13 @@ _cogl_texture_rectangle_can_create (unsigned int width,
gl_type,
width,
height))
- return FALSE;
+ {
+ g_set_error (error,
+ COGL_TEXTURE_ERROR,
+ COGL_TEXTURE_ERROR_SIZE,
+ "The requested texture size + format is unsupported");
+ return FALSE;
+ }
return TRUE;
}
@@ -141,7 +154,6 @@ _cogl_texture_rectangle_can_create (unsigned int width,
static CoglTextureRectangle *
_cogl_texture_rectangle_create_base (unsigned int width,
unsigned int height,
- CoglTextureFlags flags,
CoglPixelFormat internal_format)
{
CoglTextureRectangle *tex_rect = g_new (CoglTextureRectangle, 1);
@@ -165,32 +177,32 @@ _cogl_texture_rectangle_create_base (unsigned int width,
return tex_rect;
}
-CoglHandle
-_cogl_texture_rectangle_new_with_size (unsigned int width,
- unsigned int height,
- CoglTextureFlags flags,
- CoglPixelFormat internal_format)
+CoglTextureRectangle *
+cogl_texture_rectangle_new_with_size (CoglContext *ctx,
+ int width,
+ int height,
+ CoglPixelFormat internal_format,
+ GError **error)
{
CoglTextureRectangle *tex_rect;
GLenum gl_intformat;
GLenum gl_format;
GLenum gl_type;
- _COGL_GET_CONTEXT (ctx, COGL_INVALID_HANDLE);
-
/* Since no data, we need some internal format */
if (internal_format == COGL_PIXEL_FORMAT_ANY)
internal_format = COGL_PIXEL_FORMAT_RGBA_8888_PRE;
- if (!_cogl_texture_rectangle_can_create (width, height, internal_format))
- return COGL_INVALID_HANDLE;
+ if (!_cogl_texture_rectangle_can_create (width, height,
+ internal_format, error))
+ return NULL;
internal_format = ctx->texture_driver->pixel_format_to_gl (internal_format,
&gl_intformat,
&gl_format,
&gl_type);
- tex_rect = _cogl_texture_rectangle_create_base (width, height, flags,
+ tex_rect = _cogl_texture_rectangle_create_base (width, height,
internal_format);
ctx->texture_driver->gen (GL_TEXTURE_RECTANGLE_ARB, 1, &tex_rect->gl_texture);
@@ -200,10 +212,10 @@ _cogl_texture_rectangle_new_with_size (unsigned int width,
GE( ctx, glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, gl_intformat,
width, height, 0, gl_format, gl_type, NULL) );
- return _cogl_texture_rectangle_handle_new (tex_rect);
+ return _cogl_texture_rectangle_object_new (tex_rect);
}
-CoglHandle
+CoglTextureRectangle *
_cogl_texture_rectangle_new_from_bitmap (CoglBitmap *bmp,
CoglTextureFlags flags,
CoglPixelFormat internal_format)
@@ -214,9 +226,9 @@ _cogl_texture_rectangle_new_from_bitmap (CoglBitmap *bmp,
GLenum gl_format;
GLenum gl_type;
- _COGL_GET_CONTEXT (ctx, COGL_INVALID_HANDLE);
+ _COGL_GET_CONTEXT (ctx, NULL);
- _COGL_RETURN_VAL_IF_FAIL (cogl_is_bitmap (bmp), COGL_INVALID_HANDLE);
+ _COGL_RETURN_VAL_IF_FAIL (cogl_is_bitmap (bmp), NULL);
internal_format =
_cogl_texture_determine_internal_format (_cogl_bitmap_get_format (bmp),
@@ -224,8 +236,9 @@ _cogl_texture_rectangle_new_from_bitmap (CoglBitmap *bmp,
if (!_cogl_texture_rectangle_can_create (_cogl_bitmap_get_width (bmp),
_cogl_bitmap_get_height (bmp),
- internal_format))
- return COGL_INVALID_HANDLE;
+ internal_format,
+ NULL))
+ return NULL;
dst_bmp = _cogl_texture_prepare_for_upload (bmp,
internal_format,
@@ -235,11 +248,10 @@ _cogl_texture_rectangle_new_from_bitmap (CoglBitmap *bmp,
&gl_type);
if (dst_bmp == NULL)
- return COGL_INVALID_HANDLE;
+ return NULL;
tex_rect = _cogl_texture_rectangle_create_base (_cogl_bitmap_get_width (bmp),
_cogl_bitmap_get_height (bmp),
- flags,
internal_format);
ctx->texture_driver->gen (GL_TEXTURE_RECTANGLE_ARB, 1, &tex_rect->gl_texture);
@@ -255,10 +267,10 @@ _cogl_texture_rectangle_new_from_bitmap (CoglBitmap *bmp,
cogl_object_unref (dst_bmp);
- return _cogl_texture_rectangle_handle_new (tex_rect);
+ return _cogl_texture_rectangle_object_new (tex_rect);
}
-CoglHandle
+CoglTextureRectangle *
_cogl_texture_rectangle_new_from_foreign (GLuint gl_handle,
GLuint width,
GLuint height,
@@ -273,14 +285,14 @@ _cogl_texture_rectangle_new_from_foreign (GLuint gl_handle,
GLenum gl_int_format = 0;
CoglTextureRectangle *tex_rect;
- _COGL_GET_CONTEXT (ctx, COGL_INVALID_HANDLE);
+ _COGL_GET_CONTEXT (ctx, NULL);
if (!ctx->texture_driver->allows_foreign_gl_target (GL_TEXTURE_RECTANGLE_ARB))
- return COGL_INVALID_HANDLE;
+ return NULL;
/* Make sure it is a valid GL texture object */
if (!ctx->glIsTexture (gl_handle))
- return COGL_INVALID_HANDLE;
+ return NULL;
/* Make sure binding succeeds */
while ((gl_error = ctx->glGetError ()) != GL_NO_ERROR)
@@ -288,7 +300,7 @@ _cogl_texture_rectangle_new_from_foreign (GLuint gl_handle,
_cogl_bind_gl_texture_transient (GL_TEXTURE_RECTANGLE_ARB, gl_handle, TRUE);
if (ctx->glGetError () != GL_NO_ERROR)
- return COGL_INVALID_HANDLE;
+ return NULL;
/* Obtain texture parameters */
@@ -311,7 +323,7 @@ _cogl_texture_rectangle_new_from_foreign (GLuint gl_handle,
the passed in format and use that. */
if (!ctx->texture_driver->pixel_format_from_gl_internal (gl_int_format,
&format))
- return COGL_INVALID_HANDLE;
+ return NULL;
}
else
#endif
@@ -333,16 +345,14 @@ _cogl_texture_rectangle_new_from_foreign (GLuint gl_handle,
/* Validate width and height */
if (width <= 0 || height <= 0)
- return COGL_INVALID_HANDLE;
+ return NULL;
/* Compressed texture images not supported */
if (gl_compressed == GL_TRUE)
- return COGL_INVALID_HANDLE;
+ return NULL;
/* Create new texture */
- tex_rect = _cogl_texture_rectangle_create_base (width, height,
- COGL_TEXTURE_NO_AUTO_MIPMAP,
- format);
+ tex_rect = _cogl_texture_rectangle_create_base (width, height, format);
/* Setup bitmap info */
tex_rect->is_foreign = TRUE;
diff --git a/cogl/cogl-texture-rectangle.h b/cogl/cogl-texture-rectangle.h
new file mode 100644
index 0000000..927bb93
--- /dev/null
+++ b/cogl/cogl-texture-rectangle.h
@@ -0,0 +1,118 @@
+/*
+ * Cogl
+ *
+ * An object oriented GL/GLES Abstraction/Utility Layer
+ *
+ * Copyright (C) 2011 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:
+ * Robert Bragg <robert linux intel com>
+ */
+
+#ifndef __COGL_TEXURE_RECTANGLE_H
+#define __COGL_TEXURE_RECTANGLE_H
+
+#include "cogl-context.h"
+
+G_BEGIN_DECLS
+
+/**
+ * SECTION:cogl-texture-rectangle
+ * @short_description: Functions for creating and manipulating rectangle
+ * textures for use with non-normalized coordinates.
+ *
+ * These functions allow low-level "rectangle" textures to be allocated.
+ * These textures are never constrained to power-of-two sizes but they
+ * also don't support having a mipmap and can only be wrapped with
+ * %COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE.
+ *
+ * The most notable difference between rectangle textures and 2D
+ * textures is that rectangle textures are sampled using un-normalized
+ * texture coordinates, so instead of using coordinates (0,0) and
+ * (1,1) to map to the top-left and bottom right corners of the
+ * texture you would instead use (0,0) and (width,height).
+ *
+ * The use of non-normalized coordinates can be particularly
+ * convenient when writing glsl shaders that use a texture as a lookup
+ * table since you don't need to upload separate uniforms to map
+ * normalized coordinates to texels.
+ *
+ * If you want to sample from a rectangle texture from GLSL you should
+ * use the sampler2DRect sampler type.
+ *
+ * Applications wanting to use #CoglTextureRectangle should first check
+ * for the %COGL_FEATURE_ID_TEXTURE_RECTANGLE feature using
+ * cogl_has_feature().
+ */
+
+typedef struct _CoglTextureRectangle CoglTextureRectangle;
+#define COGL_TEXTURE_RECTANGLE(X) ((CoglTextureRectangle *)X)
+
+#define cogl_is_texture_rectangle cogl_is_texture_rectangle_EXP
+/**
+ * cogl_is_texture_rectangle:
+ * @object: A #CoglObject
+ *
+ * Gets whether the given object references an existing
+ * #CoglTextureRectangle object.
+ *
+ * Return value: %TRUE if the object references a
+ * #CoglTextureRectangle, %FALSE otherwise.
+ */
+gboolean
+cogl_is_texture_rectangle (void *object);
+
+#define cogl_texture_rectangle_new_with_size \
+ cogl_texture_rectangle_new_with_size_EXP
+/**
+ * cogl_texture_rectangle_new_with_size:
+ * @context: A #CoglContext pointer
+ * @width: The texture width to allocate
+ * @height: The texture height to allocate
+ * @internal_format: The desired internal texture format
+ * @error: An optional GError pointer for reporting exceptions
+ *
+ * Allocates a new #CoglRectangle texture with a given @width, @height
+ * and @internal_format. This texture is a low-level texture that
+ * the GPU can sample from directly unlike high-level textures such
+ * as #CoglTexture2DSliced and #CoglAtlasTexture.
+ *
+ * <note>If you want to sample from a rectangle texture from GLSL you
+ * should use the sampler2DRect sampler type.</note>
+ *
+ * <note>Applications wanting to use #CoglTextureRectangle should
+ * first check for the %COGL_FEATURE_ID_TEXTURE_RECTANGLE feature
+ * using cogl_has_feature().</note>
+ *
+ * Returns: A pointer to a newly allocated #CoglRectangle texture
+ * or if the size was too large or there wasn't enough memory
+ * %NULL is returned and @error set.
+ *
+ * Since: 1.10
+ * Stability: unstable
+ */
+CoglTextureRectangle *
+cogl_texture_rectangle_new_with_size (CoglContext *ctx,
+ int width,
+ int height,
+ CoglPixelFormat internal_format,
+ GError **error);
+
+G_END_DECLS
+
+#endif /* __COGL_TEXURE_RECTANGLE_H */
diff --git a/cogl/cogl-texture.h b/cogl/cogl-texture.h
index 295e279..ba54188 100644
--- a/cogl/cogl-texture.h
+++ b/cogl/cogl-texture.h
@@ -74,7 +74,8 @@ typedef struct _CoglTexture CoglTexture;
typedef enum {
COGL_TEXTURE_ERROR_SIZE,
COGL_TEXTURE_ERROR_FORMAT,
- COGL_TEXTURE_ERROR_BAD_PARAMETER
+ COGL_TEXTURE_ERROR_BAD_PARAMETER,
+ COGL_TEXTURE_ERROR_TYPE
} CoglTextureError;
GQuark cogl_texture_error_quark (void);
diff --git a/cogl/cogl.h b/cogl/cogl.h
index 3367360..aa32948 100644
--- a/cogl/cogl.h
+++ b/cogl/cogl.h
@@ -80,6 +80,7 @@ typedef struct _CoglFramebuffer CoglFramebuffer;
#include <cogl/cogl-euler.h>
#include <cogl/cogl-quaternion.h>
#include <cogl/cogl-texture-2d.h>
+#include <cogl/cogl-texture-rectangle.h>
#include <cogl/cogl-texture-3d.h>
#include <cogl/cogl-texture-2d-sliced.h>
#include <cogl/cogl-meta-texture.h>
diff --git a/cogl/winsys/cogl-texture-pixmap-x11.c b/cogl/winsys/cogl-texture-pixmap-x11.c
index 76ad7fe..caacc90 100644
--- a/cogl/winsys/cogl-texture-pixmap-x11.c
+++ b/cogl/winsys/cogl-texture-pixmap-x11.c
@@ -785,7 +785,7 @@ _cogl_texture_pixmap_x11_foreach_sub_texture_in_region
* CoglTextureRectangle texture which uses un-normalized texture
* coordinates but we want to consistently deal with normalized
* texture coordinates with CoglTexturePixmapX11... */
- if (_cogl_is_texture_rectangle (child_tex))
+ if (cogl_is_texture_rectangle (child_tex))
{
NormalizeCoordsWrapperData data;
int width = tex_pixmap->width;
diff --git a/cogl/winsys/cogl-winsys-glx.c b/cogl/winsys/cogl-winsys-glx.c
index 61af5fd..dec96a1 100644
--- a/cogl/winsys/cogl-winsys-glx.c
+++ b/cogl/winsys/cogl-winsys-glx.c
@@ -1923,6 +1923,7 @@ _cogl_winsys_texture_pixmap_x11_update (CoglTexturePixmapX11 *tex_pixmap,
if (glx_tex_pixmap->glx_tex == COGL_INVALID_HANDLE)
{
CoglPixelFormat texture_format;
+ GError *error = NULL;
texture_format = (tex_pixmap->depth >= 32 ?
COGL_PIXEL_FORMAT_RGBA_8888_PRE :
@@ -1931,10 +1932,11 @@ _cogl_winsys_texture_pixmap_x11_update (CoglTexturePixmapX11 *tex_pixmap,
if (should_use_rectangle (ctx))
{
glx_tex_pixmap->glx_tex =
- _cogl_texture_rectangle_new_with_size (tex_pixmap->width,
- tex_pixmap->height,
- COGL_TEXTURE_NO_ATLAS,
- texture_format);
+ cogl_texture_rectangle_new_with_size (ctx,
+ tex_pixmap->width,
+ tex_pixmap->height,
+ texture_format,
+ &error);
if (glx_tex_pixmap->glx_tex)
COGL_NOTE (TEXTURE_PIXMAP, "Created a texture rectangle for %p",
@@ -1942,8 +1944,9 @@ _cogl_winsys_texture_pixmap_x11_update (CoglTexturePixmapX11 *tex_pixmap,
else
{
COGL_NOTE (TEXTURE_PIXMAP, "Falling back for %p because a "
- "texture rectangle could not be created",
- tex_pixmap);
+ "texture rectangle could not be created: %s",
+ tex_pixmap, error->message);
+ g_error_free (error);
free_glx_pixmap (ctx, glx_tex_pixmap);
return FALSE;
}
diff --git a/doc/reference/cogl-2.0-experimental/cogl-2.0-experimental-sections.txt b/doc/reference/cogl-2.0-experimental/cogl-2.0-experimental-sections.txt
index d97ddcc..f26fc4f 100644
--- a/doc/reference/cogl-2.0-experimental/cogl-2.0-experimental-sections.txt
+++ b/doc/reference/cogl-2.0-experimental/cogl-2.0-experimental-sections.txt
@@ -305,6 +305,13 @@ COGL_TEXTURE_MAX_WASTE
</SECTION>
<SECTION>
+<FILE>cogl-texture-rectangle</FILE>
+<TITLE>Rectangle textures (non-normalized coordinates)</TITLE>
+cogl_texture_rectangle_new_with_size
+cogl_is_texture_rectangle
+</SECTION>
+
+<SECTION>
<FILE>cogl-texture-3d</FILE>
<TITLE>3D textures</TITLE>
cogl_texture_3d_new_with_size
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
