2008-04-25 09:37:36 -04:00
|
|
|
/*
|
2009-04-27 10:48:12 -04:00
|
|
|
* Cogl
|
2008-04-25 09:37:36 -04:00
|
|
|
*
|
2009-04-27 10:48:12 -04:00
|
|
|
* An object oriented GL/GLES Abstraction/Utility Layer
|
2008-04-25 09:37:36 -04:00
|
|
|
*
|
2009-04-27 10:48:12 -04:00
|
|
|
* Copyright (C) 2007,2008,2009 Intel Corporation.
|
2008-04-25 09:37:36 -04:00
|
|
|
*
|
|
|
|
* 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
|
2010-03-01 07:56:10 -05:00
|
|
|
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*
|
|
|
|
*
|
2008-04-25 09:37:36 -04:00
|
|
|
*/
|
|
|
|
|
2009-07-27 19:37:11 -04:00
|
|
|
#ifndef __COGL_TEXTURE_PRIVATE_H
|
|
|
|
#define __COGL_TEXTURE_PRIVATE_H
|
2008-04-25 09:37:36 -04:00
|
|
|
|
2009-04-30 13:00:22 -04:00
|
|
|
#include "cogl-bitmap-private.h"
|
2009-04-01 12:16:44 -04:00
|
|
|
#include "cogl-handle.h"
|
[cogl] Improving Cogl journal to minimize driver overheads + GPU state changes
Previously the journal was always flushed at the end of
_cogl_rectangles_with_multitexture_coords, (i.e. the end of any
cogl_rectangle* calls) but now we have broadened the potential for batching
geometry. In ideal circumstances we will only flush once per scene.
In summary the journal works like this:
When you use any of the cogl_rectangle* APIs then nothing is emitted to the
GPU at this point, we just log one or more quads into the journal. A
journal entry consists of the quad coordinates, an associated material
reference, and a modelview matrix. Ideally the journal only gets flushed
once at the end of a scene, but in fact there are things to consider that
may cause unwanted flushing, including:
- modifying materials mid-scene
This is because each quad in the journal has an associated material
reference (i.e. not copy), so if you try and modify a material that is
already referenced in the journal we force a flush first)
NOTE: For now this means you should avoid using cogl_set_source_color()
since that currently uses a single shared material. Later we
should change it to use a pool of materials that is recycled
when the journal is flushed.
- modifying any state that isn't currently logged, such as depth, fog and
backface culling enables.
The first thing that happens when flushing, is to upload all the vertex data
associated with the journal into a single VBO.
We then go through a process of splitting up the journal into batches that
have compatible state so they can be emitted to the GPU together. This is
currently broken up into 3 levels so we can stagger the state changes:
1) we break the journal up according to changes in the number of material layers
associated with logged quads. The number of layers in a material determines
the stride of the associated vertices, so we have to update our vertex
array offsets at this level. (i.e. calling gl{Vertex,Color},Pointer etc)
2) we further split batches up according to material compatability. (e.g.
materials with different textures) We flush material state at this level.
3) Finally we split batches up according to modelview changes. At this level
we update the modelview matrix and actually emit the actual draw command.
This commit is largely about putting the initial design in-place; this will be
followed by other changes that take advantage of the extended batching.
2009-06-17 13:46:42 -04:00
|
|
|
#include "cogl-material-private.h"
|
2008-04-25 09:37:36 -04:00
|
|
|
|
2009-08-30 06:36:11 -04:00
|
|
|
#define COGL_TEXTURE(tex) ((CoglTexture *)(tex))
|
2008-04-25 09:37:36 -04:00
|
|
|
|
2009-11-26 12:32:52 -05:00
|
|
|
typedef struct _CoglTexture CoglTexture;
|
|
|
|
typedef struct _CoglTextureVtable CoglTextureVtable;
|
2008-04-25 09:37:36 -04:00
|
|
|
|
2009-09-16 06:56:17 -04:00
|
|
|
typedef void (*CoglTextureSliceCallback) (CoglHandle handle,
|
|
|
|
GLuint gl_handle,
|
|
|
|
GLenum gl_target,
|
2009-12-02 12:17:24 -05:00
|
|
|
const float *slice_coords,
|
|
|
|
const float *virtual_coords,
|
2009-09-16 06:56:17 -04:00
|
|
|
void *user_data);
|
|
|
|
|
2009-12-02 08:41:49 -05:00
|
|
|
typedef void (* CoglTextureManualRepeatCallback) (const float *coords,
|
|
|
|
void *user_data);
|
|
|
|
|
2010-03-01 16:49:04 -05:00
|
|
|
/* Encodes three possibiloities result of transforming a quad */
|
|
|
|
typedef enum {
|
|
|
|
/* quad doesn't cross the boundaries of a texture */
|
|
|
|
COGL_TRANSFORM_NO_REPEAT,
|
|
|
|
/* quad crosses boundaries, hardware wrap mode can handle */
|
|
|
|
COGL_TRANSFORM_HARDWARE_REPEAT,
|
|
|
|
/* quad crosses boundaries, needs software fallback;
|
|
|
|
* for a sliced texture, this might not actually involve
|
|
|
|
* repeating, just a quad crossing multiple slices */
|
|
|
|
COGL_TRANSFORM_SOFTWARE_REPEAT,
|
|
|
|
} CoglTransformResult;
|
|
|
|
|
2010-06-09 12:39:59 -04:00
|
|
|
/* Flags given to the pre_paint method */
|
|
|
|
typedef enum {
|
|
|
|
/* The texture is going to be used with filters that require
|
|
|
|
mipmapping. This gives the texture the opportunity to
|
|
|
|
automatically update the mipmap tree */
|
|
|
|
COGL_TEXTURE_NEEDS_MIPMAP = 1
|
|
|
|
} CoglTexturePrePaintFlags;
|
|
|
|
|
2009-11-25 08:39:45 -05:00
|
|
|
struct _CoglTextureVtable
|
|
|
|
{
|
|
|
|
/* Virtual functions that must be implemented for a texture
|
|
|
|
backend */
|
|
|
|
|
2010-07-08 10:15:22 -04:00
|
|
|
/* This should update the specified sub region of the texture with a
|
|
|
|
sub region of the given bitmap. The bitmap will have first been
|
|
|
|
converted to a suitable format for uploading if neccessary. */
|
2009-11-25 08:39:45 -05:00
|
|
|
gboolean (* set_region) (CoglTexture *tex,
|
|
|
|
int src_x,
|
|
|
|
int src_y,
|
|
|
|
int dst_x,
|
|
|
|
int dst_y,
|
|
|
|
unsigned int dst_width,
|
|
|
|
unsigned int dst_height,
|
2010-07-08 10:15:22 -04:00
|
|
|
CoglBitmap *bitmap);
|
2009-11-25 08:39:45 -05:00
|
|
|
|
2010-07-08 08:54:37 -04:00
|
|
|
/* This should copy the image data of the texture into @data. The
|
|
|
|
requested format will have been first passed through
|
|
|
|
_cogl_texture_driver_find_best_gl_get_data_format so it should
|
|
|
|
always be a format that is valid for GL (ie, no conversion should
|
|
|
|
be necessary). */
|
|
|
|
gboolean (* get_data) (CoglTexture *tex,
|
|
|
|
CoglPixelFormat format,
|
|
|
|
unsigned int rowstride,
|
|
|
|
guint8 *data);
|
2009-11-25 08:39:45 -05:00
|
|
|
|
|
|
|
void (* foreach_sub_texture_in_region) (CoglTexture *tex,
|
|
|
|
float virtual_tx_1,
|
|
|
|
float virtual_ty_1,
|
|
|
|
float virtual_tx_2,
|
|
|
|
float virtual_ty_2,
|
|
|
|
CoglTextureSliceCallback callback,
|
|
|
|
void *user_data);
|
|
|
|
|
cogl: improves header and coding style consistency
We've had complaints that our Cogl code/headers are a bit "special" so
this is a first pass at tidying things up by giving them some
consistency. These changes are all consistent with how new code in Cogl
is being written, but the style isn't consistently applied across all
code yet.
There are two parts to this patch; but since each one required a large
amount of effort to maintain tidy indenting it made sense to combine the
changes to reduce the time spent re indenting the same lines.
The first change is to use a consistent style for declaring function
prototypes in headers. Cogl headers now consistently use this style for
prototypes:
return_type
cogl_function_name (CoglType arg0,
CoglType arg1);
Not everyone likes this style, but it seems that most of the currently
active Cogl developers agree on it.
The second change is to constrain the use of redundant glib data types
in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all
been replaced with int, unsigned int, float, long, unsigned long and char
respectively. When talking about pixel data; use of guchar has been
replaced with guint8, otherwise unsigned char can be used.
The glib types that we continue to use for portability are gboolean,
gint{8,16,32,64}, guint{8,16,32,64} and gsize.
The general intention is that Cogl should look palatable to the widest
range of C programmers including those outside the Gnome community so
- especially for the public API - we want to minimize the number of
foreign looking typedefs.
2010-02-09 20:57:32 -05:00
|
|
|
int (* get_max_waste) (CoglTexture *tex);
|
2009-11-25 08:39:45 -05:00
|
|
|
|
|
|
|
gboolean (* is_sliced) (CoglTexture *tex);
|
|
|
|
|
|
|
|
gboolean (* can_hardware_repeat) (CoglTexture *tex);
|
|
|
|
|
|
|
|
void (* transform_coords_to_gl) (CoglTexture *tex,
|
|
|
|
float *s,
|
|
|
|
float *t);
|
2010-03-01 16:49:04 -05:00
|
|
|
CoglTransformResult (* transform_quad_coords_to_gl) (CoglTexture *tex,
|
|
|
|
float *coords);
|
2009-11-25 08:39:45 -05:00
|
|
|
|
|
|
|
gboolean (* get_gl_texture) (CoglTexture *tex,
|
|
|
|
GLuint *out_gl_handle,
|
|
|
|
GLenum *out_gl_target);
|
|
|
|
|
|
|
|
void (* set_filters) (CoglTexture *tex,
|
|
|
|
GLenum min_filter,
|
|
|
|
GLenum mag_filter);
|
|
|
|
|
2010-06-09 12:39:59 -04:00
|
|
|
void (* pre_paint) (CoglTexture *tex, CoglTexturePrePaintFlags flags);
|
2010-01-18 04:22:04 -05:00
|
|
|
void (* ensure_non_quad_rendering) (CoglTexture *tex);
|
2009-11-25 08:39:45 -05:00
|
|
|
|
2010-03-25 13:29:22 -04:00
|
|
|
void (* set_wrap_mode_parameters) (CoglTexture *tex,
|
|
|
|
GLenum wrap_mode_s,
|
|
|
|
GLenum wrap_mode_t,
|
|
|
|
GLenum wrap_mode_r);
|
2009-11-26 13:58:17 -05:00
|
|
|
|
|
|
|
CoglPixelFormat (* get_format) (CoglTexture *tex);
|
|
|
|
GLenum (* get_gl_format) (CoglTexture *tex);
|
cogl: improves header and coding style consistency
We've had complaints that our Cogl code/headers are a bit "special" so
this is a first pass at tidying things up by giving them some
consistency. These changes are all consistent with how new code in Cogl
is being written, but the style isn't consistently applied across all
code yet.
There are two parts to this patch; but since each one required a large
amount of effort to maintain tidy indenting it made sense to combine the
changes to reduce the time spent re indenting the same lines.
The first change is to use a consistent style for declaring function
prototypes in headers. Cogl headers now consistently use this style for
prototypes:
return_type
cogl_function_name (CoglType arg0,
CoglType arg1);
Not everyone likes this style, but it seems that most of the currently
active Cogl developers agree on it.
The second change is to constrain the use of redundant glib data types
in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all
been replaced with int, unsigned int, float, long, unsigned long and char
respectively. When talking about pixel data; use of guchar has been
replaced with guint8, otherwise unsigned char can be used.
The glib types that we continue to use for portability are gboolean,
gint{8,16,32,64}, guint{8,16,32,64} and gsize.
The general intention is that Cogl should look palatable to the widest
range of C programmers including those outside the Gnome community so
- especially for the public API - we want to minimize the number of
foreign looking typedefs.
2010-02-09 20:57:32 -05:00
|
|
|
int (* get_width) (CoglTexture *tex);
|
|
|
|
int (* get_height) (CoglTexture *tex);
|
2010-04-26 05:01:43 -04:00
|
|
|
|
|
|
|
gboolean (* is_foreign) (CoglTexture *tex);
|
2009-11-25 08:39:45 -05:00
|
|
|
};
|
|
|
|
|
|
|
|
struct _CoglTexture
|
|
|
|
{
|
|
|
|
CoglHandleObject _parent;
|
|
|
|
const CoglTextureVtable *vtable;
|
|
|
|
};
|
|
|
|
|
2010-04-26 05:01:43 -04:00
|
|
|
typedef enum _CoglTextureChangeFlags
|
|
|
|
{
|
|
|
|
/* Whenever the internals of a texture are changed such that the
|
|
|
|
* underlying GL textures that represent the CoglTexture change then
|
|
|
|
* we notify cogl-material.c via
|
|
|
|
* _cogl_material_texture_pre_change_notify
|
|
|
|
*/
|
|
|
|
COGL_TEXTURE_CHANGE_GL_TEXTURES
|
|
|
|
|
|
|
|
} CoglTextureChangeFlags;
|
|
|
|
|
|
|
|
void
|
|
|
|
_cogl_texture_free (CoglTexture *texture);
|
|
|
|
|
2010-06-11 08:50:36 -04:00
|
|
|
/* This is used to register a type to the list of handle types that
|
|
|
|
will be considered a texture in cogl_is_texture() */
|
|
|
|
void
|
|
|
|
_cogl_texture_register_texture_type (GQuark type);
|
|
|
|
|
|
|
|
#define COGL_TEXTURE_DEFINE(TypeName, type_name) \
|
|
|
|
COGL_HANDLE_DEFINE_WITH_CODE \
|
|
|
|
(TypeName, type_name, \
|
|
|
|
_cogl_texture_register_texture_type (_cogl_handle_ \
|
|
|
|
## type_name ## _get_type ()))
|
|
|
|
|
2009-03-23 08:29:15 -04:00
|
|
|
void
|
2009-09-16 06:56:17 -04:00
|
|
|
_cogl_texture_foreach_sub_texture_in_region (CoglHandle handle,
|
|
|
|
float virtual_tx_1,
|
|
|
|
float virtual_ty_1,
|
|
|
|
float virtual_tx_2,
|
|
|
|
float virtual_ty_2,
|
|
|
|
CoglTextureSliceCallback callback,
|
|
|
|
void *user_data);
|
|
|
|
|
|
|
|
gboolean
|
|
|
|
_cogl_texture_can_hardware_repeat (CoglHandle handle);
|
|
|
|
|
|
|
|
void
|
|
|
|
_cogl_texture_transform_coords_to_gl (CoglHandle handle,
|
|
|
|
float *s,
|
|
|
|
float *t);
|
2010-03-01 16:49:04 -05:00
|
|
|
CoglTransformResult
|
2010-01-18 04:22:04 -05:00
|
|
|
_cogl_texture_transform_quad_coords_to_gl (CoglHandle handle,
|
|
|
|
float *coords);
|
|
|
|
|
2009-09-16 06:56:17 -04:00
|
|
|
GLenum
|
2009-11-26 13:58:17 -05:00
|
|
|
_cogl_texture_get_gl_format (CoglHandle handle);
|
2009-09-16 06:56:17 -04:00
|
|
|
|
|
|
|
void
|
2010-03-25 13:29:22 -04:00
|
|
|
_cogl_texture_set_wrap_mode_parameters (CoglHandle handle,
|
|
|
|
GLenum wrap_mode_s,
|
|
|
|
GLenum wrap_mode_t,
|
|
|
|
GLenum wrap_mode_r);
|
|
|
|
|
2009-03-23 08:29:15 -04:00
|
|
|
|
2009-06-04 11:04:57 -04:00
|
|
|
void
|
|
|
|
_cogl_texture_set_filters (CoglHandle handle,
|
|
|
|
GLenum min_filter,
|
|
|
|
GLenum mag_filter);
|
|
|
|
|
|
|
|
void
|
2010-06-09 12:39:59 -04:00
|
|
|
_cogl_texture_pre_paint (CoglHandle handle, CoglTexturePrePaintFlags flags);
|
2009-06-04 11:04:57 -04:00
|
|
|
|
2010-01-18 04:22:04 -05:00
|
|
|
void
|
|
|
|
_cogl_texture_ensure_non_quad_rendering (CoglHandle handle);
|
|
|
|
|
2010-02-03 17:54:44 -05:00
|
|
|
/* Utility function to determine which pixel format to use when
|
|
|
|
dst_format is COGL_PIXEL_FORMAT_ANY. If dst_format is not ANY then
|
|
|
|
it will just be returned directly */
|
|
|
|
CoglPixelFormat
|
|
|
|
_cogl_texture_determine_internal_format (CoglPixelFormat src_format,
|
|
|
|
CoglPixelFormat dst_format);
|
|
|
|
|
2010-02-01 07:11:58 -05:00
|
|
|
/* Utility function to help uploading a bitmap. If the bitmap needs
|
|
|
|
premult conversion then it will be copied and *copied_bitmap will
|
|
|
|
be set to TRUE. Otherwise dst_bmp will be set to a shallow copy of
|
|
|
|
src_bmp. The GLenums needed for uploading are returned */
|
2009-11-27 13:45:36 -05:00
|
|
|
|
2009-08-30 06:36:11 -04:00
|
|
|
gboolean
|
2010-02-01 07:11:58 -05:00
|
|
|
_cogl_texture_prepare_for_upload (CoglBitmap *src_bmp,
|
|
|
|
CoglPixelFormat dst_format,
|
|
|
|
CoglPixelFormat *dst_format_out,
|
|
|
|
CoglBitmap *dst_bmp,
|
|
|
|
gboolean *copied_bitmap,
|
|
|
|
GLenum *out_glintformat,
|
|
|
|
GLenum *out_glformat,
|
|
|
|
GLenum *out_gltype);
|
2009-08-30 06:36:11 -04:00
|
|
|
|
2009-07-27 19:37:11 -04:00
|
|
|
void
|
|
|
|
_cogl_texture_prep_gl_alignment_for_pixels_upload (int pixels_rowstride);
|
|
|
|
|
|
|
|
void
|
|
|
|
_cogl_texture_prep_gl_alignment_for_pixels_download (int pixels_rowstride);
|
|
|
|
|
2009-12-02 08:41:49 -05:00
|
|
|
/* Utility function for implementing manual repeating. Even texture
|
|
|
|
backends that always support hardware repeating need this because
|
|
|
|
when foreach_sub_texture_in_region is invoked Cogl will set the
|
|
|
|
wrap mode to GL_CLAMP_TO_EDGE so hardware repeating can't be
|
|
|
|
done */
|
|
|
|
void
|
|
|
|
_cogl_texture_iterate_manual_repeats (CoglTextureManualRepeatCallback callback,
|
|
|
|
float tx_1, float ty_1,
|
|
|
|
float tx_2, float ty_2,
|
|
|
|
void *user_data);
|
|
|
|
|
2009-11-26 12:32:52 -05:00
|
|
|
/* Utility function to use as a fallback for getting the data of any
|
|
|
|
texture via the framebuffer */
|
|
|
|
|
2009-08-30 06:36:11 -04:00
|
|
|
gboolean
|
2009-11-26 12:32:52 -05:00
|
|
|
_cogl_texture_draw_and_read (CoglHandle handle,
|
2009-08-30 06:36:11 -04:00
|
|
|
CoglBitmap *target_bmp,
|
|
|
|
GLuint target_gl_format,
|
|
|
|
GLuint target_gl_type);
|
|
|
|
|
2010-04-26 05:01:43 -04:00
|
|
|
gboolean
|
|
|
|
_cogl_texture_is_foreign (CoglHandle handle);
|
|
|
|
|
2010-07-08 10:15:22 -04:00
|
|
|
gboolean
|
|
|
|
_cogl_texture_set_region_from_bitmap (CoglHandle handle,
|
|
|
|
int src_x,
|
|
|
|
int src_y,
|
|
|
|
int dst_x,
|
|
|
|
int dst_y,
|
|
|
|
unsigned int dst_width,
|
|
|
|
unsigned int dst_height,
|
|
|
|
CoglBitmap *bmp);
|
|
|
|
|
2009-07-27 19:37:11 -04:00
|
|
|
#endif /* __COGL_TEXTURE_PRIVATE_H */
|