brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

cogl: Port Texture* away from CoglObject

Browse Source 
- Make Texture a parent GObject class and move the vtable funcs as vfuncs
instead of an interface as we would like to have dispose free the TextureLoader.
- Make the various texture sub-types inherit from it.
- Make all the sub-types constructors return a CoglTexture instead of their respective
specific type. As most of the times, the used functions accept a CoglTexture,
like all the GTK widgets constructors returning GtkWidget.
- Fix up the basics of gi-docgen for all these types.
- Remove CoglPrimitiveTexture as it is useless: It is just a texture underhood.
- Remove CoglMetaTexture: for the exact same reason as above.
- Switch various memory management functions to use g_ variant instead of the cogl_ one

Note we would still want to get rid of the _cogl_texture_init which is something
for the next commit

Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/3193>
This commit is contained in:
Bilal Elmoussaoui 2023-09-18 16:58:36 +02:00 committed by Marge Bot
parent 586c43d5a9
commit 863163cc6e
115 changed files with 2278 additions and 2449 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
clutter/clutter/clutter-blur.c
View File

@ -230,7 +230,7 @@ create_fbo (ClutterBlur *blur,
float height;
float width;
cogl_clear_object (&pass->texture);
g_clear_object (&pass->texture);
g_clear_object (&pass->framebuffer);
width = cogl_texture_get_width (blur->source_texture);
@ -238,9 +238,9 @@ create_fbo (ClutterBlur *blur,
scaled_width = floorf (width / blur->downscale_factor);
scaled_height = floorf (height / blur->downscale_factor);
pass->texture = COGL_TEXTURE (cogl_texture_2d_new_with_size (ctx,
pass->texture = cogl_texture_2d_new_with_size (ctx,
scaled_width,
scaled_height));
scaled_height);
if (!pass->texture)
return FALSE;
@ -327,7 +327,7 @@ static void
clear_blur_pass (BlurPass *pass)
{
cogl_clear_object (&pass->pipeline);
cogl_clear_object (&pass->texture);
g_clear_object (&pass->texture);
g_clear_object (&pass->framebuffer);
}
@ -358,7 +358,7 @@ clutter_blur_new (CoglTexture *texture,
blur = g_new0 (ClutterBlur, 1);
blur->sigma = sigma;
blur->source_texture = cogl_object_ref (texture);
blur->source_texture = g_object_ref (texture);
blur->downscale_factor = calculate_downscale_factor (width, height, sigma);
if (G_APPROX_VALUE (sigma, 0.0, FLT_EPSILON))
@ -426,6 +426,6 @@ clutter_blur_free (ClutterBlur *blur)
clear_blur_pass (&blur->pass[VERTICAL]);
clear_blur_pass (&blur->pass[HORIZONTAL]);
cogl_clear_object (&blur->source_texture);
g_clear_object (&blur->source_texture);
g_free (blur);
}

6
clutter/clutter/clutter-canvas.c
View File

@ -128,7 +128,7 @@ clutter_canvas_finalize (GObject *gobject)
ClutterCanvasPrivate *priv = CLUTTER_CANVAS (gobject)->priv;
g_clear_object (&priv->buffer);
cogl_clear_object (&priv->texture);
g_clear_object (&priv->texture);
G_OBJECT_CLASS (clutter_canvas_parent_class)->finalize (gobject);
}
@ -317,10 +317,10 @@ clutter_canvas_paint_content (ClutterContent *content,
return;
if (priv->dirty)
cogl_clear_object (&priv->texture);
g_clear_object (&priv->texture);
if (priv->texture == NULL)
priv->texture = COGL_TEXTURE (cogl_texture_2d_new_from_bitmap (priv->buffer));
priv->texture = cogl_texture_2d_new_from_bitmap (priv->buffer);
if (priv->texture == NULL)
return;

12
clutter/clutter/clutter-image.c
View File

@ -70,7 +70,7 @@ create_texture_from_data (unsigned int width,
{
CoglContext *ctx =
clutter_backend_get_cogl_context (clutter_get_default_backend ());
CoglTexture2D *texture_2d;
CoglTexture *texture_2d;
texture_2d = cogl_texture_2d_new_from_data (ctx,
width,
@ -80,7 +80,7 @@ create_texture_from_data (unsigned int width,
data,
error);
return texture_2d ? COGL_TEXTURE (texture_2d) : NULL;
return texture_2d;
}
static void
@ -111,7 +111,7 @@ clutter_image_finalize (GObject *gobject)
ClutterImage *image = CLUTTER_IMAGE (gobject);
ClutterImagePrivate *priv = clutter_image_get_instance_private (image);
cogl_clear_object (&priv->texture);
g_clear_object (&priv->texture);
G_OBJECT_CLASS (clutter_image_parent_class)->finalize (gobject);
}
@ -248,7 +248,7 @@ clutter_image_set_data (ClutterImage *image,
priv = clutter_image_get_instance_private (image);
if (priv->texture != NULL)
cogl_object_unref (priv->texture);
g_object_unref (priv->texture);
priv->texture = create_texture_from_data (width,
height,
@ -306,7 +306,7 @@ clutter_image_set_bytes (ClutterImage *image,
priv = clutter_image_get_instance_private (image);
if (priv->texture != NULL)
cogl_object_unref (priv->texture);
g_object_unref (priv->texture);
priv->texture = create_texture_from_data (width,
height,
@ -391,7 +391,7 @@ clutter_image_set_area (ClutterImage *image,
if (!res)
{
cogl_clear_object (&priv->texture);
g_clear_object (&priv->texture);
}
}

6
clutter/clutter/clutter-offscreen-effect.c
View File

@ -155,7 +155,7 @@ clutter_offscreen_effect_real_create_texture (ClutterOffscreenEffect *effect,
CoglContext *ctx =
clutter_backend_get_cogl_context (clutter_get_default_backend ());
return COGL_TEXTURE (cogl_texture_2d_new_with_size (ctx, MAX (width, 1), MAX (height, 1)));
return cogl_texture_2d_new_with_size (ctx, MAX (width, 1), MAX (height, 1));
}
static void
@ -256,7 +256,7 @@ update_fbo (ClutterEffect *effect,
return TRUE;
}
g_clear_pointer (&priv->texture, cogl_object_unref);
g_clear_object (&priv->texture);
g_clear_object (&priv->offscreen);
priv->texture =
@ -576,7 +576,7 @@ clutter_offscreen_effect_finalize (GObject *gobject)
ClutterOffscreenEffectPrivate *priv = self->priv;
g_clear_object (&priv->offscreen);
g_clear_pointer (&priv->texture, cogl_object_unref);
g_clear_object (&priv->texture);
g_clear_pointer (&priv->pipeline, cogl_object_unref);
G_OBJECT_CLASS (clutter_offscreen_effect_parent_class)->finalize (gobject);

10
clutter/clutter/clutter-paint-nodes.c
View File

@ -710,7 +710,7 @@ clutter_scaling_filter_to_cogl_pipeline_filter (ClutterScalingFilter filter)
* Creates a new #ClutterPaintNode that will paint the passed @texture.
*
* This function will take a reference on @texture, so it is safe to
* call cogl_object_unref() on @texture when it returns.
* call g_object_unref() on @texture when it returns.
*
* The @color must not be pre-multiplied with its #ClutterColor.alpha
* channel value; if @color is %NULL, a fully opaque white color will
@ -729,7 +729,7 @@ clutter_texture_node_new (CoglTexture *texture,
CoglColor cogl_color;
CoglPipelineFilter min_f, mag_f;
g_return_val_if_fail (cogl_is_texture (texture), NULL);
g_return_val_if_fail (COGL_IS_TEXTURE (texture), NULL);
tnode = _clutter_paint_node_create (CLUTTER_TYPE_TEXTURE_NODE);
@ -1782,7 +1782,6 @@ clutter_blur_node_new (unsigned int width,
g_autoptr (GError) error = NULL;
ClutterLayerNode *layer_node;
ClutterBlurNode *blur_node;
CoglTexture2D *tex_2d;
CoglContext *context;
CoglTexture *texture;
ClutterBlur *blur;
@ -1792,13 +1791,12 @@ clutter_blur_node_new (unsigned int width,
blur_node = _clutter_paint_node_create (CLUTTER_TYPE_BLUR_NODE);
blur_node->sigma = sigma;
context = clutter_backend_get_cogl_context (clutter_get_default_backend ());
tex_2d = cogl_texture_2d_new_with_size (context, width, height);
texture = cogl_texture_2d_new_with_size (context, width, height);
texture = COGL_TEXTURE (tex_2d);
cogl_texture_set_premultiplied (texture, TRUE);
offscreen = cogl_offscreen_new_with_texture (texture);
cogl_object_unref (tex_2d);
g_object_unref (texture);
if (!cogl_framebuffer_allocate (COGL_FRAMEBUFFER (offscreen), &error))
{
g_warning ("Unable to allocate paint node offscreen: %s",

13
clutter/clutter/clutter-stage-view.c
View File

@ -381,20 +381,19 @@ create_offscreen_framebuffer (CoglContext *context,
GError **error)
{
CoglOffscreen *framebuffer;
CoglTexture2D *texture;
CoglTexture *texture;
texture = cogl_texture_2d_new_with_size (context, width, height);
cogl_primitive_texture_set_auto_mipmap (COGL_PRIMITIVE_TEXTURE (texture),
FALSE);
cogl_primitive_texture_set_auto_mipmap (texture, FALSE);
if (!cogl_texture_allocate (COGL_TEXTURE (texture), error))
if (!cogl_texture_allocate (texture, error))
{
cogl_object_unref (texture);
g_object_unref (texture);
return FALSE;
}
framebuffer = cogl_offscreen_new_with_texture (COGL_TEXTURE (texture));
cogl_object_unref (texture);
framebuffer = cogl_offscreen_new_with_texture (texture);
g_object_unref (texture);
if (!cogl_framebuffer_allocate (COGL_FRAMEBUFFER (framebuffer), error))
{
g_object_unref (framebuffer);

12
clutter/clutter/clutter-stage.c
View File

@ -2784,7 +2784,7 @@ clutter_stage_paint_to_buffer (ClutterStage *stage,
CoglContext *cogl_context =
clutter_backend_get_cogl_context (clutter_backend);
int texture_width, texture_height;
CoglTexture2D *texture;
CoglTexture *texture;
CoglOffscreen *offscreen;
CoglFramebuffer *framebuffer;
CoglBitmap *bitmap;
@ -2802,10 +2802,10 @@ clutter_stage_paint_to_buffer (ClutterStage *stage,
return FALSE;
}
offscreen = cogl_offscreen_new_with_texture (COGL_TEXTURE (texture));
offscreen = cogl_offscreen_new_with_texture (texture);
framebuffer = COGL_FRAMEBUFFER (offscreen);
cogl_object_unref (texture);
g_object_unref (texture);
if (!cogl_framebuffer_allocate (framebuffer, error))
return FALSE;
@ -2853,7 +2853,7 @@ clutter_stage_paint_to_content (ClutterStage *stage,
CoglContext *cogl_context =
clutter_backend_get_cogl_context (clutter_backend);
int texture_width, texture_height;
CoglTexture2D *texture;
CoglTexture *texture;
CoglOffscreen *offscreen;
g_autoptr (CoglFramebuffer) framebuffer = NULL;
@ -2870,10 +2870,10 @@ clutter_stage_paint_to_content (ClutterStage *stage,
return NULL;
}
offscreen = cogl_offscreen_new_with_texture (COGL_TEXTURE (texture));
offscreen = cogl_offscreen_new_with_texture (texture);
framebuffer = COGL_FRAMEBUFFER (offscreen);
cogl_object_unref (texture);
g_object_unref (texture);
if (!cogl_framebuffer_allocate (framebuffer, error))
return NULL;

17
clutter/clutter/clutter-texture-content.c
View File

@ -51,7 +51,7 @@ clutter_texture_content_finalize (GObject *gobject)
{
ClutterTextureContent *texture_content = CLUTTER_TEXTURE_CONTENT (gobject);
g_clear_pointer (&texture_content->texture, cogl_object_unref);
g_clear_object (&texture_content->texture);
G_OBJECT_CLASS (clutter_texture_content_parent_class)->finalize (gobject);
}
@ -114,7 +114,7 @@ clutter_content_iface_init (ClutterContentInterface *iface)
* Creates a new [class@TextureContent] instance for @texture, taking an
* internal reference to @texture.
*
* If you change the contents of the [iface@Cogl.Texture] you will need
* If you change the contents of the [class@Cogl.Texture] you will need
* to manually invalidate the @texture_content with [method@Content.invalidate]
* in order to update the actors using @texture_content as their content.
*
@ -135,17 +135,16 @@ clutter_texture_content_new_from_texture (CoglTexture *texture,
if (clip)
{
texture_content->texture =
COGL_TEXTURE (cogl_sub_texture_new (cogl_context,
texture_content->texture = cogl_sub_texture_new (cogl_context,
texture,
clip->x,
clip->y,
clip->width,
clip->height));
clip->height);
}
else
{
texture_content->texture = cogl_object_ref (texture);
texture_content->texture = g_object_ref (texture);
}
return CLUTTER_CONTENT (texture_content);
@ -155,13 +154,13 @@ clutter_texture_content_new_from_texture (CoglTexture *texture,
* clutter_texture_content_get_texture:
* @texture_content: a #ClutterTextureContent
*
* Retrieves a pointer to the [iface@Cogl.Texture] used by @texture_content.
* Retrieves a pointer to the [class@Cogl.Texture] used by @texture_content.
*
* If you change the contents of the returned [iface@Cogl.Texture] you will need
* If you change the contents of the returned [class@Cogl.Texture] you will need
* to manually invalidate the @texture_content with [method@Content.invalidate]
* in order to update the actors using @texture_content as their content.
*
* Return value: (transfer none): a pointer to the [iface@Cogl.Texture]
* Return value: (transfer none): a pointer to the [class@Cogl.Texture]
*/
CoglTexture *
clutter_texture_content_get_texture (ClutterTextureContent *texture_content)

4
cogl/cogl-pango/cogl-pango-display-list.c
View File

@ -167,7 +167,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_object_ref (texture);
node->d.texture.texture = g_object_ref (texture);
node->d.texture.rectangles
= g_array_new (FALSE, FALSE, sizeof (CoglPangoDisplayListRectangle));
node->d.texture.primitive = NULL;
@ -461,7 +461,7 @@ _cogl_pango_display_list_node_free (CoglPangoDisplayListNode *node)
{
g_array_free (node->d.texture.rectangles, TRUE);
if (node->d.texture.texture != NULL)
cogl_object_unref (node->d.texture.texture);
g_object_unref (node->d.texture.texture);
if (node->d.texture.primitive != NULL)
cogl_object_unref (node->d.texture.primitive);
}

12
cogl/cogl-pango/cogl-pango-glyph-cache.c
View File

@ -76,7 +76,7 @@ static void
cogl_pango_glyph_cache_value_free (CoglPangoGlyphCacheValue *value)
{
if (value->texture)
cogl_object_unref (value->texture);
g_object_unref (value->texture);
g_free (value);
}
@ -192,8 +192,8 @@ cogl_pango_glyph_cache_update_position_cb (void *user_data,
float tex_width, tex_height;
if (value->texture)
cogl_object_unref (value->texture);
value->texture = cogl_object_ref (new_texture);
g_object_unref (value->texture);
value->texture = g_object_ref (new_texture);
tex_width = cogl_texture_get_width (new_texture);
tex_height = cogl_texture_get_height (new_texture);
@ -216,7 +216,7 @@ cogl_pango_glyph_cache_add_to_global_atlas (CoglPangoGlyphCache *cache,
PangoGlyph glyph,
CoglPangoGlyphCacheValue *value)
{
CoglAtlasTexture *texture;
CoglTexture *texture;
GError *ignore_error = NULL;
if (COGL_DEBUG_ENABLED (COGL_DEBUG_DISABLE_SHARED_ATLAS))
@ -230,13 +230,13 @@ cogl_pango_glyph_cache_add_to_global_atlas (CoglPangoGlyphCache *cache,
texture = cogl_atlas_texture_new_with_size (cache->ctx,
value->draw_width,
value->draw_height);
if (!cogl_texture_allocate (COGL_TEXTURE (texture), &ignore_error))
if (!cogl_texture_allocate (texture, &ignore_error))
{
g_error_free (ignore_error);
return FALSE;
}
value->texture = COGL_TEXTURE (texture);
value->texture = texture;
value->tx1 = 0;
value->ty1 = 0;
value->tx2 = 1;

6
cogl/cogl-pango/cogl-pango-pipeline-cache.c
View File

@ -64,7 +64,7 @@ _cogl_pango_pipeline_cache_value_destroy (void *data)
CoglPangoPipelineCacheEntry *cache_entry = data;
if (cache_entry->texture)
cogl_object_unref (cache_entry->texture);
g_object_unref (cache_entry->texture);
/* We don't need to unref the pipeline because it only takes a weak
reference */
@ -188,7 +188,7 @@ _cogl_pango_pipeline_cache_get (CoglPangoPipelineCache *cache,
{
CoglPipeline *base;
entry->texture = cogl_object_ref (texture);
entry->texture = g_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_object_ref (texture) : NULL,
texture ? g_object_ref (texture) : NULL,
entry);
/* This doesn't take a reference on the pipeline so that it will use

2
cogl/cogl-pango/cogl-pango-render.c
View File

@ -175,7 +175,7 @@ cogl_pango_renderer_draw_glyph (CoglPangoRenderer *priv,
the neighbouring glyphs are coming from the same atlas and bundle
them together into a single VBO */
cogl_meta_texture_foreach_in_region (COGL_META_TEXTURE (cache_value->texture),
cogl_meta_texture_foreach_in_region (cache_value->texture,
cache_value->tx1,
cache_value->ty1,
cache_value->tx2,

11
cogl/cogl/cogl-atlas-texture-private.h
View File

@ -30,7 +30,6 @@
#pragma once
#include "cogl/cogl-object-private.h"
#include "cogl/cogl-texture-private.h"
#include "cogl/cogl-rectangle-map.h"
#include "cogl/cogl-atlas.h"
@ -38,7 +37,7 @@
struct _CoglAtlasTexture
{
CoglTexture _parent;
CoglTexture parent_instance;
/* The format that the texture is in. This isn't necessarily the
same format as the atlas texture because we can store
@ -60,6 +59,11 @@ struct _CoglAtlasTexture
CoglTexture *sub_texture;
};
struct _CoglAtlasTextureClass
{
CoglTextureClass parent_class;
};
COGL_EXPORT void
_cogl_atlas_texture_add_reorganize_callback (CoglContext *ctx,
GHookFunc callback,
@ -69,6 +73,3 @@ COGL_EXPORT void
_cogl_atlas_texture_remove_reorganize_callback (CoglContext *ctx,
GHookFunc callback,
void *user_data);
gboolean
_cogl_is_atlas_texture (void *object);

255
cogl/cogl/cogl-atlas-texture.c
View File

@ -40,31 +40,50 @@
#include "cogl/cogl-texture-2d-private.h"
#include "cogl/cogl-sub-texture-private.h"
#include "cogl/cogl-context-private.h"
#include "cogl/cogl-object-private.h"
#include "cogl/cogl-texture-driver.h"
#include "cogl/cogl-rectangle-map.h"
#include "cogl/cogl-journal-private.h"
#include "cogl/cogl-atlas.h"
#include "cogl/cogl1-context.h"
#include "cogl/cogl-sub-texture.h"
#include "cogl/cogl-gtype-private.h"
#include "cogl/driver/gl/cogl-texture-gl-private.h"
#include <stdlib.h>
static void _cogl_atlas_texture_free (CoglAtlasTexture *sub_tex);
static GQuark atlas_private_key = 0;
COGL_TEXTURE_DEFINE (AtlasTexture, atlas_texture);
COGL_GTYPE_DEFINE_CLASS (AtlasTexture, atlas_texture);
G_DEFINE_FINAL_TYPE (CoglAtlasTexture, cogl_atlas_texture, COGL_TYPE_TEXTURE)
static const CoglTextureVtable cogl_atlas_texture_vtable;
static void
_cogl_atlas_texture_remove_from_atlas (CoglAtlasTexture *atlas_tex)
{
if (atlas_tex->atlas)
{
_cogl_atlas_remove (atlas_tex->atlas,
&atlas_tex->rectangle);
static CoglSubTexture *
g_object_unref (atlas_tex->atlas);
atlas_tex->atlas = NULL;
}
}
static void
cogl_atlas_texture_dispose (GObject *object)
{
CoglAtlasTexture *atlas_tex = COGL_ATLAS_TEXTURE (object);
_cogl_atlas_texture_remove_from_atlas (atlas_tex);
if (atlas_tex->sub_texture)
g_object_unref (atlas_tex->sub_texture);
G_OBJECT_CLASS (cogl_atlas_texture_parent_class)->dispose (object);
}
static CoglTexture *
_cogl_atlas_texture_create_sub_texture (CoglTexture *full_texture,
const CoglRectangleMapEntry *rectangle)
{
CoglContext *ctx = full_texture->context;
CoglContext *ctx = cogl_texture_get_context (full_texture);
/* Create a subtexture for the given rectangle not including the
1-pixel border */
return cogl_sub_texture_new (ctx,
@ -84,9 +103,9 @@ _cogl_atlas_texture_update_position_cb (void *user_data,
/* Update the sub texture */
if (atlas_tex->sub_texture)
cogl_object_unref (atlas_tex->sub_texture);
atlas_tex->sub_texture = COGL_TEXTURE (
_cogl_atlas_texture_create_sub_texture (new_texture, rectangle));
g_object_unref (atlas_tex->sub_texture);
atlas_tex->sub_texture =
_cogl_atlas_texture_create_sub_texture (new_texture, rectangle);
/* Update the position */
atlas_tex->rectangle = *rectangle;
@ -102,7 +121,7 @@ _cogl_atlas_texture_pre_reorganize_foreach_cb
/* Keep a reference to the texture because we don't want it to be
destroyed during the reorganization */
cogl_object_ref (atlas_tex);
g_object_ref (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
@ -178,7 +197,7 @@ _cogl_atlas_texture_post_reorganize_cb (void *user_data)
the structure for the texture so that it can get stored
in the atlas but it isn't a valid object yet */
if (data.textures[i]->atlas)
cogl_object_unref (data.textures[i]);
g_object_unref (data.textures[i]);
}
g_free (data.textures);
@ -237,10 +256,9 @@ _cogl_atlas_texture_foreach_sub_texture_in_region (
void *user_data)
{
CoglAtlasTexture *atlas_tex = COGL_ATLAS_TEXTURE (tex);
CoglMetaTexture *meta_texture = COGL_META_TEXTURE (atlas_tex->sub_texture);
/* Forward on to the sub texture */
cogl_meta_texture_foreach_in_region (meta_texture,
cogl_meta_texture_foreach_in_region (atlas_tex->sub_texture,
virtual_tx_1,
virtual_ty_1,
virtual_tx_2,
@ -264,31 +282,6 @@ _cogl_atlas_texture_gl_flush_legacy_texobj_wrap_modes (CoglTexture *tex,
wrap_mode_t);
}
static void
_cogl_atlas_texture_remove_from_atlas (CoglAtlasTexture *atlas_tex)
{
if (atlas_tex->atlas)
{
_cogl_atlas_remove (atlas_tex->atlas,
&atlas_tex->rectangle);
g_object_unref (atlas_tex->atlas);
atlas_tex->atlas = NULL;
}
}
static void
_cogl_atlas_texture_free (CoglAtlasTexture *atlas_tex)
{
_cogl_atlas_texture_remove_from_atlas (atlas_tex);
if (atlas_tex->sub_texture)
cogl_object_unref (atlas_tex->sub_texture);
/* Chain up */
_cogl_texture_free (COGL_TEXTURE (atlas_tex));
}
static int
_cogl_atlas_texture_get_max_waste (CoglTexture *tex)
{
@ -410,7 +403,7 @@ _cogl_atlas_texture_migrate_out_of_atlas (CoglAtlasTexture *atlas_tex)
the copy can involve rendering which might cause the texture
to be used if it is used from a layer that is left in a
texture unit */
cogl_object_unref (atlas_tex->sub_texture);
g_object_unref (atlas_tex->sub_texture);
atlas_tex->sub_texture = standalone_tex;
_cogl_atlas_texture_remove_from_atlas (atlas_tex);
@ -648,60 +641,6 @@ _cogl_atlas_texture_can_use_format (CoglPixelFormat format)
format == COGL_PIXEL_FORMAT_RGBA_8888);
}
static CoglAtlasTexture *
_cogl_atlas_texture_create_base (CoglContext *ctx,
int width,
int height,
CoglPixelFormat internal_format,
CoglTextureLoader *loader)
{
CoglAtlasTexture *atlas_tex;
COGL_NOTE (ATLAS, "Adding texture of size %ix%i", width, height);
/* We need to allocate the texture now because we need the pointer
to set as the data for the rectangle in the atlas */
atlas_tex = g_new0 (CoglAtlasTexture, 1);
/* Mark it as having no atlas so we don't try to unref it in
_cogl_atlas_texture_post_reorganize_cb */
atlas_tex->atlas = NULL;
_cogl_texture_init (COGL_TEXTURE (atlas_tex),
ctx,
width, height,
internal_format,
loader,
&cogl_atlas_texture_vtable);
atlas_tex->sub_texture = NULL;
atlas_tex->atlas = NULL;
return _cogl_atlas_texture_object_new (atlas_tex);
}
CoglAtlasTexture *
cogl_atlas_texture_new_with_size (CoglContext *ctx,
int width,
int height)
{
CoglTextureLoader *loader;
/* We can't atlas zero-sized textures because it breaks the atlas
* data structure */
g_return_val_if_fail (width > 0 && height > 0, NULL);
loader = _cogl_texture_create_loader ();
loader->src_type = COGL_TEXTURE_SOURCE_TYPE_SIZE;
loader->src.sized.width = width;
loader->src.sized.height = height;
loader->src.sized.format = COGL_PIXEL_FORMAT_ANY;
return _cogl_atlas_texture_create_base (ctx, width, height,
COGL_PIXEL_FORMAT_RGBA_8888_PRE,
loader);
}
static gboolean
allocate_space (CoglAtlasTexture *atlas_tex,
int width,
@ -710,7 +649,7 @@ allocate_space (CoglAtlasTexture *atlas_tex,
GError **error)
{
CoglTexture *tex = COGL_TEXTURE (atlas_tex);
CoglContext *ctx = tex->context;
CoglContext *ctx = cogl_texture_get_context (tex);
CoglAtlas *atlas;
GSList *l;
@ -795,7 +734,7 @@ allocate_with_size (CoglAtlasTexture *atlas_tex,
internal_format,
error))
{
_cogl_texture_set_allocated (COGL_TEXTURE (atlas_tex),
_cogl_texture_set_allocated (tex,
internal_format,
loader->src.sized.width,
loader->src.sized.height);
@ -869,7 +808,7 @@ _cogl_atlas_texture_allocate (CoglTexture *tex,
GError **error)
{
CoglAtlasTexture *atlas_tex = COGL_ATLAS_TEXTURE (tex);
CoglTextureLoader *loader = tex->loader;
CoglTextureLoader *loader = cogl_texture_get_loader (tex);
g_return_val_if_fail (loader, FALSE);
@ -886,7 +825,95 @@ _cogl_atlas_texture_allocate (CoglTexture *tex,
g_return_val_if_reached (FALSE);
}
CoglAtlasTexture *
static void
cogl_atlas_texture_class_init (CoglAtlasTextureClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
CoglTextureClass *texture_class = COGL_TEXTURE_CLASS (klass);
object_class->dispose = cogl_atlas_texture_dispose;
texture_class->allocate = _cogl_atlas_texture_allocate;
texture_class->set_region = _cogl_atlas_texture_set_region;
texture_class->foreach_sub_texture_in_region = _cogl_atlas_texture_foreach_sub_texture_in_region;
texture_class->get_max_waste = _cogl_atlas_texture_get_max_waste;
texture_class->is_sliced = _cogl_atlas_texture_is_sliced;
texture_class->can_hardware_repeat = _cogl_atlas_texture_can_hardware_repeat;
texture_class->transform_coords_to_gl = _cogl_atlas_texture_transform_coords_to_gl;
texture_class->transform_quad_coords_to_gl = _cogl_atlas_texture_transform_quad_coords_to_gl;
texture_class->get_gl_texture = _cogl_atlas_texture_get_gl_texture;
texture_class->gl_flush_legacy_texobj_filters = _cogl_atlas_texture_gl_flush_legacy_texobj_filters;
texture_class->pre_paint = _cogl_atlas_texture_pre_paint;
texture_class->ensure_non_quad_rendering = _cogl_atlas_texture_ensure_non_quad_rendering;
texture_class->gl_flush_legacy_texobj_wrap_modes = _cogl_atlas_texture_gl_flush_legacy_texobj_wrap_modes;
texture_class->get_format = _cogl_atlas_texture_get_format;
texture_class->get_gl_format = _cogl_atlas_texture_get_gl_format;
}
static void
cogl_atlas_texture_init (CoglAtlasTexture *self)
{
CoglTexture *texture = COGL_TEXTURE (self);
texture->is_primitive = FALSE;
}
static CoglTexture *
_cogl_atlas_texture_create_base (CoglContext *ctx,
int width,
int height,
CoglPixelFormat internal_format,
CoglTextureLoader *loader)
{
CoglAtlasTexture *atlas_tex;
CoglTexture *tex;
COGL_NOTE (ATLAS, "Adding texture of size %ix%i", width, height);
/* We need to allocate the texture now because we need the pointer
to set as the data for the rectangle in the atlas */
atlas_tex = g_object_new (COGL_TYPE_ATLAS_TEXTURE, NULL);
/* Mark it as having no atlas so we don't try to unref it in
_cogl_atlas_texture_post_reorganize_cb */
atlas_tex->atlas = NULL;
tex = COGL_TEXTURE (atlas_tex);
_cogl_texture_init (tex,
ctx,
width, height,
internal_format,
loader);
atlas_tex->sub_texture = NULL;
atlas_tex->atlas = NULL;
return tex;
}
CoglTexture *
cogl_atlas_texture_new_with_size (CoglContext *ctx,
int width,
int height)
{
CoglTextureLoader *loader;
/* We can't atlas zero-sized textures because it breaks the atlas
* data structure */
g_return_val_if_fail (width > 0 && height > 0, NULL);
loader = _cogl_texture_create_loader ();
loader->src_type = COGL_TEXTURE_SOURCE_TYPE_SIZE;
loader->src.sized.width = width;
loader->src.sized.height = height;
loader->src.sized.format = COGL_PIXEL_FORMAT_ANY;
return _cogl_atlas_texture_create_base (ctx, width, height,
COGL_PIXEL_FORMAT_RGBA_8888_PRE,
loader);
}
CoglTexture *
cogl_atlas_texture_new_from_bitmap (CoglBitmap *bmp)
{
CoglTextureLoader *loader;
@ -904,7 +931,7 @@ cogl_atlas_texture_new_from_bitmap (CoglBitmap *bmp)
loader);
}
CoglAtlasTexture *
CoglTexture *
cogl_atlas_texture_new_from_data (CoglContext *ctx,
int width,
int height,
@ -914,7 +941,7 @@ cogl_atlas_texture_new_from_data (CoglContext *ctx,
GError **error)
{
CoglBitmap *bmp;
CoglAtlasTexture *atlas_tex;
CoglTexture *atlas_tex;
g_return_val_if_fail (format != COGL_PIXEL_FORMAT_ANY, NULL);
g_return_val_if_fail (cogl_pixel_format_get_n_planes (format) == 1, NULL);
@ -938,7 +965,7 @@ cogl_atlas_texture_new_from_data (CoglContext *ctx,
if (atlas_tex &&
!cogl_texture_allocate (COGL_TEXTURE (atlas_tex), error))
{
cogl_object_unref (atlas_tex);
g_object_unref (atlas_tex);
return NULL;
}
@ -969,27 +996,3 @@ _cogl_atlas_texture_remove_reorganize_callback (CoglContext *ctx,
if (hook)
g_hook_destroy_link (&ctx->atlas_reorganize_callbacks, hook);
}
static const CoglTextureVtable
cogl_atlas_texture_vtable =
{
FALSE, /* not primitive */
_cogl_atlas_texture_allocate,
_cogl_atlas_texture_set_region,
NULL, /* is_get_data_supported */
NULL, /* get_data */
_cogl_atlas_texture_foreach_sub_texture_in_region,
_cogl_atlas_texture_get_max_waste,
_cogl_atlas_texture_is_sliced,
_cogl_atlas_texture_can_hardware_repeat,
_cogl_atlas_texture_transform_coords_to_gl,
_cogl_atlas_texture_transform_quad_coords_to_gl,
_cogl_atlas_texture_get_gl_texture,
_cogl_atlas_texture_gl_flush_legacy_texobj_filters,
_cogl_atlas_texture_pre_paint,
_cogl_atlas_texture_ensure_non_quad_rendering,
_cogl_atlas_texture_gl_flush_legacy_texobj_wrap_modes,
_cogl_atlas_texture_get_format,
_cogl_atlas_texture_get_gl_format,
NULL /* set_auto_mipmap */
};

42
cogl/cogl/cogl-atlas-texture.h
View File

@ -41,8 +41,9 @@
G_BEGIN_DECLS
/**
* SECTION:cogl-atlas-texture
* @short_description: Functions for managing textures in Cogl's global
* CoglAtlasTexture:
*
* Functions for managing textures in Cogl's global
* set of texture atlases
*
* A texture atlas is a texture that contains many smaller images that
@ -63,18 +64,21 @@ G_BEGIN_DECLS
* some limitations to be aware of. Please see the documentation for
* #CoglMetaTexture for more details.</note>
*/
#define COGL_TYPE_ATLAS_TEXTURE (cogl_atlas_texture_get_type ())
#define COGL_ATLAS_TEXTURE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), COGL_TYPE_ATLAS_TEXTURE, CoglAtlasTexture))
#define COGL_ATLAS_TEXTURE_CONST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), COGL_TYPE_ATLAS_TEXTURE, CoglAtlasTexture const))
#define COGL_ATLAS_TEXTURE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), COGL_TYPE_ATLAS_TEXTURE, CoglAtlasTextureClass))
#define COGL_IS_ATLAS_TEXTURE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), COGL_TYPE_ATLAS_TEXTURE))
#define COGL_IS_ATLAS_TEXTURE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), COGL_TYPE_ATLAS_TEXTURE))
#define COGL_ATLAS_TEXTURE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), COGL_TYPE_ATLAS_TEXTURE, CoglAtlasTextureClass))
typedef struct _CoglAtlasTextureClass CoglAtlasTextureClass;
typedef struct _CoglAtlasTexture CoglAtlasTexture;
#define COGL_ATLAS_TEXTURE(tex) ((CoglAtlasTexture *) tex)
/**
* cogl_atlas_texture_get_gtype:
*
* Returns: a #GType that can be used with the GLib type system.
*/
G_DEFINE_AUTOPTR_CLEANUP_FUNC (CoglAtlasTexture, g_object_unref)
COGL_EXPORT
GType cogl_atlas_texture_get_gtype (void);
GType cogl_atlas_texture_get_type (void) G_GNUC_CONST;
/**
* cogl_atlas_texture_new_with_size:
@ -106,7 +110,7 @@ GType cogl_atlas_texture_get_gtype (void);
*
* Returns: (transfer full): A new #CoglAtlasTexture object.
*/
COGL_EXPORT CoglAtlasTexture *
COGL_EXPORT CoglTexture *
cogl_atlas_texture_new_with_size (CoglContext *ctx,
int width,
int height);
@ -149,7 +153,7 @@ cogl_atlas_texture_new_with_size (CoglContext *ctx,
* Return value: (transfer full): A new #CoglAtlasTexture object or
* %NULL on failure and @error will be updated.
*/
COGL_EXPORT CoglAtlasTexture *
COGL_EXPORT CoglTexture *
cogl_atlas_texture_new_from_data (CoglContext *ctx,
int width,
int height,
@ -187,19 +191,7 @@ cogl_atlas_texture_new_from_data (CoglContext *ctx,
*
* Returns: (transfer full): A new #CoglAtlasTexture object.
*/
COGL_EXPORT CoglAtlasTexture *
COGL_EXPORT CoglTexture *
cogl_atlas_texture_new_from_bitmap (CoglBitmap *bmp);
/**
* cogl_is_atlas_texture:
* @object: a #CoglObject
*
* Checks whether the given object references a #CoglAtlasTexture
*
* Return value: %TRUE if the passed object represents an atlas
* texture and %FALSE otherwise
*/
COGL_EXPORT gboolean
cogl_is_atlas_texture (void *object);
G_END_DECLS

41
cogl/cogl/cogl-atlas.c
View File

@ -55,7 +55,7 @@ cogl_atlas_dispose (GObject *object)
COGL_NOTE (ATLAS, "%p: Atlas destroyed", atlas);
if (atlas->texture)
cogl_object_unref (atlas->texture);
g_object_unref (atlas->texture);
if (atlas->map)
_cogl_rectangle_map_free (atlas->map);
@ -291,12 +291,12 @@ _cogl_atlas_create_map (CoglPixelFormat format,
return NULL;
}
static CoglTexture2D *
static CoglTexture *
_cogl_atlas_create_texture (CoglAtlas *atlas,
int width,
int height)
{
CoglTexture2D *tex;
CoglTexture *tex;
GError *ignore_error = NULL;
_COGL_GET_CONTEXT (ctx, NULL);
@ -323,13 +323,13 @@ _cogl_atlas_create_texture (CoglAtlas *atlas,
tex = cogl_texture_2d_new_from_bitmap (clear_bmp);
_cogl_texture_set_internal_format (COGL_TEXTURE (tex),
_cogl_texture_set_internal_format (tex,
atlas->texture_format);
if (!cogl_texture_allocate (COGL_TEXTURE (tex), &ignore_error))
if (!cogl_texture_allocate (tex, &ignore_error))
{
g_error_free (ignore_error);
cogl_object_unref (tex);
g_object_unref (tex);
tex = NULL;
}
@ -341,13 +341,13 @@ _cogl_atlas_create_texture (CoglAtlas *atlas,
{
tex = cogl_texture_2d_new_with_size (ctx, width, height);
_cogl_texture_set_internal_format (COGL_TEXTURE (tex),
_cogl_texture_set_internal_format (tex,
atlas->texture_format);
if (!cogl_texture_allocate (COGL_TEXTURE (tex), &ignore_error))
if (!cogl_texture_allocate (tex, &ignore_error))
{
g_error_free (ignore_error);
cogl_object_unref (tex);
g_object_unref (tex);
tex = NULL;
}
}
@ -389,7 +389,7 @@ _cogl_atlas_reserve_space (CoglAtlas *atlas,
{
CoglAtlasGetRectanglesData data;
CoglRectangleMap *new_map;
CoglTexture2D *new_tex;
CoglTexture *new_tex;
unsigned int map_width = 0, map_height = 0;
gboolean ret;
CoglRectangleMapEntry new_position;
@ -516,20 +516,20 @@ _cogl_atlas_reserve_space (CoglAtlas *atlas,
data.n_textures,
data.textures,
atlas->texture,
COGL_TEXTURE (new_tex),
new_tex,
user_data);
_cogl_rectangle_map_free (atlas->map);
cogl_object_unref (atlas->texture);
g_object_unref (atlas->texture);
}
else
/* We know there's only one texture so we can just directly
update the rectangle from its new position */
atlas->update_position_cb (data.textures[0].user_data,
COGL_TEXTURE (new_tex),
new_tex,
&data.textures[0].new_position);
atlas->map = new_map;
atlas->texture = COGL_TEXTURE (new_tex);
atlas->texture = new_tex;
waste = (_cogl_rectangle_map_get_remaining_space (atlas->map) *
100 / (_cogl_rectangle_map_get_width (atlas->map) *
@ -582,7 +582,7 @@ create_migration_texture (CoglContext *ctx,
GError *skip_error = NULL;
/* First try creating a fast-path non-sliced texture */
tex = COGL_TEXTURE (cogl_texture_2d_new_with_size (ctx, width, height));
tex = cogl_texture_2d_new_with_size (ctx, width, height);
_cogl_texture_set_internal_format (tex, internal_format);
@ -593,22 +593,19 @@ create_migration_texture (CoglContext *ctx,
if (!cogl_texture_allocate (tex, &skip_error))
{
g_error_free (skip_error);
cogl_object_unref (tex);
g_object_unref (tex);
tex = NULL;
}
if (!tex)
{
CoglTexture2DSliced *tex_2ds =
cogl_texture_2d_sliced_new_with_size (ctx,
tex = cogl_texture_2d_sliced_new_with_size (ctx,
width,
height,
COGL_TEXTURE_MAX_WASTE);
_cogl_texture_set_internal_format (COGL_TEXTURE (tex_2ds),
_cogl_texture_set_internal_format (tex,
internal_format);
tex = COGL_TEXTURE (tex_2ds);
}
return tex;
@ -633,7 +630,7 @@ _cogl_atlas_copy_rectangle (CoglAtlas *atlas,
if (!cogl_texture_allocate (tex, &ignore_error))
{
g_error_free (ignore_error);
cogl_object_unref (tex);
g_object_unref (tex);
return NULL;
}

8
cogl/cogl/cogl-blit.c
View File

@ -48,7 +48,7 @@ static const CoglBlitMode *_cogl_blit_default_mode = NULL;
static gboolean
_cogl_blit_texture_render_begin (CoglBlitData *data)
{
CoglContext *ctx = data->src_tex->context;
CoglContext *ctx = cogl_texture_get_context (data->src_tex);
CoglOffscreen *offscreen;
CoglFramebuffer *fb;
CoglPipeline *pipeline;
@ -129,7 +129,7 @@ _cogl_blit_texture_render_blit (CoglBlitData *data,
static void
_cogl_blit_texture_render_end (CoglBlitData *data)
{
CoglContext *ctx = data->src_tex->context;
CoglContext *ctx = cogl_texture_get_context (data->src_tex);
/* Attach the target texture to the texture render pipeline so that
we don't keep a reference to the source texture forever. This is
@ -148,7 +148,7 @@ _cogl_blit_texture_render_end (CoglBlitData *data)
static gboolean
_cogl_blit_framebuffer_begin (CoglBlitData *data)
{
CoglContext *ctx = data->src_tex->context;
CoglContext *ctx = cogl_texture_get_context (data->src_tex);
CoglOffscreen *dst_offscreen = NULL, *src_offscreen = NULL;
CoglFramebuffer *dst_fb, *src_fb;
GError *ignore_error = NULL;
@ -228,7 +228,7 @@ _cogl_blit_copy_tex_sub_image_begin (CoglBlitData *data)
GError *ignore_error = NULL;
/* This will only work if the target texture is a CoglTexture2D */
if (!cogl_is_texture_2d (data->dst_tex))
if (!COGL_IS_TEXTURE_2D (data->dst_tex))
return FALSE;
offscreen = _cogl_offscreen_new_with_texture_full

2
cogl/cogl/cogl-context-private.h
View File

@ -134,7 +134,7 @@ struct _CoglContext
CoglPipelineCache *pipeline_cache;
/* Textures */
CoglTexture2D *default_gl_texture_2d_tex;
CoglTexture *default_gl_texture_2d_tex;
/* Central list of all framebuffers so all journals can be flushed
* at any time. */

2
cogl/cogl/cogl-context.c
View File

@ -78,7 +78,7 @@ cogl_context_dispose (GObject *object)
winsys->context_deinit (context);
if (context->default_gl_texture_2d_tex)
cogl_object_unref (context->default_gl_texture_2d_tex);
g_object_unref (context->default_gl_texture_2d_tex);
if (context->opaque_color_pipeline)
cogl_object_unref (context->opaque_color_pipeline);

55
cogl/cogl/cogl-gtype-private.h
View File

@ -59,15 +59,6 @@ struct _CoglGtypeClass
/**/
#define COGL_GTYPE_IMPLEMENT_INTERFACE(name) { \
const GInterfaceInfo g_implement_interface_info = { \
(GInterfaceInitFunc) _cogl_gtype_dummy_iface_init, NULL, NULL \
}; \
g_type_add_interface_static (fundamental_type_id, \
cogl_##name##_get_gtype(), \
&g_implement_interface_info); \
}
#define _COGL_GTYPE_DEFINE_BASE_CLASS_BEGIN(Name,name) \
GType \
cogl_##name##_get_gtype (void) \
@ -121,52 +112,6 @@ cogl_##name##_get_gtype (void) \
{__VA_ARGS__;} \
_COGL_GTYPE_DEFINE_BASE_CLASS_END()
#define _COGL_GTYPE_DEFINE_INTERFACE_EXTENDED_BEGIN(Name,name) \
\
static void name##_default_init (Name##Interface *klass); \
GType \
name##_get_gtype (void) \
{ \
static size_t g_type_id = 0; \
if (g_once_init_enter (&g_type_id)) \
{ \
GType fundamental_type_id = \
g_type_register_static_simple (G_TYPE_INTERFACE, \
g_intern_static_string (#Name), \
sizeof (Name##Interface), \
(GClassInitFunc)name##_default_init, \
0, \
(GInstanceInitFunc)NULL, \
(GTypeFlags) 0); \
g_type_interface_add_prerequisite (fundamental_type_id, \
cogl_object_get_gtype()); \
{ /* custom code follows */
#define _COGL_GTYPE_DEFINE_INTERFACE_EXTENDED_END() \
/* following custom code */ \
} \
g_once_init_leave (&g_type_id, \
fundamental_type_id); \
} \
return g_type_id; \
} /* closes name##_get_type() */
#define COGL_GTYPE_DEFINE_INTERFACE(Name,name) \
typedef struct _Cogl##Name##Iface Cogl##Name##Iface; \
typedef Cogl##Name##Iface Cogl##Name##Interface; \
struct _Cogl##Name##Iface \
{ \
/*< private >*/ \
GTypeInterface g_iface; \
}; \
_COGL_GTYPE_DEFINE_INTERFACE_EXTENDED_BEGIN (Cogl##Name, cogl_##name) \
_COGL_GTYPE_DEFINE_INTERFACE_EXTENDED_END () \
static void \
cogl_##name##_default_init (Cogl##Name##Interface *iface) \
{ \
}
#define _COGL_GTYPE_DEFINE_TYPE_EXTENDED_BEGIN(Name,name,parent,flags) \
\
static void name##_init (Name *self); \

24
cogl/cogl/cogl-meta-texture.c
View File

@ -36,6 +36,7 @@
#include "cogl/cogl-spans.h"
#include "cogl/cogl-meta-texture.h"
#include "cogl/cogl-texture-private.h"
#include "cogl/cogl-pipeline-layer-state.h"
#include <string.h>
#include <math.h>
@ -277,7 +278,7 @@ clamp_t_cb (CoglTexture *sub_texture,
}
static gboolean
foreach_clamped_region (CoglMetaTexture *meta_texture,
foreach_clamped_region (CoglTexture *texture,
float *tx_1,
float *ty_1,
float *tx_2,
@ -287,7 +288,7 @@ foreach_clamped_region (CoglMetaTexture *meta_texture,
CoglMetaTextureCallback callback,
void *user_data)
{
float width = cogl_texture_get_width (COGL_TEXTURE (meta_texture));
float width = cogl_texture_get_width (texture);
ClampData clamp_data;
/* Consider that *tx_1 may be > *tx_2 and to simplify things
@ -325,7 +326,7 @@ foreach_clamped_region (CoglMetaTexture *meta_texture,
{
clamp_data.start = *tx_1;
clamp_data.end = MIN (0, *tx_2);
cogl_meta_texture_foreach_in_region (meta_texture,
cogl_meta_texture_foreach_in_region (texture,
half_texel_width, *ty_1,
half_texel_width, *ty_2,
COGL_PIPELINE_WRAP_MODE_REPEAT,
@ -345,7 +346,7 @@ foreach_clamped_region (CoglMetaTexture *meta_texture,
{
clamp_data.start = MAX (max_s_coord, *tx_1);
clamp_data.end = *tx_2;
cogl_meta_texture_foreach_in_region (meta_texture,
cogl_meta_texture_foreach_in_region (texture,
max_s_coord - half_texel_width,
*ty_1,
max_s_coord - half_texel_width,
@ -366,7 +367,7 @@ foreach_clamped_region (CoglMetaTexture *meta_texture,
if (wrap_t == COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE)
{
float height = cogl_texture_get_height (COGL_TEXTURE (meta_texture));
float height = cogl_texture_get_height (texture);
float max_t_coord = 1.0;
float half_texel_height;
@ -377,7 +378,7 @@ foreach_clamped_region (CoglMetaTexture *meta_texture,
{
clamp_data.start = *ty_1;
clamp_data.end = MIN (0, *ty_2);
cogl_meta_texture_foreach_in_region (meta_texture,
cogl_meta_texture_foreach_in_region (texture,
*tx_1, half_texel_height,
*tx_2, half_texel_height,
wrap_s,
@ -397,7 +398,7 @@ foreach_clamped_region (CoglMetaTexture *meta_texture,
{
clamp_data.start = MAX (max_t_coord, *ty_1);
clamp_data.end = *ty_2;
cogl_meta_texture_foreach_in_region (meta_texture,
cogl_meta_texture_foreach_in_region (texture,
*tx_1,
max_t_coord - half_texel_height,
*tx_2,
@ -452,7 +453,7 @@ normalize_meta_coords_cb (CoglTexture *slice_texture,
}
void
cogl_meta_texture_foreach_in_region (CoglMetaTexture *meta_texture,
cogl_meta_texture_foreach_in_region (CoglTexture *texture,
float tx_1,
float ty_1,
float tx_2,
@ -462,7 +463,6 @@ cogl_meta_texture_foreach_in_region (CoglMetaTexture *meta_texture,
CoglMetaTextureCallback callback,
void *user_data)
{
CoglTexture *texture = COGL_TEXTURE (meta_texture);
float width = cogl_texture_get_width (texture);
float height = cogl_texture_get_height (texture);
NormalizeData normalize_data;
@ -475,7 +475,7 @@ cogl_meta_texture_foreach_in_region (CoglMetaTexture *meta_texture,
if (wrap_s == COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE ||
wrap_t == COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE)
{
gboolean finished = foreach_clamped_region (meta_texture,
gboolean finished = foreach_clamped_region (texture,
&tx_1, &ty_1, &tx_2, &ty_2,
wrap_s, wrap_t,
callback,
@ -512,7 +512,7 @@ cogl_meta_texture_foreach_in_region (CoglMetaTexture *meta_texture,
* vtable, instead there will be a separate CoglMetaTexture
* interface vtable. */
if (texture->vtable->foreach_sub_texture_in_region)
if (COGL_TEXTURE_GET_CLASS (texture)->foreach_sub_texture_in_region)
{
ForeachData data;
@ -554,7 +554,7 @@ cogl_meta_texture_foreach_in_region (CoglMetaTexture *meta_texture,
* that we can batch geometry.
*/
texture->vtable->foreach_sub_texture_in_region (texture,
COGL_TEXTURE_GET_CLASS (texture)->foreach_sub_texture_in_region (texture,
0, 0, 1, 1,
create_grid_and_repeat_cb,
&data);

13
cogl/cogl/cogl-meta-texture.h
View File

@ -89,17 +89,6 @@ G_BEGIN_DECLS
* meta-textures.</note>
*/
#if defined(__COGL_H_INSIDE__) && !defined(COGL_ENABLE_MUTTER_API) && \
!defined(COGL_GIR_SCANNING)
/* For the public C api we typedef interface types as void to avoid needing
* lots of casting in code and instead we will rely on runtime type checking
* for these objects. */
typedef void CoglMetaTexture;
#else
typedef struct _CoglMetaTexture CoglMetaTexture;
#define COGL_META_TEXTURE(X) ((CoglMetaTexture *)X)
#endif
/**
* CoglMetaTextureCallback:
* @sub_texture: A low-level #CoglTexture making up part of a
@ -171,7 +160,7 @@ typedef void (*CoglMetaTextureCallback) (CoglTexture *sub_texture,
* low-level texture maps to the original region.
*/
COGL_EXPORT void
cogl_meta_texture_foreach_in_region (CoglMetaTexture *meta_texture,
cogl_meta_texture_foreach_in_region (CoglTexture *texture,
float tx_1,
float ty_1,
float tx_2,

8
cogl/cogl/cogl-offscreen.c
View File

@ -48,12 +48,12 @@ _cogl_offscreen_new_with_texture_full (CoglTexture *texture,
CoglOffscreenFlags flags,
int level)
{
CoglContext *ctx = texture->context;
CoglContext *ctx = cogl_texture_get_context (texture);
CoglFramebufferDriverConfig driver_config;
CoglOffscreen *offscreen;
CoglFramebuffer *fb;
g_return_val_if_fail (cogl_is_texture (texture), NULL);
g_return_val_if_fail (COGL_IS_TEXTURE (texture), NULL);
driver_config = (CoglFramebufferDriverConfig) {
.type = COGL_FRAMEBUFFER_DRIVER_TYPE_FBO,
@ -64,7 +64,7 @@ _cogl_offscreen_new_with_texture_full (CoglTexture *texture,
"context", ctx,
"driver-config", &driver_config,
NULL);
offscreen->texture = cogl_object_ref (texture);
offscreen->texture = g_object_ref (texture);
offscreen->texture_level = level;
fb = COGL_FRAMEBUFFER (offscreen);
@ -141,7 +141,7 @@ cogl_offscreen_dispose (GObject *object)
G_OBJECT_CLASS (cogl_offscreen_parent_class)->dispose (object);
cogl_clear_object (&offscreen->texture);
g_clear_object (&offscreen->texture);
}
static void

6
cogl/cogl/cogl-pipeline-layer-state.c
View File

@ -180,7 +180,7 @@ _cogl_pipeline_set_layer_texture_data (CoglPipeline *pipeline,
layer->differences &= ~change;
if (layer->texture != NULL)
cogl_object_unref (layer->texture);
g_object_unref (layer->texture);
g_assert (layer->owner == pipeline);
if (layer->differences == 0)
@ -192,10 +192,10 @@ _cogl_pipeline_set_layer_texture_data (CoglPipeline *pipeline,
}
if (texture != NULL)
cogl_object_ref (texture);
g_object_ref (texture);
if (layer == authority &&
layer->texture != NULL)
cogl_object_unref (layer->texture);
g_object_unref (layer->texture);
layer->texture = texture;
/* If we weren't previously the authority on this state then we need

4
cogl/cogl/cogl-pipeline-layer.c
View File

@ -189,7 +189,7 @@ _cogl_pipeline_layer_copy_differences (CoglPipelineLayer *dest,
case COGL_PIPELINE_LAYER_STATE_TEXTURE_DATA_INDEX:
dest->texture = src->texture;
if (dest->texture)
cogl_object_ref (dest->texture);
g_object_ref (dest->texture);
break;
case COGL_PIPELINE_LAYER_STATE_SAMPLER_INDEX:
@ -703,7 +703,7 @@ _cogl_pipeline_layer_free (CoglPipelineLayer *layer)
if (layer->differences & COGL_PIPELINE_LAYER_STATE_TEXTURE_DATA &&
layer->texture != NULL)
cogl_object_unref (layer->texture);
g_object_unref (layer->texture);
if (layer->differences & COGL_PIPELINE_LAYER_STATE_VERTEX_SNIPPETS)
_cogl_pipeline_snippet_list_free (&layer->big_state->vertex_snippets);

4
cogl/cogl/cogl-pipeline.c
View File

@ -1752,7 +1752,7 @@ fallback_layer_cb (CoglPipelineLayer *layer, void *user_data)
COGL_COUNTER_INC (_cogl_uprof_context, layer_fallback_counter);
texture = COGL_TEXTURE (ctx->default_gl_texture_2d_tex);
texture = ctx->default_gl_texture_2d_tex;
if (texture == NULL)
{
@ -1760,7 +1760,7 @@ fallback_layer_cb (CoglPipelineLayer *layer, void *user_data)
"in for an invalid pipeline layer, since it was "
"using an unsupported texture target ");
/* might get away with this... */
texture = COGL_TEXTURE (ctx->default_gl_texture_2d_tex);
texture = ctx->default_gl_texture_2d_tex;
}
cogl_pipeline_set_layer_texture (pipeline, layer->index, texture);

19
cogl/cogl/cogl-primitive-texture.c
View File

@ -35,24 +35,15 @@
#include "cogl/cogl-primitive-texture.h"
#include "cogl/cogl-texture-private.h"
gboolean
cogl_is_primitive_texture (void *object)
{
return (cogl_is_texture (object) &&
COGL_TEXTURE (object)->vtable->is_primitive);
}
void
cogl_primitive_texture_set_auto_mipmap (CoglPrimitiveTexture *primitive_texture,
cogl_primitive_texture_set_auto_mipmap (CoglTexture *texture,
gboolean value)
{
CoglTexture *texture;
g_return_if_fail (COGL_IS_TEXTURE (texture) &&
texture->is_primitive);
g_return_if_fail (cogl_is_primitive_texture (primitive_texture));
g_assert (COGL_TEXTURE_GET_CLASS (texture)->set_auto_mipmap != NULL);
texture = COGL_TEXTURE (primitive_texture);
g_assert (texture->vtable->set_auto_mipmap != NULL);
texture->vtable->set_auto_mipmap (texture, value);
COGL_TEXTURE_GET_CLASS (texture)->set_auto_mipmap (texture, value);
}

50
cogl/cogl/cogl-primitive-texture.h
View File

@ -34,56 +34,10 @@
#error "Only <cogl/cogl.h> can be included directly."
#endif
#include "cogl/cogl-types.h"
#include "cogl/cogl-texture.h"
G_BEGIN_DECLS
/**
* SECTION:cogl-primitive-texture
* @short_description: Interface for low-level textures like
* #CoglTexture2D.
*
* A #CoglPrimitiveTexture is a texture that is directly represented
* by a single texture on the GPU. For example this could be a
* #CoglTexture2D. This is opposed to high level meta textures which
* may be composed of multiple primitive textures or a sub-region of
* another texture such as #CoglAtlasTexture and #CoglTexture2DSliced.
*
* A texture that implements this interface can be directly used with
* the low level cogl_primitive_draw() API. Other types of textures
* need to be first resolved to primitive textures using the
* #CoglMetaTexture interface.
*
* <note>Most developers won't need to use this interface directly but
* still it is worth understanding the distinction between high-level
* and primitive textures because you may find other references in the
* documentation that detail limitations of using
* primitive textures.</note>
*/
#if defined(__COGL_H_INSIDE__) && !defined(COGL_ENABLE_MUTTER_API) && \
!defined(COGL_GIR_SCANNING)
/* For the public C api we typedef interface types as void to avoid needing
* lots of casting in code and instead we will rely on runtime type checking
* for these objects. */
typedef void CoglPrimitiveTexture;
#else
typedef struct _CoglPrimitiveTexture CoglPrimitiveTexture;
#define COGL_PRIMITIVE_TEXTURE(X) ((CoglPrimitiveTexture *)X)
#endif
/**
* cogl_is_primitive_texture:
* @object: A #CoglObject pointer
*
* Gets whether the given object references a primitive texture object.
*
* Return value: %TRUE if the pointer references a primitive texture, and
* %FALSE otherwise
*/
gboolean
cogl_is_primitive_texture (void *object);
/**
* cogl_primitive_texture_set_auto_mipmap:
* @primitive_texture: A #CoglPrimitiveTexture
@ -97,7 +51,7 @@ cogl_is_primitive_texture (void *object);
* levels. By default auto mipmapping is enabled.
*/
COGL_EXPORT void
cogl_primitive_texture_set_auto_mipmap (CoglPrimitiveTexture *primitive_texture,
cogl_primitive_texture_set_auto_mipmap (CoglTexture *primitive_texture,
gboolean value);
G_END_DECLS

7
cogl/cogl/cogl-primitives.c
View File

@ -272,7 +272,7 @@ _cogl_texture_quad_multiple_primitives (CoglFramebuffer *framebuffer,
if (wrap_t == COGL_PIPELINE_WRAP_MODE_AUTOMATIC)
wrap_t = COGL_PIPELINE_WRAP_MODE_REPEAT;
cogl_meta_texture_foreach_in_region (COGL_META_TEXTURE (texture),
cogl_meta_texture_foreach_in_region (texture,
tx_1, ty_1, tx_2, ty_2,
wrap_s,
wrap_t,
@ -580,7 +580,7 @@ _cogl_rectangles_validate_layer_cb (CoglPipeline *pipeline,
else
{
static gboolean warning_seen = FALSE;
CoglTexture2D *tex_2d;
CoglTexture *tex_2d;
if (!warning_seen)
g_warning ("Skipping layer %d of your pipeline consisting of "
@ -590,8 +590,7 @@ _cogl_rectangles_validate_layer_cb (CoglPipeline *pipeline,
/* Note: currently only 2D textures can be sliced. */
tex_2d = state->ctx->default_gl_texture_2d_tex;
cogl_pipeline_set_layer_texture (pipeline, layer_index,
COGL_TEXTURE (tex_2d));
cogl_pipeline_set_layer_texture (pipeline, layer_index, tex_2d);
return TRUE;
}
}

7
cogl/cogl/cogl-sub-texture-private.h
View File

@ -36,7 +36,7 @@
struct _CoglSubTexture
{
CoglTexture _parent;
CoglTexture parent_instance;
/* This is the texture that was passed in to
_cogl_sub_texture_new. If this is also a sub texture then we will
@ -57,3 +57,8 @@ struct _CoglSubTexture
int sub_x;
int sub_y;
};
struct _CoglSubTextureClass
{
CoglTextureClass parent_class;
};

225
cogl/cogl/cogl-sub-texture.c
View File

@ -38,21 +38,26 @@
#include "cogl/cogl-sub-texture-private.h"
#include "cogl/cogl-sub-texture.h"
#include "cogl/cogl-context-private.h"
#include "cogl/cogl-object.h"
#include "cogl/cogl-texture-driver.h"
#include "cogl/cogl-texture-2d.h"
#include "cogl/cogl-gtype-private.h"
#include "cogl/driver/gl/cogl-texture-gl-private.h"
#include <string.h>
#include <math.h>
static void _cogl_sub_texture_free (CoglSubTexture *sub_tex);
COGL_TEXTURE_DEFINE (SubTexture, sub_texture);
COGL_GTYPE_DEFINE_CLASS (SubTexture, sub_texture);
G_DEFINE_FINAL_TYPE (CoglSubTexture, cogl_sub_texture, COGL_TYPE_TEXTURE)
static const CoglTextureVtable cogl_sub_texture_vtable;
static void
cogl_sub_texture_dispose (GObject *object)
{
CoglSubTexture *sub_tex = COGL_SUB_TEXTURE (object);
g_object_unref (sub_tex->next_texture);
g_object_unref (sub_tex->full_texture);
G_OBJECT_CLASS (cogl_sub_texture_parent_class)->dispose (object);
}
static void
_cogl_sub_texture_unmap_quad (CoglSubTexture *sub_tex,
@ -62,10 +67,10 @@ _cogl_sub_texture_unmap_quad (CoglSubTexture *sub_tex,
float width = cogl_texture_get_width (sub_tex->full_texture);
float height = cogl_texture_get_height (sub_tex->full_texture);
coords[0] = (coords[0] * width - sub_tex->sub_x) / tex->width;
coords[1] = (coords[1] * height - sub_tex->sub_y) / tex->height;
coords[2] = (coords[2] * width - sub_tex->sub_x) / tex->width;
coords[3] = (coords[3] * height - sub_tex->sub_y) / tex->height;
coords[0] = (coords[0] * width - sub_tex->sub_x) / cogl_texture_get_width (tex);
coords[1] = (coords[1] * height - sub_tex->sub_y) / cogl_texture_get_height (tex);
coords[2] = (coords[2] * width - sub_tex->sub_x) / cogl_texture_get_width (tex);
coords[3] = (coords[3] * height - sub_tex->sub_y) / cogl_texture_get_height (tex);
}
static void
@ -76,10 +81,10 @@ _cogl_sub_texture_map_quad (CoglSubTexture *sub_tex,
float width = cogl_texture_get_width (sub_tex->full_texture);
float height = cogl_texture_get_height (sub_tex->full_texture);
coords[0] = (coords[0] * tex->width + sub_tex->sub_x) / width;
coords[1] = (coords[1] * tex->height + sub_tex->sub_y) / height;
coords[2] = (coords[2] * tex->width + sub_tex->sub_x) / width;
coords[3] = (coords[3] * tex->height + sub_tex->sub_y) / height;
coords[0] = (coords[0] * cogl_texture_get_width (tex) + sub_tex->sub_x) / width;
coords[1] = (coords[1] * cogl_texture_get_height (tex) + sub_tex->sub_y) / height;
coords[2] = (coords[2] * cogl_texture_get_width (tex) + sub_tex->sub_x) / width;
coords[3] = (coords[3] * cogl_texture_get_height (tex) + sub_tex->sub_y) / height;
}
typedef struct _CoglSubTextureForeachData
@ -129,7 +134,7 @@ _cogl_sub_texture_foreach_sub_texture_in_region (
_cogl_sub_texture_map_quad (sub_tex, mapped_coords);
/* TODO: Add something like cogl_is_low_level_texture() */
if (cogl_is_texture_2d (full_texture))
if (COGL_IS_TEXTURE_2D (full_texture))
{
callback (sub_tex->full_texture,
mapped_coords,
@ -144,7 +149,7 @@ _cogl_sub_texture_foreach_sub_texture_in_region (
data.callback = callback;
data.user_data = user_data;
cogl_meta_texture_foreach_in_region (COGL_META_TEXTURE (full_texture),
cogl_meta_texture_foreach_in_region (full_texture,
mapped_coords[0],
mapped_coords[1],
mapped_coords[2],
@ -168,67 +173,6 @@ _cogl_sub_texture_gl_flush_legacy_texobj_wrap_modes (CoglTexture *tex,
wrap_mode_t);
}
static void
_cogl_sub_texture_free (CoglSubTexture *sub_tex)
{
cogl_object_unref (sub_tex->next_texture);
cogl_object_unref (sub_tex->full_texture);
/* Chain up */
_cogl_texture_free (COGL_TEXTURE (sub_tex));
}
CoglSubTexture *
cogl_sub_texture_new (CoglContext *ctx,
CoglTexture *next_texture,
int sub_x, int sub_y,
int sub_width, int sub_height)
{
CoglTexture *full_texture;
CoglSubTexture *sub_tex;
CoglTexture *tex;
unsigned int next_width, next_height;
next_width = cogl_texture_get_width (next_texture);
next_height = cogl_texture_get_height (next_texture);
/* The region must specify a non-zero subset of the full texture */
g_return_val_if_fail (sub_x >= 0 && sub_y >= 0, NULL);
g_return_val_if_fail (sub_width > 0 && sub_height > 0, NULL);
g_return_val_if_fail (sub_x + sub_width <= next_width, NULL);
g_return_val_if_fail (sub_y + sub_height <= next_height, NULL);
sub_tex = g_new (CoglSubTexture, 1);
tex = COGL_TEXTURE (sub_tex);
_cogl_texture_init (tex, ctx, sub_width, sub_height,
_cogl_texture_get_format (next_texture),
NULL, /* no loader */
&cogl_sub_texture_vtable);
/* If the next texture is also a sub texture we can avoid one level
of indirection by referencing the full texture of that texture
instead. */
if (cogl_is_sub_texture (next_texture))
{
CoglSubTexture *other_sub_tex = COGL_SUB_TEXTURE (next_texture);
full_texture = other_sub_tex->full_texture;
sub_x += other_sub_tex->sub_x;
sub_y += other_sub_tex->sub_y;
}
else
full_texture = next_texture;
sub_tex->next_texture = cogl_object_ref (next_texture);
sub_tex->full_texture = cogl_object_ref (full_texture);
sub_tex->sub_x = sub_x;
sub_tex->sub_y = sub_y;
return _cogl_sub_texture_object_new (sub_tex);
}
static gboolean
_cogl_sub_texture_allocate (CoglTexture *tex,
GError **error)
@ -238,17 +182,12 @@ _cogl_sub_texture_allocate (CoglTexture *tex,
_cogl_texture_set_allocated (tex,
_cogl_texture_get_format (sub_tex->full_texture),
tex->width, tex->height);
cogl_texture_get_width (tex),
cogl_texture_get_height (tex));
return status;
}
CoglTexture *
cogl_sub_texture_get_parent (CoglSubTexture *sub_texture)
{
return sub_texture->next_texture;
}
static int
_cogl_sub_texture_get_max_waste (CoglTexture *tex)
{
@ -272,9 +211,9 @@ _cogl_sub_texture_can_hardware_repeat (CoglTexture *tex)
/* We can hardware repeat if the subtexture actually represents all of the
of the full texture */
return (tex->width ==
return (cogl_texture_get_width (tex) ==
cogl_texture_get_width (sub_tex->full_texture) &&
tex->height ==
cogl_texture_get_height (tex) ==
cogl_texture_get_height (sub_tex->full_texture) &&
_cogl_texture_can_hardware_repeat (sub_tex->full_texture));
}
@ -288,9 +227,9 @@ _cogl_sub_texture_transform_coords_to_gl (CoglTexture *tex,
/* This won't work if the sub texture is not the size of the full
texture and the coordinates are outside the range [0,1] */
*s = ((*s * tex->width + sub_tex->sub_x) /
*s = ((*s * cogl_texture_get_width (tex) + sub_tex->sub_x) /
cogl_texture_get_width (sub_tex->full_texture));
*t = ((*t * tex->height + sub_tex->sub_y) /
*t = ((*t * cogl_texture_get_height (tex) + sub_tex->sub_y) /
cogl_texture_get_height (sub_tex->full_texture));
_cogl_texture_transform_coords_to_gl (sub_tex->full_texture, s, t);
@ -413,26 +352,92 @@ _cogl_sub_texture_get_gl_format (CoglTexture *tex)
return _cogl_texture_gl_get_format (sub_tex->full_texture);
}
static const CoglTextureVtable
cogl_sub_texture_vtable =
static void
cogl_sub_texture_class_init (CoglSubTextureClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
CoglTextureClass *texture_class = COGL_TEXTURE_CLASS (klass);
gobject_class->dispose = cogl_sub_texture_dispose;
texture_class->allocate = _cogl_sub_texture_allocate;
texture_class->set_region = _cogl_sub_texture_set_region;
texture_class->is_get_data_supported = _cogl_sub_texture_is_get_data_supported;
texture_class->foreach_sub_texture_in_region = _cogl_sub_texture_foreach_sub_texture_in_region;
texture_class->get_max_waste = _cogl_sub_texture_get_max_waste;
texture_class->is_sliced = _cogl_sub_texture_is_sliced;
texture_class->can_hardware_repeat = _cogl_sub_texture_can_hardware_repeat;
texture_class->transform_coords_to_gl = _cogl_sub_texture_transform_coords_to_gl;
texture_class->transform_quad_coords_to_gl = _cogl_sub_texture_transform_quad_coords_to_gl;
texture_class->get_gl_texture = _cogl_sub_texture_get_gl_texture;
texture_class->gl_flush_legacy_texobj_filters = _cogl_sub_texture_gl_flush_legacy_texobj_filters;
texture_class->pre_paint = _cogl_sub_texture_pre_paint;
texture_class->ensure_non_quad_rendering = _cogl_sub_texture_ensure_non_quad_rendering;
texture_class->gl_flush_legacy_texobj_wrap_modes = _cogl_sub_texture_gl_flush_legacy_texobj_wrap_modes;
texture_class->get_format = _cogl_sub_texture_get_format;
texture_class->get_gl_format = _cogl_sub_texture_get_gl_format;
}
static void
cogl_sub_texture_init (CoglSubTexture *self)
{
CoglTexture *texture = COGL_TEXTURE (self);
texture->is_primitive = FALSE;
}
CoglTexture *
cogl_sub_texture_new (CoglContext *ctx,
CoglTexture *next_texture,
int sub_x, int sub_y,
int sub_width, int sub_height)
{
CoglTexture *full_texture;
CoglSubTexture *sub_tex;
CoglTexture *tex;
unsigned int next_width, next_height;
next_width = cogl_texture_get_width (next_texture);
next_height = cogl_texture_get_height (next_texture);
/* The region must specify a non-zero subset of the full texture */
g_return_val_if_fail (sub_x >= 0 && sub_y >= 0, NULL);
g_return_val_if_fail (sub_width > 0 && sub_height > 0, NULL);
g_return_val_if_fail (sub_x + sub_width <= next_width, NULL);
g_return_val_if_fail (sub_y + sub_height <= next_height, NULL);
sub_tex = g_object_new (COGL_TYPE_SUB_TEXTURE, NULL);
tex = COGL_TEXTURE (sub_tex);
_cogl_texture_init (tex, ctx, sub_width, sub_height,
_cogl_texture_get_format (next_texture),
NULL);
/* If the next texture is also a sub texture we can avoid one level
of indirection by referencing the full texture of that texture
instead. */
if (COGL_IS_SUB_TEXTURE (next_texture))
{
FALSE, /* not primitive */
_cogl_sub_texture_allocate,
_cogl_sub_texture_set_region,
_cogl_sub_texture_is_get_data_supported,
NULL, /* get_data */
_cogl_sub_texture_foreach_sub_texture_in_region,
_cogl_sub_texture_get_max_waste,
_cogl_sub_texture_is_sliced,
_cogl_sub_texture_can_hardware_repeat,
_cogl_sub_texture_transform_coords_to_gl,
_cogl_sub_texture_transform_quad_coords_to_gl,
_cogl_sub_texture_get_gl_texture,
_cogl_sub_texture_gl_flush_legacy_texobj_filters,
_cogl_sub_texture_pre_paint,
_cogl_sub_texture_ensure_non_quad_rendering,
_cogl_sub_texture_gl_flush_legacy_texobj_wrap_modes,
_cogl_sub_texture_get_format,
_cogl_sub_texture_get_gl_format,
NULL /* set_auto_mipmap */
};
CoglSubTexture *other_sub_tex = COGL_SUB_TEXTURE (next_texture);
full_texture = other_sub_tex->full_texture;
sub_x += other_sub_tex->sub_x;
sub_y += other_sub_tex->sub_y;
}
else
full_texture = next_texture;
sub_tex->next_texture = g_object_ref (next_texture);
sub_tex->full_texture = g_object_ref (full_texture);
sub_tex->sub_x = sub_x;
sub_tex->sub_y = sub_y;
return tex;
}
CoglTexture *
cogl_sub_texture_get_parent (CoglSubTexture *sub_texture)
{
return sub_texture->next_texture;
}

39
cogl/cogl/cogl-sub-texture.h
View File

@ -38,26 +38,29 @@
G_BEGIN_DECLS
/**
* SECTION:cogl-sub-texture
* @short_description: Functions for creating and manipulating
* sub-textures.
* CoglSubTexture:
*
* Functions for creating and manipulating sub-textures.
*
* These functions allow high-level textures to be created that
* represent a sub-region of another texture. For example these
* can be used to implement custom texture atlasing schemes.
*/
#define COGL_TYPE_SUB_TEXTURE (cogl_sub_texture_get_type ())
#define COGL_SUB_TEXTURE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), COGL_TYPE_SUB_TEXTURE, CoglSubTexture))
#define COGL_SUB_TEXTURE_CONST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), COGL_TYPE_SUB_TEXTURE, CoglSubTexture const))
#define COGL_SUB_TEXTURE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), COGL_TYPE_SUB_TEXTURE, CoglSubTextureClass))
#define COGL_IS_SUB_TEXTURE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), COGL_TYPE_SUB_TEXTURE))
#define COGL_IS_SUB_TEXTURE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), COGL_TYPE_SUB_TEXTURE))
#define COGL_SUB_TEXTURE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), COGL_TYPE_SUB_TEXTURE, CoglSubTextureClass))
#define COGL_SUB_TEXTURE(tex) ((CoglSubTexture *) tex)
typedef struct _CoglSubTextureClass CoglSubTextureClass;
typedef struct _CoglSubTexture CoglSubTexture;
/**
* cogl_sub_texture_get_gtype:
*
* Returns: a #GType that can be used with the GLib type system.
*/
GType cogl_sub_texture_get_gtype (void);
G_DEFINE_AUTOPTR_CLEANUP_FUNC (CoglSubTexture, g_object_unref)
COGL_EXPORT
GType cogl_sub_texture_get_type (void) G_GNUC_CONST;
/**
* cogl_sub_texture_new:
* @ctx: A #CoglContext pointer
@ -86,7 +89,7 @@ GType cogl_sub_texture_get_gtype (void);
* Return value: (transfer full): A newly allocated #CoglSubTexture
* representing a sub-region of @parent_texture.
*/
COGL_EXPORT CoglSubTexture *
COGL_EXPORT CoglTexture *
cogl_sub_texture_new (CoglContext *ctx,
CoglTexture *parent_texture,
int sub_x,
@ -108,16 +111,4 @@ cogl_sub_texture_new (CoglContext *ctx,
COGL_EXPORT CoglTexture *
cogl_sub_texture_get_parent (CoglSubTexture *sub_texture);
/**
* cogl_is_sub_texture:
* @object: a #CoglObject
*
* Checks whether @object is a #CoglSubTexture.
*
* Return value: %TRUE if the passed @object represents a
* #CoglSubTexture and %FALSE otherwise.
*/
COGL_EXPORT gboolean
cogl_is_sub_texture (void *object);
G_END_DECLS

10
cogl/cogl/cogl-texture-2d-private.h
View File

@ -30,14 +30,13 @@
#pragma once
#include "cogl/cogl-object-private.h"
#include "cogl/cogl-pipeline-private.h"
#include "cogl/cogl-texture-private.h"
#include "cogl/cogl-texture-2d.h"
struct _CoglTexture2D
{
CoglTexture _parent;
CoglTexture parent_instance;
/* The internal format of the GL texture represented as a
CoglPixelFormat */
@ -67,7 +66,12 @@ struct _CoglTexture2D
} egl_image_external;
};
CoglTexture2D *
struct _CoglTexture2DClass
{
CoglTextureClass parent_class;
};
CoglTexture *
_cogl_texture_2d_create_base (CoglContext *ctx,
int width,
int height,

7
cogl/cogl/cogl-texture-2d-sliced-private.h
View File

@ -39,7 +39,7 @@
struct _CoglTexture2DSliced
{
CoglTexture _parent;
CoglTexture parent_instance;
GArray *slice_x_spans;
GArray *slice_y_spans;
@ -47,3 +47,8 @@ struct _CoglTexture2DSliced
int max_waste;
CoglPixelFormat internal_format;
};
struct _CoglTexture2DSlicedClass
{
CoglTextureClass parent_class;
};

1299
cogl/cogl/cogl-texture-2d-sliced.c
View File

File diff suppressed because it is too large Load Diff

45
cogl/cogl/cogl-texture-2d-sliced.h
View File

@ -36,10 +36,11 @@
#include "cogl/cogl-types.h"
/**
* SECTION:cogl-texture-2d-sliced
* @short_description: Functions for creating and manipulating 2D meta
* textures that may internally be comprised of
* multiple 2D textures with power-of-two sizes.
* CoglTexture2DSliced:
*
* Functions for creating and manipulating 2D meta textures
* that may internally be comprised of multiple 2D textures
* with power-of-two sizes.
*
* These functions allow high-level meta textures (See the
* #CoglMetaTexture interface) to be allocated that may internally be
@ -65,17 +66,21 @@
* max-waste threshold. The same logic for slicing from left to right
* is also applied from top to bottom.
*/
#define COGL_TYPE_TEXTURE_2D_SLICED (cogl_texture_2d_sliced_get_type ())
#define COGL_TEXTURE_2D_SLICED(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), COGL_TYPE_TEXTURE_2D_SLICED, CoglTexture2DSliced))
#define COGL_TEXTURE_2D_SLICED_CONST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), COGL_TYPE_TEXTURE_2D_SLICED, CoglTexture2DSliced const))
#define COGL_TEXTURE_2D_SLICED_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), COGL_TYPE_TEXTURE_2D_SLICED, CoglTexture2DSlicedClass))
#define COGL_IS_TEXTURE_2D_SLICED(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), COGL_TYPE_TEXTURE_2D_SLICED))
#define COGL_IS_TEXTURE_2D_SLICED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), COGL_TYPE_TEXTURE_2D_SLICED))
#define COGL_TEXTURE_2D_SLICED_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), COGL_TYPE_TEXTURE_2D_SLICED, CoglTexture2DSlicedClass))
typedef struct _CoglTexture2DSlicedClass CoglTexture2DSlicedClass;
typedef struct _CoglTexture2DSliced CoglTexture2DSliced;
#define COGL_TEXTURE_2D_SLICED(X) ((CoglTexture2DSliced *)X)
/**
* cogl_texture_2d_sliced_get_gtype:
*
* Returns: a #GType that can be used with the GLib type system.
*/
G_DEFINE_AUTOPTR_CLEANUP_FUNC (CoglTexture2DSliced, g_object_unref)
COGL_EXPORT
GType cogl_texture_2d_sliced_get_gtype (void);
GType cogl_texture_2d_sliced_get_type (void) G_GNUC_CONST;
/**
* cogl_texture_2d_sliced_new_with_size: (skip)
@ -115,7 +120,7 @@ GType cogl_texture_2d_sliced_get_gtype (void);
* Returns: (transfer full): A new #CoglTexture2DSliced object with no storage
* allocated yet.
*/
COGL_EXPORT CoglTexture2DSliced *
COGL_EXPORT CoglTexture *
cogl_texture_2d_sliced_new_with_size (CoglContext *ctx,
int width,
int height,
@ -174,7 +179,7 @@ cogl_texture_2d_sliced_new_with_size (CoglContext *ctx,
* Return value: (transfer full): A newly created #CoglTexture2DSliced
* or %NULL on failure and @error will be updated.
*/
COGL_EXPORT CoglTexture2DSliced *
COGL_EXPORT CoglTexture *
cogl_texture_2d_sliced_new_from_data (CoglContext *ctx,
int width,
int height,
@ -223,18 +228,6 @@ cogl_texture_2d_sliced_new_from_data (CoglContext *ctx,
* Return value: (transfer full): A newly created #CoglTexture2DSliced
* or %NULL on failure and @error will be updated.
*/
COGL_EXPORT CoglTexture2DSliced *
COGL_EXPORT CoglTexture *
cogl_texture_2d_sliced_new_from_bitmap (CoglBitmap *bmp,
int max_waste);
/**
* cogl_is_texture_2d_sliced:
* @object: A #CoglObject pointer
*
* Gets whether the given object references a #CoglTexture2DSliced.
*
* Return value: %TRUE if the object references a #CoglTexture2DSliced
* and %FALSE otherwise.
*/
COGL_EXPORT gboolean
cogl_is_texture_2d_sliced (void *object);

402
cogl/cogl/cogl-texture-2d.c
View File

@ -39,10 +39,8 @@
#include "cogl/cogl-texture-2d-private.h"
#include "cogl/cogl-texture-driver.h"
#include "cogl/cogl-context-private.h"
#include "cogl/cogl-object-private.h"
#include "cogl/cogl-journal-private.h"
#include "cogl/cogl-framebuffer-private.h"
#include "cogl/cogl-gtype-private.h"
#include "cogl/driver/gl/cogl-texture-2d-gl-private.h"
#ifdef COGL_HAS_EGL_SUPPORT
#include "cogl/winsys/cogl-winsys-egl-private.h"
@ -51,13 +49,7 @@
#include <string.h>
#include <math.h>
static void _cogl_texture_2d_free (CoglTexture2D *tex_2d);
COGL_TEXTURE_DEFINE (Texture2D, texture_2d);
COGL_GTYPE_DEFINE_CLASS (Texture2D, texture_2d,
COGL_GTYPE_IMPLEMENT_INTERFACE (texture));
static const CoglTextureVtable cogl_texture_2d_vtable;
G_DEFINE_FINAL_TYPE (CoglTexture2D, cogl_texture_2d, COGL_TYPE_TEXTURE)
typedef struct _CoglTexture2DManualRepeatData
{
@ -67,14 +59,14 @@ typedef struct _CoglTexture2DManualRepeatData
} CoglTexture2DManualRepeatData;
static void
_cogl_texture_2d_free (CoglTexture2D *tex_2d)
cogl_texture_2d_dispose (GObject *object)
{
CoglContext *ctx = COGL_TEXTURE (tex_2d)->context;
CoglTexture2D *tex_2d = COGL_TEXTURE_2D (object);
CoglContext *ctx = cogl_texture_get_context (COGL_TEXTURE (tex_2d));
ctx->driver_vtable->texture_2d_free (tex_2d);
/* Chain up */
_cogl_texture_free (COGL_TEXTURE (tex_2d));
G_OBJECT_CLASS (cogl_texture_2d_parent_class)->dispose (object);
}
void
@ -86,18 +78,17 @@ _cogl_texture_2d_set_auto_mipmap (CoglTexture *tex,
tex_2d->auto_mipmap = value;
}
CoglTexture2D *
CoglTexture *
_cogl_texture_2d_create_base (CoglContext *ctx,
int width,
int height,
CoglPixelFormat internal_format,
CoglTextureLoader *loader)
{
CoglTexture2D *tex_2d = g_new (CoglTexture2D, 1);
CoglTexture2D *tex_2d = g_object_new (COGL_TYPE_TEXTURE_2D, NULL);
CoglTexture *tex = COGL_TEXTURE (tex_2d);
_cogl_texture_init (tex, ctx, width, height, internal_format, loader,
&cogl_texture_2d_vtable);
_cogl_texture_init (tex, ctx, width, height, internal_format, loader);
tex_2d->mipmaps_dirty = TRUE;
tex_2d->auto_mipmap = TRUE;
@ -107,171 +98,18 @@ _cogl_texture_2d_create_base (CoglContext *ctx,
ctx->driver_vtable->texture_2d_init (tex_2d);
return _cogl_texture_2d_object_new (tex_2d);
}
CoglTexture2D *
cogl_texture_2d_new_with_format (CoglContext *ctx,
int width,
int height,
CoglPixelFormat format)
{
CoglTextureLoader *loader;
g_return_val_if_fail (width >= 1, NULL);
g_return_val_if_fail (height >= 1, NULL);
loader = _cogl_texture_create_loader ();
loader->src_type = COGL_TEXTURE_SOURCE_TYPE_SIZE;
loader->src.sized.width = width;
loader->src.sized.height = height;
loader->src.sized.format = format;
return _cogl_texture_2d_create_base (ctx, width, height, format, loader);
}
CoglTexture2D *
cogl_texture_2d_new_with_size (CoglContext *ctx,
int width,
int height)
{
CoglTextureLoader *loader;
g_return_val_if_fail (width >= 1, NULL);
g_return_val_if_fail (height >= 1, NULL);
loader = _cogl_texture_create_loader ();
loader->src_type = COGL_TEXTURE_SOURCE_TYPE_SIZE;
loader->src.sized.width = width;
loader->src.sized.height = height;
loader->src.sized.format = COGL_PIXEL_FORMAT_ANY;
return _cogl_texture_2d_create_base (ctx, width, height,
COGL_PIXEL_FORMAT_RGBA_8888_PRE, loader);
return tex;
}
static gboolean
_cogl_texture_2d_allocate (CoglTexture *tex,
GError **error)
{
CoglContext *ctx = tex->context;
CoglContext *ctx = cogl_texture_get_context (tex);
return ctx->driver_vtable->texture_2d_allocate (tex, error);
}
CoglTexture2D *
cogl_texture_2d_new_from_bitmap (CoglBitmap *bmp)
{
CoglTextureLoader *loader;
g_return_val_if_fail (bmp != NULL, NULL);
loader = _cogl_texture_create_loader ();
loader->src_type = COGL_TEXTURE_SOURCE_TYPE_BITMAP;
loader->src.bitmap.bitmap = g_object_ref (bmp);
return _cogl_texture_2d_create_base (_cogl_bitmap_get_context (bmp),
cogl_bitmap_get_width (bmp),
cogl_bitmap_get_height (bmp),
cogl_bitmap_get_format (bmp),
loader);
}
CoglTexture2D *
cogl_texture_2d_new_from_data (CoglContext *ctx,
int width,
int height,
CoglPixelFormat format,
int rowstride,
const uint8_t *data,
GError **error)
{
CoglBitmap *bmp;
CoglTexture2D *tex_2d;
g_return_val_if_fail (format != COGL_PIXEL_FORMAT_ANY, NULL);
g_return_val_if_fail (cogl_pixel_format_get_n_planes (format) == 1, NULL);
g_return_val_if_fail (data != NULL, NULL);
/* Rowstride from width if not given */
if (rowstride == 0)
rowstride = width * cogl_pixel_format_get_bytes_per_pixel (format, 0);
/* Wrap the data into a bitmap */
bmp = cogl_bitmap_new_for_data (ctx,
width, height,
format,
rowstride,
(uint8_t *) data);
tex_2d = cogl_texture_2d_new_from_bitmap (bmp);
g_object_unref (bmp);
if (tex_2d &&
!cogl_texture_allocate (COGL_TEXTURE (tex_2d), error))
{
cogl_object_unref (tex_2d);
return NULL;
}
return tex_2d;
}
#if defined (COGL_HAS_EGL_SUPPORT) && defined (EGL_KHR_image_base)
/* NB: The reason we require the width, height and format to be passed
* even though they may seem redundant is because GLES 1/2 don't
* provide a way to query these properties. */
CoglTexture2D *
cogl_egl_texture_2d_new_from_image (CoglContext *ctx,
int width,
int height,
CoglPixelFormat format,
EGLImageKHR image,
CoglEglImageFlags flags,
GError **error)
{
CoglTextureLoader *loader;
CoglTexture2D *tex;
g_return_val_if_fail (_cogl_context_get_winsys (ctx)->constraints &
COGL_RENDERER_CONSTRAINT_USES_EGL,
NULL);
g_return_val_if_fail (_cogl_has_private_feature
(ctx,
COGL_PRIVATE_FEATURE_TEXTURE_2D_FROM_EGL_IMAGE),
NULL);
loader = _cogl_texture_create_loader ();
loader->src_type = COGL_TEXTURE_SOURCE_TYPE_EGL_IMAGE;
loader->src.egl_image.image = image;
loader->src.egl_image.width = width;
loader->src.egl_image.height = height;
loader->src.egl_image.format = format;
loader->src.egl_image.flags = flags;
tex = _cogl_texture_2d_create_base (ctx, width, height, format, loader);
if (!cogl_texture_allocate (COGL_TEXTURE (tex), error))
{
cogl_object_unref (tex);
return NULL;
}
return tex;
}
#endif /* defined (COGL_HAS_EGL_SUPPORT) && defined (EGL_KHR_image_base) */
void
_cogl_texture_2d_externally_modified (CoglTexture *texture)
{
if (!cogl_is_texture_2d (texture))
return;
COGL_TEXTURE_2D (texture)->mipmaps_dirty = TRUE;
}
void
_cogl_texture_2d_copy_from_framebuffer (CoglTexture2D *tex_2d,
int src_x,
@ -284,7 +122,7 @@ _cogl_texture_2d_copy_from_framebuffer (CoglTexture2D *tex_2d,
int level)
{
CoglTexture *tex = COGL_TEXTURE (tex_2d);
CoglContext *ctx = tex->context;
CoglContext *ctx = cogl_texture_get_context (tex);
/* Assert that the storage for this texture has been allocated */
cogl_texture_allocate (tex, NULL); /* (abort on error) */
@ -356,7 +194,7 @@ _cogl_texture_2d_get_gl_texture (CoglTexture *tex,
GLuint *out_gl_handle,
GLenum *out_gl_target)
{
CoglContext *ctx = tex->context;
CoglContext *ctx = cogl_texture_get_context (tex);
CoglTexture2D *tex_2d = COGL_TEXTURE_2D (tex);
if (ctx->driver_vtable->texture_2d_get_gl_handle)
@ -386,7 +224,7 @@ _cogl_texture_2d_pre_paint (CoglTexture *tex, CoglTexturePrePaintFlags flags)
if ((flags & COGL_TEXTURE_NEEDS_MIPMAP) &&
tex_2d->auto_mipmap && tex_2d->mipmaps_dirty)
{
CoglContext *ctx = tex->context;
CoglContext *ctx = cogl_texture_get_context (tex);
/* Since we are about to ask the GPU to generate mipmaps of tex, we
* better make sure tex is up-to-date.
@ -421,7 +259,7 @@ _cogl_texture_2d_set_region (CoglTexture *tex,
CoglBitmap *bmp,
GError **error)
{
CoglContext *ctx = tex->context;
CoglContext *ctx = cogl_texture_get_context (tex);
CoglTexture2D *tex_2d = COGL_TEXTURE_2D (tex);
if (!ctx->driver_vtable->texture_2d_copy_from_bitmap (tex_2d,
@ -447,7 +285,7 @@ static gboolean
_cogl_texture_2d_is_get_data_supported (CoglTexture *tex)
{
CoglTexture2D *tex_2d = COGL_TEXTURE_2D (tex);
CoglContext *ctx = tex->context;
CoglContext *ctx = cogl_texture_get_context (tex);
return ctx->driver_vtable->texture_2d_is_get_data_supported (tex_2d);
}
@ -458,7 +296,7 @@ _cogl_texture_2d_get_data (CoglTexture *tex,
int rowstride,
uint8_t *data)
{
CoglContext *ctx = tex->context;
CoglContext *ctx = cogl_texture_get_context (tex);
if (ctx->driver_vtable->texture_2d_get_data)
{
@ -482,26 +320,190 @@ _cogl_texture_2d_get_gl_format (CoglTexture *tex)
return COGL_TEXTURE_2D (tex)->gl_internal_format;
}
static const CoglTextureVtable
cogl_texture_2d_vtable =
static void
cogl_texture_2d_class_init (CoglTexture2DClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
CoglTextureClass *texture_class = COGL_TEXTURE_CLASS (klass);
gobject_class->dispose = cogl_texture_2d_dispose;
texture_class->allocate = _cogl_texture_2d_allocate;
texture_class->set_region = _cogl_texture_2d_set_region;
texture_class->is_get_data_supported = _cogl_texture_2d_is_get_data_supported;
texture_class->get_data = _cogl_texture_2d_get_data;
texture_class->get_max_waste = _cogl_texture_2d_get_max_waste;
texture_class->is_sliced = _cogl_texture_2d_is_sliced;
texture_class->can_hardware_repeat = _cogl_texture_2d_can_hardware_repeat;
texture_class->transform_coords_to_gl = _cogl_texture_2d_transform_coords_to_gl;
texture_class->transform_quad_coords_to_gl = _cogl_texture_2d_transform_quad_coords_to_gl;
texture_class->get_gl_texture = _cogl_texture_2d_get_gl_texture;
texture_class->gl_flush_legacy_texobj_filters = _cogl_texture_2d_gl_flush_legacy_texobj_filters;
texture_class->pre_paint = _cogl_texture_2d_pre_paint;
texture_class->ensure_non_quad_rendering = _cogl_texture_2d_ensure_non_quad_rendering;
texture_class->gl_flush_legacy_texobj_wrap_modes = _cogl_texture_2d_gl_flush_legacy_texobj_wrap_modes;
texture_class->get_format = _cogl_texture_2d_get_format;
texture_class->get_gl_format = _cogl_texture_2d_get_gl_format;
texture_class->set_auto_mipmap = _cogl_texture_2d_set_auto_mipmap;
}
static void
cogl_texture_2d_init (CoglTexture2D *self)
{
CoglTexture *texture = COGL_TEXTURE (self);
texture->is_primitive = TRUE;
}
CoglTexture *
cogl_texture_2d_new_with_format (CoglContext *ctx,
int width,
int height,
CoglPixelFormat format)
{
CoglTextureLoader *loader;
g_return_val_if_fail (width >= 1, NULL);
g_return_val_if_fail (height >= 1, NULL);
loader = _cogl_texture_create_loader ();
loader->src_type = COGL_TEXTURE_SOURCE_TYPE_SIZE;
loader->src.sized.width = width;
loader->src.sized.height = height;
loader->src.sized.format = format;
return _cogl_texture_2d_create_base (ctx, width, height, format, loader);
}
CoglTexture *
cogl_texture_2d_new_with_size (CoglContext *ctx,
int width,
int height)
{
CoglTextureLoader *loader;
g_return_val_if_fail (width >= 1, NULL);
g_return_val_if_fail (height >= 1, NULL);
loader = _cogl_texture_create_loader ();
loader->src_type = COGL_TEXTURE_SOURCE_TYPE_SIZE;
loader->src.sized.width = width;
loader->src.sized.height = height;
loader->src.sized.format = COGL_PIXEL_FORMAT_ANY;
return _cogl_texture_2d_create_base (ctx, width, height,
COGL_PIXEL_FORMAT_RGBA_8888_PRE, loader);
}
CoglTexture *
cogl_texture_2d_new_from_bitmap (CoglBitmap *bmp)
{
CoglTextureLoader *loader;
g_return_val_if_fail (bmp != NULL, NULL);
loader = _cogl_texture_create_loader ();
loader->src_type = COGL_TEXTURE_SOURCE_TYPE_BITMAP;
loader->src.bitmap.bitmap = g_object_ref (bmp);
return _cogl_texture_2d_create_base (_cogl_bitmap_get_context (bmp),
cogl_bitmap_get_width (bmp),
cogl_bitmap_get_height (bmp),
cogl_bitmap_get_format (bmp),
loader);
}
CoglTexture *
cogl_texture_2d_new_from_data (CoglContext *ctx,
int width,
int height,
CoglPixelFormat format,
int rowstride,
const uint8_t *data,
GError **error)
{
CoglBitmap *bmp;
CoglTexture *tex_2d;
g_return_val_if_fail (format != COGL_PIXEL_FORMAT_ANY, NULL);
g_return_val_if_fail (cogl_pixel_format_get_n_planes (format) == 1, NULL);
g_return_val_if_fail (data != NULL, NULL);
/* Rowstride from width if not given */
if (rowstride == 0)
rowstride = width * cogl_pixel_format_get_bytes_per_pixel (format, 0);
/* Wrap the data into a bitmap */
bmp = cogl_bitmap_new_for_data (ctx,
width, height,
format,
rowstride,
(uint8_t *) data);
tex_2d = cogl_texture_2d_new_from_bitmap (bmp);
g_object_unref (bmp);
if (tex_2d &&
!cogl_texture_allocate (COGL_TEXTURE (tex_2d), error))
{
TRUE, /* primitive */
_cogl_texture_2d_allocate,
_cogl_texture_2d_set_region,
_cogl_texture_2d_is_get_data_supported,
_cogl_texture_2d_get_data,
NULL, /* foreach_sub_texture_in_region */
_cogl_texture_2d_get_max_waste,
_cogl_texture_2d_is_sliced,
_cogl_texture_2d_can_hardware_repeat,
_cogl_texture_2d_transform_coords_to_gl,
_cogl_texture_2d_transform_quad_coords_to_gl,
_cogl_texture_2d_get_gl_texture,
_cogl_texture_2d_gl_flush_legacy_texobj_filters,
_cogl_texture_2d_pre_paint,
_cogl_texture_2d_ensure_non_quad_rendering,
_cogl_texture_2d_gl_flush_legacy_texobj_wrap_modes,
_cogl_texture_2d_get_format,
_cogl_texture_2d_get_gl_format,
_cogl_texture_2d_set_auto_mipmap
};
g_object_unref (tex_2d);
return NULL;
}
return tex_2d;
}
#if defined (COGL_HAS_EGL_SUPPORT) && defined (EGL_KHR_image_base)
/* NB: The reason we require the width, height and format to be passed
* even though they may seem redundant is because GLES 1/2 don't
* provide a way to query these properties. */
CoglTexture *
cogl_egl_texture_2d_new_from_image (CoglContext *ctx,
int width,
int height,
CoglPixelFormat format,
EGLImageKHR image,
CoglEglImageFlags flags,
GError **error)
{
CoglTextureLoader *loader;
CoglTexture *tex;
g_return_val_if_fail (_cogl_context_get_winsys (ctx)->constraints &
COGL_RENDERER_CONSTRAINT_USES_EGL,
NULL);
g_return_val_if_fail (_cogl_has_private_feature
(ctx,
COGL_PRIVATE_FEATURE_TEXTURE_2D_FROM_EGL_IMAGE),
NULL);
loader = _cogl_texture_create_loader ();
loader->src_type = COGL_TEXTURE_SOURCE_TYPE_EGL_IMAGE;
loader->src.egl_image.image = image;
loader->src.egl_image.width = width;
loader->src.egl_image.height = height;
loader->src.egl_image.format = format;
loader->src.egl_image.flags = flags;
tex = _cogl_texture_2d_create_base (ctx, width, height, format, loader);
if (!cogl_texture_allocate (COGL_TEXTURE (tex), error))
{
g_object_unref (tex);
return NULL;
}
return tex;
}
#endif /* defined (COGL_HAS_EGL_SUPPORT) && defined (EGL_KHR_image_base) */
void
_cogl_texture_2d_externally_modified (CoglTexture *texture)
{
if (!COGL_IS_TEXTURE_2D (texture))
return;
COGL_TEXTURE_2D (texture)->mipmaps_dirty = TRUE;
}

53
cogl/cogl/cogl-texture-2d.h
View File

@ -46,8 +46,9 @@
G_BEGIN_DECLS
/**
* SECTION:cogl-texture-2d
* @short_description: Functions for creating and manipulating 2D textures
* CoglTexture2D:
*
* Functions for creating and manipulating 2D textures
*
* These functions allow low-level 2D textures to be allocated. These
* differ from sliced textures for example which may internally be
@ -56,8 +57,21 @@ G_BEGIN_DECLS
* by the GPU.
*/
#define COGL_TYPE_TEXTURE_2D (cogl_texture_2d_get_type ())
#define COGL_TEXTURE_2D(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), COGL_TYPE_TEXTURE_2D, CoglTexture2D))
#define COGL_TEXTURE_2D_CONST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), COGL_TYPE_TEXTURE_2D, CoglTexture2D const))
#define COGL_TEXTURE_2D_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), COGL_TYPE_TEXTURE_2D, CoglTexture2DClass))
#define COGL_IS_TEXTURE_2D(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), COGL_TYPE_TEXTURE_2D))
#define COGL_IS_TEXTURE_2D_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), COGL_TYPE_TEXTURE_2D))
#define COGL_TEXTURE_2D_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), COGL_TYPE_TEXTURE_2D, CoglTexture2DClass))
typedef struct _CoglTexture2DClass CoglTexture2DClass;
typedef struct _CoglTexture2D CoglTexture2D;
#define COGL_TEXTURE_2D(X) ((CoglTexture2D *)X)
G_DEFINE_AUTOPTR_CLEANUP_FUNC (CoglTexture2D, g_object_unref)
COGL_EXPORT
GType cogl_texture_2d_get_type (void) G_GNUC_CONST;
typedef enum _CoglEglImageFlags
{
@ -65,27 +79,6 @@ typedef enum _CoglEglImageFlags
COGL_EGL_IMAGE_FLAG_NO_GET_DATA = 1 << 0,
} CoglEglImageFlags;
/**
* cogl_texture_2d_get_gtype:
*
* Returns: a #GType that can be used with the GLib type system.
*/
COGL_EXPORT
GType cogl_texture_2d_get_gtype (void);
/**
* cogl_is_texture_2d:
* @object: A #CoglObject
*
* Gets whether the given object references an existing #CoglTexture2D
* object.
*
* Return value: %TRUE if the object references a #CoglTexture2D,
* %FALSE otherwise
*/
COGL_EXPORT gboolean
cogl_is_texture_2d (void *object);
/**
* cogl_texture_2d_new_with_format: (skip)
* @ctx: A #CoglContext
@ -111,7 +104,7 @@ cogl_is_texture_2d (void *object);
*
* Since: 2.0
*/
COGL_EXPORT CoglTexture2D *
COGL_EXPORT CoglTexture *
cogl_texture_2d_new_with_format (CoglContext *ctx,
int width,
int height,
@ -139,7 +132,7 @@ cogl_texture_2d_new_with_format (CoglContext *ctx,
*
* Returns: (transfer full): A new #CoglTexture2D object with no storage yet allocated.
*/
COGL_EXPORT CoglTexture2D *
COGL_EXPORT CoglTexture *
cogl_texture_2d_new_with_size (CoglContext *ctx,
int width,
int height);
@ -175,7 +168,7 @@ cogl_texture_2d_new_with_size (CoglContext *ctx,
* non-power-of-two size that the hardware doesn't support)
* it will return %NULL and set @error.
*/
COGL_EXPORT CoglTexture2D *
COGL_EXPORT CoglTexture *
cogl_texture_2d_new_from_data (CoglContext *ctx,
int width,
int height,
@ -204,7 +197,7 @@ cogl_texture_2d_new_from_data (CoglContext *ctx,
*
* Returns: (transfer full): A newly allocated #CoglTexture2D
*/
COGL_EXPORT CoglTexture2D *
COGL_EXPORT CoglTexture *
cogl_texture_2d_new_from_bitmap (CoglBitmap *bitmap);
/**
@ -214,7 +207,7 @@ cogl_texture_2d_new_from_bitmap (CoglBitmap *bitmap);
/* NB: The reason we require the width, height and format to be passed
* even though they may seem redundant is because GLES 1/2 don't
* provide a way to query these properties. */
COGL_EXPORT CoglTexture2D *
COGL_EXPORT CoglTexture *
cogl_egl_texture_2d_new_from_image (CoglContext *ctx,
int width,
int height,
@ -230,7 +223,7 @@ typedef gboolean (*CoglTexture2DEGLImageExternalAlloc) (CoglTexture2D *tex_2d,
/**
* cogl_texture_2d_new_from_egl_image_external: (skip)
*/
COGL_EXPORT CoglTexture2D *
COGL_EXPORT CoglTexture *
cogl_texture_2d_new_from_egl_image_external (CoglContext *ctx,
int width,
int height,

180
cogl/cogl/cogl-texture-private.h
View File

@ -31,7 +31,6 @@
#pragma once
#include "cogl/cogl-bitmap-private.h"
#include "cogl/cogl-object-private.h"
#include "cogl/cogl-pipeline-private.h"
#include "cogl/cogl-spans.h"
#include "cogl/cogl-meta-texture.h"
@ -42,8 +41,6 @@
#include "cogl/cogl-egl-defines.h"
#endif
typedef struct _CoglTextureVtable CoglTextureVtable;
/* Encodes three possibiloities result of transforming a quad */
typedef enum
{
@ -66,13 +63,79 @@ typedef enum
COGL_TEXTURE_NEEDS_MIPMAP = 1
} CoglTexturePrePaintFlags;
struct _CoglTextureVtable
typedef enum _CoglTextureSourceType {
COGL_TEXTURE_SOURCE_TYPE_SIZE = 1,
COGL_TEXTURE_SOURCE_TYPE_BITMAP,
COGL_TEXTURE_SOURCE_TYPE_EGL_IMAGE,
COGL_TEXTURE_SOURCE_TYPE_EGL_IMAGE_EXTERNAL
} CoglTextureSourceType;
typedef struct _CoglTextureLoader
{
/* Virtual functions that must be implemented for a texture
backend */
CoglTextureSourceType src_type;
union {
struct {
int width;
int height;
int depth; /* for 3d textures */
CoglPixelFormat format;
} sized;
struct {
CoglBitmap *bitmap;
int height; /* for 3d textures */
int depth; /* for 3d textures */
} bitmap;
#if defined (COGL_HAS_EGL_SUPPORT) && defined (EGL_KHR_image_base)
struct {
EGLImageKHR image;
int width;
int height;
CoglPixelFormat format;
CoglEglImageFlags flags;
} egl_image;
#endif
#if defined (COGL_HAS_EGL_SUPPORT)
struct {
int width;
int height;
CoglTexture2DEGLImageExternalAlloc alloc;
CoglPixelFormat format;
} egl_image_external;
#endif
struct {
int width;
int height;
unsigned int gl_handle;
CoglPixelFormat format;
} gl_foreign;
} src;
} CoglTextureLoader;
struct _CoglTexture
{
GObject parent_instance;
CoglContext *context;
gboolean is_primitive;
CoglTextureLoader *loader;
GList *framebuffers;
int max_level_set;
int max_level_requested;
int width;
int height;
gboolean allocated;
/*
* Internal format
*/
CoglTextureComponents components;
unsigned int premultiplied : 1;
};
struct _CoglTextureClass
{
GObjectClass parent_class;
gboolean (* allocate) (CoglTexture *tex,
GError **error);
@ -133,7 +196,8 @@ struct _CoglTextureVtable
GLenum min_filter,
GLenum mag_filter);
void (* pre_paint) (CoglTexture *tex, CoglTexturePrePaintFlags flags);
void (* pre_paint) (CoglTexture *tex,
CoglTexturePrePaintFlags flags);
void (* ensure_non_quad_rendering) (CoglTexture *tex);
/* OpenGL driver specific virtual function */
@ -149,75 +213,6 @@ struct _CoglTextureVtable
gboolean value);
};
typedef enum _CoglTextureSourceType {
COGL_TEXTURE_SOURCE_TYPE_SIZE = 1,
COGL_TEXTURE_SOURCE_TYPE_BITMAP,
COGL_TEXTURE_SOURCE_TYPE_EGL_IMAGE,
COGL_TEXTURE_SOURCE_TYPE_EGL_IMAGE_EXTERNAL
} CoglTextureSourceType;
typedef struct _CoglTextureLoader
{
CoglTextureSourceType src_type;
union {
struct {
int width;
int height;
int depth; /* for 3d textures */
CoglPixelFormat format;
} sized;
struct {
CoglBitmap *bitmap;
int height; /* for 3d textures */
int depth; /* for 3d textures */
} bitmap;
#if defined (COGL_HAS_EGL_SUPPORT) && defined (EGL_KHR_image_base)
struct {
EGLImageKHR image;
int width;
int height;
CoglPixelFormat format;
CoglEglImageFlags flags;
} egl_image;
#endif
#if defined (COGL_HAS_EGL_SUPPORT)
struct {
int width;
int height;
CoglTexture2DEGLImageExternalAlloc alloc;
CoglPixelFormat format;
} egl_image_external;
#endif
struct {
int width;
int height;
unsigned int gl_handle;
CoglPixelFormat format;
} gl_foreign;
} src;
} CoglTextureLoader;
struct _CoglTexture
{
CoglObject _parent;
CoglContext *context;
CoglTextureLoader *loader;
GList *framebuffers;
int max_level_set;
int max_level_requested;
int width;
int height;
gboolean allocated;
/*
* Internal format
*/
CoglTextureComponents components;
unsigned int premultiplied:1;
const CoglTextureVtable *vtable;
};
typedef enum _CoglTextureChangeFlags
{
/* Whenever the internals of a texture are changed such that the
@ -251,26 +246,8 @@ _cogl_texture_init (CoglTexture *texture,
int width,
int height,
CoglPixelFormat src_format,
CoglTextureLoader *loader,
const CoglTextureVtable *vtable);
CoglTextureLoader *loader);
void
_cogl_texture_free (CoglTexture *texture);
/* 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 (const CoglObjectClass *klass);
#define COGL_TEXTURE_DEFINE(TypeName, type_name) \
COGL_OBJECT_DEFINE_WITH_CODE_GTYPE \
(TypeName, type_name, \
_cogl_texture_register_texture_type (&_cogl_##type_name##_class))
#define COGL_TEXTURE_INTERNAL_DEFINE(TypeName, type_name) \
COGL_OBJECT_INTERNAL_DEFINE_WITH_CODE \
(TypeName, type_name, \
_cogl_texture_register_texture_type (&_cogl_##type_name##_class))
COGL_EXPORT gboolean
_cogl_texture_can_hardware_repeat (CoglTexture *texture);
@ -403,3 +380,16 @@ _cogl_texture_create_loader (void);
void
_cogl_texture_copy_internal_format (CoglTexture *src,
CoglTexture *dest);
CoglContext *
cogl_texture_get_context (CoglTexture *texture);
CoglTextureLoader *
cogl_texture_get_loader (CoglTexture *texture);
int
cogl_texture_get_max_level_set (CoglTexture *texture);
void
cogl_texture_set_max_level_set (CoglTexture *texture,
int max_level_set);

261
cogl/cogl/cogl-texture.c
View File

@ -50,94 +50,17 @@
#include "cogl/cogl-atlas-texture-private.h"
#include "cogl/cogl-pipeline.h"
#include "cogl/cogl-context-private.h"
#include "cogl/cogl-object-private.h"
#include "cogl/cogl-object-private.h"
#include "cogl/cogl-offscreen-private.h"
#include "cogl/cogl-framebuffer-private.h"
#include "cogl/cogl1-context.h"
#include "cogl/cogl-sub-texture.h"
#include "cogl/cogl-primitive-texture.h"
#include "cogl/cogl-gtype-private.h"
#include <string.h>
#include <stdlib.h>
#include <math.h>
COGL_GTYPE_DEFINE_INTERFACE (Texture, texture);
uint32_t
cogl_texture_error_quark (void)
{
return g_quark_from_static_string ("cogl-texture-error-quark");
}
/* XXX:
* The CoglObject macros don't support any form of inheritance, so for
* now we implement the CoglObject support for the CoglTexture
* abstract class manually.
*/
static GSList *_cogl_texture_types;
void
_cogl_texture_register_texture_type (const CoglObjectClass *klass)
{
_cogl_texture_types = g_slist_prepend (_cogl_texture_types, (void *) klass);
}
gboolean
cogl_is_texture (void *object)
{
CoglObject *obj = (CoglObject *)object;
GSList *l;
if (object == NULL)
return FALSE;
for (l = _cogl_texture_types; l; l = l->next)
if (l->data == obj->klass)
return TRUE;
return FALSE;
}
void
_cogl_texture_init (CoglTexture *texture,
CoglContext *context,
int width,
int height,
CoglPixelFormat src_format,
CoglTextureLoader *loader,
const CoglTextureVtable *vtable)
{
texture->context = context;
texture->max_level_set = 0;
texture->max_level_requested = 1000; /* OpenGL default GL_TEXTURE_MAX_LEVEL */
texture->width = width;
texture->height = height;
texture->allocated = FALSE;
texture->vtable = vtable;
texture->framebuffers = NULL;
texture->loader = loader;
_cogl_texture_set_internal_format (texture, src_format);
/* Although we want to initialize texture::components according
* to the source format, we always want the internal layout to
* be considered premultiplied by default.
*
* NB: this ->premultiplied state is user configurable so to avoid
* awkward documentation, setting this to 'true' does not depend on
* ->components having an alpha component (we will simply ignore the
* premultiplied status later if there is no alpha component).
* This way we don't have to worry about updating the
* ->premultiplied state in _set_components(). Similarly we don't
* have to worry about updating the ->components state in
* _set_premultiplied().
*/
texture->premultiplied = TRUE;
}
G_DEFINE_ABSTRACT_TYPE (CoglTexture, cogl_texture, G_TYPE_OBJECT)
static void
_cogl_texture_free_loader (CoglTexture *texture)
@ -160,20 +83,75 @@ _cogl_texture_free_loader (CoglTexture *texture)
}
}
static void
cogl_texture_dispose (GObject *object)
{
CoglTexture *texture = COGL_TEXTURE (object);
_cogl_texture_free_loader (texture);
G_OBJECT_CLASS (cogl_texture_parent_class)->dispose (object);
}
static void
cogl_texture_class_init (CoglTextureClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
gobject_class->dispose = cogl_texture_dispose;
}
static void
cogl_texture_init (CoglTexture *texture)
{
texture->max_level_set = 0;
texture->max_level_requested = 1000; /* OpenGL default GL_TEXTURE_MAX_LEVEL */
texture->allocated = FALSE;
texture->framebuffers = NULL;
}
uint32_t
cogl_texture_error_quark (void)
{
return g_quark_from_static_string ("cogl-texture-error-quark");
}
void
_cogl_texture_init (CoglTexture *texture,
CoglContext *context,
int width,
int height,
CoglPixelFormat src_format,
CoglTextureLoader *loader)
{
texture->context = context;
texture->width = width;
texture->height = height;
texture->loader = loader;
_cogl_texture_set_internal_format (texture, src_format);
/* Although we want to initialize texture::components according
* to the source format, we always want the internal layout to
* be considered premultiplied by default.
*
* NB: this ->premultiplied state is user configurable so to avoid
* awkward documentation, setting this to 'true' does not depend on
* ->components having an alpha component (we will simply ignore the
* premultiplied status later if there is no alpha component).
* This way we don't have to worry about updating the
* ->premultiplied state in _set_components(). Similarly we don't
* have to worry about updating the ->components state in
* _set_premultiplied().
*/
texture->premultiplied = TRUE;
}
CoglTextureLoader *
_cogl_texture_create_loader (void)
{
return g_new0 (CoglTextureLoader, 1);
}
void
_cogl_texture_free (CoglTexture *texture)
{
_cogl_texture_free_loader (texture);
g_free (texture);
}
gboolean
_cogl_texture_needs_premult_conversion (CoglPixelFormat src_format,
CoglPixelFormat dst_format)
@ -188,8 +166,8 @@ _cogl_texture_needs_premult_conversion (CoglPixelFormat src_format,
gboolean
cogl_texture_is_get_data_supported (CoglTexture *texture)
{
if (texture->vtable->is_get_data_supported)
return texture->vtable->is_get_data_supported (texture);
if (COGL_TEXTURE_GET_CLASS (texture)->is_get_data_supported)
return COGL_TEXTURE_GET_CLASS (texture)->is_get_data_supported (texture);
else
return TRUE;
}
@ -197,7 +175,7 @@ cogl_texture_is_get_data_supported (CoglTexture *texture)
unsigned int
cogl_texture_get_width (CoglTexture *texture)
{
g_return_val_if_fail (cogl_is_texture (texture), 0);
g_return_val_if_fail (COGL_IS_TEXTURE (texture), 0);
return texture->width;
}
@ -205,7 +183,7 @@ cogl_texture_get_width (CoglTexture *texture)
unsigned int
cogl_texture_get_height (CoglTexture *texture)
{
g_return_val_if_fail (cogl_is_texture (texture), 0);
g_return_val_if_fail (COGL_IS_TEXTURE (texture), 0);
return texture->height;
}
@ -215,15 +193,16 @@ _cogl_texture_get_format (CoglTexture *texture)
{
if (!texture->allocated)
cogl_texture_allocate (texture, NULL);
return texture->vtable->get_format (texture);
return COGL_TEXTURE_GET_CLASS (texture)->get_format (texture);
}
int
cogl_texture_get_max_waste (CoglTexture *texture)
{
g_return_val_if_fail (cogl_is_texture (texture), 0);
g_return_val_if_fail (COGL_IS_TEXTURE (texture), 0);
return texture->vtable->get_max_waste (texture);
return COGL_TEXTURE_GET_CLASS (texture)->get_max_waste (texture);
}
int
@ -278,11 +257,12 @@ _cogl_texture_get_level_size (CoglTexture *texture,
gboolean
cogl_texture_is_sliced (CoglTexture *texture)
{
g_return_val_if_fail (cogl_is_texture (texture), FALSE);
g_return_val_if_fail (COGL_IS_TEXTURE (texture), FALSE);
if (!texture->allocated)
cogl_texture_allocate (texture, NULL);
return texture->vtable->is_sliced (texture);
return COGL_TEXTURE_GET_CLASS (texture)->is_sliced (texture);
}
/* If this returns FALSE, that implies _foreach_sub_texture_in_region
@ -294,7 +274,7 @@ _cogl_texture_can_hardware_repeat (CoglTexture *texture)
{
if (!texture->allocated)
cogl_texture_allocate (texture, NULL);
return texture->vtable->can_hardware_repeat (texture);
return COGL_TEXTURE_GET_CLASS (texture)->can_hardware_repeat (texture);
}
/* NB: You can't use this with textures comprised of multiple sub textures (use
@ -305,14 +285,14 @@ _cogl_texture_transform_coords_to_gl (CoglTexture *texture,
float *s,
float *t)
{
texture->vtable->transform_coords_to_gl (texture, s, t);
COGL_TEXTURE_GET_CLASS (texture)->transform_coords_to_gl (texture, s, t);
}
CoglTransformResult
_cogl_texture_transform_quad_coords_to_gl (CoglTexture *texture,
float *coords)
{
return texture->vtable->transform_quad_coords_to_gl (texture, coords);
return COGL_TEXTURE_GET_CLASS (texture)->transform_quad_coords_to_gl (texture, coords);
}
gboolean
@ -320,13 +300,14 @@ cogl_texture_get_gl_texture (CoglTexture *texture,
GLuint *out_gl_handle,
GLenum *out_gl_target)
{
g_return_val_if_fail (cogl_is_texture (texture), FALSE);
g_return_val_if_fail (COGL_IS_TEXTURE (texture), FALSE);
if (!texture->allocated)
cogl_texture_allocate (texture, NULL);
return texture->vtable->get_gl_texture (texture,
out_gl_handle, out_gl_target);
return COGL_TEXTURE_GET_CLASS (texture)->get_gl_texture (texture,
out_gl_handle,
out_gl_target);
}
void
@ -346,13 +327,14 @@ _cogl_texture_pre_paint (CoglTexture *texture, CoglTexturePrePaintFlags flags)
*/
cogl_texture_allocate (texture, NULL);
texture->vtable->pre_paint (texture, flags);
COGL_TEXTURE_GET_CLASS (texture)->pre_paint (texture,
flags);
}
void
_cogl_texture_ensure_non_quad_rendering (CoglTexture *texture)
{
texture->vtable->ensure_non_quad_rendering (texture);
COGL_TEXTURE_GET_CLASS (texture)->ensure_non_quad_rendering (texture);
}
gboolean
@ -383,7 +365,7 @@ _cogl_texture_set_region_from_bitmap (CoglTexture *texture,
always stored in an RGBA texture even if the texture format is
advertised as RGB. */
return texture->vtable->set_region (texture,
return COGL_TEXTURE_GET_CLASS (texture)->set_region (texture,
src_x, src_y,
dst_x, dst_y,
width, height,
@ -405,7 +387,7 @@ cogl_texture_set_region_from_bitmap (CoglTexture *texture,
GError *ignore_error = NULL;
gboolean status;
g_return_val_if_fail (cogl_is_texture (texture), FALSE);
g_return_val_if_fail (COGL_IS_TEXTURE (texture), FALSE);
status = _cogl_texture_set_region_from_bitmap (texture,
src_x, src_y,
@ -431,7 +413,7 @@ _cogl_texture_set_region (CoglTexture *texture,
int level,
GError **error)
{
CoglContext *ctx = texture->context;
CoglContext *ctx = cogl_texture_get_context (texture);
CoglBitmap *source_bmp;
gboolean ret;
@ -481,7 +463,7 @@ cogl_texture_set_region (CoglTexture *texture,
int bytes_per_pixel;
gboolean status;
g_return_val_if_fail (cogl_is_texture (texture), FALSE);
g_return_val_if_fail (COGL_IS_TEXTURE (texture), FALSE);
g_return_val_if_fail (format != COGL_PIXEL_FORMAT_ANY, FALSE);
g_return_val_if_fail (cogl_pixel_format_get_n_planes (format) == 1, FALSE);
@ -517,7 +499,7 @@ cogl_texture_set_data (CoglTexture *texture,
int level_width;
int level_height;
g_return_val_if_fail (cogl_is_texture (texture), FALSE);
g_return_val_if_fail (COGL_IS_TEXTURE (texture), FALSE);
_cogl_texture_get_level_size (texture,
level,
@ -547,7 +529,7 @@ get_texture_bits_via_offscreen (CoglTexture *meta_texture,
unsigned int dst_rowstride,
CoglPixelFormat closest_format)
{
CoglContext *ctx = sub_texture->context;
CoglContext *ctx = cogl_texture_get_context (sub_texture);
CoglOffscreen *offscreen;
CoglFramebuffer *framebuffer;
CoglBitmap *bitmap;
@ -628,7 +610,7 @@ get_texture_bits_via_copy (CoglTexture *texture,
full_rowstride = bpp * full_tex_width;
full_bits = g_malloc (full_rowstride * full_tex_height);
if (texture->vtable->get_data (texture,
if (COGL_TEXTURE_GET_CLASS (texture)->get_data (texture,
dst_format,
full_rowstride,
full_bits))
@ -702,7 +684,7 @@ texture_get_cb (CoglTexture *subtexture,
if (x_in_subtexture == 0 && y_in_subtexture == 0 &&
width == subtexture_width && height == subtexture_height)
{
if (subtexture->vtable->get_data (subtexture,
if (COGL_TEXTURE_GET_CLASS (subtexture)->get_data (subtexture,
closest_format,
rowstride,
dst_bits))
@ -752,7 +734,7 @@ cogl_texture_get_data (CoglTexture *texture,
GError *ignore_error = NULL;
CoglTextureGetData tg_data;
g_return_val_if_fail (cogl_is_texture (texture), 0);
g_return_val_if_fail (COGL_IS_TEXTURE (texture), 0);
texture_format = _cogl_texture_get_format (texture);
@ -776,7 +758,7 @@ cogl_texture_get_data (CoglTexture *texture,
if (data == NULL)
return byte_size;
ctx = texture->context;
ctx = cogl_texture_get_context (texture);
closest_format =
ctx->texture_driver->find_best_gl_get_data_format (ctx,
format,
@ -856,7 +838,7 @@ cogl_texture_get_data (CoglTexture *texture,
* 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_meta_texture_foreach_in_region (COGL_META_TEXTURE (texture),
cogl_meta_texture_foreach_in_region (texture,
0, 0, 1, 1,
COGL_PIPELINE_WRAP_MODE_REPEAT,
COGL_PIPELINE_WRAP_MODE_REPEAT,
@ -939,12 +921,12 @@ _cogl_texture_get_associated_framebuffers (CoglTexture *texture)
void
_cogl_texture_flush_journal_rendering (CoglTexture *texture)
{
GList *l;
const 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 = texture->framebuffers; l; l = l->next)
for (l = _cogl_texture_get_associated_framebuffers (texture); l; l = l->next)
_cogl_framebuffer_flush_journal (l->data);
}
@ -1081,7 +1063,7 @@ gboolean
cogl_texture_allocate (CoglTexture *texture,
GError **error)
{
g_return_val_if_fail (cogl_is_texture (texture), FALSE);
g_return_val_if_fail (COGL_IS_TEXTURE (texture), FALSE);
if (texture->allocated)
return TRUE;
@ -1094,7 +1076,7 @@ cogl_texture_allocate (CoglTexture *texture,
"A red-green texture was requested but the driver "
"does not support them");
texture->allocated = texture->vtable->allocate (texture, error);
texture->allocated = COGL_TEXTURE_GET_CLASS (texture)->allocate (texture, error);
return texture->allocated;
}
@ -1138,14 +1120,14 @@ CoglPixelFormat
_cogl_texture_determine_internal_format (CoglTexture *texture,
CoglPixelFormat src_format)
{
switch (texture->components)
switch (cogl_texture_get_components (texture))
{
case COGL_TEXTURE_COMPONENTS_DEPTH:
if (src_format & COGL_DEPTH_BIT)
return src_format;
else
{
CoglContext *ctx = texture->context;
CoglContext *ctx = cogl_texture_get_context (texture);
if (_cogl_has_private_feature (ctx,
COGL_PRIVATE_FEATURE_EXT_PACKED_DEPTH_STENCIL) ||
@ -1177,7 +1159,7 @@ _cogl_texture_determine_internal_format (CoglTexture *texture,
else
format = COGL_PIXEL_FORMAT_RGBA_8888;
if (texture->premultiplied)
if (cogl_texture_get_premultiplied (texture))
{
if (COGL_PIXEL_FORMAT_CAN_HAVE_PREMULT (format))
return format |= COGL_PREMULT_BIT;
@ -1196,7 +1178,7 @@ void
cogl_texture_set_components (CoglTexture *texture,
CoglTextureComponents components)
{
g_return_if_fail (cogl_is_texture (texture));
g_return_if_fail (COGL_IS_TEXTURE (texture));
g_return_if_fail (!texture->allocated);
if (texture->components == components)
@ -1208,7 +1190,7 @@ cogl_texture_set_components (CoglTexture *texture,
CoglTextureComponents
cogl_texture_get_components (CoglTexture *texture)
{
g_return_val_if_fail (cogl_is_texture (texture), 0);
g_return_val_if_fail (COGL_IS_TEXTURE (texture), 0);
return texture->components;
}
@ -1217,7 +1199,7 @@ void
cogl_texture_set_premultiplied (CoglTexture *texture,
gboolean premultiplied)
{
g_return_if_fail (cogl_is_texture (texture));
g_return_if_fail (COGL_IS_TEXTURE (texture));
g_return_if_fail (!texture->allocated);
premultiplied = !!premultiplied;
@ -1231,7 +1213,7 @@ cogl_texture_set_premultiplied (CoglTexture *texture,
gboolean
cogl_texture_get_premultiplied (CoglTexture *texture)
{
g_return_val_if_fail (cogl_is_texture (texture), FALSE);
g_return_val_if_fail (COGL_IS_TEXTURE (texture), FALSE);
return texture->premultiplied;
}
@ -1240,6 +1222,31 @@ void
_cogl_texture_copy_internal_format (CoglTexture *src,
CoglTexture *dest)
{
cogl_texture_set_components (dest, src->components);
cogl_texture_set_premultiplied (dest, src->premultiplied);
cogl_texture_set_components (dest, cogl_texture_get_components (src));
cogl_texture_set_premultiplied (dest, cogl_texture_get_premultiplied (src));
}
CoglContext *
cogl_texture_get_context (CoglTexture *texture)
{
return texture->context;
}
CoglTextureLoader *
cogl_texture_get_loader (CoglTexture *texture)
{
return texture->loader;
}
int
cogl_texture_get_max_level_set (CoglTexture *texture)
{
return texture->max_level_set;
}
void
cogl_texture_set_max_level_set (CoglTexture *texture,
int max_level_set)
{
texture->max_level_set = max_level_set;
}

53
cogl/cogl/cogl-texture.h
View File

@ -34,21 +34,6 @@
#error "Only <cogl/cogl.h> can be included directly."
#endif
/* We forward declare the CoglTexture type here to avoid some circular
* dependency issues with the following headers.
*/
#if defined(__COGL_H_INSIDE__) && !defined(COGL_ENABLE_MUTTER_API) && \
!defined(COGL_GIR_SCANNING)
/* For the public C api we typedef interface types as void to avoid needing
* lots of casting in code and instead we will rely on runtime type checking
* for these objects. */
typedef void CoglTexture;
#else
typedef struct _CoglTexture CoglTexture;
#define COGL_TEXTURE(X) ((CoglTexture *)X)
#endif
#include "cogl/cogl-types.h"
#include "cogl/cogl-macros.h"
#include "cogl/cogl-defines.h"
#include "cogl/cogl-pixel-buffer.h"
@ -60,23 +45,32 @@ typedef struct _CoglTexture CoglTexture;
G_BEGIN_DECLS
/**
* SECTION:cogl-texture
* @short_description: Functions for creating and manipulating textures
* CoglTexture:
*
* Functions for creating and manipulating textures
*
* Cogl allows creating and manipulating textures using a uniform
* API that tries to hide all the various complexities of creating,
* loading and manipulating textures.
*/
#define COGL_TEXTURE_MAX_WASTE 127
#define COGL_TYPE_TEXTURE (cogl_texture_get_type ())
#define COGL_TEXTURE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), COGL_TYPE_TEXTURE, CoglTexture))
#define COGL_TEXTURE_CONST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), COGL_TYPE_TEXTURE, CoglTexture const))
#define COGL_TEXTURE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), COGL_TYPE_TEXTURE, CoglTextureClass))
#define COGL_IS_TEXTURE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), COGL_TYPE_TEXTURE))
#define COGL_IS_TEXTURE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), COGL_TYPE_TEXTURE))
#define COGL_TEXTURE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), COGL_TYPE_TEXTURE, CoglTextureClass))
typedef struct _CoglTextureClass CoglTextureClass;
typedef struct _CoglTexture CoglTexture;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (CoglTexture, g_object_unref)
/**
* cogl_texture_get_gtype:
*
* Returns: a #GType that can be used with the GLib type system.
*/
COGL_EXPORT
GType cogl_texture_get_gtype (void);
GType cogl_texture_get_type (void) G_GNUC_CONST;
#define COGL_TEXTURE_MAX_WASTE 127
/**
* COGL_TEXTURE_ERROR:
@ -105,17 +99,6 @@ typedef enum
COGL_EXPORT
uint32_t cogl_texture_error_quark (void);
/**
* cogl_is_texture:
* @object: A #CoglObject pointer
*
* Gets whether the given object references a texture object.
*
* Return value: %TRUE if the @object references a texture, and
* %FALSE otherwise
*/
COGL_EXPORT gboolean
cogl_is_texture (void *object);
/**
* CoglTextureComponents:

3
cogl/cogl/deprecated/cogl-type-casts.h
View File

@ -45,7 +45,4 @@
#if !defined(COGL_ENABLE_MUTTER_API) && !defined(COGL_GIR_SCANNING)
#define COGL_BUFFER(X) (X)
#define COGL_TEXTURE(X) (X)
#define COGL_META_TEXTURE(X) (X)
#define COGL_PRIMITIVE_TEXTURE(X) (X)
#endif

2
cogl/cogl/driver/gl/cogl-pipeline-opengl.c
View File

@ -503,7 +503,7 @@ flush_layers_common_gl_state_cb (CoglPipelineLayer *layer, void *user_data)
GLenum gl_target;
if (texture == NULL)
texture = COGL_TEXTURE (ctx->default_gl_texture_2d_tex);
texture = ctx->default_gl_texture_2d_tex;
cogl_texture_get_gl_texture (texture,
&gl_texture,

32
cogl/cogl/driver/gl/cogl-texture-2d-gl.c
View File

@ -130,7 +130,7 @@ allocate_with_size (CoglTexture2D *tex_2d,
CoglPixelFormat internal_format;
int width = loader->src.sized.width;
int height = loader->src.sized.height;
CoglContext *ctx = tex->context;
CoglContext *ctx = cogl_texture_get_context (tex);
GLenum gl_intformat;
GLenum gl_format;
GLenum gl_type;
@ -267,7 +267,7 @@ allocate_from_egl_image (CoglTexture2D *tex_2d,
GError **error)
{
CoglTexture *tex = COGL_TEXTURE (tex_2d);
CoglContext *ctx = tex->context;
CoglContext *ctx = cogl_texture_get_context (tex);
CoglPixelFormat internal_format = loader->src.egl_image.format;
tex_2d->gl_texture =
@ -301,7 +301,7 @@ allocate_custom_egl_image_external (CoglTexture2D *tex_2d,
GError **error)
{
CoglTexture *tex = COGL_TEXTURE (tex_2d);
CoglContext *ctx = tex->context;
CoglContext *ctx = cogl_texture_get_context (tex);
CoglPixelFormat external_format;
CoglPixelFormat internal_format;
@ -356,7 +356,7 @@ cogl_texture_2d_gl_bind_egl_image (CoglTexture2D *tex_2d,
EGLImageKHR image,
GError **error)
{
CoglContext *ctx = COGL_TEXTURE (tex_2d)->context;
CoglContext *ctx = cogl_texture_get_context (COGL_TEXTURE (tex_2d));
_cogl_bind_gl_texture_transient (GL_TEXTURE_2D,
tex_2d->gl_texture);
@ -376,7 +376,7 @@ cogl_texture_2d_gl_bind_egl_image (CoglTexture2D *tex_2d,
return TRUE;
}
CoglTexture2D *
CoglTexture *
cogl_texture_2d_new_from_egl_image_external (CoglContext *ctx,
int width,
int height,
@ -404,14 +404,14 @@ cogl_texture_2d_new_from_egl_image_external (CoglContext *ctx,
loader->src.egl_image_external.alloc = alloc;
loader->src.egl_image_external.format = internal_format;
tex_2d = _cogl_texture_2d_create_base (ctx, width, height,
internal_format, loader);
tex_2d = COGL_TEXTURE_2D (_cogl_texture_2d_create_base (ctx, width, height,
internal_format, loader));
tex_2d->egl_image_external.user_data = user_data;
tex_2d->egl_image_external.destroy = destroy;
return tex_2d;
return COGL_TEXTURE (tex_2d);
}
#endif /* defined (COGL_HAS_EGL_SUPPORT) */
@ -420,7 +420,7 @@ _cogl_texture_2d_gl_allocate (CoglTexture *tex,
GError **error)
{
CoglTexture2D *tex_2d = COGL_TEXTURE_2D (tex);
CoglTextureLoader *loader = tex->loader;
CoglTextureLoader *loader = cogl_texture_get_loader (tex);
g_return_val_if_fail (loader, FALSE);
@ -453,7 +453,7 @@ _cogl_texture_2d_gl_flush_legacy_texobj_filters (CoglTexture *tex,
GLenum mag_filter)
{
CoglTexture2D *tex_2d = COGL_TEXTURE_2D (tex);
CoglContext *ctx = tex->context;
CoglContext *ctx = cogl_texture_get_context (tex);
if (min_filter == tex_2d->gl_legacy_texobj_min_filter
&& mag_filter == tex_2d->gl_legacy_texobj_mag_filter)
@ -485,7 +485,7 @@ _cogl_texture_2d_gl_flush_legacy_texobj_wrap_modes (CoglTexture *tex,
GLenum wrap_mode_t)
{
CoglTexture2D *tex_2d = COGL_TEXTURE_2D (tex);
CoglContext *ctx = tex->context;
CoglContext *ctx = cogl_texture_get_context (tex);
/* Only set the wrap mode if it's different from the current value
to avoid too many GL calls. Texture 2D doesn't make use of the r
@ -519,7 +519,7 @@ _cogl_texture_2d_gl_copy_from_framebuffer (CoglTexture2D *tex_2d,
int level)
{
CoglTexture *tex = COGL_TEXTURE (tex_2d);
CoglContext *ctx = tex->context;
CoglContext *ctx = cogl_texture_get_context (tex);
/* Make sure the current framebuffers are bound, though we don't need to
* flush the clip state here since we aren't going to draw to the
@ -565,7 +565,7 @@ _cogl_texture_2d_gl_copy_from_bitmap (CoglTexture2D *tex_2d,
GError **error)
{
CoglTexture *tex = COGL_TEXTURE (tex_2d);
CoglContext *ctx = tex->context;
CoglContext *ctx = cogl_texture_get_context (tex);
CoglBitmap *upload_bmp;
CoglPixelFormat upload_format;
GLenum gl_format;
@ -592,7 +592,7 @@ _cogl_texture_2d_gl_copy_from_bitmap (CoglTexture2D *tex_2d,
&gl_format,
&gl_type);
if (tex->max_level_set < level)
if (cogl_texture_get_max_level_set (tex) < level)
cogl_texture_gl_set_max_level (tex, level);
status = ctx->texture_driver->upload_subregion_to_gl (ctx,
@ -623,9 +623,9 @@ _cogl_texture_2d_gl_get_data (CoglTexture2D *tex_2d,
int rowstride,
uint8_t *data)
{
CoglContext *ctx = COGL_TEXTURE (tex_2d)->context;
CoglContext *ctx = cogl_texture_get_context (COGL_TEXTURE (tex_2d));
uint8_t bpp;
int width = COGL_TEXTURE (tex_2d)->width;
int width = cogl_texture_get_width (COGL_TEXTURE (tex_2d));
GLenum gl_format;
GLenum gl_type;

19
cogl/cogl/driver/gl/cogl-texture-gl.c
View File

@ -83,7 +83,7 @@ _cogl_texture_gl_flush_legacy_texobj_wrap_modes (CoglTexture *texture,
unsigned int wrap_mode_s,
unsigned int wrap_mode_t)
{
texture->vtable->gl_flush_legacy_texobj_wrap_modes (texture,
COGL_TEXTURE_GET_CLASS (texture)->gl_flush_legacy_texobj_wrap_modes (texture,
wrap_mode_s,
wrap_mode_t);
}
@ -93,8 +93,9 @@ _cogl_texture_gl_flush_legacy_texobj_filters (CoglTexture *texture,
unsigned int min_filter,
unsigned int mag_filter)
{
texture->vtable->gl_flush_legacy_texobj_filters (texture,
min_filter, mag_filter);
COGL_TEXTURE_GET_CLASS (texture)->gl_flush_legacy_texobj_filters (texture,
min_filter,
mag_filter);
}
/* GL and GLES3 have this by default, but GLES2 does not except via extension.
@ -110,7 +111,7 @@ void
cogl_texture_gl_set_max_level (CoglTexture *texture,
int max_level)
{
CoglContext *ctx = texture->context;
CoglContext *ctx = cogl_texture_get_context (texture);
if (_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_TEXTURE_MAX_LEVEL))
{
@ -119,25 +120,25 @@ cogl_texture_gl_set_max_level (CoglTexture *texture,
cogl_texture_get_gl_texture (texture, &gl_handle, &gl_target);
texture->max_level_set = max_level;
cogl_texture_set_max_level_set (texture, max_level);
_cogl_bind_gl_texture_transient (gl_target,
gl_handle);
GE( ctx, glTexParameteri (gl_target,
GL_TEXTURE_MAX_LEVEL, texture->max_level_set));
GL_TEXTURE_MAX_LEVEL, cogl_texture_get_max_level_set (texture)));
}
}
void
_cogl_texture_gl_generate_mipmaps (CoglTexture *texture)
{
CoglContext *ctx = texture->context;
CoglContext *ctx = cogl_texture_get_context (texture);
int n_levels = _cogl_texture_get_n_levels (texture);
GLuint gl_handle;
GLenum gl_target;
if (texture->max_level_set != n_levels - 1)
if (cogl_texture_get_max_level_set (texture) != n_levels - 1)
cogl_texture_gl_set_max_level (texture, n_levels - 1);
cogl_texture_get_gl_texture (texture, &gl_handle, &gl_target);
@ -150,5 +151,5 @@ _cogl_texture_gl_generate_mipmaps (CoglTexture *texture)
GLenum
_cogl_texture_gl_get_format (CoglTexture *texture)
{
return texture->vtable->get_gl_format (texture);
return COGL_TEXTURE_GET_CLASS (texture)->get_gl_format (texture);
}

2
cogl/cogl/driver/gl/gl/cogl-texture-driver-gl.c
View File

@ -250,7 +250,7 @@ _cogl_texture_driver_upload_subregion_to_gl (CoglContext *ctx,
* glTexImage2D first to assert that the storage for this
* level exists.
*/
if (texture->max_level_set < level)
if (cogl_texture_get_max_level_set (texture) < level)
{
ctx->glTexImage2D (gl_target,
level,

2
cogl/cogl/driver/gl/gles/cogl-texture-driver-gles.c
View File

@ -303,7 +303,7 @@ _cogl_texture_driver_upload_subregion_to_gl (CoglContext *ctx,
* glTexImage2D first to assert that the storage for this
* level exists.
*/
if (texture->max_level_set < level)
if (cogl_texture_get_max_level_set (texture) < level)
{
ctx->glTexImage2D (gl_target,
level,

8
cogl/cogl/winsys/cogl-texture-pixmap-x11-private.h
View File

@ -40,7 +40,6 @@
#include <GL/glx.h>
#endif
#include "cogl/cogl-object-private.h"
#include "cogl/cogl-texture-private.h"
#include "cogl/winsys/cogl-texture-pixmap-x11.h"
@ -70,7 +69,7 @@ typedef enum
struct _CoglTexturePixmapX11
{
CoglTexture _parent;
CoglTexture parent_instance;
CoglTexturePixmapStereoMode stereo_mode;
CoglTexturePixmapX11 *left; /* Set only if stereo_mode=RIGHT */
@ -97,3 +96,8 @@ struct _CoglTexturePixmapX11
texture */
gboolean use_winsys_texture;
};
struct _CoglTexturePixmapX11Class
{
CoglTextureClass parent_class;
};

691
cogl/cogl/winsys/cogl-texture-pixmap-x11.c
View File

@ -47,12 +47,10 @@
#include "cogl/cogl-context-private.h"
#include "cogl/cogl-display-private.h"
#include "cogl/cogl-renderer-private.h"
#include "cogl/cogl-object-private.h"
#include "cogl/cogl-xlib.h"
#include "cogl/cogl-xlib-renderer-private.h"
#include "cogl/cogl-x11-renderer-private.h"
#include "cogl/cogl-private.h"
#include "cogl/cogl-gtype-private.h"
#include "cogl/driver/gl/cogl-texture-gl-private.h"
#include "cogl/winsys/cogl-winsys-private.h"
@ -66,17 +64,36 @@
#include <string.h>
#include <math.h>
static void _cogl_texture_pixmap_x11_free (CoglTexturePixmapX11 *tex_pixmap);
G_DEFINE_FINAL_TYPE (CoglTexturePixmapX11, cogl_texture_pixmap_x11, COGL_TYPE_TEXTURE)
COGL_TEXTURE_DEFINE (TexturePixmapX11, texture_pixmap_x11);
COGL_GTYPE_DEFINE_CLASS (TexturePixmapX11, texture_pixmap_x11);
static const CoglTextureVtable cogl_texture_pixmap_x11_vtable;
uint32_t
cogl_texture_pixmap_x11_error_quark (void)
static const CoglWinsysVtable *
_cogl_texture_pixmap_x11_get_winsys (CoglTexturePixmapX11 *tex_pixmap)
{
return g_quark_from_static_string ("cogl-texture-pixmap-error-quark");
/* FIXME: A CoglContext should be reachable from a CoglTexture
* pointer */
_COGL_GET_CONTEXT (ctx, NULL);
return ctx->display->renderer->winsys_vtable;
}
static int
_cogl_xlib_get_damage_base (void)
{
CoglX11Renderer *x11_renderer;
_COGL_GET_CONTEXT (ctxt, -1);
x11_renderer =
(CoglX11Renderer *) _cogl_xlib_renderer_get_data (ctxt->display->renderer);
return x11_renderer->damage_base;
}
static gboolean
cogl_damage_rectangle_is_whole (const CoglDamageRectangle *damage_rect,
unsigned int width,
unsigned int height)
{
return (damage_rect->x1 == 0 && damage_rect->y1 == 0
&& damage_rect->x2 == width && damage_rect->y2 == height);
}
static void
@ -109,25 +126,6 @@ cogl_damage_rectangle_union (CoglDamageRectangle *damage_rect,
}
}
static gboolean
cogl_damage_rectangle_is_whole (const CoglDamageRectangle *damage_rect,
unsigned int width,
unsigned int height)
{
return (damage_rect->x1 == 0 && damage_rect->y1 == 0
&& damage_rect->x2 == width && damage_rect->y2 == height);
}
static const CoglWinsysVtable *
_cogl_texture_pixmap_x11_get_winsys (CoglTexturePixmapX11 *tex_pixmap)
{
/* FIXME: A CoglContext should be reachable from a CoglTexture
* pointer */
_COGL_GET_CONTEXT (ctx, NULL);
return ctx->display->renderer->winsys_vtable;
}
static void
process_damage_event (CoglTexturePixmapX11 *tex_pixmap,
XDamageNotifyEvent *damage_event)
@ -176,8 +174,8 @@ process_damage_event (CoglTexturePixmapX11 *tex_pixmap,
need to request the bounding box of the region because we're
going to update the whole texture anyway. */
if (cogl_damage_rectangle_is_whole (&tex_pixmap->damage_rect,
tex->width,
tex->height))
cogl_texture_get_width (tex),
cogl_texture_get_height (tex)))
{
if (handle_mode != DO_NOTHING)
XDamageSubtract (display, tex_pixmap->damage, None, None);
@ -232,17 +230,6 @@ process_damage_event (CoglTexturePixmapX11 *tex_pixmap,
}
}
static int
_cogl_xlib_get_damage_base (void)
{
CoglX11Renderer *x11_renderer;
_COGL_GET_CONTEXT (ctxt, -1);
x11_renderer =
(CoglX11Renderer *) _cogl_xlib_renderer_get_data (ctxt->display->renderer);
return x11_renderer->damage_base;
}
static CoglFilterReturn
_cogl_texture_pixmap_x11_filter (XEvent *event, void *data)
{
@ -293,171 +280,102 @@ set_damage_object_internal (CoglContext *ctx,
tex_pixmap);
}
static CoglTexturePixmapX11 *
_cogl_texture_pixmap_x11_new (CoglContext *ctxt,
uint32_t pixmap,
gboolean automatic_updates,
CoglTexturePixmapStereoMode stereo_mode,
GError **error)
static void
cogl_texture_pixmap_x11_dispose (GObject *object)
{
CoglTexturePixmapX11 *tex_pixmap = g_new (CoglTexturePixmapX11, 1);
Display *display = cogl_xlib_renderer_get_display (ctxt->display->renderer);
Window pixmap_root_window;
int pixmap_x, pixmap_y;
unsigned int pixmap_width, pixmap_height;
unsigned int pixmap_border_width;
CoglPixelFormat internal_format;
CoglTexture *tex = COGL_TEXTURE (tex_pixmap);
XWindowAttributes window_attributes;
int damage_base;
const CoglWinsysVtable *winsys;
CoglTexturePixmapX11 *tex_pixmap = COGL_TEXTURE_PIXMAP_X11 (object);
if (!XGetGeometry (display, pixmap, &pixmap_root_window,
&pixmap_x, &pixmap_y,
&pixmap_width, &pixmap_height,
&pixmap_border_width, &tex_pixmap->depth))
Display *display;
_COGL_GET_CONTEXT (ctxt, NO_RETVAL);
if (tex_pixmap->stereo_mode == COGL_TEXTURE_PIXMAP_RIGHT)
{
g_free (tex_pixmap);
g_set_error_literal (error,
COGL_TEXTURE_PIXMAP_X11_ERROR,
COGL_TEXTURE_PIXMAP_X11_ERROR_X11,
"Unable to query pixmap size");
return NULL;
g_object_unref (tex_pixmap->left);
G_OBJECT_CLASS (cogl_texture_pixmap_x11_parent_class)->dispose (object);
return;
}
/* Note: the detailed pixel layout doesn't matter here, we are just
* interested in RGB vs RGBA... */
internal_format = (tex_pixmap->depth >= 32
? COGL_PIXEL_FORMAT_RGBA_8888_PRE
: COGL_PIXEL_FORMAT_RGB_888);
display = cogl_xlib_renderer_get_display (ctxt->display->renderer);
_cogl_texture_init (tex, ctxt, pixmap_width, pixmap_height,
internal_format,
NULL, /* no loader */
&cogl_texture_pixmap_x11_vtable);
set_damage_object_internal (ctxt, tex_pixmap, 0, 0);
tex_pixmap->pixmap = pixmap;
tex_pixmap->stereo_mode = stereo_mode;
tex_pixmap->left = NULL;
tex_pixmap->image = NULL;
tex_pixmap->shm_info.shmid = -1;
tex_pixmap->tex = NULL;
tex_pixmap->damage_owned = FALSE;
tex_pixmap->damage = 0;
if (tex_pixmap->image)
XDestroyImage (tex_pixmap->image);
/* We need a visual to use for shared memory images so we'll query
it from the pixmap's root window */
if (!XGetWindowAttributes (display, pixmap_root_window, &window_attributes))
if (tex_pixmap->shm_info.shmid != -1)
{
g_free (tex_pixmap);
g_set_error_literal (error,
COGL_TEXTURE_PIXMAP_X11_ERROR,
COGL_TEXTURE_PIXMAP_X11_ERROR_X11,
"Unable to query root window attributes");
return NULL;
XShmDetach (display, &tex_pixmap->shm_info);
shmdt (tex_pixmap->shm_info.shmaddr);
shmctl (tex_pixmap->shm_info.shmid, IPC_RMID, 0);
}
tex_pixmap->visual = window_attributes.visual;
if (tex_pixmap->tex)
g_object_unref (tex_pixmap->tex);
/* If automatic updates are requested and the Xlib connection
supports damage events then we'll register a damage object on the
pixmap */
damage_base = _cogl_xlib_get_damage_base ();
if (automatic_updates && damage_base >= 0)
if (tex_pixmap->winsys)
{
Damage damage = XDamageCreate (display,
pixmap,
XDamageReportBoundingBox);
set_damage_object_internal (ctxt,
tex_pixmap,
damage,
COGL_TEXTURE_PIXMAP_X11_DAMAGE_BOUNDING_BOX);
tex_pixmap->damage_owned = TRUE;
const CoglWinsysVtable *winsys =
_cogl_texture_pixmap_x11_get_winsys (tex_pixmap);
winsys->texture_pixmap_x11_free (tex_pixmap);
}
/* Assume the entire pixmap is damaged to begin with */
tex_pixmap->damage_rect.x1 = 0;
tex_pixmap->damage_rect.x2 = pixmap_width;
tex_pixmap->damage_rect.y1 = 0;
tex_pixmap->damage_rect.y2 = pixmap_height;
G_OBJECT_CLASS (cogl_texture_pixmap_x11_parent_class)->dispose (object);
}
winsys = _cogl_texture_pixmap_x11_get_winsys (tex_pixmap);
if (winsys->texture_pixmap_x11_create)
static void
_cogl_texture_pixmap_x11_set_use_winsys_texture (CoglTexturePixmapX11 *tex_pixmap,
gboolean new_value)
{
if (tex_pixmap->use_winsys_texture != new_value)
{
tex_pixmap->use_winsys_texture =
winsys->texture_pixmap_x11_create (tex_pixmap);
/* 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 (COGL_TEXTURE (tex_pixmap));
tex_pixmap->use_winsys_texture = new_value;
}
else
tex_pixmap->use_winsys_texture = FALSE;
if (!tex_pixmap->use_winsys_texture)
tex_pixmap->winsys = NULL;
_cogl_texture_set_allocated (tex, internal_format,
pixmap_width, pixmap_height);
return _cogl_texture_pixmap_x11_object_new (tex_pixmap);
}
CoglTexturePixmapX11 *
cogl_texture_pixmap_x11_new (CoglContext *ctxt,
uint32_t pixmap,
gboolean automatic_updates,
GError **error)
static CoglTexture *
create_fallback_texture (CoglContext *ctx,
int width,
int height,
CoglPixelFormat internal_format)
{
return _cogl_texture_pixmap_x11_new (ctxt, pixmap,
automatic_updates, COGL_TEXTURE_PIXMAP_MONO,
error);
CoglTexture *tex;
GError *skip_error = NULL;
/* First try creating a fast-path non-sliced texture */
tex = cogl_texture_2d_new_with_size (ctx, width, height);
_cogl_texture_set_internal_format (tex, internal_format);
/* TODO: instead of allocating storage here it would be better
* if we had some api that let us just check that the size is
* supported by the hardware so storage could be allocated
* lazily when uploading data. */
if (!cogl_texture_allocate (tex, &skip_error))
{
g_error_free (skip_error);
g_object_unref (tex);
tex = NULL;
}
if (!tex)
{
tex =
cogl_texture_2d_sliced_new_with_size (ctx,
width,
height,
COGL_TEXTURE_MAX_WASTE);
_cogl_texture_set_internal_format (tex, internal_format);
}
return tex;
}
CoglTexturePixmapX11 *
cogl_texture_pixmap_x11_new_left (CoglContext *ctxt,
uint32_t pixmap,
gboolean automatic_updates,
GError **error)
{
return _cogl_texture_pixmap_x11_new (ctxt, pixmap,
automatic_updates, COGL_TEXTURE_PIXMAP_LEFT,
error);
}
CoglTexturePixmapX11 *
cogl_texture_pixmap_x11_new_right (CoglTexturePixmapX11 *tfp_left)
{
CoglTexture *texture_left = COGL_TEXTURE (tfp_left);
CoglTexturePixmapX11 *tfp_right;
CoglPixelFormat internal_format;
g_return_val_if_fail (tfp_left->stereo_mode == COGL_TEXTURE_PIXMAP_LEFT, NULL);
tfp_right = g_new0 (CoglTexturePixmapX11, 1);
tfp_right->stereo_mode = COGL_TEXTURE_PIXMAP_RIGHT;
tfp_right->left = cogl_object_ref (tfp_left);
internal_format = (tfp_left->depth >= 32
? COGL_PIXEL_FORMAT_RGBA_8888_PRE
: COGL_PIXEL_FORMAT_RGB_888);
_cogl_texture_init (COGL_TEXTURE (tfp_right),
texture_left->context,
texture_left->width,
texture_left->height,
internal_format,
NULL, /* no loader */
&cogl_texture_pixmap_x11_vtable);
_cogl_texture_set_allocated (COGL_TEXTURE (tfp_right), internal_format,
texture_left->width, texture_left->height);
return _cogl_texture_pixmap_x11_object_new (tfp_right);
}
static gboolean
_cogl_texture_pixmap_x11_allocate (CoglTexture *tex,
GError **error)
{
return TRUE;
}
/* Tries to allocate enough shared mem to handle a full size
* update size of the X Pixmap. */
@ -491,8 +409,8 @@ try_alloc_shm (CoglTexturePixmapX11 *tex_pixmap)
ZPixmap,
NULL,
NULL, /* shminfo, */
tex->width,
tex->height);
cogl_texture_get_width (tex),
cogl_texture_get_height (tex));
if (!dummy_image)
goto failed_image_create;
@ -532,80 +450,6 @@ try_alloc_shm (CoglTexturePixmapX11 *tex_pixmap)
tex_pixmap->shm_info.shmid = -1;
}
void
cogl_texture_pixmap_x11_update_area (CoglTexturePixmapX11 *tex_pixmap,
int x,
int y,
int width,
int height)
{
/* We'll queue the update for both the GLX texture and the regular
texture because we can't determine which will be needed until we
actually render something */
if (tex_pixmap->stereo_mode == COGL_TEXTURE_PIXMAP_RIGHT)
tex_pixmap = tex_pixmap->left;
if (tex_pixmap->winsys)
{
const CoglWinsysVtable *winsys;
winsys = _cogl_texture_pixmap_x11_get_winsys (tex_pixmap);
winsys->texture_pixmap_x11_damage_notify (tex_pixmap);
}
cogl_damage_rectangle_union (&tex_pixmap->damage_rect,
x, y, width, height);
}
gboolean
cogl_texture_pixmap_x11_is_using_tfp_extension (CoglTexturePixmapX11 *tex_pixmap)
{
if (tex_pixmap->stereo_mode == COGL_TEXTURE_PIXMAP_RIGHT)
tex_pixmap = tex_pixmap->left;
return !!tex_pixmap->winsys;
}
static CoglTexture *
create_fallback_texture (CoglContext *ctx,
int width,
int height,
CoglPixelFormat internal_format)
{
CoglTexture *tex;
GError *skip_error = NULL;
/* First try creating a fast-path non-sliced texture */
tex = COGL_TEXTURE (cogl_texture_2d_new_with_size (ctx, width, height));
_cogl_texture_set_internal_format (tex, internal_format);
/* TODO: instead of allocating storage here it would be better
* if we had some api that let us just check that the size is
* supported by the hardware so storage could be allocated
* lazily when uploading data. */
if (!cogl_texture_allocate (tex, &skip_error))
{
g_error_free (skip_error);
cogl_object_unref (tex);
tex = NULL;
}
if (!tex)
{
CoglTexture2DSliced *tex_2ds =
cogl_texture_2d_sliced_new_with_size (ctx,
width,
height,
COGL_TEXTURE_MAX_WASTE);
tex = COGL_TEXTURE (tex_2ds);
_cogl_texture_set_internal_format (tex, internal_format);
}
return tex;
}
static void
_cogl_texture_pixmap_x11_update_image_texture (CoglTexturePixmapX11 *tex_pixmap)
{
@ -646,8 +490,8 @@ _cogl_texture_pixmap_x11_update_image_texture (CoglTexturePixmapX11 *tex_pixmap)
: COGL_PIXEL_FORMAT_RGB_888);
tex_pixmap->tex = create_fallback_texture (ctx,
tex->width,
tex->height,
cogl_texture_get_width (tex),
cogl_texture_get_height (tex),
texture_format);
}
@ -671,7 +515,8 @@ _cogl_texture_pixmap_x11_update_image_texture (CoglTexturePixmapX11 *tex_pixmap)
tex_pixmap->image = XGetImage (display,
tex_pixmap->pixmap,
0, 0,
tex->width, tex->height,
cogl_texture_get_width (tex),
cogl_texture_get_height (tex),
AllPlanes, ZPixmap);
image = tex_pixmap->image;
src_x = x;
@ -747,21 +592,6 @@ _cogl_texture_pixmap_x11_update_image_texture (CoglTexturePixmapX11 *tex_pixmap)
memset (&tex_pixmap->damage_rect, 0, sizeof (CoglDamageRectangle));
}
static void
_cogl_texture_pixmap_x11_set_use_winsys_texture (CoglTexturePixmapX11 *tex_pixmap,
gboolean new_value)
{
if (tex_pixmap->use_winsys_texture != new_value)
{
/* 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 (COGL_TEXTURE (tex_pixmap));
tex_pixmap->use_winsys_texture = new_value;
}
}
static void
_cogl_texture_pixmap_x11_update (CoglTexturePixmapX11 *tex_pixmap,
gboolean needs_mipmap)
@ -831,6 +661,13 @@ _cogl_texture_pixmap_x11_get_texture (CoglTexturePixmapX11 *tex_pixmap)
return NULL;
}
static gboolean
_cogl_texture_pixmap_x11_allocate (CoglTexture *tex,
GError **error)
{
return TRUE;
}
static gboolean
_cogl_texture_pixmap_x11_set_region (CoglTexture *tex,
int src_x,
@ -866,6 +703,15 @@ _cogl_texture_pixmap_x11_get_data (CoglTexture *tex,
return cogl_texture_get_data (child_tex, format, rowstride, data);
}
static int
_cogl_texture_pixmap_x11_get_max_waste (CoglTexture *tex)
{
CoglTexturePixmapX11 *tex_pixmap = COGL_TEXTURE_PIXMAP_X11 (tex);
CoglTexture *child_tex = _cogl_texture_pixmap_x11_get_texture (tex_pixmap);
return cogl_texture_get_max_waste (child_tex);
}
static void
_cogl_texture_pixmap_x11_foreach_sub_texture_in_region
(CoglTexture *tex,
@ -880,7 +726,7 @@ _cogl_texture_pixmap_x11_foreach_sub_texture_in_region
CoglTexture *child_tex = _cogl_texture_pixmap_x11_get_texture (tex_pixmap);
/* Forward on to the child texture */
cogl_meta_texture_foreach_in_region (COGL_META_TEXTURE (child_tex),
cogl_meta_texture_foreach_in_region (child_tex,
virtual_tx_1,
virtual_ty_1,
virtual_tx_2,
@ -891,15 +737,6 @@ _cogl_texture_pixmap_x11_foreach_sub_texture_in_region
user_data);
}
static int
_cogl_texture_pixmap_x11_get_max_waste (CoglTexture *tex)
{
CoglTexturePixmapX11 *tex_pixmap = COGL_TEXTURE_PIXMAP_X11 (tex);
CoglTexture *child_tex = _cogl_texture_pixmap_x11_get_texture (tex_pixmap);
return cogl_texture_get_max_waste (child_tex);
}
static gboolean
_cogl_texture_pixmap_x11_is_sliced (CoglTexture *tex)
{
@ -1027,70 +864,234 @@ _cogl_texture_pixmap_x11_get_gl_format (CoglTexture *tex)
}
static void
_cogl_texture_pixmap_x11_free (CoglTexturePixmapX11 *tex_pixmap)
cogl_texture_pixmap_x11_class_init (CoglTexturePixmapX11Class *klass)
{
Display *display;
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
CoglTextureClass *texture_class = COGL_TEXTURE_CLASS (klass);
_COGL_GET_CONTEXT (ctxt, NO_RETVAL);
gobject_class->dispose = cogl_texture_pixmap_x11_dispose;
texture_class->allocate = _cogl_texture_pixmap_x11_allocate;
texture_class->set_region = _cogl_texture_pixmap_x11_set_region;
texture_class->get_data = _cogl_texture_pixmap_x11_get_data;
texture_class->get_max_waste = _cogl_texture_pixmap_x11_get_max_waste;
texture_class->foreach_sub_texture_in_region = _cogl_texture_pixmap_x11_foreach_sub_texture_in_region;
texture_class->is_sliced = _cogl_texture_pixmap_x11_is_sliced;
texture_class->can_hardware_repeat = _cogl_texture_pixmap_x11_can_hardware_repeat;
texture_class->transform_coords_to_gl = _cogl_texture_pixmap_x11_transform_coords_to_gl;
texture_class->transform_quad_coords_to_gl = _cogl_texture_pixmap_x11_transform_quad_coords_to_gl;
texture_class->get_gl_texture = _cogl_texture_pixmap_x11_get_gl_texture;
texture_class->gl_flush_legacy_texobj_filters = _cogl_texture_pixmap_x11_gl_flush_legacy_texobj_filters;
texture_class->pre_paint = _cogl_texture_pixmap_x11_pre_paint;
texture_class->ensure_non_quad_rendering = _cogl_texture_pixmap_x11_ensure_non_quad_rendering;
texture_class->gl_flush_legacy_texobj_wrap_modes = _cogl_texture_pixmap_x11_gl_flush_legacy_texobj_wrap_modes;
texture_class->get_format = _cogl_texture_pixmap_x11_get_format;
texture_class->get_gl_format = _cogl_texture_pixmap_x11_get_gl_format;
}
static void
cogl_texture_pixmap_x11_init (CoglTexturePixmapX11 *self)
{
CoglTexture *texture = COGL_TEXTURE (self);
texture->is_primitive = FALSE;
}
uint32_t
cogl_texture_pixmap_x11_error_quark (void)
{
return g_quark_from_static_string ("cogl-texture-pixmap-error-quark");
}
static CoglTexture *
_cogl_texture_pixmap_x11_new (CoglContext *ctxt,
uint32_t pixmap,
gboolean automatic_updates,
CoglTexturePixmapStereoMode stereo_mode,
GError **error)
{
CoglTexturePixmapX11 *tex_pixmap = g_object_new (COGL_TYPE_TEXTURE_PIXMAP_X11, NULL);
Display *display = cogl_xlib_renderer_get_display (ctxt->display->renderer);
Window pixmap_root_window;
int pixmap_x, pixmap_y;
unsigned int pixmap_width, pixmap_height;
unsigned int pixmap_border_width;
CoglPixelFormat internal_format;
CoglTexture *tex = COGL_TEXTURE (tex_pixmap);
XWindowAttributes window_attributes;
int damage_base;
const CoglWinsysVtable *winsys;
if (!XGetGeometry (display, pixmap, &pixmap_root_window,
&pixmap_x, &pixmap_y,
&pixmap_width, &pixmap_height,
&pixmap_border_width, &tex_pixmap->depth))
{
g_free (tex_pixmap);
g_set_error_literal (error,
COGL_TEXTURE_PIXMAP_X11_ERROR,
COGL_TEXTURE_PIXMAP_X11_ERROR_X11,
"Unable to query pixmap size");
return NULL;
}
/* Note: the detailed pixel layout doesn't matter here, we are just
* interested in RGB vs RGBA... */
internal_format = (tex_pixmap->depth >= 32
? COGL_PIXEL_FORMAT_RGBA_8888_PRE
: COGL_PIXEL_FORMAT_RGB_888);
_cogl_texture_init (tex, ctxt, pixmap_width, pixmap_height,
internal_format,
NULL);
tex_pixmap->pixmap = pixmap;
tex_pixmap->stereo_mode = stereo_mode;
tex_pixmap->left = NULL;
tex_pixmap->image = NULL;
tex_pixmap->shm_info.shmid = -1;
tex_pixmap->tex = NULL;
tex_pixmap->damage_owned = FALSE;
tex_pixmap->damage = 0;
/* We need a visual to use for shared memory images so we'll query
it from the pixmap's root window */
if (!XGetWindowAttributes (display, pixmap_root_window, &window_attributes))
{
g_free (tex_pixmap);
g_set_error_literal (error,
COGL_TEXTURE_PIXMAP_X11_ERROR,
COGL_TEXTURE_PIXMAP_X11_ERROR_X11,
"Unable to query root window attributes");
return NULL;
}
tex_pixmap->visual = window_attributes.visual;
/* If automatic updates are requested and the Xlib connection
supports damage events then we'll register a damage object on the
pixmap */
damage_base = _cogl_xlib_get_damage_base ();
if (automatic_updates && damage_base >= 0)
{
Damage damage = XDamageCreate (display,
pixmap,
XDamageReportBoundingBox);
set_damage_object_internal (ctxt,
tex_pixmap,
damage,
COGL_TEXTURE_PIXMAP_X11_DAMAGE_BOUNDING_BOX);
tex_pixmap->damage_owned = TRUE;
}
/* Assume the entire pixmap is damaged to begin with */
tex_pixmap->damage_rect.x1 = 0;
tex_pixmap->damage_rect.x2 = pixmap_width;
tex_pixmap->damage_rect.y1 = 0;
tex_pixmap->damage_rect.y2 = pixmap_height;
winsys = _cogl_texture_pixmap_x11_get_winsys (tex_pixmap);
if (winsys->texture_pixmap_x11_create)
{
tex_pixmap->use_winsys_texture =
winsys->texture_pixmap_x11_create (tex_pixmap);
}
else
tex_pixmap->use_winsys_texture = FALSE;
if (!tex_pixmap->use_winsys_texture)
tex_pixmap->winsys = NULL;
_cogl_texture_set_allocated (tex, internal_format,
pixmap_width, pixmap_height);
return COGL_TEXTURE (tex_pixmap);
}
CoglTexture *
cogl_texture_pixmap_x11_new (CoglContext *ctxt,
uint32_t pixmap,
gboolean automatic_updates,
GError **error)
{
return _cogl_texture_pixmap_x11_new (ctxt, pixmap,
automatic_updates, COGL_TEXTURE_PIXMAP_MONO,
error);
}
CoglTexture *
cogl_texture_pixmap_x11_new_left (CoglContext *ctxt,
uint32_t pixmap,
gboolean automatic_updates,
GError **error)
{
return _cogl_texture_pixmap_x11_new (ctxt, pixmap,
automatic_updates, COGL_TEXTURE_PIXMAP_LEFT,
error);
}
CoglTexture *
cogl_texture_pixmap_x11_new_right (CoglTexturePixmapX11 *tfp_left)
{
CoglTexture *texture_left = COGL_TEXTURE (tfp_left);
CoglTexturePixmapX11 *tfp_right;
CoglPixelFormat internal_format;
g_return_val_if_fail (tfp_left->stereo_mode == COGL_TEXTURE_PIXMAP_LEFT, NULL);
tfp_right = g_object_new (COGL_TYPE_TEXTURE_PIXMAP_X11, NULL);
tfp_right->stereo_mode = COGL_TEXTURE_PIXMAP_RIGHT;
tfp_right->left = g_object_ref (tfp_left);
internal_format = (tfp_left->depth >= 32
? COGL_PIXEL_FORMAT_RGBA_8888_PRE
: COGL_PIXEL_FORMAT_RGB_888);
_cogl_texture_init (COGL_TEXTURE (tfp_right),
cogl_texture_get_context (texture_left),
cogl_texture_get_width (texture_left),
cogl_texture_get_height (texture_left),
internal_format,
NULL);
_cogl_texture_set_allocated (COGL_TEXTURE (tfp_right), internal_format,
cogl_texture_get_width (texture_left),
cogl_texture_get_height (texture_left));
return COGL_TEXTURE (tfp_right);
}
void
cogl_texture_pixmap_x11_update_area (CoglTexturePixmapX11 *tex_pixmap,
int x,
int y,
int width,
int height)
{
/* We'll queue the update for both the GLX texture and the regular
texture because we can't determine which will be needed until we
actually render something */
if (tex_pixmap->stereo_mode == COGL_TEXTURE_PIXMAP_RIGHT)
{
cogl_object_unref (tex_pixmap->left);
/* Chain up */
_cogl_texture_free (COGL_TEXTURE (tex_pixmap));
return;
}
display = cogl_xlib_renderer_get_display (ctxt->display->renderer);
set_damage_object_internal (ctxt, tex_pixmap, 0, 0);
if (tex_pixmap->image)
XDestroyImage (tex_pixmap->image);
if (tex_pixmap->shm_info.shmid != -1)
{
XShmDetach (display, &tex_pixmap->shm_info);
shmdt (tex_pixmap->shm_info.shmaddr);
shmctl (tex_pixmap->shm_info.shmid, IPC_RMID, 0);
}
if (tex_pixmap->tex)
cogl_object_unref (tex_pixmap->tex);
tex_pixmap = tex_pixmap->left;
if (tex_pixmap->winsys)
{
const CoglWinsysVtable *winsys =
_cogl_texture_pixmap_x11_get_winsys (tex_pixmap);
winsys->texture_pixmap_x11_free (tex_pixmap);
const CoglWinsysVtable *winsys;
winsys = _cogl_texture_pixmap_x11_get_winsys (tex_pixmap);
winsys->texture_pixmap_x11_damage_notify (tex_pixmap);
}
/* Chain up */
_cogl_texture_free (COGL_TEXTURE (tex_pixmap));
cogl_damage_rectangle_union (&tex_pixmap->damage_rect,
x, y, width, height);
}
gboolean
cogl_texture_pixmap_x11_is_using_tfp_extension (CoglTexturePixmapX11 *tex_pixmap)
{
if (tex_pixmap->stereo_mode == COGL_TEXTURE_PIXMAP_RIGHT)
tex_pixmap = tex_pixmap->left;
return !!tex_pixmap->winsys;
}
static const CoglTextureVtable
cogl_texture_pixmap_x11_vtable =
{
FALSE, /* not primitive */
_cogl_texture_pixmap_x11_allocate,
_cogl_texture_pixmap_x11_set_region,
NULL, /* is_get_data_supported */
_cogl_texture_pixmap_x11_get_data,
_cogl_texture_pixmap_x11_foreach_sub_texture_in_region,
_cogl_texture_pixmap_x11_get_max_waste,
_cogl_texture_pixmap_x11_is_sliced,
_cogl_texture_pixmap_x11_can_hardware_repeat,
_cogl_texture_pixmap_x11_transform_coords_to_gl,
_cogl_texture_pixmap_x11_transform_quad_coords_to_gl,
_cogl_texture_pixmap_x11_get_gl_texture,
_cogl_texture_pixmap_x11_gl_flush_legacy_texobj_filters,
_cogl_texture_pixmap_x11_pre_paint,
_cogl_texture_pixmap_x11_ensure_non_quad_rendering,
_cogl_texture_pixmap_x11_gl_flush_legacy_texobj_wrap_modes,
_cogl_texture_pixmap_x11_get_format,
_cogl_texture_pixmap_x11_get_gl_format,
NULL /* set_auto_mipmap */
};

40
cogl/cogl/winsys/cogl-texture-pixmap-x11.h
View File

@ -54,26 +54,30 @@
G_BEGIN_DECLS
/**
* SECTION:cogl-texture-pixmap-x11
* @short_description: Functions for creating and manipulating 2D meta
* CoglTexturePixmapX11:
*
* Functions for creating and manipulating 2D meta
* textures derived from X11 pixmaps.
*
* These functions allow high-level meta textures (See the
* #CoglMetaTexture interface) that derive their contents from an X11
* pixmap.
*/
#define COGL_TYPE_TEXTURE_PIXMAP_X11 (cogl_texture_pixmap_x11_get_type ())
#define COGL_TEXTURE_PIXMAP_X11(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), COGL_TYPE_TEXTURE_PIXMAP_X11, CoglTexturePixmapX11))
#define COGL_TEXTURE_PIXMAP_X11_CONST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), COGL_TYPE_TEXTURE_PIXMAP_X11, CoglTexturePixmapX11 const))
#define COGL_TEXTURE_PIXMAP_X11_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), COGL_TYPE_TEXTURE_PIXMAP_X11, CoglTexturePixmapX11Class))
#define COGL_IS_TEXTURE_PIXMAP_X11(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), COGL_TYPE_TEXTURE_PIXMAP_X11))
#define COGL_IS_TEXTURE_PIXMAP_X11_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), COGL_TYPE_TEXTURE_PIXMAP_X11))
#define COGL_TEXTURE_PIXMAP_X11_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), COGL_TYPE_TEXTURE_PIXMAP_X11, CoglTexturePixmapX11Class))
typedef struct _CoglTexturePixmapX11Class CoglTexturePixmapX11Class;
typedef struct _CoglTexturePixmapX11 CoglTexturePixmapX11;
#define COGL_TEXTURE_PIXMAP_X11(X) ((CoglTexturePixmapX11 *)X)
G_DEFINE_AUTOPTR_CLEANUP_FUNC (CoglTexturePixmapX11, g_object_unref)
/**
* cogl_texture_pixmap_x11_get_gtype:
*
* Returns: a #GType that can be used with the GLib type system.
*/
COGL_EXPORT
GType cogl_texture_pixmap_x11_get_gtype (void);
GType cogl_texture_pixmap_x11_get_type (void) G_GNUC_CONST;
typedef enum
{
@ -120,7 +124,7 @@ uint32_t cogl_texture_pixmap_x11_error_quark (void);
*
* Return value: a new #CoglTexturePixmapX11 instance
*/
COGL_EXPORT CoglTexturePixmapX11 *
COGL_EXPORT CoglTexture *
cogl_texture_pixmap_x11_new (CoglContext *context,
uint32_t pixmap,
gboolean automatic_updates,
@ -156,7 +160,7 @@ cogl_texture_pixmap_x11_new (CoglContext *context,
*
* Return value: a new #CoglTexturePixmapX11 instance
*/
COGL_EXPORT CoglTexturePixmapX11 *
COGL_EXPORT CoglTexture *
cogl_texture_pixmap_x11_new_left (CoglContext *context,
uint32_t pixmap,
gboolean automatic_updates,
@ -173,7 +177,7 @@ cogl_texture_pixmap_x11_new_left (CoglContext *context,
*
* Return value: a new #CoglTexturePixmapX11 instance
*/
COGL_EXPORT CoglTexturePixmapX11 *
COGL_EXPORT CoglTexture *
cogl_texture_pixmap_x11_new_right (CoglTexturePixmapX11 *left_texture);
/**
@ -211,18 +215,6 @@ cogl_texture_pixmap_x11_update_area (CoglTexturePixmapX11 *texture,
COGL_EXPORT gboolean
cogl_texture_pixmap_x11_is_using_tfp_extension (CoglTexturePixmapX11 *texture);
/**
* cogl_is_texture_pixmap_x11:
* @object: A pointer to a #CoglObject
*
* Checks whether @object points to a #CoglTexturePixmapX11 instance.
*
* Return value: %TRUE if the object is a #CoglTexturePixmapX11, and
* %FALSE otherwise
*/
COGL_EXPORT gboolean
cogl_is_texture_pixmap_x11 (void *object);
G_END_DECLS
/* The gobject introspection scanner seems to parse public headers in

12
cogl/cogl/winsys/cogl-winsys-egl-x11.c
View File

@ -455,7 +455,7 @@ static gboolean
_cogl_winsys_texture_pixmap_x11_create (CoglTexturePixmapX11 *tex_pixmap)
{
CoglTexture *tex = COGL_TEXTURE (tex_pixmap);
CoglContext *ctx = tex->context;
CoglContext *ctx = cogl_texture_get_context (tex);
CoglTexturePixmapEGL *egl_tex_pixmap;
EGLint attribs[] = {EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE};
CoglPixelFormat texture_format;
@ -489,14 +489,14 @@ _cogl_winsys_texture_pixmap_x11_create (CoglTexturePixmapX11 *tex_pixmap)
COGL_PIXEL_FORMAT_RGBA_8888_PRE :
COGL_PIXEL_FORMAT_RGB_888);
egl_tex_pixmap->texture = COGL_TEXTURE (
egl_tex_pixmap->texture =
cogl_egl_texture_2d_new_from_image (ctx,
tex->width,
tex->height,
cogl_texture_get_width (tex),
cogl_texture_get_height (tex),
texture_format,
egl_tex_pixmap->image,
COGL_EGL_IMAGE_FLAG_NONE,
NULL));
NULL);
/* The image is initially bound as part of the creation */
egl_tex_pixmap->bind_tex_image_queued = FALSE;
@ -521,7 +521,7 @@ _cogl_winsys_texture_pixmap_x11_free (CoglTexturePixmapX11 *tex_pixmap)
egl_tex_pixmap = tex_pixmap->winsys;
if (egl_tex_pixmap->texture)
cogl_object_unref (egl_tex_pixmap->texture);
g_object_unref (egl_tex_pixmap->texture);
if (egl_tex_pixmap->image != EGL_NO_IMAGE_KHR)
_cogl_egl_destroy_image (ctx, egl_tex_pixmap->image);

19
cogl/cogl/winsys/cogl-winsys-glx.c
View File

@ -1129,7 +1129,7 @@ static gboolean
_cogl_winsys_texture_pixmap_x11_create (CoglTexturePixmapX11 *tex_pixmap)
{
CoglTexturePixmapGLX *glx_tex_pixmap;
CoglContext *ctx = COGL_TEXTURE (tex_pixmap)->context;
CoglContext *ctx = cogl_texture_get_context (COGL_TEXTURE (tex_pixmap));
if (!_cogl_winsys_has_feature (COGL_WINSYS_FEATURE_TEXTURE_FROM_PIXMAP))
{
@ -1221,13 +1221,14 @@ _cogl_winsys_texture_pixmap_x11_free (CoglTexturePixmapX11 *tex_pixmap)
glx_tex_pixmap = tex_pixmap->winsys;
free_glx_pixmap (COGL_TEXTURE (tex_pixmap)->context, glx_tex_pixmap);
free_glx_pixmap (cogl_texture_get_context (COGL_TEXTURE (tex_pixmap)),
glx_tex_pixmap);
if (glx_tex_pixmap->left.glx_tex)
cogl_object_unref (glx_tex_pixmap->left.glx_tex);
g_object_unref (glx_tex_pixmap->left.glx_tex);
if (glx_tex_pixmap->right.glx_tex)
cogl_object_unref (glx_tex_pixmap->right.glx_tex);
g_object_unref (glx_tex_pixmap->right.glx_tex);
tex_pixmap->winsys = NULL;
g_free (glx_tex_pixmap);
@ -1239,7 +1240,7 @@ _cogl_winsys_texture_pixmap_x11_update (CoglTexturePixmapX11 *tex_pixmap,
gboolean needs_mipmap)
{
CoglTexture *tex = COGL_TEXTURE (tex_pixmap);
CoglContext *ctx = COGL_TEXTURE (tex_pixmap)->context;
CoglContext *ctx = cogl_texture_get_context (tex);
CoglTexturePixmapGLX *glx_tex_pixmap = tex_pixmap->winsys;
CoglPixmapTextureEyeGLX *texture_info;
int buffer;
@ -1272,8 +1273,10 @@ _cogl_winsys_texture_pixmap_x11_update (CoglTexturePixmapX11 *tex_pixmap,
COGL_PIXEL_FORMAT_RGBA_8888_PRE :
COGL_PIXEL_FORMAT_RGB_888);
texture_info->glx_tex = COGL_TEXTURE (
cogl_texture_2d_new_with_size (ctx, tex->width, tex->height));
texture_info->glx_tex =
cogl_texture_2d_new_with_size (ctx,
cogl_texture_get_width (tex),
cogl_texture_get_height (tex));
_cogl_texture_set_internal_format (tex, texture_format);
@ -1314,7 +1317,7 @@ _cogl_winsys_texture_pixmap_x11_update (CoglTexturePixmapX11 *tex_pixmap,
"with mipmap support failed", tex_pixmap);
if (texture_info->glx_tex)
cogl_object_unref (texture_info->glx_tex);
g_object_unref (texture_info->glx_tex);
return FALSE;
}

6
src/backends/meta-cursor-sprite-xcursor.c
View File

@ -190,7 +190,7 @@ load_from_current_xcursor_image (MetaCursorSpriteXcursor *sprite_xcursor)
CoglPixelFormat cogl_format;
ClutterBackend *clutter_backend;
CoglContext *cogl_context;
CoglTexture2D *texture;
CoglTexture *texture;
GError *error = NULL;
int hotspot_x, hotspot_y;
@ -234,10 +234,10 @@ load_from_current_xcursor_image (MetaCursorSpriteXcursor *sprite_xcursor)
hotspot_y = xc_image->yhot;
}
meta_cursor_sprite_set_texture (sprite,
COGL_TEXTURE (texture),
texture,
hotspot_x, hotspot_y);
g_clear_pointer (&texture, cogl_object_unref);
g_clear_object (&texture);
}
void

10
src/backends/meta-cursor.c
View File

@ -96,7 +96,7 @@ meta_cursor_sprite_clear_texture (MetaCursorSprite *sprite)
MetaCursorSpritePrivate *priv =
meta_cursor_sprite_get_instance_private (sprite);
g_clear_pointer (&priv->texture, cogl_object_unref);
g_clear_object (&priv->texture);
meta_cursor_sprite_invalidate (sprite);
}
@ -109,9 +109,9 @@ meta_cursor_sprite_set_texture (MetaCursorSprite *sprite,
MetaCursorSpritePrivate *priv =
meta_cursor_sprite_get_instance_private (sprite);
g_clear_pointer (&priv->texture, cogl_object_unref);
g_clear_object (&priv->texture);
if (texture)
priv->texture = cogl_object_ref (texture);
priv->texture = g_object_ref (COGL_TEXTURE_2D (texture));
priv->hot_x = hot_x;
priv->hot_y = hot_y;
@ -264,7 +264,7 @@ meta_cursor_sprite_constructed (GObject *object)
meta_cursor_tracker_register_cursor_sprite (priv->cursor_tracker, sprite);
g_clear_pointer (&priv->texture, cogl_object_unref);
g_clear_object (&priv->texture);
G_OBJECT_CLASS (meta_cursor_sprite_parent_class)->constructed (object);
}
@ -276,7 +276,7 @@ meta_cursor_sprite_finalize (GObject *object)
MetaCursorSpritePrivate *priv =
meta_cursor_sprite_get_instance_private (sprite);
g_clear_pointer (&priv->texture, cogl_object_unref);
g_clear_object (&priv->texture);
meta_cursor_tracker_unregister_cursor_sprite (priv->cursor_tracker, sprite);
g_clear_object (&priv->cursor_tracker);

13
src/backends/meta-screen-cast-stream-src.c
View File

@ -313,7 +313,7 @@ draw_cursor_sprite_via_offscreen (MetaScreenCastStreamSrc *src,
ClutterBackend *clutter_backend = meta_backend_get_clutter_backend (backend);
CoglContext *cogl_context =
clutter_backend_get_cogl_context (clutter_backend);
CoglTexture2D *bitmap_texture;
CoglTexture *bitmap_texture;
CoglOffscreen *offscreen;
CoglFramebuffer *fb;
CoglPipeline *pipeline;
@ -322,17 +322,16 @@ draw_cursor_sprite_via_offscreen (MetaScreenCastStreamSrc *src,
bitmap_texture = cogl_texture_2d_new_with_size (cogl_context,
bitmap_width, bitmap_height);
cogl_primitive_texture_set_auto_mipmap (COGL_PRIMITIVE_TEXTURE (bitmap_texture),
FALSE);
if (!cogl_texture_allocate (COGL_TEXTURE (bitmap_texture), error))
cogl_primitive_texture_set_auto_mipmap (bitmap_texture, FALSE);
if (!cogl_texture_allocate (bitmap_texture, error))
{
cogl_object_unref (bitmap_texture);
g_object_unref (bitmap_texture);
return FALSE;
}
offscreen = cogl_offscreen_new_with_texture (COGL_TEXTURE (bitmap_texture));
offscreen = cogl_offscreen_new_with_texture (bitmap_texture);
fb = COGL_FRAMEBUFFER (offscreen);
cogl_object_unref (bitmap_texture);
g_object_unref (bitmap_texture);
if (!cogl_framebuffer_allocate (fb, error))
{
g_object_unref (fb);

6
src/backends/native/meta-drm-buffer-gbm.c
View File

@ -254,7 +254,7 @@ meta_drm_buffer_gbm_blit_to_framebuffer (CoglScanout *scanout,
CoglPixelFormat cogl_format;
CoglEglImageFlags flags;
CoglOffscreen *cogl_fbo = NULL;
CoglTexture2D *cogl_tex;
CoglTexture *cogl_tex;
uint32_t n_planes;
uint64_t *modifiers;
uint32_t *strides;
@ -332,8 +332,8 @@ meta_drm_buffer_gbm_blit_to_framebuffer (CoglScanout *scanout,
goto out;
}
cogl_fbo = cogl_offscreen_new_with_texture (COGL_TEXTURE (cogl_tex));
cogl_object_unref (cogl_tex);
cogl_fbo = cogl_offscreen_new_with_texture (cogl_tex);
g_object_unref (cogl_tex);
if (!cogl_framebuffer_allocate (COGL_FRAMEBUFFER (cogl_fbo), error))
{

18
src/backends/native/meta-renderer-native.c
View File

@ -613,7 +613,7 @@ meta_renderer_native_create_dma_buf_framebuffer (MetaRendererNative *renderer_n
uint64_t modifiers[1];
CoglPixelFormat cogl_format;
CoglEglImageFlags flags;
CoglTexture2D *cogl_tex;
CoglTexture *cogl_tex;
CoglOffscreen *cogl_fbo;
int ret;
@ -651,8 +651,8 @@ meta_renderer_native_create_dma_buf_framebuffer (MetaRendererNative *renderer_n
if (!cogl_tex)
return NULL;
cogl_fbo = cogl_offscreen_new_with_texture (COGL_TEXTURE (cogl_tex));
cogl_object_unref (cogl_tex);
cogl_fbo = cogl_offscreen_new_with_texture (cogl_tex);
g_object_unref (cogl_tex);
if (!cogl_framebuffer_allocate (COGL_FRAMEBUFFER (cogl_fbo), error))
{
@ -1151,19 +1151,19 @@ meta_renderer_native_create_offscreen (MetaRendererNative *renderer,
GError **error)
{
CoglOffscreen *fb;
CoglTexture2D *tex;
CoglTexture *tex;
tex = cogl_texture_2d_new_with_size (context, view_width, view_height);
cogl_primitive_texture_set_auto_mipmap (COGL_PRIMITIVE_TEXTURE (tex), FALSE);
cogl_primitive_texture_set_auto_mipmap (tex, FALSE);
if (!cogl_texture_allocate (COGL_TEXTURE (tex), error))
if (!cogl_texture_allocate (tex, error))
{
cogl_object_unref (tex);
g_object_unref (tex);
return FALSE;
}
fb = cogl_offscreen_new_with_texture (COGL_TEXTURE (tex));
cogl_object_unref (tex);
fb = cogl_offscreen_new_with_texture (tex);
g_object_unref (tex);
if (!cogl_framebuffer_allocate (COGL_FRAMEBUFFER (fb), error))
{
g_object_unref (fb);

6
src/backends/x11/cm/meta-cursor-sprite-xfixes.c
View File

@ -125,7 +125,7 @@ meta_cursor_sprite_xfixes_initable_init (GInitable *initable,
MetaX11Display *x11_display;
Display *xdisplay;
XFixesCursorImage *cursor_image;
CoglTexture2D *texture;
CoglTexture *texture;
uint8_t *cursor_data;
gboolean free_cursor_data;
ClutterBackend *clutter_backend;
@ -189,10 +189,10 @@ meta_cursor_sprite_xfixes_initable_init (GInitable *initable,
return FALSE;
meta_cursor_sprite_set_texture (sprite,
COGL_TEXTURE (texture),
texture,
cursor_image->xhot,
cursor_image->yhot);
cogl_object_unref (texture);
g_object_unref (texture);
XFree (cursor_image);
return TRUE;

4
src/backends/x11/nested/meta-renderer-x11-nested.c
View File

@ -75,12 +75,12 @@ create_offscreen (CoglContext *cogl_context,
int width,
int height)
{
CoglTexture2D *texture_2d;
CoglTexture *texture_2d;
CoglOffscreen *offscreen;
GError *error = NULL;
texture_2d = cogl_texture_2d_new_with_size (cogl_context, width, height);
offscreen = cogl_offscreen_new_with_texture (COGL_TEXTURE (texture_2d));
offscreen = cogl_offscreen_new_with_texture (texture_2d);
if (!cogl_framebuffer_allocate (COGL_FRAMEBUFFER (offscreen), &error))
meta_fatal ("Couldn't allocate framebuffer: %s", error->message);

6
src/compositor/cogl-utils.c
View File

@ -92,7 +92,7 @@ meta_create_texture (int width,
CoglContext *ctx = clutter_backend_get_cogl_context (backend);
CoglTexture *texture;
texture = COGL_TEXTURE (cogl_texture_2d_new_with_size (ctx, width, height));
texture = cogl_texture_2d_new_with_size (ctx, width, height);
cogl_texture_set_components (texture, components);
if ((flags & META_TEXTURE_ALLOW_SLICING) != 0)
@ -104,8 +104,8 @@ meta_create_texture (int width,
if (!cogl_texture_allocate (texture, &catch_error))
{
g_error_free (catch_error);
cogl_object_unref (texture);
texture = COGL_TEXTURE (cogl_texture_2d_sliced_new_with_size (ctx, width, height, COGL_TEXTURE_MAX_WASTE));
g_object_unref (texture);
texture = cogl_texture_2d_sliced_new_with_size (ctx, width, height, COGL_TEXTURE_MAX_WASTE);
cogl_texture_set_components (texture, components);
}
}

6
src/compositor/meta-background-image.c
View File

@ -196,7 +196,7 @@ file_loaded (GObject *source_object,
{
g_warning ("Failed to create texture for background: %s",
local_error->message);
cogl_clear_object (&texture);
g_clear_object (&texture);
}
image->texture = texture;
@ -218,7 +218,7 @@ out:
* image that is already in the process of loading or loaded.
*
* In either case, what is returned is a [class@Meta.BackgroundImage] which can be dereferenced
* to get a [iface@Cogl.Texture]. If [method@Meta.BackgroundImage.is_loaded] returns %TRUE,
* to get a [class@Cogl.Texture]. If [method@Meta.BackgroundImage.is_loaded] returns %TRUE,
* the background is loaded, otherwise the [signal@Meta.BackgroundImage::loaded]
* signal will be emitted exactly once. The 'loaded' state means that the
* loading process finished, whether it succeeded or failed.
@ -294,7 +294,7 @@ meta_background_image_finalize (GObject *object)
g_hash_table_remove (image->cache->images, image->file);
if (image->texture)
cogl_object_unref (image->texture);
g_object_unref (image->texture);
if (image->file)
g_object_unref (image->file);

14
src/compositor/meta-background.c
View File

@ -96,20 +96,20 @@ free_fbos (MetaBackground *self)
MetaBackgroundMonitor *monitor = &self->monitors[i];
g_clear_object (&monitor->fbo);
cogl_clear_object (&monitor->texture);
g_clear_object (&monitor->texture);
}
}
static void
free_color_texture (MetaBackground *self)
{
cogl_clear_object (&self->color_texture);
g_clear_object (&self->color_texture);
}
static void
free_wallpaper_texture (MetaBackground *self)
{
cogl_clear_object (&self->wallpaper_texture);
g_clear_object (&self->wallpaper_texture);
self->wallpaper_allocation_failed = FALSE;
}
@ -587,11 +587,11 @@ ensure_color_texture (MetaBackground *self)
pixels[5] = self->second_color.blue;
}
self->color_texture = COGL_TEXTURE (cogl_texture_2d_new_from_data (ctx, width, height,
self->color_texture = cogl_texture_2d_new_from_data (ctx, width, height,
COGL_PIXEL_FORMAT_RGB_888,
width * 3,
pixels,
&error));
&error);
if (error != NULL)
{
@ -680,7 +680,7 @@ ensure_wallpaper_texture (MetaBackground *self,
*/
g_error_free (catch_error);
cogl_clear_object (&self->wallpaper_texture);
g_clear_object (&self->wallpaper_texture);
g_object_unref (fbo);
self->wallpaper_allocation_failed = TRUE;
@ -843,7 +843,7 @@ meta_background_get_texture (MetaBackground *self,
* we'll try again the next time this is called. (MetaBackgroundActor
* caches the result, so user might be left without a background.)
*/
cogl_clear_object (&monitor->texture);
g_clear_object (&monitor->texture);
g_clear_object (&monitor->fbo);
g_error_free (catch_error);

2
src/compositor/meta-multi-texture.c
View File

@ -171,7 +171,7 @@ meta_multi_texture_finalize (GObject *object)
int i;
for (i = 0; i < multi_texture->n_planes; i++)
cogl_clear_object (&multi_texture->planes[i]);
g_clear_object (&multi_texture->planes[i]);
g_free (multi_texture->planes);

6
src/compositor/meta-shadow-factory.c
View File

@ -167,7 +167,7 @@ meta_shadow_unref (MetaShadow *shadow)
}
meta_window_shape_unref (shadow->key.shape);
cogl_object_unref (shadow->texture);
g_object_unref (shadow->texture);
cogl_object_unref (shadow->pipeline);
g_free (shadow);
@ -797,7 +797,7 @@ make_shadow (MetaShadow *shadow,
* in the case of top_fade >= 0. We also account for padding at the left for symmetry
* though that doesn't currently occur.
*/
shadow->texture = COGL_TEXTURE (cogl_texture_2d_new_from_data (ctx,
shadow->texture = cogl_texture_2d_new_from_data (ctx,
shadow->outer_border_left + extents.width + shadow->outer_border_right,
shadow->outer_border_top + extents.height + shadow->outer_border_bottom,
COGL_PIXEL_FORMAT_A_8,
@ -805,7 +805,7 @@ make_shadow (MetaShadow *shadow,
(buffer +
(y_offset - shadow->outer_border_top) * buffer_width +
(x_offset - shadow->outer_border_left)),
&error));
&error);
if (error)
{

12
src/compositor/meta-shaped-texture.c
View File

@ -243,7 +243,7 @@ meta_shaped_texture_dispose (GObject *object)
g_clear_pointer (&stex->texture_mipmap, meta_texture_mipmap_free);
g_clear_pointer (&stex->texture, cogl_object_unref);
g_clear_object (&stex->texture);
meta_shaped_texture_set_mask_texture (stex, NULL);
meta_shaped_texture_reset_pipelines (stex);
@ -980,12 +980,12 @@ meta_shaped_texture_set_mask_texture (MetaShapedTexture *stex,
{
g_return_if_fail (META_IS_SHAPED_TEXTURE (stex));
g_clear_pointer (&stex->mask_texture, cogl_object_unref);
g_clear_object (&stex->mask_texture);
if (mask_texture != NULL)
{
stex->mask_texture = mask_texture;
cogl_object_ref (stex->mask_texture);
g_object_ref (stex->mask_texture);
}
clutter_content_invalidate (CLUTTER_CONTENT (stex));
@ -1464,12 +1464,12 @@ meta_shaped_texture_get_image (MetaShapedTexture *stex,
texture = meta_multi_texture_get_plane (stex->texture, 0);
if (image_clip)
texture = COGL_TEXTURE (cogl_sub_texture_new (cogl_context,
texture = cogl_sub_texture_new (cogl_context,
texture,
image_clip->x,
image_clip->y,
image_clip->width,
image_clip->height));
image_clip->height);
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
cogl_texture_get_width (texture),
@ -1482,7 +1482,7 @@ meta_shaped_texture_get_image (MetaShapedTexture *stex,
cairo_surface_mark_dirty (surface);
if (image_clip)
cogl_object_unref (texture);
g_object_unref (texture);
return surface;
}

2
src/compositor/meta-surface-actor-x11.c
View File

@ -122,7 +122,7 @@ set_pixmap (MetaSurfaceActorX11 *self,
g_assert (self->pixmap == None);
self->pixmap = pixmap;
cogl_texture = COGL_TEXTURE (cogl_texture_pixmap_x11_new (ctx, self->pixmap, FALSE, &error));
cogl_texture = cogl_texture_pixmap_x11_new (ctx, self->pixmap, FALSE, &error);
if (error != NULL)
{

6
src/compositor/meta-texture-mipmap.c
View File

@ -165,16 +165,14 @@ ensure_mipmap_texture (MetaTextureMipmap *mipmap)
meta_multi_texture_get_height (mipmap->mipmap_texture) != height)
{
CoglOffscreen *offscreen;
CoglTexture2D *tex2d;
CoglTexture *tex;
free_mipmaps (mipmap);
tex2d = cogl_texture_2d_new_with_size (ctx, width, height);
if (!tex2d)
tex = cogl_texture_2d_new_with_size (ctx, width, height);
if (!tex)
return;
tex = COGL_TEXTURE (tex2d);
mipmap->mipmap_texture = meta_multi_texture_new_simple (tex);
offscreen = cogl_offscreen_new_with_texture (tex);

6
src/compositor/meta-window-actor-x11.c
View File

@ -784,7 +784,7 @@ build_and_scan_frame_mask (MetaWindowActorX11 *actor_x11,
uint8_t *mask_data;
unsigned int tex_width, tex_height;
MetaShapedTexture *stex;
CoglTexture2D *mask_texture;
CoglTexture *mask_texture;
int stride;
cairo_t *cr;
cairo_surface_t *image;
@ -868,8 +868,8 @@ build_and_scan_frame_mask (MetaWindowActorX11 *actor_x11,
if (mask_texture)
{
meta_shaped_texture_set_mask_texture (stex, COGL_TEXTURE (mask_texture));
cogl_object_unref (mask_texture);
meta_shaped_texture_set_mask_texture (stex, mask_texture);
g_object_unref (mask_texture);
}
else
{

9
src/compositor/meta-window-actor.c
View File

@ -1574,7 +1574,7 @@ create_framebuffer_from_window_actor (MetaWindowActor *self,
ClutterBackend *clutter_backend = meta_backend_get_clutter_backend (backend);
CoglContext *cogl_context =
clutter_backend_get_cogl_context (clutter_backend);
CoglTexture2D *texture;
CoglTexture *texture;
CoglOffscreen *offscreen;
CoglFramebuffer *framebuffer;
CoglColor clear_color;
@ -1589,13 +1589,12 @@ create_framebuffer_from_window_actor (MetaWindowActor *self,
if (!texture)
return NULL;
cogl_primitive_texture_set_auto_mipmap (COGL_PRIMITIVE_TEXTURE (texture),
FALSE);
cogl_primitive_texture_set_auto_mipmap (texture, FALSE);
offscreen = cogl_offscreen_new_with_texture (COGL_TEXTURE (texture));
offscreen = cogl_offscreen_new_with_texture (texture);
framebuffer = COGL_FRAMEBUFFER (offscreen);
cogl_object_unref (texture);
g_object_unref (texture);
if (!cogl_framebuffer_allocate (framebuffer, error))
{

8
src/tests/clutter/interactive/test-cogl-multitexture.c
View File

@ -224,10 +224,10 @@ test_cogl_multitexture_main (int argc, char *argv[])
cogl_object_unref (state->pipeline1);
cogl_object_unref (state->pipeline0);
cogl_object_unref (state->alpha_tex);
cogl_object_unref (state->redhand_tex);
cogl_object_unref (state->light_tex0);
cogl_object_unref (state->light_tex1);
g_object_unref (state->alpha_tex);
g_object_unref (state->redhand_tex);
g_object_unref (state->light_tex0);
g_object_unref (state->light_tex1);
g_free (state);
return 0;

2
src/tests/clutter/interactive/test-cogl-offscreen.c
View File

@ -92,7 +92,7 @@ test_coglbox_dispose (GObject *object)
{
TestCoglbox *coglbox = TEST_COGLBOX (object);
cogl_object_unref (coglbox->texture_id);
g_object_unref (coglbox->texture_id);
g_object_unref (coglbox->framebuffer);
G_OBJECT_CLASS (test_coglbox_parent_class)->dispose (object);

2
src/tests/clutter/interactive/test-cogl-point-sprites.c
View File

@ -236,7 +236,7 @@ test_cogl_point_sprites_main (int argc, char *argv[])
tex = generate_round_texture (ctx);
cogl_pipeline_set_layer_texture (data.pipeline, 0, tex);
cogl_object_unref (tex);
g_object_unref (tex);
if (!cogl_pipeline_set_layer_point_sprite_coords_enabled (data.pipeline,
0, TRUE,

4
src/tests/clutter/interactive/test-cogl-tex-polygon.c
View File

@ -219,8 +219,8 @@ test_coglbox_dispose (GObject *object)
{
TestCoglbox *coglbox = TEST_COGLBOX (object);
cogl_object_unref (coglbox->not_sliced_tex);
cogl_object_unref (coglbox->sliced_tex);
g_object_unref (coglbox->not_sliced_tex);
g_object_unref (coglbox->sliced_tex);
G_OBJECT_CLASS (test_coglbox_parent_class)->dispose (object);
}

2
src/tests/clutter/interactive/test-cogl-tex-tile.c
View File

@ -93,7 +93,7 @@ test_coglbox_dispose (GObject *object)
{
TestCoglbox *coglbox = TEST_COGLBOX (object);
cogl_object_unref (coglbox->cogl_tex_id);
g_object_unref (coglbox->cogl_tex_id);
G_OBJECT_CLASS (test_coglbox_parent_class)->dispose (object);
}

8
src/tests/clutter/test-utils.h
View File

@ -111,13 +111,13 @@ clutter_test_create_bitmap_from_file (CoglContext *ctx,
return bmp;
}
static inline CoglTexture2DSliced *
static inline CoglTexture *
clutter_test_texture_2d_sliced_new_from_file (CoglContext *ctx,
const char *filename,
GError **error)
{
CoglBitmap *bmp;
CoglTexture2DSliced *tex_2ds = NULL;
CoglTexture *tex_2ds = NULL;
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
@ -132,13 +132,13 @@ clutter_test_texture_2d_sliced_new_from_file (CoglContext *ctx,
return tex_2ds;
}
static inline CoglTexture2D *
static inline CoglTexture *
clutter_test_texture_2d_new_from_file (CoglContext *ctx,
const char *filename,
GError **error)
{
CoglBitmap *bmp;
CoglTexture2D *tex_2d = NULL;
CoglTexture *tex_2d = NULL;
g_return_val_if_fail (error == NULL || *error == NULL, NULL);

38
src/tests/cogl-test-utils.c
View File

@ -166,7 +166,7 @@ CoglTexture *
test_utils_create_color_texture (CoglContext *context,
uint32_t color)
{
CoglTexture2D *tex_2d;
CoglTexture *tex_2d;
color = GUINT32_TO_BE (color);
@ -177,7 +177,7 @@ test_utils_create_color_texture (CoglContext *context,
(uint8_t *) &color,
NULL);
return COGL_TEXTURE (tex_2d);
return tex_2d;
}
gboolean
@ -192,8 +192,7 @@ set_auto_mipmap_cb (CoglTexture *sub_texture,
const float *meta_coords,
void *user_data)
{
cogl_primitive_texture_set_auto_mipmap (COGL_PRIMITIVE_TEXTURE (sub_texture),
FALSE);
cogl_primitive_texture_set_auto_mipmap (sub_texture, FALSE);
}
CoglTexture *
@ -207,14 +206,14 @@ test_utils_texture_new_with_size (CoglContext *ctx,
GError *skip_error = NULL;
/* First try creating a fast-path non-sliced texture */
tex = COGL_TEXTURE (cogl_texture_2d_new_with_size (ctx, width, height));
tex = cogl_texture_2d_new_with_size (ctx, width, height);
cogl_texture_set_components (tex, components);
if (!cogl_texture_allocate (tex, &skip_error))
{
g_error_free (skip_error);
cogl_object_unref (tex);
g_object_unref (tex);
tex = NULL;
}
@ -223,13 +222,11 @@ test_utils_texture_new_with_size (CoglContext *ctx,
/* If it fails resort to sliced textures */
int max_waste = flags & TEST_UTILS_TEXTURE_NO_SLICING ?
-1 : COGL_TEXTURE_MAX_WASTE;
CoglTexture2DSliced *tex_2ds =
tex =
cogl_texture_2d_sliced_new_with_size (ctx,
width,
height,
max_waste);
tex = COGL_TEXTURE (tex_2ds);
cogl_texture_set_components (tex, components);
}
@ -239,7 +236,7 @@ test_utils_texture_new_with_size (CoglContext *ctx,
* need to ensure the texture is allocated... */
cogl_texture_allocate (tex, NULL); /* don't catch exceptions */
cogl_meta_texture_foreach_in_region (COGL_META_TEXTURE (tex),
cogl_meta_texture_foreach_in_region (tex,
0, 0, 1, 1,
COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE,
COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE,
@ -257,7 +254,7 @@ test_utils_texture_new_from_bitmap (CoglBitmap *bitmap,
TestUtilsTextureFlags flags,
gboolean premultiplied)
{
CoglAtlasTexture *atlas_tex;
CoglTexture *atlas_tex;
CoglTexture *tex;
GError *internal_error = NULL;
@ -266,18 +263,18 @@ test_utils_texture_new_from_bitmap (CoglBitmap *bitmap,
/* First try putting the texture in the atlas */
atlas_tex = cogl_atlas_texture_new_from_bitmap (bitmap);
cogl_texture_set_premultiplied (COGL_TEXTURE (atlas_tex), premultiplied);
cogl_texture_set_premultiplied (atlas_tex, premultiplied);
if (cogl_texture_allocate (COGL_TEXTURE (atlas_tex), &internal_error))
return COGL_TEXTURE (atlas_tex);
if (cogl_texture_allocate (atlas_tex, &internal_error))
return atlas_tex;
cogl_object_unref (atlas_tex);
g_object_unref (atlas_tex);
}
g_clear_error (&internal_error);
/* If that doesn't work try a fast path 2D texture */
tex = COGL_TEXTURE (cogl_texture_2d_new_from_bitmap (bitmap));
tex = cogl_texture_2d_new_from_bitmap (bitmap);
cogl_texture_set_premultiplied (tex, premultiplied);
@ -296,16 +293,15 @@ test_utils_texture_new_from_bitmap (CoglBitmap *bitmap,
/* Otherwise create a sliced texture */
int max_waste = flags & TEST_UTILS_TEXTURE_NO_SLICING ?
-1 : COGL_TEXTURE_MAX_WASTE;
CoglTexture2DSliced *tex_2ds =
tex =
cogl_texture_2d_sliced_new_from_bitmap (bitmap, max_waste);
tex = COGL_TEXTURE (tex_2ds);
cogl_texture_set_premultiplied (tex, premultiplied);
}
if (flags & TEST_UTILS_TEXTURE_NO_AUTO_MIPMAP)
{
cogl_meta_texture_foreach_in_region (COGL_META_TEXTURE (tex),
cogl_meta_texture_foreach_in_region (tex,
0, 0, 1, 1,
COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE,
COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE,
@ -353,14 +349,14 @@ on_before_tests (MetaContext *context)
MetaBackend *backend = meta_context_get_backend (context);
ClutterBackend *clutter_backend = meta_backend_get_clutter_backend (backend);
CoglOffscreen *offscreen;
CoglTexture2D *tex;
CoglTexture *tex;
GError *error = NULL;
test_ctx = clutter_backend_get_cogl_context (clutter_backend);
tex = cogl_texture_2d_new_with_size (test_ctx, FB_WIDTH, FB_HEIGHT);
g_assert_nonnull (tex);
offscreen = cogl_offscreen_new_with_texture (COGL_TEXTURE (tex));
offscreen = cogl_offscreen_new_with_texture (tex);
g_assert_nonnull (offscreen);
test_fb = COGL_FRAMEBUFFER (offscreen);

4
src/tests/cogl/conform/test-alpha-test.c
View File

@ -3,7 +3,7 @@
#include "tests/cogl-test-utils.h"
static CoglTexture2D *
static CoglTexture *
create_texture (CoglContext *context)
{
static const uint8_t data[] =
@ -48,7 +48,7 @@ test_alpha_test (void)
1, 1);
cogl_object_unref (pipeline);
cogl_object_unref (tex);
g_object_unref (tex);
/* The left side of the framebuffer should use the first pixel from
* the texture which is red */

6
src/tests/cogl/conform/test-alpha-textures.c
View File

@ -8,7 +8,7 @@ static void
create_pipeline (CoglTexture **tex_out,
CoglPipeline **pipeline_out)
{
CoglTexture2D *tex;
CoglTexture *tex;
CoglPipeline *pipeline;
static const uint8_t tex_data[] =
{ 0x00, 0x44, 0x88, 0xcc };
@ -76,8 +76,8 @@ test_alpha_textures (void)
-1.0f, 0.0f, /* x1/y1 */
1.0f, -1.0f /* x2/y2 */);
cogl_object_unref (tex1);
cogl_object_unref (tex2);
g_object_unref (tex1);
g_object_unref (tex2);
cogl_object_unref (pipeline1);
cogl_object_unref (pipeline2);

4
src/tests/cogl/conform/test-atlas-migration.c
View File

@ -125,7 +125,7 @@ test_atlas_migration (void)
for (tex_num = 0; tex_num < N_TEXTURES; tex_num++)
textures[tex_num] = create_texture (tex_num + 1);
for (tex_num = 0; tex_num < N_TEXTURES; tex_num++)
cogl_object_unref (textures[tex_num]);
g_object_unref (textures[tex_num]);
}
/* Create all the textures again */
@ -138,7 +138,7 @@ test_atlas_migration (void)
/* Destroy them all */
for (tex_num = 0; tex_num < N_TEXTURES; tex_num++)
cogl_object_unref (textures[tex_num]);
g_object_unref (textures[tex_num]);
if (cogl_test_verbose ())
g_print ("OK\n");

4
src/tests/cogl/conform/test-backface-culling.c
View File

@ -306,8 +306,8 @@ test_backface_culling (void)
paint (&state);
g_object_unref (state.offscreen);
cogl_object_unref (state.offscreen_tex);
cogl_object_unref (state.texture);
g_object_unref (state.offscreen_tex);
g_object_unref (state.texture);
if (cogl_test_verbose ())
g_print ("OK\n");

4
src/tests/cogl/conform/test-blend-strings.c
View File

@ -217,8 +217,8 @@ test_tex_combine (TestState *state,
y * QUAD_WIDTH + QUAD_WIDTH);
cogl_object_unref (pipeline);
cogl_object_unref (tex0);
cogl_object_unref (tex1);
g_object_unref (tex0);
g_object_unref (tex1);
/* See what we got... */

12
src/tests/cogl/conform/test-copy-replace-texture.c
View File

@ -6,6 +6,7 @@
/* Keep track of the number of textures that we've created and are
* still alive */
static int alive_texture_mask = 0;
static GQuark texture_data_key = 0;
#define N_LAYERS 3
#define N_PIPELINES 4
@ -28,8 +29,8 @@ create_texture (void)
{
static const guint8 data[] =
{ 0xff, 0xff, 0xff, 0xff };
static CoglUserDataKey texture_data_key;
CoglTexture2D *tex_2d;
texture_data_key = g_quark_from_static_string ("-cogl-test-copy-replace-texture");
CoglTexture *tex_2d;
static int texture_num = 1;
alive_texture_mask |= (1 << texture_num);
@ -40,11 +41,10 @@ create_texture (void)
4, /* rowstride */
data,
NULL);
/* Set some user data on the texture so we can track when it has
* been destroyed */
cogl_object_set_user_data (COGL_OBJECT (tex_2d),
&texture_data_key,
g_object_set_qdata_full (G_OBJECT (tex_2d),
texture_data_key,
GINT_TO_POINTER (texture_num),
free_texture_cb);
@ -77,7 +77,7 @@ test_copy_replace_texture (void)
cogl_pipeline_set_layer_texture (pipelines[pipeline_num],
layer_num,
tex);
cogl_object_unref (tex);
g_object_unref (tex);
}
}

8
src/tests/cogl/conform/test-framebuffer-get-bits.c
View File

@ -6,10 +6,10 @@ static void
test_framebuffer_get_bits (void)
{
CoglRenderer *renderer;
CoglTexture2D *tex_a;
CoglTexture *tex_a;
CoglOffscreen *offscreen_a;
CoglFramebuffer *fb_a;
CoglTexture2D *tex_rgba;
CoglTexture *tex_rgba;
CoglOffscreen *offscreen_rgba;
CoglFramebuffer *fb_rgba;
@ -44,9 +44,9 @@ test_framebuffer_get_bits (void)
g_assert_cmpint (cogl_framebuffer_get_alpha_bits (fb_rgba), >=, 1);
g_object_unref (fb_rgba);
cogl_object_unref (tex_rgba);
g_object_unref (tex_rgba);
g_object_unref (fb_a);
cogl_object_unref (tex_a);
g_object_unref (tex_a);
}
COGL_TEST_SUITE (

8
src/tests/cogl/conform/test-journal.c
View File

@ -8,7 +8,7 @@
static void
test_journal_unref_flush (void)
{
CoglTexture2D *texture;
CoglTexture *texture;
CoglOffscreen *offscreen;
CoglPipeline *pipeline;
const int width = 1;
@ -22,7 +22,7 @@ test_journal_unref_flush (void)
G_STATIC_ASSERT (sizeof data == sizeof reference_data);
texture = cogl_texture_2d_new_with_size (test_ctx, width, height);
offscreen = cogl_offscreen_new_with_texture (COGL_TEXTURE (texture));
offscreen = cogl_offscreen_new_with_texture (texture);
g_object_add_weak_pointer (G_OBJECT (offscreen), (gpointer *) &offscreen);
pipeline = cogl_pipeline_new (test_ctx);
@ -35,13 +35,13 @@ test_journal_unref_flush (void)
g_object_unref (offscreen);
g_assert_null (offscreen);
cogl_texture_get_data (COGL_TEXTURE (texture),
cogl_texture_get_data (texture,
COGL_PIXEL_FORMAT_RGBA_8888_PRE,
stride, data);
g_assert_cmpmem (data, sizeof (data),
reference_data, sizeof (reference_data));
cogl_object_unref (texture);
g_object_unref (texture);
}
COGL_TEST_SUITE (

2
src/tests/cogl/conform/test-just-vertex-shader.c
View File

@ -45,7 +45,7 @@ paint (TestState *state)
constant green color provided by a texture */
tex = create_dummy_texture ();
cogl_pipeline_set_layer_texture (pipeline, 0, tex);
cogl_object_unref (tex);
g_object_unref (tex);
if (!cogl_pipeline_set_layer_combine (pipeline, 0,
"RGBA=REPLACE(TEXTURE)",
&error))

4
src/tests/cogl/conform/test-map-buffer-range.c
View File

@ -25,7 +25,7 @@ vertex_data[4] =
static void
test_map_buffer_range (void)
{
CoglTexture2D *tex;
CoglTexture *tex;
CoglPipeline *pipeline;
int fb_width, fb_height;
CoglAttributeBuffer *buffer;
@ -122,7 +122,7 @@ test_map_buffer_range (void)
g_object_unref (tex_coord_attribute);
cogl_object_unref (pipeline);
cogl_object_unref (tex);
g_object_unref (tex);
if (cogl_test_verbose ())
g_print ("OK\n");

4
src/tests/cogl/conform/test-multitexture.c
View File

@ -152,8 +152,8 @@ on_paint (ClutterActor *actor,
tex_coords, 8);
cogl_object_unref (pipeline);
cogl_object_unref (tex0);
cogl_object_unref (tex1);
g_object_unref (tex0);
g_object_unref (tex1);
/* See what we got... */

2
src/tests/cogl/conform/test-npot-texture.c
View File

@ -138,7 +138,7 @@ paint (void)
(y + 1) / 2.0f);
cogl_object_unref (pipeline);
cogl_object_unref (texture);
g_object_unref (texture);
}
static void

36
src/tests/cogl/conform/test-offscreen-texture-formats.c
View File

@ -85,7 +85,7 @@ test_offscreen_texture_formats_store_rgb10 (void)
for (i = 0; i < G_N_ELEMENTS (formats); i++)
{
CoglTexture2D *tex;
CoglTexture *tex;
CoglOffscreen *offscreen;
uint32_t rgb8_readback[4];
int j, k;
@ -93,7 +93,7 @@ test_offscreen_texture_formats_store_rgb10 (void)
/* Allocate 2x2 to ensure we avoid any fast paths. */
tex = cogl_texture_2d_new_with_format (test_ctx, 2, 2, formats[i]);
offscreen = cogl_offscreen_new_with_texture (COGL_TEXTURE (tex));
offscreen = cogl_offscreen_new_with_texture (tex);
cogl_framebuffer_allocate (COGL_FRAMEBUFFER (offscreen), &error);
g_assert_no_error (error);
@ -179,7 +179,7 @@ test_offscreen_texture_formats_store_rgb10 (void)
}
g_object_unref (offscreen);
cogl_object_unref (tex);
g_object_unref (tex);
}
}
@ -207,7 +207,7 @@ test_offscreen_texture_formats_store_rgb8 (void)
for (i = 0; i < G_N_ELEMENTS (formats); i++)
{
CoglTexture2D *tex;
CoglTexture *tex;
CoglOffscreen *offscreen;
GError *error = NULL;
int j;
@ -215,7 +215,7 @@ test_offscreen_texture_formats_store_rgb8 (void)
/* Allocate 2x2 to ensure we avoid any fast paths. */
tex = cogl_texture_2d_new_with_format (test_ctx, 2, 2, formats[i]);
offscreen = cogl_offscreen_new_with_texture (COGL_TEXTURE (tex));
offscreen = cogl_offscreen_new_with_texture (tex);
cogl_framebuffer_allocate (COGL_FRAMEBUFFER (offscreen), &error);
g_assert_no_error (error);
@ -277,7 +277,7 @@ test_offscreen_texture_formats_store_rgb8 (void)
}
g_object_unref (offscreen);
cogl_object_unref (tex);
g_object_unref (tex);
}
}
@ -316,26 +316,26 @@ test_offscreen_texture_formats_paint_rgb10 (void)
for (i = 0; i < G_N_ELEMENTS (formats); i++)
{
CoglTexture2D *tex_src;
CoglTexture *tex_src;
CoglOffscreen *offscreen_src;
GError *error = NULL;
int j;
tex_src = cogl_texture_2d_new_with_format (test_ctx, 2, 2, formats[i]);
offscreen_src = cogl_offscreen_new_with_texture (COGL_TEXTURE (tex_src));
offscreen_src = cogl_offscreen_new_with_texture (tex_src);
cogl_framebuffer_allocate (COGL_FRAMEBUFFER (offscreen_src), &error);
g_assert_no_error (error);
for (j = 0; j < G_N_ELEMENTS (formats); j++)
{
CoglTexture2D *tex_dst;
CoglTexture *tex_dst;
CoglOffscreen *offscreen_dst;
CoglPipeline *pipeline;
uint32_t rgb10_readback[4];
int k;
tex_dst = cogl_texture_2d_new_with_format (test_ctx, 2, 2, formats[j]);
offscreen_dst = cogl_offscreen_new_with_texture (COGL_TEXTURE (tex_dst));
offscreen_dst = cogl_offscreen_new_with_texture (tex_dst);
cogl_framebuffer_allocate (COGL_FRAMEBUFFER (offscreen_dst), &error);
g_assert_no_error (error);
@ -410,11 +410,11 @@ test_offscreen_texture_formats_paint_rgb10 (void)
}
g_object_unref (offscreen_dst);
cogl_object_unref (tex_dst);
g_object_unref (tex_dst);
}
g_object_unref (offscreen_src);
cogl_object_unref (tex_src);
g_object_unref (tex_src);
}
}
@ -442,26 +442,26 @@ test_offscreen_texture_formats_paint_rgb8 (void)
for (i = 0; i < G_N_ELEMENTS (formats); i++)
{
CoglTexture2D *tex_src;
CoglTexture *tex_src;
CoglOffscreen *offscreen_src;
GError *error = NULL;
int j;
tex_src = cogl_texture_2d_new_with_format (test_ctx, 2, 2, formats[i]);
offscreen_src = cogl_offscreen_new_with_texture (COGL_TEXTURE (tex_src));
offscreen_src = cogl_offscreen_new_with_texture (tex_src);
cogl_framebuffer_allocate (COGL_FRAMEBUFFER (offscreen_src), &error);
g_assert_no_error (error);
for (j = 0; j < G_N_ELEMENTS (formats); j++)
{
CoglTexture2D *tex_dst;
CoglTexture *tex_dst;
CoglOffscreen *offscreen_dst;
CoglPipeline *pipeline;
uint8_t rgba_readback[4 * 4] = {};
int k;
tex_dst = cogl_texture_2d_new_with_format (test_ctx, 2, 2, formats[j]);
offscreen_dst = cogl_offscreen_new_with_texture (COGL_TEXTURE (tex_dst));
offscreen_dst = cogl_offscreen_new_with_texture (tex_dst);
cogl_framebuffer_allocate (COGL_FRAMEBUFFER (offscreen_dst), &error);
g_assert_no_error (error);
@ -527,11 +527,11 @@ test_offscreen_texture_formats_paint_rgb8 (void)
}
g_object_unref (offscreen_dst);
cogl_object_unref (tex_dst);
g_object_unref (tex_dst);
}
g_object_unref (offscreen_src);
cogl_object_unref (tex_src);
g_object_unref (tex_src);
}
}

12
src/tests/cogl/conform/test-offscreen.c
View File

@ -40,17 +40,15 @@ check_quadrant (TestState *state,
static void
test_paint (TestState *state)
{
CoglTexture2D *tex_2d;
CoglTexture *tex;
CoglOffscreen *offscreen;
CoglFramebuffer *framebuffer;
CoglPipeline *opaque_pipeline;
CoglPipeline *texture_pipeline;
tex_2d = cogl_texture_2d_new_with_size (test_ctx,
tex = cogl_texture_2d_new_with_size (test_ctx,
state->fb_width,
state->fb_height);
tex = tex_2d;
offscreen = cogl_offscreen_new_with_texture (tex);
framebuffer = COGL_FRAMEBUFFER (offscreen);
@ -102,7 +100,7 @@ test_paint (TestState *state)
cogl_object_unref (opaque_pipeline);
cogl_object_unref (texture_pipeline);
cogl_object_unref (tex_2d);
g_object_unref (tex);
cogl_framebuffer_pop_matrix (test_fb);
@ -123,7 +121,6 @@ static void
test_flush (TestState *state)
{
CoglPipeline *pipeline;
CoglTexture2D *tex_2d;
CoglTexture *tex;
CoglOffscreen *offscreen;
CoglFramebuffer *framebuffer;
@ -139,9 +136,8 @@ test_flush (TestState *state)
the contents of the texture will automatically flush the
journal */
tex_2d = cogl_texture_2d_new_with_size (test_ctx,
tex = cogl_texture_2d_new_with_size (test_ctx,
16, 16); /* width/height */
tex = tex_2d;
offscreen = cogl_offscreen_new_with_texture (tex);
framebuffer = COGL_FRAMEBUFFER (offscreen);
@ -184,7 +180,7 @@ test_flush (TestState *state)
0xff0000ff);
}
cogl_object_unref (tex_2d);
g_object_unref (tex);
g_object_unref (offscreen);
}

12
src/tests/cogl/conform/test-pipeline-cache-unrefs-texture.c
View File

@ -5,7 +5,7 @@
/* Keep track of the number of textures that we've created and are
* still alive */
static int destroyed_texture_count = 0;
static GQuark texture_data_key = 0;
#define N_TEXTURES 3
static void
@ -19,8 +19,8 @@ create_texture (void)
{
static const guint8 data[] =
{ 0xff, 0xff, 0xff, 0xff };
static CoglUserDataKey texture_data_key;
CoglTexture2D *tex_2d;
texture_data_key = g_quark_from_static_string ("-cogl-test-pipeline-cache-unrefs-texture");
CoglTexture *tex_2d;
tex_2d = cogl_texture_2d_new_from_data (test_ctx,
1, 1, /* width / height */
@ -31,8 +31,8 @@ create_texture (void)
/* Set some user data on the texture so we can track when it has
* been destroyed */
cogl_object_set_user_data (COGL_OBJECT (tex_2d),
&texture_data_key,
g_object_set_qdata_full (G_OBJECT (tex_2d),
texture_data_key,
GINT_TO_POINTER (1),
free_texture_cb);
@ -53,7 +53,7 @@ test_pipeline_cache_unrefs_texture (void)
{
CoglTexture *tex = create_texture ();
cogl_pipeline_set_layer_texture (pipeline, i, tex);
cogl_object_unref (tex);
g_object_unref (tex);
}
/* Draw something with the pipeline to ensure it gets into the

2
src/tests/cogl/conform/test-pipeline-shader-state.c
View File

@ -11,7 +11,7 @@ test_pipeline_shader_state (void)
CoglFramebuffer *fb;
CoglPipeline *base_pipeline;
CoglPipeline *draw_pipeline;
CoglTexture2D *tex;
CoglTexture *tex;
CoglSnippet *snippet;
float width = cogl_framebuffer_get_width (test_fb);

4
src/tests/cogl/conform/test-pipeline-user-matrix.c
View File

@ -122,8 +122,8 @@ paint (TestState *state)
0, 0,
state->width, state->height);
cogl_object_unref (tex1);
cogl_object_unref (tex0);
g_object_unref (tex1);
g_object_unref (tex0);
cogl_object_unref (pipeline);
}

10
src/tests/cogl/conform/test-pixel-buffer.c
View File

@ -77,7 +77,7 @@ create_and_fill_bitmap (void)
static CoglTexture *
create_texture_from_bitmap (CoglBitmap *bitmap)
{
CoglTexture2D *texture;
CoglTexture *texture;
texture = cogl_texture_2d_new_from_bitmap (bitmap);
@ -150,7 +150,7 @@ test_pixel_buffer_map (void)
1.0f, -1.0f);
g_object_unref (bitmap);
cogl_object_unref (texture);
g_object_unref (texture);
cogl_object_unref (pipeline);
check_colours (0x0000ffff,
@ -195,7 +195,7 @@ test_pixel_buffer_set_data (void)
1.0f, -1.0f);
g_object_unref (bitmap);
cogl_object_unref (texture);
g_object_unref (texture);
cogl_object_unref (pipeline);
check_colours (0x0000ffff,
@ -210,7 +210,7 @@ test_pixel_buffer_set_data (void)
static CoglTexture *
create_white_texture (void)
{
CoglTexture2D *texture;
CoglTexture *texture;
uint8_t *data = g_malloc (BITMAP_SIZE * BITMAP_SIZE * 4);
memset (data, 255, BITMAP_SIZE * BITMAP_SIZE * 4);
@ -256,7 +256,7 @@ test_pixel_buffer_sub_region (void)
1.0f, -1.0f);
g_object_unref (bitmap);
cogl_object_unref (texture);
g_object_unref (texture);
cogl_object_unref (pipeline);
check_colours (0xffffffff,

4
src/tests/cogl/conform/test-point-sprite-known-failure.c
View File

@ -26,7 +26,7 @@ do_test (gboolean check_orientation,
int fb_height = cogl_framebuffer_get_height (test_fb);
CoglPrimitive *prim;
GError *error = NULL;
CoglTexture2D *tex_2d;
CoglTexture *tex_2d;
CoglPipeline *pipeline, *solid_pipeline;
int tex_height;
@ -136,7 +136,7 @@ do_test (gboolean check_orientation,
cogl_object_unref (prim);
cogl_object_unref (solid_pipeline);
cogl_object_unref (pipeline);
cogl_object_unref (tex_2d);
g_object_unref (tex_2d);
test_utils_check_pixel (test_fb,
POINT_SIZE - POINT_SIZE / 4,

4
src/tests/cogl/conform/test-point-sprite.c
View File

@ -26,7 +26,7 @@ do_test (gboolean check_orientation,
int fb_height = cogl_framebuffer_get_height (test_fb);
CoglPrimitive *prim;
GError *error = NULL;
CoglTexture2D *tex_2d;
CoglTexture *tex_2d;
CoglPipeline *pipeline, *solid_pipeline;
int tex_height;
@ -136,7 +136,7 @@ do_test (gboolean check_orientation,
cogl_object_unref (prim);
cogl_object_unref (solid_pipeline);
cogl_object_unref (pipeline);
cogl_object_unref (tex_2d);
g_object_unref (tex_2d);
test_utils_check_pixel (test_fb,
POINT_SIZE - POINT_SIZE / 4,

10
src/tests/cogl/conform/test-premult.c
View File

@ -49,7 +49,7 @@ make_texture (uint32_t color,
CoglPixelFormat src_format,
MakeTextureFlags flags)
{
CoglTexture2D *tex_2d;
CoglTexture *tex;
guchar *tex_data = gen_tex_data (color);
CoglBitmap *bmp = cogl_bitmap_new_for_data (test_ctx,
QUAD_WIDTH,
@ -58,16 +58,16 @@ make_texture (uint32_t color,
QUAD_WIDTH * 4,
tex_data);
tex_2d = cogl_texture_2d_new_from_bitmap (bmp);
tex = cogl_texture_2d_new_from_bitmap (bmp);
if (flags & TEXTURE_FLAG_SET_PREMULTIPLIED)
cogl_texture_set_premultiplied (tex_2d, TRUE);
cogl_texture_set_premultiplied (tex, TRUE);
else if (flags & TEXTURE_FLAG_SET_UNPREMULTIPLIED)
cogl_texture_set_premultiplied (tex_2d, FALSE);
cogl_texture_set_premultiplied (tex, FALSE);
g_object_unref (bmp);
return tex_2d;
return tex;
}
static void

2
src/tests/cogl/conform/test-primitive.c
View File

@ -183,7 +183,7 @@ test_paint (TestState *state)
(PRIM_COLOR >> 8) & 0xff,
(PRIM_COLOR >> 0) & 0xff);
cogl_pipeline_set_layer_texture (pipeline, 0, tex);
cogl_object_unref (tex);
g_object_unref (tex);
for (i = 0; i < G_N_ELEMENTS (test_prim_funcs); i++)
{

16
src/tests/cogl/conform/test-read-texture-formats.c
View File

@ -11,7 +11,7 @@
static const uint8_t tex_data[4] = { 0x12, 0x34, 0x56, 0x78 };
static void
test_read_byte (CoglTexture2D *tex_2d,
test_read_byte (CoglTexture *tex_2d,
CoglPixelFormat format,
uint8_t expected_byte)
{
@ -26,7 +26,7 @@ test_read_byte (CoglTexture2D *tex_2d,
}
static void
test_read_short (CoglTexture2D *tex_2d,
test_read_short (CoglTexture *tex_2d,
CoglPixelFormat format,
...)
{
@ -65,7 +65,7 @@ test_read_short (CoglTexture2D *tex_2d,
}
static void
test_read_888 (CoglTexture2D *tex_2d,
test_read_888 (CoglTexture *tex_2d,
CoglPixelFormat format,
uint32_t expected_pixel)
{
@ -80,7 +80,7 @@ test_read_888 (CoglTexture2D *tex_2d,
}
static void
test_read_88 (CoglTexture2D *tex_2d,
test_read_88 (CoglTexture *tex_2d,
CoglPixelFormat format,
uint32_t expected_pixel)
{
@ -97,7 +97,7 @@ test_read_88 (CoglTexture2D *tex_2d,
}
static void
test_read_8888 (CoglTexture2D *tex_2d,
test_read_8888 (CoglTexture *tex_2d,
CoglPixelFormat format,
uint32_t expected_pixel)
{
@ -120,7 +120,7 @@ test_read_8888 (CoglTexture2D *tex_2d,
}
static void
test_read_int (CoglTexture2D *tex_2d,
test_read_int (CoglTexture *tex_2d,
CoglPixelFormat format,
...)
{
@ -161,7 +161,7 @@ test_read_int (CoglTexture2D *tex_2d,
static void
test_read_texture_formats (void)
{
CoglTexture2D *tex_2d;
CoglTexture *tex_2d;
tex_2d = cogl_texture_2d_new_from_data (test_ctx,
1, 1, /* width / height */
@ -215,7 +215,7 @@ test_read_texture_formats (void)
2, 0x78, 10, 0x56, 10, 0x34, 10, 0x12,
-1);
cogl_object_unref (tex_2d);
g_object_unref (tex_2d);
if (cogl_test_verbose ())
g_print ("OK\n");

2
src/tests/cogl/conform/test-readpixels.c
View File

@ -125,7 +125,7 @@ on_after_paint (ClutterActor *actor,
g_free (pixelsc);
cogl_object_unref (tex);
g_object_unref (tex);
/* Restore the viewport and matrices state */
cogl_set_viewport (saved_viewport[0],

Some files were not shown because too many files have changed in this diff Show More