[cogl/wip/rib/master-next: 6/10] Add a strong CoglTexture type to replace CoglHandle
- From: Robert Bragg <rbragg src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [cogl/wip/rib/master-next: 6/10] Add a strong CoglTexture type to replace CoglHandle
- Date: Thu, 8 Sep 2011 12:06:06 +0000 (UTC)
commit 621ea75c58f84931ebe902db39bb8b291dc8423d
Author: Robert Bragg <robert linux intel com>
Date: Wed Aug 24 21:30:34 2011 +0100
Add a strong CoglTexture type to replace CoglHandle
As part of the on going, incremental effort to purge the non type safe
CoglHandle type from the Cogl API this patch tackles most of the
CoglHandle uses relating to textures.
We'd postponed making this change for quite a while because we wanted to
have a clearer understanding of how we wanted to evolve the texture APIs
towards Cogl 2.0 before exposing type safety here which would be
difficult to change later since it would imply breaking APIs.
The basic idea that we are steering towards now is that CoglTexture
can be considered to be the most primitive interface we have for any
object representing a texture. The texture interface would provide
roughly these methods:
cogl_texture_get_width
cogl_texture_get_height
cogl_texture_can_repeat
cogl_texture_can_mipmap
cogl_texture_generate_mipmap;
cogl_texture_get_format
cogl_texture_set_region
cogl_texture_get_region
Besides the texture interface we will then start to expose types
corresponding to specific texture types: CoglTexture2D,
CoglTexture3D, CoglTexture2DSliced, CoglSubTexture, CoglAtlasTexture and
CoglTexturePixmapX11.
We will then also expose an interface for the high-level texture types
we have (such as CoglTexture2DSlice, CoglSubTexture and
CoglAtlasTexture) called CoglMetaTexture. CoglMetaTexture is an
additional interface that lets you iterate a virtual region of a meta
texture and get mappings of primitive textures to sub-regions of that
virtual region. Internally we already have this kind of abstraction for
dealing with sliced texture, sub-textures and atlas textures in a
consistent way, so this will just make that abstraction public. The aim
here is to clarify that there is a difference between primitive textures
(CoglTexture2D/3D) and some of the other high-level textures, and also
enable developers to implement primitives that can support meta textures
since they can only be used with the cogl_rectangle API currently.
The thing that's not so clean-cut with this are the texture constructors
we have currently; such as cogl_texture_new_from_file which no longer
make sense when CoglTexture is considered to be an interface. These
will basically just become convenient factory functions and it's just a
bit unusual that they are within the cogl_texture namespace. It's worth
noting here that all the texture type APIs will also have their own type
specific constructors so these functions will only be used for the
convenience of being able to create a texture without really wanting to
know the details of what type of texture you need. Longer term for 2.0
we may come up with replacement names for these factory functions or the
other thing we are considering is designing some asynchronous factory
functions instead since it's so often detrimental to application
performance to be blocked waiting for a texture to be uploaded to the
GPU.
cogl-pango/cogl-pango-display-list.c | 10 +-
cogl-pango/cogl-pango-display-list.h | 2 +-
cogl-pango/cogl-pango-glyph-cache.c | 12 +-
cogl-pango/cogl-pango-glyph-cache.h | 22 +-
cogl-pango/cogl-pango-pipeline-cache.c | 8 +-
cogl-pango/cogl-pango-render.c | 6 +-
cogl/cogl-atlas-texture.c | 2 +-
cogl/cogl-attribute.c | 4 +-
cogl/cogl-context.c | 8 +-
cogl/cogl-framebuffer.c | 6 +-
cogl/cogl-journal-private.h | 2 +-
cogl/cogl-journal.c | 4 +-
cogl/cogl-pipeline-fragend-glsl.c | 2 +-
cogl/cogl-pipeline-opengl.c | 18 +-
cogl/cogl-pipeline-private.h | 16 +-
cogl/cogl-pipeline.c | 35 ++--
cogl/cogl-pipeline.h | 2 +-
cogl/cogl-primitives.c | 50 ++--
cogl/cogl-sub-texture.c | 4 +-
cogl/cogl-texture-2d-sliced.c | 4 +-
cogl/cogl-texture-private.h | 35 ++--
cogl/cogl-texture.c | 412 ++++++++++++--------------------
cogl/cogl-texture.h | 164 ++++++-------
cogl/cogl.c | 6 +-
cogl/cogl.h | 6 +-
cogl/cogl2-path.c | 4 +-
cogl/winsys/cogl-texture-pixmap-x11.c | 2 +-
cogl/winsys/cogl-winsys-egl.c | 8 +-
examples/crate.c | 2 +-
29 files changed, 368 insertions(+), 488 deletions(-)
---
diff --git a/cogl-pango/cogl-pango-display-list.c b/cogl-pango/cogl-pango-display-list.c
index be62dac..a6320d8 100644
--- a/cogl-pango/cogl-pango-display-list.c
+++ b/cogl-pango/cogl-pango-display-list.c
@@ -72,7 +72,7 @@ struct _CoglPangoDisplayListNode
struct
{
/* The texture to render these coords from */
- CoglHandle texture;
+ CoglTexture *texture;
/* Array of rectangles in the format expected by
cogl_rectangles_with_texture_coords */
GArray *rectangles;
@@ -134,7 +134,7 @@ _cogl_pango_display_list_remove_color_override (CoglPangoDisplayList *dl)
void
_cogl_pango_display_list_add_texture (CoglPangoDisplayList *dl,
- CoglHandle texture,
+ CoglTexture *texture,
float x_1, float y_1,
float x_2, float y_2,
float tx_1, float ty_1,
@@ -168,7 +168,7 @@ _cogl_pango_display_list_add_texture (CoglPangoDisplayList *dl,
node->color_override = dl->color_override;
node->color = dl->color;
node->pipeline = NULL;
- node->d.texture.texture = cogl_handle_ref (texture);
+ node->d.texture.texture = cogl_object_ref (texture);
node->d.texture.rectangles
= g_array_new (FALSE, FALSE, sizeof (CoglPangoDisplayListRectangle));
node->d.texture.primitive = NULL;
@@ -465,8 +465,8 @@ _cogl_pango_display_list_node_free (CoglPangoDisplayListNode *node)
if (node->type == COGL_PANGO_DISPLAY_LIST_TEXTURE)
{
g_array_free (node->d.texture.rectangles, TRUE);
- if (node->d.texture.texture != COGL_INVALID_HANDLE)
- cogl_handle_unref (node->d.texture.texture);
+ if (node->d.texture.texture != NULL)
+ cogl_object_unref (node->d.texture.texture);
if (node->d.texture.primitive != NULL)
cogl_object_unref (node->d.texture.primitive);
}
diff --git a/cogl-pango/cogl-pango-display-list.h b/cogl-pango/cogl-pango-display-list.h
index dd14edd..f98dbc8 100644
--- a/cogl-pango/cogl-pango-display-list.h
+++ b/cogl-pango/cogl-pango-display-list.h
@@ -39,7 +39,7 @@ void _cogl_pango_display_list_set_color_override (CoglPangoDisplayList *dl,
void _cogl_pango_display_list_remove_color_override (CoglPangoDisplayList *dl);
void _cogl_pango_display_list_add_texture (CoglPangoDisplayList *dl,
- CoglHandle texture,
+ CoglTexture *texture,
float x_1, float y_1,
float x_2, float y_2,
float tx_1, float ty_1,
diff --git a/cogl-pango/cogl-pango-glyph-cache.c b/cogl-pango/cogl-pango-glyph-cache.c
index bbcfe8f..317d826 100644
--- a/cogl-pango/cogl-pango-glyph-cache.c
+++ b/cogl-pango/cogl-pango-glyph-cache.c
@@ -71,7 +71,7 @@ static void
cogl_pango_glyph_cache_value_free (CoglPangoGlyphCacheValue *value)
{
if (value->texture)
- cogl_handle_unref (value->texture);
+ cogl_object_unref (value->texture);
g_slice_free (CoglPangoGlyphCacheValue, value);
}
@@ -178,8 +178,8 @@ cogl_pango_glyph_cache_update_position_cb (void *user_data,
float tex_width, tex_height;
if (value->texture)
- cogl_handle_unref (value->texture);
- value->texture = cogl_handle_ref (new_texture);
+ cogl_object_unref (value->texture);
+ value->texture = cogl_object_ref (new_texture);
tex_width = cogl_texture_get_width (new_texture);
tex_height = cogl_texture_get_height (new_texture);
@@ -202,7 +202,7 @@ cogl_pango_glyph_cache_add_to_global_atlas (CoglPangoGlyphCache *cache,
PangoGlyph glyph,
CoglPangoGlyphCacheValue *value)
{
- CoglHandle texture;
+ CoglTexture *texture;
if (COGL_DEBUG_ENABLED (COGL_DEBUG_DISABLE_SHARED_ATLAS))
return FALSE;
@@ -217,7 +217,7 @@ cogl_pango_glyph_cache_add_to_global_atlas (CoglPangoGlyphCache *cache,
COGL_TEXTURE_NONE,
COGL_PIXEL_FORMAT_RGBA_8888_PRE);
- if (texture == COGL_INVALID_HANDLE)
+ if (texture == NULL)
return FALSE;
value->texture = texture;
@@ -310,7 +310,7 @@ cogl_pango_glyph_cache_lookup (CoglPangoGlyphCache *cache,
PangoRectangle ink_rect;
value = g_slice_new (CoglPangoGlyphCacheValue);
- value->texture = COGL_INVALID_HANDLE;
+ value->texture = NULL;
pango_font_get_glyph_extents (font, glyph, &ink_rect, NULL);
pango_extents_to_pixels (&ink_rect, NULL);
diff --git a/cogl-pango/cogl-pango-glyph-cache.h b/cogl-pango/cogl-pango-glyph-cache.h
index 2020447..df6b632 100644
--- a/cogl-pango/cogl-pango-glyph-cache.h
+++ b/cogl-pango/cogl-pango-glyph-cache.h
@@ -35,20 +35,20 @@ typedef struct _CoglPangoGlyphCacheValue CoglPangoGlyphCacheValue;
struct _CoglPangoGlyphCacheValue
{
- CoglHandle texture;
+ CoglTexture *texture;
- float tx1;
- float ty1;
- float tx2;
- float ty2;
+ float tx1;
+ float ty1;
+ float tx2;
+ float ty2;
- int tx_pixel;
- int ty_pixel;
+ int tx_pixel;
+ int ty_pixel;
- int draw_x;
- int draw_y;
- int draw_width;
- int draw_height;
+ int draw_x;
+ int draw_y;
+ int draw_width;
+ int draw_height;
/* This will be set to TRUE when the glyph atlas is reorganized
which means the glyph will need to be redrawn */
diff --git a/cogl-pango/cogl-pango-pipeline-cache.c b/cogl-pango/cogl-pango-pipeline-cache.c
index 5f6a5a0..6733282 100644
--- a/cogl-pango/cogl-pango-pipeline-cache.c
+++ b/cogl-pango/cogl-pango-pipeline-cache.c
@@ -49,7 +49,7 @@ struct _CoglPangoPipelineCacheEntry
{
/* This will take a reference or it can be NULL to represent the
pipeline used to render colors */
- CoglHandle texture;
+ CoglTexture *texture;
/* This will only take a weak reference */
CoglHandle pipeline;
@@ -155,7 +155,7 @@ get_base_texture_alpha_pipeline (CoglPangoPipelineCache *cache)
typedef struct
{
CoglPangoPipelineCache *cache;
- CoglHandle texture;
+ CoglTexture *texture;
} PipelineDestroyNotifyData;
static void
@@ -188,7 +188,7 @@ _cogl_pango_pipeline_cache_get (CoglPangoPipelineCache *cache,
{
CoglPipeline *base;
- entry->texture = cogl_handle_ref (texture);
+ entry->texture = cogl_object_ref (texture);
if (cogl_texture_get_format (entry->texture) == COGL_PIXEL_FORMAT_A_8)
base = get_base_texture_alpha_pipeline (cache);
@@ -216,7 +216,7 @@ _cogl_pango_pipeline_cache_get (CoglPangoPipelineCache *cache,
pipeline_destroy_notify_cb);
g_hash_table_insert (cache->hash_table,
- texture ? cogl_handle_ref (texture) : NULL,
+ texture ? cogl_object_ref (texture) : NULL,
entry);
/* This doesn't take a reference on the pipeline so that it will use
diff --git a/cogl-pango/cogl-pango-render.c b/cogl-pango/cogl-pango-render.c
index 5c12741..9ffaf2b 100644
--- a/cogl-pango/cogl-pango-render.c
+++ b/cogl-pango/cogl-pango-render.c
@@ -94,7 +94,7 @@ typedef struct
} CoglPangoRendererSliceCbData;
void
-cogl_pango_renderer_slice_cb (CoglHandle handle,
+cogl_pango_renderer_slice_cb (CoglTexture *texture,
const float *slice_coords,
const float *virtual_coords,
void *user_data)
@@ -106,7 +106,7 @@ cogl_pango_renderer_slice_cb (CoglHandle handle,
coordinates based on the virtual_coords */
_cogl_pango_display_list_add_texture (data->display_list,
- handle,
+ texture,
data->x1,
data->y1,
data->x2,
@@ -486,7 +486,7 @@ cogl_pango_renderer_set_dirty_glyph (PangoFont *font,
/* Glyphs that don't take up any space will end up without a
texture. These should never become dirty so they shouldn't end up
here */
- g_return_if_fail (value->texture != COGL_INVALID_HANDLE);
+ g_return_if_fail (value->texture != NULL);
if (cogl_texture_get_format (value->texture) == COGL_PIXEL_FORMAT_A_8)
{
diff --git a/cogl/cogl-atlas-texture.c b/cogl/cogl-atlas-texture.c
index 08e1db9..042cd7b 100644
--- a/cogl/cogl-atlas-texture.c
+++ b/cogl/cogl-atlas-texture.c
@@ -384,7 +384,7 @@ _cogl_atlas_texture_migrate_out_of_atlas (CoglAtlasTexture *atlas_tex)
/* Notify cogl-pipeline.c that the texture's underlying GL texture
* storage is changing so it knows it may need to bind a new texture
* if the CoglTexture is reused with the same texture unit. */
- _cogl_pipeline_texture_storage_change_notify (atlas_tex);
+ _cogl_pipeline_texture_storage_change_notify (COGL_TEXTURE (atlas_tex));
/* We need to unref the sub texture after doing the copy because
the copy can involve rendering which might cause the texture
diff --git a/cogl/cogl-attribute.c b/cogl/cogl-attribute.c
index b6e9957..6637737 100644
--- a/cogl/cogl-attribute.c
+++ b/cogl/cogl-attribute.c
@@ -338,14 +338,14 @@ validate_layer_cb (CoglPipeline *pipeline,
int layer_index,
void *user_data)
{
- CoglHandle texture =
+ CoglTexture *texture =
_cogl_pipeline_get_layer_texture (pipeline, layer_index);
ValidateLayerState *state = user_data;
gboolean status = TRUE;
/* invalid textures will be handled correctly in
* _cogl_pipeline_flush_layers_gl_state */
- if (texture == COGL_INVALID_HANDLE)
+ if (texture == NULL)
goto validated;
_cogl_texture_flush_journal_rendering (texture);
diff --git a/cogl/cogl-context.c b/cogl/cogl-context.c
index 02f05a6..7407ccb 100644
--- a/cogl/cogl-context.c
+++ b/cogl/cogl-context.c
@@ -244,8 +244,8 @@ cogl_context_new (CoglDisplay *display,
context->legacy_state_set = 0;
- context->default_gl_texture_2d_tex = COGL_INVALID_HANDLE;
- context->default_gl_texture_rect_tex = COGL_INVALID_HANDLE;
+ context->default_gl_texture_2d_tex = NULL;
+ context->default_gl_texture_rect_tex = NULL;
context->framebuffers = NULL;
@@ -405,9 +405,9 @@ _cogl_context_free (CoglContext *context)
cogl_handle_unref (context->current_path);
if (context->default_gl_texture_2d_tex)
- cogl_handle_unref (context->default_gl_texture_2d_tex);
+ cogl_object_unref (context->default_gl_texture_2d_tex);
if (context->default_gl_texture_rect_tex)
- cogl_handle_unref (context->default_gl_texture_rect_tex);
+ cogl_object_unref (context->default_gl_texture_rect_tex);
if (context->opaque_color_pipeline)
cogl_handle_unref (context->opaque_color_pipeline);
diff --git a/cogl/cogl-framebuffer.c b/cogl/cogl-framebuffer.c
index c42a16a..5516e90 100644
--- a/cogl/cogl-framebuffer.c
+++ b/cogl/cogl-framebuffer.c
@@ -733,7 +733,7 @@ _cogl_offscreen_new_to_texture_full (CoglHandle texhandle,
}
offscreen = g_new0 (CoglOffscreen, 1);
- offscreen->texture = cogl_handle_ref (texhandle);
+ offscreen->texture = cogl_object_ref (texhandle);
offscreen->texture_level = level;
offscreen->texture_level_width = level_width;
offscreen->texture_level_height = level_height;
@@ -778,8 +778,8 @@ _cogl_offscreen_free (CoglOffscreen *offscreen)
GE (ctx, glDeleteFramebuffers (1, &offscreen->fbo_handle));
- if (offscreen->texture != COGL_INVALID_HANDLE)
- cogl_handle_unref (offscreen->texture);
+ if (offscreen->texture != NULL)
+ cogl_object_unref (offscreen->texture);
g_free (offscreen);
}
diff --git a/cogl/cogl-journal-private.h b/cogl/cogl-journal-private.h
index 6eb7a2d..9befcd4 100644
--- a/cogl/cogl-journal-private.h
+++ b/cogl/cogl-journal-private.h
@@ -76,7 +76,7 @@ _cogl_journal_log_quad (CoglJournal *journal,
const float *position,
CoglPipeline *pipeline,
int n_layers,
- CoglHandle layer0_override_texture,
+ CoglTexture *layer0_override_texture,
const float *tex_coords,
unsigned int tex_coords_len);
diff --git a/cogl/cogl-journal.c b/cogl/cogl-journal.c
index c58328c..2ebc3da 100644
--- a/cogl/cogl-journal.c
+++ b/cogl/cogl-journal.c
@@ -1445,7 +1445,7 @@ static gboolean
add_framebuffer_deps_cb (CoglPipelineLayer *layer, void *user_data)
{
CoglFramebuffer *framebuffer = user_data;
- CoglHandle texture = _cogl_pipeline_layer_get_texture_real (layer);
+ CoglTexture *texture = _cogl_pipeline_layer_get_texture_real (layer);
const GList *l;
if (!texture)
@@ -1462,7 +1462,7 @@ _cogl_journal_log_quad (CoglJournal *journal,
const float *position,
CoglPipeline *pipeline,
int n_layers,
- CoglHandle layer0_override_texture,
+ CoglTexture *layer0_override_texture,
const float *tex_coords,
unsigned int tex_coords_len)
{
diff --git a/cogl/cogl-pipeline-fragend-glsl.c b/cogl/cogl-pipeline-fragend-glsl.c
index 48e523b..a7a21e3 100644
--- a/cogl/cogl-pipeline-fragend-glsl.c
+++ b/cogl/cogl-pipeline-fragend-glsl.c
@@ -366,7 +366,7 @@ ensure_texture_lookup_generated (CoglPipelineShaderState *shader_state,
texture = _cogl_pipeline_layer_get_texture (layer);
- if (texture == COGL_INVALID_HANDLE)
+ if (texture == NULL)
{
target_string = "2D";
tex_coord_swizzle = "st";
diff --git a/cogl/cogl-pipeline-opengl.c b/cogl/cogl-pipeline-opengl.c
index 28693e6..523ebf4 100644
--- a/cogl/cogl-pipeline-opengl.c
+++ b/cogl/cogl-pipeline-opengl.c
@@ -217,7 +217,7 @@ _cogl_delete_gl_texture (GLuint gl_texture)
* if it is reused again with the same texture unit.
*/
void
-_cogl_pipeline_texture_storage_change_notify (CoglHandle texture)
+_cogl_pipeline_texture_storage_change_notify (CoglTexture *texture)
{
int i;
@@ -729,11 +729,11 @@ flush_layers_common_gl_state_cb (CoglPipelineLayer *layer, void *user_data)
unsigned long state = COGL_PIPELINE_LAYER_STATE_TEXTURE_DATA;
CoglPipelineLayer *authority =
_cogl_pipeline_layer_get_authority (layer, state);
- CoglHandle texture;
- GLuint gl_texture;
- GLenum gl_target;
+ CoglTexture *texture;
+ GLuint gl_texture;
+ GLenum gl_target;
- texture = (authority->texture == COGL_INVALID_HANDLE ?
+ texture = (authority->texture == NULL ?
ctx->default_gl_texture_2d_tex :
authority->texture);
@@ -845,12 +845,12 @@ _cogl_pipeline_flush_common_gl_state (CoglPipeline *pipeline,
*/
static void
_cogl_pipeline_layer_forward_wrap_modes (CoglPipelineLayer *layer,
- CoglHandle texture)
+ CoglTexture *texture)
{
CoglPipelineWrapModeInternal wrap_mode_s, wrap_mode_t, wrap_mode_p;
GLenum gl_wrap_mode_s, gl_wrap_mode_t, gl_wrap_mode_p;
- if (texture == COGL_INVALID_HANDLE)
+ if (texture == NULL)
return;
_cogl_pipeline_layer_get_wrap_modes (layer,
@@ -912,9 +912,9 @@ foreach_texture_unit_update_filter_and_wrap_modes (void)
if (unit->layer)
{
- CoglHandle texture = _cogl_pipeline_layer_get_texture (unit->layer);
+ CoglTexture *texture = _cogl_pipeline_layer_get_texture (unit->layer);
- if (texture != COGL_INVALID_HANDLE)
+ if (texture != NULL)
{
CoglPipelineFilter min;
CoglPipelineFilter mag;
diff --git a/cogl/cogl-pipeline-private.h b/cogl/cogl-pipeline-private.h
index 6e8fc35..a995eb6 100644
--- a/cogl/cogl-pipeline-private.h
+++ b/cogl/cogl-pipeline-private.h
@@ -387,9 +387,9 @@ struct _CoglPipelineLayer
/* Each layer is directly associated with a single texture unit */
int unit_index;
- /* The texture for this layer, or COGL_INVALID_HANDLE for an empty
+ /* The texture for this layer, or NULL for an empty
* layer */
- CoglHandle texture;
+ CoglTexture *texture;
GLenum target;
CoglPipelineFilter mag_filter;
@@ -913,7 +913,7 @@ typedef struct _CoglPipelineFlushOptions
guint32 fallback_layers;
guint32 disable_layers;
- CoglHandle layer0_override_texture;
+ CoglTexture *layer0_override_texture;
} CoglPipelineFlushOptions;
void
@@ -1109,7 +1109,7 @@ _cogl_pipeline_get_layer_matrix (CoglPipeline *pipeline,
int layer_index);
void
-_cogl_pipeline_texture_storage_change_notify (CoglHandle texture);
+_cogl_pipeline_texture_storage_change_notify (CoglTexture *texture);
void
_cogl_pipeline_apply_legacy_state (CoglPipeline *pipeline);
@@ -1141,7 +1141,7 @@ _cogl_pipeline_find_equivalent_parent (CoglPipeline *pipeline,
CoglPipelineState pipeline_state,
CoglPipelineLayerState layer_state);
-CoglHandle
+CoglTexture *
_cogl_pipeline_get_layer_texture (CoglPipeline *pipeline,
int layer_index);
@@ -1185,10 +1185,10 @@ typedef enum {
CoglPipelineLayerType
_cogl_pipeline_layer_get_type (CoglPipelineLayer *layer);
-CoglHandle
+CoglTexture *
_cogl_pipeline_layer_get_texture (CoglPipelineLayer *layer);
-CoglHandle
+CoglTexture *
_cogl_pipeline_layer_get_texture_real (CoglPipelineLayer *layer);
CoglPipelineFilter
@@ -1214,7 +1214,7 @@ CoglPipelineLayer *
_cogl_pipeline_layer_get_authority (CoglPipelineLayer *layer,
unsigned long difference);
-CoglHandle
+CoglTexture *
_cogl_pipeline_layer_get_texture (CoglPipelineLayer *layer);
typedef gboolean (*CoglPipelineInternalLayerCallback) (CoglPipelineLayer *layer,
diff --git a/cogl/cogl-pipeline.c b/cogl/cogl-pipeline.c
index 8b87a2e..8f2a9ae 100644
--- a/cogl/cogl-pipeline.c
+++ b/cogl/cogl-pipeline.c
@@ -2123,7 +2123,7 @@ _cogl_pipeline_get_layer (CoglPipeline *pipeline,
return layer;
}
-CoglHandle
+CoglTexture *
_cogl_pipeline_layer_get_texture_real (CoglPipelineLayer *layer)
{
CoglPipelineLayer *authority =
@@ -2133,7 +2133,7 @@ _cogl_pipeline_layer_get_texture_real (CoglPipelineLayer *layer)
return authority->texture;
}
-CoglHandle
+CoglTexture *
_cogl_pipeline_get_layer_texture (CoglPipeline *pipeline,
int layer_index)
{
@@ -2294,7 +2294,7 @@ changed:
static void
_cogl_pipeline_set_layer_texture_data (CoglPipeline *pipeline,
int layer_index,
- CoglHandle texture)
+ CoglTexture *texture)
{
CoglPipelineLayerState change = COGL_PIPELINE_LAYER_STATE_TEXTURE_DATA;
CoglPipelineLayer *layer;
@@ -2336,8 +2336,8 @@ _cogl_pipeline_set_layer_texture_data (CoglPipeline *pipeline,
{
layer->differences &= ~change;
- if (layer->texture != COGL_INVALID_HANDLE)
- cogl_handle_unref (layer->texture);
+ if (layer->texture != NULL)
+ cogl_object_unref (layer->texture);
g_assert (layer->owner == pipeline);
if (layer->differences == 0)
@@ -2348,11 +2348,11 @@ _cogl_pipeline_set_layer_texture_data (CoglPipeline *pipeline,
}
}
- if (texture != COGL_INVALID_HANDLE)
- cogl_handle_ref (texture);
+ if (texture != NULL)
+ cogl_object_ref (texture);
if (layer == authority &&
- layer->texture != COGL_INVALID_HANDLE)
- cogl_handle_unref (layer->texture);
+ layer->texture != NULL)
+ cogl_object_unref (layer->texture);
layer->texture = texture;
/* If we weren't previously the authority on this state then we need
@@ -2390,7 +2390,7 @@ get_texture_target (CoglHandle texture)
void
cogl_pipeline_set_layer_texture (CoglPipeline *pipeline,
int layer_index,
- CoglHandle texture)
+ CoglTexture *texture)
{
/* For the convenience of fragend code we separate texture state
* into the "target" and the "data", and setting a layer texture
@@ -2443,7 +2443,7 @@ fallback_layer_cb (CoglPipelineLayer *layer, void *user_data)
COGL_COUNTER_INC (_cogl_uprof_context, layer_fallback_counter);
- if (G_LIKELY (texture != COGL_INVALID_HANDLE))
+ if (G_LIKELY (texture != NULL))
cogl_texture_get_gl_texture (texture, NULL, &gl_target);
else
gl_target = GL_TEXTURE_2D;
@@ -4887,8 +4887,8 @@ _cogl_pipeline_layer_free (CoglPipelineLayer *layer)
_cogl_pipeline_layer_unparent (COGL_PIPELINE_NODE (layer));
if (layer->differences & COGL_PIPELINE_LAYER_STATE_TEXTURE_DATA &&
- layer->texture != COGL_INVALID_HANDLE)
- cogl_handle_unref (layer->texture);
+ layer->texture != NULL)
+ cogl_object_unref (layer->texture);
if (layer->differences & COGL_PIPELINE_LAYER_STATE_NEEDS_BIG_STATE)
g_slice_free (CoglPipelineLayerBigState, layer->big_state);
@@ -4942,7 +4942,7 @@ _cogl_pipeline_init_default_layers (void)
layer->unit_index = 0;
- layer->texture = COGL_INVALID_HANDLE;
+ layer->texture = NULL;
layer->target = 0;
layer->mag_filter = COGL_PIPELINE_FILTER_LINEAR;
@@ -5514,11 +5514,10 @@ cogl_pipeline_get_n_layers (CoglPipeline *pipeline)
/* FIXME: deprecate and replace with
* cogl_pipeline_get_layer_texture() instead. */
-CoglHandle
+CoglTexture *
_cogl_pipeline_layer_get_texture (CoglPipelineLayer *layer)
{
- g_return_val_if_fail (_cogl_is_pipeline_layer (layer),
- COGL_INVALID_HANDLE);
+ g_return_val_if_fail (_cogl_is_pipeline_layer (layer), NULL);
return _cogl_pipeline_layer_get_texture_real (layer);
}
@@ -5607,7 +5606,7 @@ _cogl_pipeline_layer_pre_paint (CoglPipelineLayer *layer)
_cogl_pipeline_layer_get_authority (layer,
COGL_PIPELINE_LAYER_STATE_TEXTURE_DATA);
- if (texture_authority->texture != COGL_INVALID_HANDLE)
+ if (texture_authority->texture != NULL)
{
CoglTexturePrePaintFlags flags = 0;
CoglPipelineFilter min_filter;
diff --git a/cogl/cogl-pipeline.h b/cogl/cogl-pipeline.h
index 15b100c..0a17884 100644
--- a/cogl/cogl-pipeline.h
+++ b/cogl/cogl-pipeline.h
@@ -750,7 +750,7 @@ cogl_pipeline_set_user_program (CoglPipeline *pipeline,
void
cogl_pipeline_set_layer_texture (CoglPipeline *pipeline,
int layer_index,
- CoglHandle texture);
+ CoglTexture *texture);
/**
* cogl_pipeline_remove_layer:
diff --git a/cogl/cogl-primitives.c b/cogl/cogl-primitives.c
index cf0720b..0a76225 100644
--- a/cogl/cogl-primitives.c
+++ b/cogl/cogl-primitives.c
@@ -45,7 +45,7 @@
typedef struct _TextureSlicedQuadState
{
CoglPipeline *pipeline;
- CoglHandle main_texture;
+ CoglTexture *main_texture;
float tex_virtual_origin_x;
float tex_virtual_origin_y;
float quad_origin_x;
@@ -67,14 +67,14 @@ typedef struct _TextureSlicedPolygonState
} TextureSlicedPolygonState;
static void
-log_quad_sub_textures_cb (CoglHandle texture_handle,
+log_quad_sub_textures_cb (CoglTexture *texture,
const float *subtexture_coords,
const float *virtual_coords,
void *user_data)
{
TextureSlicedQuadState *state = user_data;
CoglFramebuffer *framebuffer = cogl_get_draw_framebuffer ();
- CoglHandle texture_override;
+ CoglTexture *texture_override;
float quad_coords[4];
#define TEX_VIRTUAL_TO_QUAD(V, Q, AXIS) \
@@ -111,10 +111,10 @@ log_quad_sub_textures_cb (CoglHandle texture_handle,
/* We only need to override the texture if it's different from the
main texture */
- if (texture_handle == state->main_texture)
- texture_override = COGL_INVALID_HANDLE;
+ if (texture == state->main_texture)
+ texture_override = NULL;
else
- texture_override = texture_handle;
+ texture_override = texture;
_cogl_journal_log_quad (framebuffer->journal,
quad_coords,
@@ -179,7 +179,7 @@ validate_first_layer_cb (CoglPipeline *pipeline,
*/
/* TODO: support multitexturing */
static void
-_cogl_texture_quad_multiple_primitives (CoglHandle tex_handle,
+_cogl_texture_quad_multiple_primitives (CoglTexture *texture,
CoglPipeline *pipeline,
gboolean clamp_s,
gboolean clamp_t,
@@ -219,7 +219,7 @@ _cogl_texture_quad_multiple_primitives (CoglHandle tex_handle,
(position[2] - position[0]) *
(tx_1 - old_tx_1) / (old_tx_2 - old_tx_1)),
position[3] };
- _cogl_texture_quad_multiple_primitives (tex_handle, pipeline,
+ _cogl_texture_quad_multiple_primitives (texture, pipeline,
FALSE, clamp_t,
tmp_position,
tx_1, ty_1, tx_1, ty_2);
@@ -234,7 +234,7 @@ _cogl_texture_quad_multiple_primitives (CoglHandle tex_handle,
(position[2] - position[0]) *
(tx_2 - old_tx_1) / (old_tx_2 - old_tx_1)),
position[1], position[2], position[3] };
- _cogl_texture_quad_multiple_primitives (tex_handle, pipeline,
+ _cogl_texture_quad_multiple_primitives (texture, pipeline,
FALSE, clamp_t,
tmp_position,
tx_2, ty_1, tx_2, ty_2);
@@ -266,7 +266,7 @@ _cogl_texture_quad_multiple_primitives (CoglHandle tex_handle,
(position[1] +
(position[3] - position[1]) *
(ty_1 - old_ty_1) / (old_ty_2 - old_ty_1)) };
- _cogl_texture_quad_multiple_primitives (tex_handle, pipeline,
+ _cogl_texture_quad_multiple_primitives (texture, pipeline,
clamp_s, FALSE,
tmp_position,
tx_1, ty_1, tx_2, ty_1);
@@ -282,7 +282,7 @@ _cogl_texture_quad_multiple_primitives (CoglHandle tex_handle,
(position[3] - position[1]) *
(ty_2 - old_ty_1) / (old_ty_2 - old_ty_1)),
position[2], position[3] };
- _cogl_texture_quad_multiple_primitives (tex_handle, pipeline,
+ _cogl_texture_quad_multiple_primitives (texture, pipeline,
clamp_s, FALSE,
tmp_position,
tx_1, ty_2, tx_2, ty_2);
@@ -301,7 +301,7 @@ _cogl_texture_quad_multiple_primitives (CoglHandle tex_handle,
validate_first_layer_cb,
&validate_first_layer_state);
- state.main_texture = tex_handle;
+ state.main_texture = texture;
if (validate_first_layer_state.override_pipeline)
state.pipeline = validate_first_layer_state.override_pipeline;
@@ -349,7 +349,7 @@ _cogl_texture_quad_multiple_primitives (CoglHandle tex_handle,
state.v_to_q_scale_x = fabs (state.quad_len_x / (tx_2 - tx_1));
state.v_to_q_scale_y = fabs (state.quad_len_y / (ty_2 - ty_1));
- _cogl_texture_foreach_sub_texture_in_region (tex_handle,
+ _cogl_texture_foreach_sub_texture_in_region (texture,
tx_1, ty_1, tx_2, ty_2,
log_quad_sub_textures_cb,
&state);
@@ -378,7 +378,7 @@ validate_tex_coords_cb (CoglPipeline *pipeline,
void *user_data)
{
ValidateTexCoordsState *state = user_data;
- CoglHandle texture;
+ CoglTexture *texture;
const float *in_tex_coords;
float *out_tex_coords;
float default_tex_coords[4] = {0.0, 0.0, 1.0, 1.0};
@@ -456,7 +456,7 @@ validate_tex_coords_cb (CoglPipeline *pipeline,
"supported with multi-texturing.", state->i);
warning_seen = TRUE;
- cogl_pipeline_set_layer_texture (texture, layer_index, NULL);
+ cogl_pipeline_set_layer_texture (pipeline, layer_index, NULL);
}
}
@@ -542,7 +542,7 @@ _cogl_multitexture_quad_single_primitive (const float *position,
position,
pipeline,
n_layers,
- COGL_INVALID_HANDLE, /* no texture override */
+ NULL, /* no texture override */
final_tex_coords,
n_layers * 4);
@@ -566,7 +566,7 @@ _cogl_rectangles_validate_layer_cb (CoglPipeline *pipeline,
void *user_data)
{
ValidateLayerState *state = user_data;
- CoglHandle texture;
+ CoglTexture *texture;
state->i++;
@@ -614,9 +614,9 @@ _cogl_rectangles_validate_layer_cb (CoglPipeline *pipeline,
texture = _cogl_pipeline_get_layer_texture (pipeline, layer_index);
- /* COGL_INVALID_HANDLE textures are handled by
+ /* NULL textures are handled by
* _cogl_pipeline_flush_gl_state */
- if (texture == COGL_INVALID_HANDLE)
+ if (texture == NULL)
return TRUE;
if (state->i == 0)
@@ -739,7 +739,7 @@ _cogl_rectangles_with_multitexture_coords (
for (i = 0; i < n_rects; i++)
{
- CoglHandle texture;
+ CoglTexture *texture;
const float default_tex_coords[4] = {0.0, 0.0, 1.0, 1.0};
const float *tex_coords;
gboolean clamp_s, clamp_t;
@@ -967,19 +967,19 @@ append_tex_coord_attributes_cb (CoglPipeline *pipeline,
void *user_data)
{
AppendTexCoordsState *state = user_data;
- CoglHandle tex_handle;
+ CoglTexture *texture;
float tx, ty;
float *t;
tx = state->vertices_in[state->vertex].tx;
ty = state->vertices_in[state->vertex].ty;
- /* COGL_INVALID_HANDLE textures will be handled in
+ /* NULL textures will be handled in
* _cogl_pipeline_flush_layers_gl_state but there is no need to worry
* about scaling texture coordinates in this case */
- tex_handle = _cogl_pipeline_get_layer_texture (pipeline, layer_index);
- if (tex_handle != COGL_INVALID_HANDLE)
- _cogl_texture_transform_coords_to_gl (tex_handle, &tx, &ty);
+ texture = _cogl_pipeline_get_layer_texture (pipeline, layer_index);
+ if (texture != NULL)
+ _cogl_texture_transform_coords_to_gl (texture, &tx, &ty);
/* NB: [X,Y,Z,TX,TY...,R,G,B,A,...] */
t = state->vertices_out + 3 + 2 * state->layer;
diff --git a/cogl/cogl-sub-texture.c b/cogl/cogl-sub-texture.c
index 933a325..331eecc 100644
--- a/cogl/cogl-sub-texture.c
+++ b/cogl/cogl-sub-texture.c
@@ -155,7 +155,7 @@ typedef struct _CoglSubTextureForeachData
} CoglSubTextureForeachData;
static void
-_cogl_sub_texture_foreach_cb (CoglHandle handle,
+_cogl_sub_texture_foreach_cb (CoglTexture *texture,
const float *slice_coords,
const float *full_virtual_coords,
void *user_data)
@@ -173,7 +173,7 @@ _cogl_sub_texture_foreach_cb (CoglHandle handle,
&virtual_coords[2],
&virtual_coords[3]);
- data->callback (handle,
+ data->callback (texture,
slice_coords, virtual_coords,
data->user_data);
}
diff --git a/cogl/cogl-texture-2d-sliced.c b/cogl/cogl-texture-2d-sliced.c
index f592617..ffaeb75 100644
--- a/cogl/cogl-texture-2d-sliced.c
+++ b/cogl/cogl-texture-2d-sliced.c
@@ -67,7 +67,7 @@ typedef struct
} ForeachData;
static void
-_cogl_texture_2d_sliced_foreach_cb (CoglHandle handle,
+_cogl_texture_2d_sliced_foreach_cb (CoglTexture *texture,
const float *slice_coords,
const float *virtual_coords_in,
void *user_data)
@@ -86,7 +86,7 @@ _cogl_texture_2d_sliced_foreach_cb (CoglHandle handle,
virtual_coords_out[3] = (virtual_coords_in[3] * data->y_span->size +
data->y_span->start) / data->tex->height;
- data->callback (handle,
+ data->callback (texture,
slice_coords,
virtual_coords_out,
data->user_data);
diff --git a/cogl/cogl-texture-private.h b/cogl/cogl-texture-private.h
index 01fba91..0ca0a45 100644
--- a/cogl/cogl-texture-private.h
+++ b/cogl/cogl-texture-private.h
@@ -28,12 +28,9 @@
#include "cogl-handle.h"
#include "cogl-pipeline-private.h"
-#define COGL_TEXTURE(tex) ((CoglTexture *)(tex))
-
-typedef struct _CoglTexture CoglTexture;
typedef struct _CoglTextureVtable CoglTextureVtable;
-typedef void (*CoglTextureSliceCallback) (CoglHandle handle,
+typedef void (*CoglTextureSliceCallback) (CoglTexture *texture,
const float *slice_coords,
const float *virtual_coords,
void *user_data);
@@ -136,7 +133,7 @@ struct _CoglTextureVtable
struct _CoglTexture
{
- CoglHandleObject _parent;
+ CoglObject _parent;
GList *framebuffers;
const CoglTextureVtable *vtable;
};
@@ -193,7 +190,7 @@ _cogl_texture_register_texture_type (GQuark type);
## type_name ## _get_type ()))
void
-_cogl_texture_foreach_sub_texture_in_region (CoglHandle handle,
+_cogl_texture_foreach_sub_texture_in_region (CoglTexture *texture,
float virtual_tx_1,
float virtual_ty_1,
float virtual_tx_2,
@@ -202,36 +199,36 @@ _cogl_texture_foreach_sub_texture_in_region (CoglHandle handle,
void *user_data);
gboolean
-_cogl_texture_can_hardware_repeat (CoglHandle handle);
+_cogl_texture_can_hardware_repeat (CoglTexture *texture);
void
-_cogl_texture_transform_coords_to_gl (CoglHandle handle,
+_cogl_texture_transform_coords_to_gl (CoglTexture *texture,
float *s,
float *t);
CoglTransformResult
-_cogl_texture_transform_quad_coords_to_gl (CoglHandle handle,
+_cogl_texture_transform_quad_coords_to_gl (CoglTexture *texture,
float *coords);
GLenum
-_cogl_texture_get_gl_format (CoglHandle handle);
+_cogl_texture_get_gl_format (CoglTexture *texture);
void
-_cogl_texture_set_wrap_mode_parameters (CoglHandle handle,
+_cogl_texture_set_wrap_mode_parameters (CoglTexture *texture,
GLenum wrap_mode_s,
GLenum wrap_mode_t,
GLenum wrap_mode_p);
void
-_cogl_texture_set_filters (CoglHandle handle,
+_cogl_texture_set_filters (CoglTexture *texture,
GLenum min_filter,
GLenum mag_filter);
void
-_cogl_texture_pre_paint (CoglHandle handle, CoglTexturePrePaintFlags flags);
+_cogl_texture_pre_paint (CoglTexture *texture, CoglTexturePrePaintFlags flags);
void
-_cogl_texture_ensure_non_quad_rendering (CoglHandle handle);
+_cogl_texture_ensure_non_quad_rendering (CoglTexture *texture);
/* Utility function to determine which pixel format to use when
dst_format is COGL_PIXEL_FORMAT_ANY. If dst_format is not ANY then
@@ -274,22 +271,22 @@ _cogl_texture_iterate_manual_repeats (CoglTextureManualRepeatCallback callback,
texture via the framebuffer */
gboolean
-_cogl_texture_draw_and_read (CoglHandle handle,
+_cogl_texture_draw_and_read (CoglTexture *texture,
CoglBitmap *target_bmp,
GLuint target_gl_format,
GLuint target_gl_type);
gboolean
-_cogl_texture_is_foreign (CoglHandle handle);
+_cogl_texture_is_foreign (CoglTexture *texture);
void
-_cogl_texture_associate_framebuffer (CoglHandle handle,
+_cogl_texture_associate_framebuffer (CoglTexture *texture,
CoglFramebuffer *framebuffer);
const GList *
-_cogl_texture_get_associated_framebuffers (CoglHandle handle);
+_cogl_texture_get_associated_framebuffers (CoglTexture *texture);
void
-_cogl_texture_flush_journal_rendering (CoglHandle handle);
+_cogl_texture_flush_journal_rendering (CoglTexture *texture);
#endif /* __COGL_TEXTURE_PRIVATE_H */
diff --git a/cogl/cogl-texture.c b/cogl/cogl-texture.c
index 8a6fbd2..cf7ff0a 100644
--- a/cogl/cogl-texture.c
+++ b/cogl/cogl-texture.c
@@ -79,14 +79,14 @@ _cogl_texture_register_texture_type (GQuark type)
}
gboolean
-cogl_is_texture (CoglHandle handle)
+cogl_is_texture (void *object)
{
- CoglHandleObject *obj = (CoglHandleObject *)handle;
+ CoglObject *obj = (CoglObject *)object;
GSList *l;
_COGL_GET_CONTEXT (ctxt, FALSE);
- if (handle == COGL_INVALID_HANDLE)
+ if (object == NULL)
return FALSE;
for (l = ctxt->texture_types; l; l = l->next)
@@ -96,33 +96,33 @@ cogl_is_texture (CoglHandle handle)
return FALSE;
}
-CoglHandle
-cogl_texture_ref (CoglHandle handle)
+void *
+cogl_texture_ref (void *object)
{
- if (!cogl_is_texture (handle))
- return COGL_INVALID_HANDLE;
+ if (!cogl_is_texture (object))
+ return NULL;
- _COGL_HANDLE_DEBUG_REF (CoglTexture, handle);
+ _COGL_OBJECT_DEBUG_REF (CoglTexture, object);
- cogl_handle_ref (handle);
+ cogl_object_ref (object);
- return handle;
+ return object;
}
void
-cogl_texture_unref (CoglHandle handle)
+cogl_texture_unref (void *object)
{
- if (!cogl_is_texture (handle))
+ if (!cogl_is_texture (object))
{
g_warning (G_STRINGIFY (cogl_texture_unref)
- ": Ignoring unref of Cogl handle "
+ ": Ignoring unref of CoglObject "
"due to type mismatch");
return;
}
- _COGL_HANDLE_DEBUG_UNREF (CoglTexture, handle);
+ _COGL_OBJECT_DEBUG_UNREF (CoglTexture, object);
- cogl_handle_unref (handle);
+ cogl_object_unref (object);
}
void
@@ -281,17 +281,15 @@ _cogl_texture_prep_gl_alignment_for_pixels_download (int pixels_rowstride)
/* FIXME: wrap modes should be set on pipelines not textures */
void
-_cogl_texture_set_wrap_mode_parameters (CoglHandle handle,
+_cogl_texture_set_wrap_mode_parameters (CoglTexture *texture,
GLenum wrap_mode_s,
GLenum wrap_mode_t,
GLenum wrap_mode_p)
{
- CoglTexture *tex = COGL_TEXTURE (handle);
-
- tex->vtable->set_wrap_mode_parameters (tex,
- wrap_mode_s,
- wrap_mode_t,
- wrap_mode_p);
+ texture->vtable->set_wrap_mode_parameters (texture,
+ wrap_mode_s,
+ wrap_mode_t,
+ wrap_mode_p);
}
/* This is like CoglSpanIter except it deals with floats and it
@@ -389,32 +387,33 @@ _cogl_texture_iterate_manual_repeats (CoglTextureManualRepeatCallback callback,
}
}
-CoglHandle
+CoglTexture *
cogl_texture_new_with_size (unsigned int width,
unsigned int height,
CoglTextureFlags flags,
CoglPixelFormat internal_format)
{
- CoglHandle tex;
+ CoglTexture *tex;
_COGL_GET_CONTEXT (ctx, COGL_INVALID_HANDLE);
/* First try creating a fast-path non-sliced texture */
- tex = cogl_texture_2d_new_with_size (ctx,
- width, height, internal_format,
- NULL);
+ tex = COGL_TEXTURE (cogl_texture_2d_new_with_size (ctx,
+ width, height,
+ internal_format,
+ NULL));
/* If it fails resort to sliced textures */
- if (tex == COGL_INVALID_HANDLE)
- tex = _cogl_texture_2d_sliced_new_with_size (width,
- height,
- flags,
- internal_format);
+ if (tex == NULL)
+ tex = COGL_TEXTURE (_cogl_texture_2d_sliced_new_with_size (width,
+ height,
+ flags,
+ internal_format));
return tex;
}
-CoglHandle
+CoglTexture *
cogl_texture_new_from_data (unsigned int width,
unsigned int height,
CoglTextureFlags flags,
@@ -424,13 +423,13 @@ cogl_texture_new_from_data (unsigned int width,
const guint8 *data)
{
CoglBitmap *bmp;
- CoglHandle tex;
+ CoglTexture *tex;
if (format == COGL_PIXEL_FORMAT_ANY)
- return COGL_INVALID_HANDLE;
+ return NULL;
if (data == NULL)
- return COGL_INVALID_HANDLE;
+ return NULL;
/* Rowstride from width if not given */
if (rowstride == 0)
@@ -451,47 +450,47 @@ cogl_texture_new_from_data (unsigned int width,
return tex;
}
-CoglHandle
-cogl_texture_new_from_bitmap (CoglHandle bmp_handle,
+CoglTexture *
+cogl_texture_new_from_bitmap (CoglBitmap *bitmap,
CoglTextureFlags flags,
CoglPixelFormat internal_format)
{
- CoglHandle tex;
+ CoglTexture *tex;
/* First try putting the texture in the atlas */
- if ((tex = _cogl_atlas_texture_new_from_bitmap (bmp_handle,
+ if ((tex = _cogl_atlas_texture_new_from_bitmap (bitmap,
flags,
internal_format)))
return tex;
/* If that doesn't work try a fast path 2D texture */
- if ((tex = _cogl_texture_2d_new_from_bitmap (bmp_handle,
+ if ((tex = _cogl_texture_2d_new_from_bitmap (bitmap,
flags,
internal_format,
NULL)))
return tex;
/* Otherwise create a sliced texture */
- return _cogl_texture_2d_sliced_new_from_bitmap (bmp_handle,
+ return _cogl_texture_2d_sliced_new_from_bitmap (bitmap,
flags,
internal_format);
}
-CoglHandle
+CoglTexture *
cogl_texture_new_from_file (const char *filename,
CoglTextureFlags flags,
CoglPixelFormat internal_format,
GError **error)
{
CoglBitmap *bmp;
- CoglHandle handle = COGL_INVALID_HANDLE;
+ CoglTexture *texture = NULL;
CoglPixelFormat src_format;
- g_return_val_if_fail (error == NULL || *error == NULL, COGL_INVALID_HANDLE);
+ g_return_val_if_fail (error == NULL || *error == NULL, NULL);
bmp = cogl_bitmap_new_from_file (filename, error);
if (bmp == NULL)
- return COGL_INVALID_HANDLE;
+ return NULL;
src_format = _cogl_bitmap_get_format (bmp);
@@ -503,14 +502,14 @@ cogl_texture_new_from_file (const char *filename,
_cogl_texture_determine_internal_format (src_format, internal_format);
if (!_cogl_texture_needs_premult_conversion (src_format, internal_format) ||
_cogl_bitmap_convert_premult_status (bmp, src_format ^ COGL_PREMULT_BIT))
- handle = cogl_texture_new_from_bitmap (bmp, flags, internal_format);
+ texture = cogl_texture_new_from_bitmap (bmp, flags, internal_format);
cogl_object_unref (bmp);
- return handle;
+ return texture;
}
-CoglHandle
+CoglTexture *
cogl_texture_new_from_foreign (GLuint gl_handle,
GLenum gl_target,
GLuint width,
@@ -549,43 +548,37 @@ cogl_texture_new_from_foreign (GLuint gl_handle,
else
{
_COGL_GET_CONTEXT (ctx, COGL_INVALID_HANDLE);
- return cogl_texture_2d_new_from_foreign (ctx,
- gl_handle,
- width,
- height,
- format,
- NULL);
+ return COGL_TEXTURE (cogl_texture_2d_new_from_foreign (ctx,
+ gl_handle,
+ width,
+ height,
+ format,
+ NULL));
}
}
gboolean
-_cogl_texture_is_foreign (CoglHandle handle)
+_cogl_texture_is_foreign (CoglTexture *texture)
{
- CoglTexture *tex;
-
- g_return_val_if_fail (cogl_is_texture (handle), FALSE);
-
- tex = COGL_TEXTURE (handle);
-
- if (tex->vtable->is_foreign)
- return tex->vtable->is_foreign (tex);
+ if (texture->vtable->is_foreign)
+ return texture->vtable->is_foreign (texture);
else
return FALSE;
}
-CoglHandle
-cogl_texture_new_from_sub_texture (CoglHandle full_texture,
- int sub_x,
- int sub_y,
- int sub_width,
- int sub_height)
+CoglTexture *
+cogl_texture_new_from_sub_texture (CoglTexture *full_texture,
+ int sub_x,
+ int sub_y,
+ int sub_width,
+ int sub_height)
{
return _cogl_sub_texture_new (full_texture, sub_x, sub_y,
sub_width, sub_height);
}
-CoglHandle
-cogl_texture_new_from_buffer_EXP (CoglHandle buffer,
+CoglTexture *
+cogl_texture_new_from_buffer_EXP (CoglPixelBuffer *buffer,
unsigned int width,
unsigned int height,
CoglTextureFlags flags,
@@ -594,15 +587,15 @@ cogl_texture_new_from_buffer_EXP (CoglHandle buffer,
unsigned int rowstride,
const unsigned int offset)
{
- CoglHandle texture;
+ CoglTexture *texture;
CoglBuffer *cogl_buffer;
CoglPixelBuffer *pixel_buffer;
CoglBitmap *bmp;
- g_return_val_if_fail (cogl_is_buffer (buffer), COGL_INVALID_HANDLE);
+ g_return_val_if_fail (cogl_is_buffer (buffer), NULL);
if (format == COGL_PIXEL_FORMAT_ANY)
- return COGL_INVALID_HANDLE;
+ return NULL;
cogl_buffer = COGL_BUFFER (buffer);
pixel_buffer = COGL_PIXEL_BUFFER (buffer);
@@ -623,7 +616,7 @@ cogl_texture_new_from_buffer_EXP (CoglHandle buffer,
/* no width or height specified, neither at creation time (because the
* array was created by cogl_pixel_buffer_new()) nor when calling this
* function */
- return COGL_INVALID_HANDLE;
+ return NULL;
}
/* Wrap the buffer into a bitmap */
@@ -641,87 +634,45 @@ cogl_texture_new_from_buffer_EXP (CoglHandle buffer,
}
unsigned int
-cogl_texture_get_width (CoglHandle handle)
+cogl_texture_get_width (CoglTexture *texture)
{
- CoglTexture *tex;
-
- if (!cogl_is_texture (handle))
- return 0;
-
- tex = COGL_TEXTURE (handle);
-
- return tex->vtable->get_width (tex);
+ return texture->vtable->get_width (texture);
}
unsigned int
-cogl_texture_get_height (CoglHandle handle)
+cogl_texture_get_height (CoglTexture *texture)
{
- CoglTexture *tex;
-
- if (!cogl_is_texture (handle))
- return 0;
-
- tex = COGL_TEXTURE (handle);
-
- return tex->vtable->get_height (tex);
+ return texture->vtable->get_height (texture);
}
CoglPixelFormat
-cogl_texture_get_format (CoglHandle handle)
+cogl_texture_get_format (CoglTexture *texture)
{
- CoglTexture *tex;
-
- if (!cogl_is_texture (handle))
- return COGL_PIXEL_FORMAT_ANY;
-
- tex = COGL_TEXTURE (handle);
-
- return tex->vtable->get_format (tex);
+ return texture->vtable->get_format (texture);
}
unsigned int
-cogl_texture_get_rowstride (CoglHandle handle)
+cogl_texture_get_rowstride (CoglTexture *texture)
{
- CoglTexture *tex;
-
- if (!cogl_is_texture (handle))
- return 0;
-
/* FIXME: This function should go away. It previously just returned
the rowstride that was used to upload the data as far as I can
tell. This is not helpful */
- tex = COGL_TEXTURE (handle);
-
/* Just guess at a suitable rowstride */
- return (_cogl_get_format_bpp (cogl_texture_get_format (tex))
- * cogl_texture_get_width (tex));
+ return (_cogl_get_format_bpp (cogl_texture_get_format (texture))
+ * cogl_texture_get_width (texture));
}
int
-cogl_texture_get_max_waste (CoglHandle handle)
+cogl_texture_get_max_waste (CoglTexture *texture)
{
- CoglTexture *tex;
-
- if (!cogl_is_texture (handle))
- return 0;
-
- tex = COGL_TEXTURE (handle);
-
- return tex->vtable->get_max_waste (tex);
+ return texture->vtable->get_max_waste (texture);
}
gboolean
-cogl_texture_is_sliced (CoglHandle handle)
+cogl_texture_is_sliced (CoglTexture *texture)
{
- CoglTexture *tex;
-
- if (!cogl_is_texture (handle))
- return FALSE;
-
- tex = COGL_TEXTURE (handle);
-
- return tex->vtable->is_sliced (tex);
+ return texture->vtable->is_sliced (texture);
}
/* Some CoglTextures, notably sliced textures or atlas textures when repeating
@@ -734,7 +685,7 @@ cogl_texture_is_sliced (CoglHandle handle)
* region specified in texture coordinates.
*/
void
-_cogl_texture_foreach_sub_texture_in_region (CoglHandle handle,
+_cogl_texture_foreach_sub_texture_in_region (CoglTexture *texture,
float virtual_tx_1,
float virtual_ty_1,
float virtual_tx_2,
@@ -742,15 +693,13 @@ _cogl_texture_foreach_sub_texture_in_region (CoglHandle handle,
CoglTextureSliceCallback callback,
void *user_data)
{
- CoglTexture *tex = COGL_TEXTURE (handle);
-
- tex->vtable->foreach_sub_texture_in_region (tex,
- virtual_tx_1,
- virtual_ty_1,
- virtual_tx_2,
- virtual_ty_2,
- callback,
- user_data);
+ texture->vtable->foreach_sub_texture_in_region (texture,
+ virtual_tx_1,
+ virtual_ty_1,
+ virtual_tx_2,
+ virtual_ty_2,
+ callback,
+ user_data);
}
/* If this returns FALSE, that implies _foreach_sub_texture_in_region
@@ -758,101 +707,66 @@ _cogl_texture_foreach_sub_texture_in_region (CoglHandle handle,
* texture coordinates extend out of the range [0,1]
*/
gboolean
-_cogl_texture_can_hardware_repeat (CoglHandle handle)
+_cogl_texture_can_hardware_repeat (CoglTexture *texture)
{
- CoglTexture *tex = (CoglTexture *)handle;
-
- return tex->vtable->can_hardware_repeat (tex);
+ return texture->vtable->can_hardware_repeat (texture);
}
/* NB: You can't use this with textures comprised of multiple sub textures (use
* cogl_texture_is_sliced() to check) since coordinate transformation for such
* textures will be different for each slice. */
void
-_cogl_texture_transform_coords_to_gl (CoglHandle handle,
+_cogl_texture_transform_coords_to_gl (CoglTexture *texture,
float *s,
float *t)
{
- CoglTexture *tex = COGL_TEXTURE (handle);
-
- tex->vtable->transform_coords_to_gl (tex, s, t);
+ texture->vtable->transform_coords_to_gl (texture, s, t);
}
CoglTransformResult
-_cogl_texture_transform_quad_coords_to_gl (CoglHandle handle,
+_cogl_texture_transform_quad_coords_to_gl (CoglTexture *texture,
float *coords)
{
- CoglTexture *tex = COGL_TEXTURE (handle);
-
- return tex->vtable->transform_quad_coords_to_gl (tex, coords);
+ return texture->vtable->transform_quad_coords_to_gl (texture, coords);
}
GLenum
-_cogl_texture_get_gl_format (CoglHandle handle)
+_cogl_texture_get_gl_format (CoglTexture *texture)
{
- CoglTexture *tex = COGL_TEXTURE (handle);
-
- return tex->vtable->get_gl_format (tex);
+ return texture->vtable->get_gl_format (texture);
}
gboolean
-cogl_texture_get_gl_texture (CoglHandle handle,
+cogl_texture_get_gl_texture (CoglTexture *texture,
GLuint *out_gl_handle,
GLenum *out_gl_target)
{
- CoglTexture *tex;
-
- if (!cogl_is_texture (handle))
- return FALSE;
-
- tex = COGL_TEXTURE (handle);
-
- return tex->vtable->get_gl_texture (tex, out_gl_handle, out_gl_target);
+ return texture->vtable->get_gl_texture (texture,
+ out_gl_handle, out_gl_target);
}
void
-_cogl_texture_set_filters (CoglHandle handle,
+_cogl_texture_set_filters (CoglTexture *texture,
GLenum min_filter,
GLenum mag_filter)
{
- CoglTexture *tex;
-
- if (!cogl_is_texture (handle))
- return;
-
- tex = COGL_TEXTURE (handle);
-
- tex->vtable->set_filters (tex, min_filter, mag_filter);
+ texture->vtable->set_filters (texture, min_filter, mag_filter);
}
void
-_cogl_texture_pre_paint (CoglHandle handle, CoglTexturePrePaintFlags flags)
+_cogl_texture_pre_paint (CoglTexture *texture, CoglTexturePrePaintFlags flags)
{
- CoglTexture *tex;
-
- if (!cogl_is_texture (handle))
- return;
-
- tex = COGL_TEXTURE (handle);
-
- tex->vtable->pre_paint (tex, flags);
+ texture->vtable->pre_paint (texture, flags);
}
void
-_cogl_texture_ensure_non_quad_rendering (CoglHandle handle)
+_cogl_texture_ensure_non_quad_rendering (CoglTexture *texture)
{
- CoglTexture *tex;
-
- if (!cogl_is_texture (handle))
- return;
-
- tex = COGL_TEXTURE (handle);
-
- tex->vtable->ensure_non_quad_rendering (tex);
+ texture->vtable->ensure_non_quad_rendering (texture);
}
gboolean
-cogl_texture_set_region_from_bitmap (CoglHandle handle,
+cogl_texture_set_region_from_bitmap (CoglTexture *texture,
int src_x,
int src_y,
int dst_x,
@@ -861,8 +775,7 @@ cogl_texture_set_region_from_bitmap (CoglHandle handle,
unsigned int dst_height,
CoglBitmap *bmp)
{
- CoglTexture *tex = COGL_TEXTURE (handle);
- gboolean ret;
+ gboolean ret;
/* Shortcut out early if the image is empty */
if (dst_width == 0 || dst_height == 0)
@@ -875,17 +788,17 @@ cogl_texture_set_region_from_bitmap (CoglHandle handle,
always stored in an RGBA texture even if the texture format is
advertised as RGB. */
- ret = tex->vtable->set_region (handle,
- src_x, src_y,
- dst_x, dst_y,
- dst_width, dst_height,
- bmp);
+ ret = texture->vtable->set_region (texture,
+ src_x, src_y,
+ dst_x, dst_y,
+ dst_width, dst_height,
+ bmp);
return ret;
}
gboolean
-cogl_texture_set_region (CoglHandle handle,
+cogl_texture_set_region (CoglTexture *texture,
int src_x,
int src_y,
int dst_x,
@@ -918,7 +831,7 @@ cogl_texture_set_region (CoglHandle handle,
NULL, /* destroy_fn */
NULL); /* destroy_fn_data */
- ret = cogl_texture_set_region_from_bitmap (handle,
+ ret = cogl_texture_set_region_from_bitmap (texture,
src_x, src_y,
dst_x, dst_y,
dst_width, dst_height,
@@ -943,7 +856,7 @@ cogl_texture_set_region (CoglHandle handle,
* glGetTexImage, but may be used as a fallback in some circumstances.
*/
static void
-do_texture_draw_and_read (CoglHandle handle,
+do_texture_draw_and_read (CoglTexture *texture,
CoglBitmap *target_bmp,
float *viewport)
{
@@ -958,8 +871,8 @@ do_texture_draw_and_read (CoglHandle handle,
bpp = _cogl_get_format_bpp (COGL_PIXEL_FORMAT_RGBA_8888);
- tex_width = cogl_texture_get_width (handle);
- tex_height = cogl_texture_get_height (handle);
+ tex_width = cogl_texture_get_width (texture);
+ tex_height = cogl_texture_get_height (texture);
ry2 = 0;
ty2 = 0;
@@ -1045,7 +958,7 @@ do_texture_draw_and_read (CoglHandle handle,
* glGetTexImage, but may be used as a fallback in some circumstances.
*/
gboolean
-_cogl_texture_draw_and_read (CoglHandle handle,
+_cogl_texture_draw_and_read (CoglTexture *texture,
CoglBitmap *target_bmp,
GLuint target_gl_format,
GLuint target_gl_type)
@@ -1091,7 +1004,7 @@ _cogl_texture_draw_and_read (CoglHandle handle,
/* Direct copy operation */
- if (ctx->texture_download_pipeline == COGL_INVALID_HANDLE)
+ if (ctx->texture_download_pipeline == NULL)
{
ctx->texture_download_pipeline = cogl_pipeline_new ();
cogl_pipeline_set_blend (ctx->texture_download_pipeline,
@@ -1101,7 +1014,7 @@ _cogl_texture_draw_and_read (CoglHandle handle,
cogl_push_source (ctx->texture_download_pipeline);
- cogl_pipeline_set_layer_texture (ctx->texture_download_pipeline, 0, handle);
+ cogl_pipeline_set_layer_texture (ctx->texture_download_pipeline, 0, texture);
cogl_pipeline_set_layer_combine (ctx->texture_download_pipeline,
0, /* layer */
@@ -1112,7 +1025,7 @@ _cogl_texture_draw_and_read (CoglHandle handle,
COGL_PIPELINE_FILTER_NEAREST,
COGL_PIPELINE_FILTER_NEAREST);
- do_texture_draw_and_read (handle, target_bmp, viewport);
+ do_texture_draw_and_read (texture, target_bmp, viewport);
/* Check whether texture has alpha and framebuffer not */
/* FIXME: For some reason even if ALPHA_BITS is 8, the framebuffer
@@ -1127,7 +1040,7 @@ _cogl_texture_draw_and_read (CoglHandle handle,
printf ("G bits: %d\n", g_bits);
printf ("B bits: %d\n", b_bits);
printf ("A bits: %d\n", a_bits); */
- if ((cogl_texture_get_format (handle) & COGL_A_BIT)/* && a_bits == 0*/)
+ if ((cogl_texture_get_format (texture) & COGL_A_BIT)/* && a_bits == 0*/)
{
guint8 *srcdata;
guint8 *dstdata;
@@ -1157,7 +1070,7 @@ _cogl_texture_draw_and_read (CoglHandle handle,
"RGBA = REPLACE (TEXTURE[A])",
NULL);
- do_texture_draw_and_read (handle, alpha_bmp, viewport);
+ do_texture_draw_and_read (texture, alpha_bmp, viewport);
/* Copy temp R to target A */
@@ -1189,7 +1102,7 @@ _cogl_texture_draw_and_read (CoglHandle handle,
}
static gboolean
-get_texture_bits_via_offscreen (CoglHandle texture_handle,
+get_texture_bits_via_offscreen (CoglTexture *texture,
int x,
int y,
int width,
@@ -1206,7 +1119,7 @@ get_texture_bits_via_offscreen (CoglHandle texture_handle,
return FALSE;
framebuffer = _cogl_offscreen_new_to_texture_full
- (texture_handle,
+ (texture,
COGL_OFFSCREEN_DISABLE_DEPTH_AND_STENCIL,
0);
@@ -1227,7 +1140,7 @@ get_texture_bits_via_offscreen (CoglHandle texture_handle,
}
static gboolean
-get_texture_bits_via_copy (CoglHandle texture_handle,
+get_texture_bits_via_copy (CoglTexture *texture,
int x,
int y,
int width,
@@ -1236,25 +1149,24 @@ get_texture_bits_via_copy (CoglHandle texture_handle,
unsigned int dst_rowstride,
CoglPixelFormat dst_format)
{
- CoglTexture *tex = COGL_TEXTURE (texture_handle);
unsigned int full_rowstride;
guint8 *full_bits;
gboolean ret = TRUE;
int bpp;
int full_tex_width, full_tex_height;
- full_tex_width = cogl_texture_get_width (texture_handle);
- full_tex_height = cogl_texture_get_height (texture_handle);
+ full_tex_width = cogl_texture_get_width (texture);
+ full_tex_height = cogl_texture_get_height (texture);
bpp = _cogl_get_format_bpp (dst_format);
full_rowstride = bpp * full_tex_width;
full_bits = g_malloc (full_rowstride * full_tex_height);
- if (tex->vtable->get_data (tex,
- dst_format,
- full_rowstride,
- full_bits))
+ if (texture->vtable->get_data (texture,
+ dst_format,
+ full_rowstride,
+ full_bits))
{
guint8 *dst = dst_bits;
guint8 *src = full_bits + x * bpp + y * full_rowstride;
@@ -1285,18 +1197,17 @@ typedef struct
} CoglTextureGetData;
static void
-texture_get_cb (CoglHandle texture_handle,
+texture_get_cb (CoglTexture *texture,
const float *subtexture_coords,
const float *virtual_coords,
void *user_data)
{
- CoglTexture *tex = COGL_TEXTURE (texture_handle);
CoglTextureGetData *tg_data = user_data;
CoglPixelFormat format = _cogl_bitmap_get_format (tg_data->target_bmp);
int bpp = _cogl_get_format_bpp (format);
unsigned int rowstride = _cogl_bitmap_get_rowstride (tg_data->target_bmp);
- int subtexture_width = cogl_texture_get_width (texture_handle);
- int subtexture_height = cogl_texture_get_height (texture_handle);
+ int subtexture_width = cogl_texture_get_width (texture);
+ int subtexture_height = cogl_texture_get_height (texture);
int x_in_subtexture = (int) (0.5 + subtexture_width * subtexture_coords[0]);
int y_in_subtexture = (int) (0.5 + subtexture_height * subtexture_coords[1]);
@@ -1321,15 +1232,15 @@ texture_get_cb (CoglHandle texture_handle,
if (x_in_subtexture == 0 && y_in_subtexture == 0 &&
width == subtexture_width && height == subtexture_height)
{
- if (tex->vtable->get_data (tex,
- format,
- rowstride,
- dst_bits))
+ if (texture->vtable->get_data (texture,
+ format,
+ rowstride,
+ dst_bits))
return;
}
/* Next best option is a FBO and glReadPixels */
- if (get_texture_bits_via_offscreen (texture_handle,
+ if (get_texture_bits_via_offscreen (texture,
x_in_subtexture, y_in_subtexture,
width, height,
dst_bits,
@@ -1338,7 +1249,7 @@ texture_get_cb (CoglHandle texture_handle,
return;
/* Getting ugly: read the entire texture, copy out the part we want */
- if (get_texture_bits_via_copy (texture_handle,
+ if (get_texture_bits_via_copy (texture,
x_in_subtexture, y_in_subtexture,
width, height,
dst_bits,
@@ -1352,12 +1263,11 @@ texture_get_cb (CoglHandle texture_handle,
}
int
-cogl_texture_get_data (CoglHandle handle,
+cogl_texture_get_data (CoglTexture *texture,
CoglPixelFormat format,
unsigned int rowstride,
guint8 *data)
{
- CoglTexture *tex;
int bpp;
int byte_size;
CoglPixelFormat closest_format;
@@ -1376,17 +1286,12 @@ cogl_texture_get_data (CoglHandle handle,
_COGL_GET_CONTEXT (ctx, 0);
- if (!cogl_is_texture (handle))
- return 0;
-
- tex = COGL_TEXTURE (handle);
-
/* Default to internal format if none specified */
if (format == COGL_PIXEL_FORMAT_ANY)
- format = cogl_texture_get_format (handle);
+ format = cogl_texture_get_format (texture);
- tex_width = cogl_texture_get_width (handle);
- tex_height = cogl_texture_get_height (handle);
+ tex_width = cogl_texture_get_width (texture);
+ tex_height = cogl_texture_get_height (texture);
/* Rowstride from texture width if none specified */
bpp = _cogl_get_format_bpp (format);
@@ -1442,7 +1347,7 @@ cogl_texture_get_data (CoglHandle handle,
* the data for a sliced texture, and allows us to do the
* read-from-framebuffer logic here in a simple fashion rather than
* passing offsets down through the code. */
- _cogl_texture_foreach_sub_texture_in_region (handle,
+ _cogl_texture_foreach_sub_texture_in_region (texture,
0, 0, 1, 1,
texture_get_cb,
&tg_data);
@@ -1454,7 +1359,7 @@ cogl_texture_get_data (CoglHandle handle,
* support glGetTexImage, so here we fallback to drawing the
* texture and reading the pixels from the framebuffer. */
if (!tg_data.success)
- _cogl_texture_draw_and_read (tex, target_bmp,
+ _cogl_texture_draw_and_read (texture, target_bmp,
closest_gl_format,
closest_gl_type);
@@ -1512,40 +1417,37 @@ _cogl_texture_framebuffer_destroy_cb (void *user_data,
}
void
-_cogl_texture_associate_framebuffer (CoglHandle handle,
+_cogl_texture_associate_framebuffer (CoglTexture *texture,
CoglFramebuffer *framebuffer)
{
- CoglTexture *tex = COGL_TEXTURE (handle);
static CoglUserDataKey framebuffer_destroy_notify_key;
/* Note: we don't take a reference on the framebuffer here because
* that would introduce a circular reference. */
- tex->framebuffers = g_list_prepend (tex->framebuffers, framebuffer);
+ texture->framebuffers = g_list_prepend (texture->framebuffers, framebuffer);
/* Since we haven't taken a reference on the framebuffer we setup
- * some private data so we will be notified if it is destroyed... */
+ * some private data so we will be notified if it is destroyed... */
_cogl_object_set_user_data (COGL_OBJECT (framebuffer),
&framebuffer_destroy_notify_key,
- tex,
+ texture,
_cogl_texture_framebuffer_destroy_cb);
}
const GList *
-_cogl_texture_get_associated_framebuffers (CoglHandle handle)
+_cogl_texture_get_associated_framebuffers (CoglTexture *texture)
{
- CoglTexture *tex = COGL_TEXTURE (handle);
- return tex->framebuffers;
+ return texture->framebuffers;
}
void
-_cogl_texture_flush_journal_rendering (CoglHandle handle)
+_cogl_texture_flush_journal_rendering (CoglTexture *texture)
{
- CoglTexture *tex = COGL_TEXTURE (handle);
GList *l;
/* It could be that a referenced texture is part of a framebuffer
* which has an associated journal that must be flushed before it
* can be sampled from by the current primitive... */
- for (l = tex->framebuffers; l; l = l->next)
+ for (l = texture->framebuffers; l; l = l->next)
_cogl_framebuffer_flush_journal (l->data);
}
diff --git a/cogl/cogl-texture.h b/cogl/cogl-texture.h
index 41e6ee4..12a6b74 100644
--- a/cogl/cogl-texture.h
+++ b/cogl/cogl-texture.h
@@ -30,6 +30,9 @@
#include <cogl/cogl-types.h>
#include <cogl/cogl-defines.h>
+#if defined (COGL_ENABLE_EXPERIMENTAL_API)
+#include <cogl/cogl-pixel-buffer.h>
+#endif
G_BEGIN_DECLS
@@ -37,11 +40,14 @@ G_BEGIN_DECLS
* SECTION:cogl-texture
* @short_description: Fuctions for creating and manipulating textures
*
- * COGL allows creating and manipulating GL textures using a uniform
+ * Cogl allows creating and manipulating textures using a uniform
* API that tries to hide all the various complexities of creating,
* loading and manipulating textures.
*/
+typedef struct _CoglTexture CoglTexture;
+#define COGL_TEXTURE(X) ((CoglTexture *)X)
+
#define COGL_TEXTURE_MAX_WASTE 127
/**
@@ -80,14 +86,13 @@ GQuark cogl_texture_error_quark (void);
* @internal_format: the #CoglPixelFormat to use for the GPU storage of the
* texture.
*
- * Creates a new COGL texture with the specified dimensions and pixel format.
+ * Creates a new #CoglTexture with the specified dimensions and pixel format.
*
- * Return value: a #CoglHandle to the newly created texture or
- * %COGL_INVALID_HANDLE on failure
+ * Return value: A newly created #CoglTexture or %NULL on failure
*
* Since: 0.8
*/
-CoglHandle
+CoglTexture *
cogl_texture_new_with_size (unsigned int width,
unsigned int height,
CoglTextureFlags flags,
@@ -107,14 +112,13 @@ cogl_texture_new_with_size (unsigned int width,
* other than straight blending.
* @error: return location for a #GError or %NULL
*
- * Creates a COGL texture from an image file.
+ * Creates a #CoglTexture from an image file.
*
- * Return value: a #CoglHandle to the newly created texture or
- * %COGL_INVALID_HANDLE on failure
+ * Return value: A newly created #CoglTexture or %NULL on failure
*
* Since: 0.8
*/
-CoglHandle
+CoglTexture *
cogl_texture_new_from_file (const char *filename,
CoglTextureFlags flags,
CoglPixelFormat internal_format,
@@ -138,14 +142,13 @@ cogl_texture_new_from_file (const char *filename,
* scanlines in @data
* @data: pointer the memory region where the source buffer resides
*
- * Creates a new COGL texture based on data residing in memory.
+ * Creates a new #CoglTexture based on data residing in memory.
*
- * Return value: a #CoglHandle to the newly created texture or
- * %COGL_INVALID_HANDLE on failure
+ * Return value: A newly created #CoglTexture or %NULL on failure
*
* Since: 0.8
*/
-CoglHandle
+CoglTexture *
cogl_texture_new_from_data (unsigned int width,
unsigned int height,
CoglTextureFlags flags,
@@ -164,7 +167,7 @@ cogl_texture_new_from_data (unsigned int width,
* @y_pot_waste: vertical waste on the bottom edge of the texture.
* @format: format of the foreign texture.
*
- * Creates a COGL texture based on an existing OpenGL texture; the
+ * Creates a #CoglTexture based on an existing OpenGL texture; the
* width, height and format are passed along since it is not always
* possible to query these from OpenGL.
*
@@ -175,12 +178,11 @@ cogl_texture_new_from_data (unsigned int width,
* the waste arguments to tell Cogl which region should be mapped to
* the texture coordinate range [0:1].
*
- * Return value: a #CoglHandle to the newly created texture or
- * %COGL_INVALID_HANDLE on failure
+ * Return value: A newly created #CoglTexture or %NULL on failure
*
* Since: 0.8
*/
-CoglHandle
+CoglTexture *
cogl_texture_new_from_foreign (GLuint gl_handle,
GLenum gl_target,
GLuint width,
@@ -191,83 +193,82 @@ cogl_texture_new_from_foreign (GLuint gl_handle,
/**
* cogl_texture_new_from_bitmap:
- * @bmp_handle: A CoglBitmap handle
+ * @bitmap: A #CoglBitmap pointer
* @flags: Optional flags for the texture, or %COGL_TEXTURE_NONE
* @internal_format: the #CoglPixelFormat to use for the GPU storage of the
* texture
*
- * Creates a COGL texture from a CoglBitmap.
+ * Creates a #CoglTexture from a #CoglBitmap.
*
- * Return value: a #CoglHandle to the newly created texture or
- * %COGL_INVALID_HANDLE on failure
+ * Return value: A newly created #CoglTexture or %NULL on failure
*
* Since: 1.0
*/
-CoglHandle
-cogl_texture_new_from_bitmap (CoglHandle bmp_handle,
+CoglTexture *
+cogl_texture_new_from_bitmap (CoglBitmap *bitmap,
CoglTextureFlags flags,
- CoglPixelFormat internal_format);
+ CoglPixelFormat internal_format);
/**
* cogl_is_texture:
- * @handle: A CoglHandle
+ * @object: A #CoglObject pointer
*
- * Gets whether the given handle references an existing texture object.
+ * Gets whether the given object references a texture object.
*
* Return value: %TRUE if the handle references a texture, and
* %FALSE otherwise
*/
gboolean
-cogl_is_texture (CoglHandle handle);
+cogl_is_texture (void *object);
/**
* cogl_texture_get_width:
- * @handle: a #CoglHandle for a texture.
+ * @texture a #CoglTexture pointer.
*
* Queries the width of a cogl texture.
*
* Return value: the width of the GPU side texture in pixels
*/
unsigned int
-cogl_texture_get_width (CoglHandle handle);
+cogl_texture_get_width (CoglTexture *texture);
/**
* cogl_texture_get_height:
- * @handle: a #CoglHandle for a texture.
+ * @texture a #CoglTexture pointer.
*
* Queries the height of a cogl texture.
*
* Return value: the height of the GPU side texture in pixels
*/
unsigned int
-cogl_texture_get_height (CoglHandle handle);
+cogl_texture_get_height (CoglTexture *texture);
/**
* cogl_texture_get_format:
- * @handle: a #CoglHandle for a texture.
+ * @texture a #CoglTexture pointer.
*
* Queries the #CoglPixelFormat of a cogl texture.
*
* Return value: the #CoglPixelFormat of the GPU side texture
*/
CoglPixelFormat
-cogl_texture_get_format (CoglHandle handle);
+cogl_texture_get_format (CoglTexture *texture);
/**
* cogl_texture_get_rowstride:
- * @handle: a #CoglHandle for a texture.
+ * @texture a #CoglTexture pointer.
*
* Queries the rowstride of a cogl texture.
*
* Return value: the offset in bytes between each consequetive row of pixels
*/
unsigned int
-cogl_texture_get_rowstride (CoglHandle handle);
+cogl_texture_get_rowstride (CoglTexture *texture);
/**
* cogl_texture_get_max_waste:
- * @handle: a #CoglHandle for a texture.
+ * @texture a #CoglTexture pointer.
*
* Queries the maximum wasted (unused) pixels in one dimension of a GPU side
* texture.
@@ -275,11 +276,11 @@ cogl_texture_get_rowstride (CoglHandle handle);
* Return value: the maximum waste
*/
int
-cogl_texture_get_max_waste (CoglHandle handle);
+cogl_texture_get_max_waste (CoglTexture *texture);
/**
* cogl_texture_is_sliced:
- * @handle: a #CoglHandle for a texture.
+ * @texture a #CoglTexture pointer.
*
* Queries if a texture is sliced (stored as multiple GPU side tecture
* objects).
@@ -288,17 +289,17 @@ cogl_texture_get_max_waste (CoglHandle handle);
* is stored as a single GPU texture
*/
gboolean
-cogl_texture_is_sliced (CoglHandle handle);
+cogl_texture_is_sliced (CoglTexture *texture);
/**
* cogl_texture_get_gl_texture:
- * @handle: a #CoglHandle for a texture.
+ * @texture a #CoglTexture pointer.
* @out_gl_handle: (out) (allow-none): pointer to return location for the
* textures GL handle, or %NULL.
* @out_gl_target: (out) (allow-none): pointer to return location for the
* GL target type, or %NULL.
*
- * Queries the GL handles for a GPU side texture through its #CoglHandle.
+ * Queries the GL handles for a GPU side texture through its #CoglTexture.
*
* If the texture is spliced the data for the first sub texture will be
* queried.
@@ -307,13 +308,13 @@ cogl_texture_is_sliced (CoglHandle handle);
* if the handle was invalid
*/
gboolean
-cogl_texture_get_gl_texture (CoglHandle handle,
+cogl_texture_get_gl_texture (CoglTexture *texture,
GLuint *out_gl_handle,
GLenum *out_gl_target);
/**
* cogl_texture_get_data:
- * @handle: a #CoglHandle for a texture.
+ * @texture a #CoglTexture pointer.
* @format: the #CoglPixelFormat to store the texture as.
* @rowstride: the rowstride of @data or retrieved from texture if none is
* specified.
@@ -326,14 +327,14 @@ cogl_texture_get_gl_texture (CoglHandle handle,
* is not valid
*/
int
-cogl_texture_get_data (CoglHandle handle,
- CoglPixelFormat format,
- unsigned int rowstride,
- guint8 *data);
+cogl_texture_get_data (CoglTexture *texture,
+ CoglPixelFormat format,
+ unsigned int rowstride,
+ guint8 *data);
/**
* cogl_texture_set_region:
- * @handle: a #CoglHandle.
+ * @texture a #CoglTexture.
* @src_x: upper left coordinate to use from source data.
* @src_y: upper left coordinate to use from source data.
* @dst_x: upper left destination horizontal coordinate.
@@ -354,7 +355,7 @@ cogl_texture_get_data (CoglHandle handle,
* %FALSE otherwise
*/
gboolean
-cogl_texture_set_region (CoglHandle handle,
+cogl_texture_set_region (CoglTexture *texture,
int src_x,
int src_y,
int dst_x,
@@ -373,7 +374,7 @@ cogl_texture_set_region (CoglHandle handle,
cogl_texture_set_region_from_bitmap_EXP
/**
* cogl_texture_set_region_from_bitmap:
- * @handle: a #CoglHandle for a texture
+ * @texture a #CoglTexture pointer
* @src_x: upper left coordinate to use from the source bitmap.
* @src_y: upper left coordinate to use from the source bitmap
* @dst_x: upper left destination horizontal coordinate.
@@ -392,7 +393,7 @@ cogl_texture_set_region (CoglHandle handle,
* Stability: unstable
*/
gboolean
-cogl_texture_set_region_from_bitmap (CoglHandle handle,
+cogl_texture_set_region_from_bitmap (CoglTexture *texture,
int src_x,
int src_y,
int dst_x,
@@ -404,7 +405,7 @@ cogl_texture_set_region_from_bitmap (CoglHandle handle,
/**
* cogl_texture_new_from_sub_texture:
- * @full_texture: a #CoglHandle to an existing texture
+ * @full_texture: a #CoglTexture pointer
* @sub_x: X coordinate of the top-left of the subregion
* @sub_y: Y coordinate of the top-left of the subregion
* @sub_width: Width in pixels of the subregion
@@ -422,22 +423,22 @@ cogl_texture_set_region_from_bitmap (CoglHandle handle,
* not need to keep one separately if you only want to use the sub
* texture.
*
- * Return value: a #CoglHandle to the new texture.
- *
+ * Return value: A newly created #CoglTexture or %NULL on failure
* Since: 1.2
*/
-CoglHandle
-cogl_texture_new_from_sub_texture (CoglHandle full_texture,
- int sub_x,
- int sub_y,
- int sub_width,
- int sub_height);
+CoglTexture *
+cogl_texture_new_from_sub_texture (CoglTexture *full_texture,
+ int sub_x,
+ int sub_y,
+ int sub_width,
+ int sub_height);
#if defined (COGL_ENABLE_EXPERIMENTAL_API)
+#define cogl_texture_new_from_buffer cogl_texture_new_from_buffer_EXP
/**
* cogl_texture_new_from_buffer:
- * @buffer: the #CoglHandle of a pixel buffer
+ * @buffer: A #CoglPixelBuffer pointer
* @width: width of texture in pixels or 0
* @height: height of texture in pixels or 0
* @flags: optional flags for the texture, or %COGL_TEXTURE_NONE
@@ -459,14 +460,13 @@ cogl_texture_new_from_sub_texture (CoglHandle full_texture,
* has been created using cogl_pixel_buffer_new_for_size() it's possible to omit
* the height and width values already specified at creation time.
*
- * Return value: a #CoglHandle to the new texture or %COGL_INVALID_HANDLE on
- * failure
+ * Return value: A newly created #CoglTexture or %NULL on failure
*
* Since: 1.2
* Stability: Unstable
*/
-CoglHandle
-cogl_texture_new_from_buffer (CoglHandle buffer,
+CoglTexture *
+cogl_texture_new_from_buffer (CoglPixelBuffer *buffer,
unsigned int width,
unsigned int height,
CoglTextureFlags flags,
@@ -474,51 +474,33 @@ cogl_texture_new_from_buffer (CoglHandle buffer,
CoglPixelFormat internal_format,
unsigned int rowstride,
unsigned int offset);
-
-/* the function above is experimental, the actual symbol is suffixed by _EXP so
- * we can ensure ABI compatibility and leave the cogl_buffer namespace free for
- * future use. A bunch of defines translates the symbols documented above into
- * the real symbols */
-
-CoglHandle
-cogl_texture_new_from_buffer_EXP (CoglHandle buffer,
- unsigned int width,
- unsigned int height,
- CoglTextureFlags flags,
- CoglPixelFormat format,
- CoglPixelFormat internal_format,
- unsigned int rowstride,
- unsigned int offset);
-
-#define cogl_texture_new_from_buffer cogl_texture_new_from_buffer_EXP
-
#endif
#ifndef COGL_DISABLE_DEPRECATED
/**
* cogl_texture_ref:
- * @handle: a @CoglHandle.
+ * @texture: a #CoglTexture.
*
* Increment the reference count for a cogl texture.
*
- * Deprecated: 1.2: Use cogl_handle_ref() instead
+ * Deprecated: 1.2: Use cogl_object_ref() instead
*
- * Return value: the @handle.
+ * Return value: the @texture pointer.
*/
-CoglHandle
-cogl_texture_ref (CoglHandle handle) G_GNUC_DEPRECATED;
+void *
+cogl_texture_ref (void *texture) G_GNUC_DEPRECATED;
/**
* cogl_texture_unref:
- * @handle: a @CoglHandle.
+ * @texture: a #CoglTexture.
*
* Decrement the reference count for a cogl texture.
*
- * Deprecated: 1.2: Use cogl_handle_unref() instead
+ * Deprecated: 1.2: Use cogl_object_unref() instead
*/
void
-cogl_texture_unref (CoglHandle handle) G_GNUC_DEPRECATED;
+cogl_texture_unref (void *texture) G_GNUC_DEPRECATED;
#endif /* COGL_DISABLE_DEPRECATED */
diff --git a/cogl/cogl.c b/cogl/cogl.c
index 67231f4..b421aae 100644
--- a/cogl/cogl.c
+++ b/cogl/cogl.c
@@ -1034,13 +1034,13 @@ cogl_set_source (void *material_or_pipeline)
}
void
-cogl_set_source_texture (CoglHandle texture_handle)
+cogl_set_source_texture (CoglTexture *texture)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
- g_return_if_fail (texture_handle != NULL);
+ g_return_if_fail (texture != NULL);
- cogl_pipeline_set_layer_texture (ctx->texture_pipeline, 0, texture_handle);
+ cogl_pipeline_set_layer_texture (ctx->texture_pipeline, 0, texture);
cogl_set_source (ctx->texture_pipeline);
}
diff --git a/cogl/cogl.h b/cogl/cogl.h
index ff7f8f4..c193a44 100644
--- a/cogl/cogl.h
+++ b/cogl/cogl.h
@@ -691,10 +691,10 @@ cogl_set_source_color4f (float red,
/**
* cogl_set_source_texture:
- * @texture_handle: The Cogl texture you want as your source
+ * @texture: The #CoglTexture you want as your source
*
* This is a convenience function for creating a material with the first
- * layer set to #texture_handle and setting that material as the source with
+ * layer set to @texture and setting that material as the source with
* cogl_set_source.
*
* Note: There is no interaction between calls to cogl_set_source_color
@@ -710,7 +710,7 @@ cogl_set_source_color4f (float red,
* Since: 1.0
*/
void
-cogl_set_source_texture (CoglHandle texture_handle);
+cogl_set_source_texture (CoglTexture *texture);
/**
* SECTION:cogl-clipping
diff --git a/cogl/cogl2-path.c b/cogl/cogl2-path.c
index 3707be6..db00f87 100644
--- a/cogl/cogl2-path.c
+++ b/cogl/cogl2-path.c
@@ -316,9 +316,9 @@ _cogl_path_fill_nodes (CoglPath *path)
for (l = _cogl_pipeline_get_layers (cogl_get_source ()); l; l = l->next)
{
CoglHandle layer = l->data;
- CoglHandle texture = _cogl_pipeline_layer_get_texture (layer);
+ CoglTexture *texture = _cogl_pipeline_layer_get_texture (layer);
- if (texture != COGL_INVALID_HANDLE &&
+ if (texture != NULL &&
(cogl_texture_is_sliced (texture) ||
!_cogl_texture_can_hardware_repeat (texture)))
{
diff --git a/cogl/winsys/cogl-texture-pixmap-x11.c b/cogl/winsys/cogl-texture-pixmap-x11.c
index 767262e..90ddbb6 100644
--- a/cogl/winsys/cogl-texture-pixmap-x11.c
+++ b/cogl/winsys/cogl-texture-pixmap-x11.c
@@ -637,7 +637,7 @@ _cogl_texture_pixmap_x11_set_use_winsys_texture (CoglTexturePixmapX11 *tex_pixma
/* Notify cogl-pipeline.c that the texture's underlying GL texture
* storage is changing so it knows it may need to bind a new texture
* if the CoglTexture is reused with the same texture unit. */
- _cogl_pipeline_texture_storage_change_notify (tex_pixmap);
+ _cogl_pipeline_texture_storage_change_notify (COGL_TEXTURE (tex_pixmap));
tex_pixmap->use_winsys_texture = new_value;
}
diff --git a/cogl/winsys/cogl-winsys-egl.c b/cogl/winsys/cogl-winsys-egl.c
index 72b678e..e7c273a 100644
--- a/cogl/winsys/cogl-winsys-egl.c
+++ b/cogl/winsys/cogl-winsys-egl.c
@@ -179,7 +179,7 @@ typedef struct _CoglOnscreenEGL
typedef struct _CoglTexturePixmapEGL
{
EGLImageKHR image;
- CoglHandle texture;
+ CoglTexture *texture;
} CoglTexturePixmapEGL;
#endif
@@ -1699,13 +1699,13 @@ _cogl_winsys_texture_pixmap_x11_create (CoglTexturePixmapX11 *tex_pixmap)
COGL_PIXEL_FORMAT_RGBA_8888_PRE :
COGL_PIXEL_FORMAT_RGB_888);
- egl_tex_pixmap->texture =
+ egl_tex_pixmap->texture = COGL_TEXTURE (
_cogl_egl_texture_2d_new_from_image (ctx,
tex_pixmap->width,
tex_pixmap->height,
texture_format,
egl_tex_pixmap->image,
- NULL);
+ NULL));
tex_pixmap->winsys = egl_tex_pixmap;
@@ -1727,7 +1727,7 @@ _cogl_winsys_texture_pixmap_x11_free (CoglTexturePixmapX11 *tex_pixmap)
egl_tex_pixmap = tex_pixmap->winsys;
if (egl_tex_pixmap->texture)
- cogl_handle_unref (egl_tex_pixmap->texture);
+ cogl_object_unref (egl_tex_pixmap->texture);
if (egl_tex_pixmap->image != EGL_NO_IMAGE_KHR)
_cogl_egl_destroy_image (ctx, egl_tex_pixmap->image);
diff --git a/examples/crate.c b/examples/crate.c
index e6a83b1..506b931 100644
--- a/examples/crate.c
+++ b/examples/crate.c
@@ -10,7 +10,7 @@ typedef struct _Data
CoglMatrix view;
CoglPrimitive *prim;
- CoglHandle texture;
+ CoglTexture *texture;
CoglPipeline *crate_pipeline;
/* The cube continually rotates around each axis. */
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
