4
* An object oriented GL/GLES Abstraction/Utility Layer
6
* Copyright (C) 2007,2008,2009 Intel Corporation.
8
* This library is free software; you can redistribute it and/or
9
* modify it under the terms of the GNU Lesser General Public
10
* License as published by the Free Software Foundation; either
11
* version 2 of the License, or (at your option) any later version.
13
* This library is distributed in the hope that it will be useful,
14
* but WITHOUT ANY WARRANTY; without even the implied warranty of
15
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16
* Lesser General Public License for more details.
18
* You should have received a copy of the GNU Lesser General Public
19
* License along with this library; if not, write to the
20
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21
* Boston, MA 02111-1307, USA.
24
#if !defined(__COGL_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
25
#error "Only <cogl/cogl.h> can be included directly."
28
#ifndef __COGL_TEXTURE_H__
29
#define __COGL_TEXTURE_H__
31
#include <cogl/cogl-types.h>
36
* SECTION:cogl-texture
37
* @short_description: Fuctions for creating and manipulating textures
39
* COGL allows creating and manipulating GL textures using a uniform
40
* API that tries to hide all the various complexities of creating,
41
* loading and manipulating textures.
44
#define COGL_TEXTURE_MAX_WASTE 127
47
* cogl_texture_new_with_size:
48
* @width: width of texture in pixels.
49
* @height: height of texture in pixels.
50
* @flags: Optional flags for the texture, or %COGL_TEXTURE_NONE
51
* @internal_format: the #CoglPixelFormat to use for the GPU storage of the
54
* Creates a new COGL texture with the specified dimensions and pixel format.
56
* Return value: a #CoglHandle to the newly created texture or
57
* %COGL_INVALID_HANDLE on failure
61
CoglHandle cogl_texture_new_with_size (guint width,
63
CoglTextureFlags flags,
64
CoglPixelFormat internal_format);
67
* cogl_texture_new_from_file:
68
* @filename: the file to load
69
* @flags: Optional flags for the texture, or %COGL_TEXTURE_NONE
70
* @internal_format: the #CoglPixelFormat to use for the GPU storage of the
71
* texture. If COGL_PIXEL_FORMAT_ANY is given then a premultiplied
72
* format similar to the format of the source data will be used. The
73
* default blending equations of Cogl expect premultiplied color data;
74
* the main use of passing a non-premultiplied format here is if you
75
* have non-premultiplied source data and are going to adjust the blend
76
* mode (see cogl_material_set_blend()) or use the data for something
77
* other than straight blending.
78
* @error: return location for a #GError or %NULL
80
* Creates a COGL texture from an image file.
82
* Return value: a #CoglHandle to the newly created texture or
83
* %COGL_INVALID_HANDLE on failure
87
CoglHandle cogl_texture_new_from_file (const gchar *filename,
88
CoglTextureFlags flags,
89
CoglPixelFormat internal_format,
93
* cogl_texture_new_from_data:
94
* @width: width of texture in pixels
95
* @height: height of texture in pixels
96
* @flags: Optional flags for the texture, or %COGL_TEXTURE_NONE
97
* @format: the #CoglPixelFormat the buffer is stored in in RAM
98
* @internal_format: the #CoglPixelFormat that will be used for storing
99
* the buffer on the GPU. If COGL_PIXEL_FORMAT_ANY is given then a
100
* premultiplied format similar to the format of the source data will
101
* be used. The default blending equations of Cogl expect premultiplied
102
* color data; the main use of passing a non-premultiplied format here
103
* is if you have non-premultiplied source data and are going to adjust
104
* the blend mode (see cogl_material_set_blend()) or use the data for
105
* something other than straight blending.
106
* @rowstride: the memory offset in bytes between the starts of
108
* @data: pointer the memory region where the source buffer resides
110
* Creates a new COGL texture based on data residing in memory.
112
* Return value: a #CoglHandle to the newly created texture or
113
* %COGL_INVALID_HANDLE on failure
117
CoglHandle cogl_texture_new_from_data (guint width,
119
CoglTextureFlags flags,
120
CoglPixelFormat format,
121
CoglPixelFormat internal_format,
126
* cogl_texture_new_from_foreign:
127
* @gl_handle: opengl target type of foreign texture
128
* @gl_target: opengl handle of foreign texture.
129
* @width: width of foreign texture
130
* @height: height of foreign texture.
131
* @x_pot_waste: maximum horizontal waste.
132
* @y_pot_waste: maximum vertical waste.
133
* @format: format of the foreign texture.
135
* Creates a COGL texture based on an existing OpenGL texture; the
136
* width, height and format are passed along since it is not possible
137
* to query this from a handle with GLES 1.0.
139
* Return value: a #CoglHandle to the newly created texture or
140
* %COGL_INVALID_HANDLE on failure
144
CoglHandle cogl_texture_new_from_foreign (GLuint gl_handle,
150
CoglPixelFormat format);
153
* cogl_texture_new_from_bitmap:
154
* @bmp_handle: A CoglBitmap handle
155
* @flags: Optional flags for the texture, or %COGL_TEXTURE_NONE
156
* @internal_format: the #CoglPixelFormat to use for the GPU storage of the
159
* Creates a COGL texture from a CoglBitmap.
161
* Return value: a #CoglHandle to the newly created texture or
162
* %COGL_INVALID_HANDLE on failure
166
CoglHandle cogl_texture_new_from_bitmap (CoglHandle bmp_handle,
167
CoglTextureFlags flags,
168
CoglPixelFormat internal_format);
172
* @handle: A CoglHandle
174
* Gets whether the given handle references an existing texture object.
176
* Returns: %TRUE if the handle references a texture,
179
gboolean cogl_is_texture (CoglHandle handle);
182
* cogl_texture_get_width:
183
* @handle: a #CoglHandle for a texture.
185
* Query the width of a cogl texture.
187
* Returns: the width of the GPU side texture in pixels:
189
guint cogl_texture_get_width (CoglHandle handle);
192
* cogl_texture_get_height:
193
* @handle: a #CoglHandle for a texture.
195
* Query the height of a cogl texture.
197
* Returns: the height of the GPU side texture in pixels:
199
guint cogl_texture_get_height (CoglHandle handle);
202
* cogl_texture_get_format:
203
* @handle: a #CoglHandle for a texture.
205
* Query the #CoglPixelFormat of a cogl texture.
207
* Returns: the #CoglPixelFormat of the GPU side texture.
209
CoglPixelFormat cogl_texture_get_format (CoglHandle handle);
213
* cogl_texture_get_rowstride:
214
* @handle: a #CoglHandle for a texture.
216
* Query the rowstride of a cogl texture.
218
* Returns: the offset in bytes between each consequetive row of pixels.
220
guint cogl_texture_get_rowstride (CoglHandle handle);
223
* cogl_texture_get_max_waste:
224
* @handle: a #CoglHandle for a texture.
226
* Query the maximum wasted (unused) pixels in one dimension of a GPU side
229
* Returns: the maximum waste.
231
gint cogl_texture_get_max_waste (CoglHandle handle);
234
* cogl_texture_is_sliced:
235
* @handle: a #CoglHandle for a texture.
237
* Query if a texture is sliced (stored as multiple GPU side tecture
240
* Returns: %TRUE if the texture is sliced, %FALSE if the texture
241
* is stored as a single GPU texture.
243
gboolean cogl_texture_is_sliced (CoglHandle handle);
246
* cogl_texture_get_gl_texture:
247
* @handle: a #CoglHandle for a texture.
248
* @out_gl_handle: (out) (allow-none): pointer to return location for the
249
* textures GL handle, or %NULL.
250
* @out_gl_target: (out) (allow-none): pointer to return location for the
251
* GL target type, or %NULL.
253
* Query the GL handles for a GPU side texture through it's #CoglHandle,
254
* if the texture is spliced the data for the first sub texture will be
257
* Returns: %TRUE if the handle was successfully retrieved %FALSE
258
* if the handle was invalid.
260
gboolean cogl_texture_get_gl_texture (CoglHandle handle,
261
GLuint *out_gl_handle,
262
GLenum *out_gl_target);
265
* cogl_texture_get_data:
266
* @handle: a #CoglHandle for a texture.
267
* @format: the #CoglPixelFormat to store the texture as.
268
* @rowstride: the rowstride of @data or retrieved from texture if none is
270
* @data: memory location to write contents of buffer, or %NULL if we're
271
* only querying the data size through the return value.
273
* Copy the pixel data from a cogl texture to system memory.
275
* Returns: the size of the texture data in bytes (or 0 if the texture
278
gint cogl_texture_get_data (CoglHandle handle,
279
CoglPixelFormat format,
284
* cogl_texture_set_region:
285
* @handle: a #CoglHandle.
286
* @src_x: upper left coordinate to use from source data.
287
* @src_y: upper left coordinate to use from source data.
288
* @dst_x: upper left destination horizontal coordinate.
289
* @dst_y: upper left destination vertical coordinate.
290
* @dst_width: width of destination region to write.
291
* @dst_height: height of destination region to write.
292
* @width: width of source data buffer.
293
* @height: height of source data buffer.
294
* @format: the #CoglPixelFormat used in the source buffer.
295
* @rowstride: rowstride of source buffer (computed from width if none
297
* @data: the actual pixel data.
299
* Sets the pixels in a rectangular subregion of @handle from an in-memory
300
* buffer containing pixel data.
302
* Returns: %TRUE if the subregion upload was successful, otherwise %FALSE.
304
gboolean cogl_texture_set_region (CoglHandle handle,
313
CoglPixelFormat format,
319
* @handle: a @CoglHandle.
321
* Increment the reference count for a cogl texture.
323
* Returns: the @handle.
325
CoglHandle cogl_texture_ref (CoglHandle handle);
328
* cogl_texture_unref:
329
* @handle: a @CoglHandle.
331
* Deccrement the reference count for a cogl texture.
333
void cogl_texture_unref (CoglHandle handle);
336
* cogl_rectangle_with_texture_coords:
337
* @x1: x coordinate upper left on screen.
338
* @y1: y coordinate upper left on screen.
339
* @x2: x coordinate lower right on screen.
340
* @y2: y coordinate lower right on screen.
341
* @tx1: x part of texture coordinate to use for upper left pixel
342
* @ty1: y part of texture coordinate to use for upper left pixel
343
* @tx2: x part of texture coordinate to use for lower right pixel
344
* @ty2: y part of texture coordinate to use for left pixel
346
* Draw a rectangle using the current material and supply texture coordinates
347
* to be used for the first texture layer of the material. To draw the entire
348
* texture pass in @tx1=0.0 @ty1=0.0 @tx2=1.0 @ty2=1.0.
352
void cogl_rectangle_with_texture_coords (float x1,
362
* cogl_rectangle_with_multitexture_coords:
363
* @x1: x coordinate upper left on screen.
364
* @y1: y coordinate upper left on screen.
365
* @x2: x coordinate lower right on screen.
366
* @y2: y coordinate lower right on screen.
367
* @tex_coords: (in) (array) (transfer none): An array containing groups of 4
368
* float values: [tx1, ty1, tx2, ty2] that are interpreted as two texture
369
* coordinates; one for the upper left texel, and one for the lower right
370
* texel. Each value should be between 0.0 and 1.0, where the coordinate
371
* (0.0, 0.0) represents the top left of the texture, and (1.0, 1.0) the
373
* @tex_coords_len: The length of the tex_coords array. (e.g. for one layer
374
* and one group of texture coordinates, this would be 4)
376
* This function draws a rectangle using the current source material to
377
* texture or fill with. As a material may contain multiple texture layers
378
* this interface lets you supply texture coordinates for each layer of the
381
* The first pair of coordinates are for the first layer (with the smallest
382
* layer index) and if you supply less texture coordinates than there are
383
* layers in the current source material then default texture coordinates
384
* (0.0, 0.0, 1.0, 1.0) are generated.
388
void cogl_rectangle_with_multitexture_coords (float x1,
392
const float *tex_coords,
393
gint tex_coords_len);
396
* cogl_rectangles_with_texture_coords:
397
* @verts: (in) (array) (transfer none): an array of vertices
398
* @n_rects: number of rectangles to draw
400
* Draws a series of rectangles in the same way that
401
* cogl_rectangle_with_texture_coords() does. In some situations it can give a
402
* significant performance boost to use this function rather than
403
* calling cogl_rectangle_with_texture_coords() separately for each rectangle.
405
* @verts should point to an array of #float<!-- -->s with
406
* @n_rects * 8 elements. Each group of 8 values corresponds to the
407
* parameters x1, y1, x2, y2, tx1, ty1, tx2 and ty2 and have the same
408
* meaning as in cogl_rectangle_with_texture_coords().
412
void cogl_rectangles_with_texture_coords (const float *verts,
417
* @verts: (in) (array) (transfer none): an array of vertices
418
* @n_rects: number of rectangles to draw
420
* Draws a series of rectangles in the same way that
421
* cogl_rectangle() does. In some situations it can give a
422
* significant performance boost to use this function rather than
423
* calling cogl_rectangle() separately for each rectangle.
425
* @verts should point to an array of #float<!-- -->s with
426
* @n_rects * 4 elements. Each group of 4 values corresponds to the
427
* parameters x1, y1, x2, and y2, and have the same
428
* meaning as in cogl_rectangle().
432
void cogl_rectangles (const float *verts,
438
* @vertices: An array of #CoglTextureVertex structs
439
* @n_vertices: The length of the vertices array
440
* @use_color: %TRUE if the color member of #CoglTextureVertex should be used
442
* Draws a convex polygon using the current source material to fill / texture
443
* with according to the texture coordinates passed.
445
* If @use_color is %TRUE then the color will be changed for each vertex using
446
* the value specified in the color member of #CoglTextureVertex. This can be
447
* used for example to make the texture fade out by setting the alpha value of
450
* All of the texture coordinates must be in the range [0,1] and repeating the
451
* texture is not supported.
453
* Because of the way this function is implemented it will currently only work
454
* if either the texture is not sliced or the backend is not OpenGL ES and the
455
* minifying and magnifying functions are both set to CGL_NEAREST.
459
void cogl_polygon (CoglTextureVertex *vertices,
465
#endif /* __COGL_TEXTURE_H__ */
added
removed
clutter/cogl/cogl-texture.h
