static void
clutter_gst_yv12_fp_paint (ClutterActor *actor,
ClutterGstVideoSink *sink)
{
ClutterGstVideoSinkPrivate *priv = sink->priv;
CoglHandle material;
material = clutter_texture_get_cogl_material (CLUTTER_TEXTURE (actor));
/* Bind the U and V textures in layers 1 and 2 */
if (priv->u_tex)
cogl_material_set_layer (material, 1, priv->u_tex);
if (priv->v_tex)
cogl_material_set_layer (material, 2, priv->v_tex);
/* Cogl doesn't support changing OpenGL state to modify how Cogl primitives
* work, but it also doesn't support ARBfp which we currently depend on. For
* now we at least ask Cogl to flush any batched primitives so we avoid
* binding our shader across the wrong geometry, but there is a risk that
* Cogl may start to use ARBfp internally which will conflict with us. */
cogl_flush ();
/* bind the shader */
glEnable (GL_FRAGMENT_PROGRAM_ARB);
priv->syms.glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, priv->fp);
}
/**
* _st_create_texture_material:
* @src_texture: The CoglTexture for the material
*
* Creates a simple material which contains the given texture as a
* single layer.
*/
CoglHandle
_st_create_texture_material (CoglHandle src_texture)
{
static CoglHandle texture_material_template = COGL_INVALID_HANDLE;
CoglHandle material;
g_return_val_if_fail (src_texture != COGL_INVALID_HANDLE,
COGL_INVALID_HANDLE);
/* We use a material that has a dummy texture as a base for all
texture materials. The idea is that only the Cogl texture object
would be different in the children so it is likely that Cogl will
be able to share GL programs between all the textures. */
if (G_UNLIKELY (texture_material_template == COGL_INVALID_HANDLE))
{
static const guint8 white_pixel[] = { 0xff, 0xff, 0xff, 0xff };
CoglHandle dummy_texture;
dummy_texture = st_cogl_texture_new_from_data_wrapper (1, 1,
COGL_TEXTURE_NONE,
COGL_PIXEL_FORMAT_RGBA_8888_PRE,
COGL_PIXEL_FORMAT_ANY,
4, white_pixel);
texture_material_template = cogl_material_new ();
cogl_material_set_layer (texture_material_template, 0, dummy_texture);
cogl_handle_unref (dummy_texture);
}
material = cogl_material_copy (texture_material_template);
cogl_material_set_layer (material, 0, src_texture);
return material;
}
/**
* meta_create_texture_material:
* @src_texture: (allow-none): texture to use initially for the layer
*
* Creates a material with a single layer. Using a common template
* allows sharing a shader for different uses in Muffin. To share the same
* shader with all other materials that are just texture plus opacity
* would require Cogl fixes.
* (See http://bugzilla.clutter-project.org/show_bug.cgi?id=2425)
*
* Return value: (transfer full): a newly created Cogl material
*/
CoglHandle
meta_create_texture_material (CoglHandle src_texture)
{
static CoglHandle texture_material_template = COGL_INVALID_HANDLE;
CoglHandle material;
/* We use a material that has a dummy texture as a base for all
texture materials. The idea is that only the Cogl texture object
would be different in the children so it is likely that Cogl will
be able to share GL programs between all the textures. */
if (G_UNLIKELY (texture_material_template == COGL_INVALID_HANDLE))
{
CoglHandle dummy_texture;
dummy_texture = meta_create_color_texture_4ub (0xff, 0xff, 0xff, 0xff,
COGL_TEXTURE_NONE);
texture_material_template = cogl_material_new ();
cogl_material_set_layer (texture_material_template, 0, dummy_texture);
cogl_handle_unref (dummy_texture);
}
material = cogl_material_copy (texture_material_template);
if (src_texture != COGL_INVALID_HANDLE)
cogl_material_set_layer (material, 0, src_texture);
return material;
}
CoglHandle
_st_create_shadow_material (StShadow *shadow_spec,
CoglHandle src_texture)
{
static CoglHandle shadow_material_template = COGL_INVALID_HANDLE;
CoglHandle material;
CoglHandle texture;
guchar *pixels_in, *pixels_out;
gint width_in, height_in, rowstride_in;
gint width_out, height_out, rowstride_out;
g_return_val_if_fail (shadow_spec != NULL, COGL_INVALID_HANDLE);
g_return_val_if_fail (src_texture != COGL_INVALID_HANDLE,
COGL_INVALID_HANDLE);
width_in = cogl_texture_get_width (src_texture);
height_in = cogl_texture_get_height (src_texture);
rowstride_in = (width_in + 3) & ~3;
pixels_in = g_malloc0 (rowstride_in * height_in);
cogl_texture_get_data (src_texture, COGL_PIXEL_FORMAT_A_8,
rowstride_in, pixels_in);
pixels_out = blur_pixels (pixels_in, width_in, height_in, rowstride_in,
shadow_spec->blur,
&width_out, &height_out, &rowstride_out);
g_free (pixels_in);
texture = cogl_texture_new_from_data (width_out,
height_out,
COGL_TEXTURE_NONE,
COGL_PIXEL_FORMAT_A_8,
COGL_PIXEL_FORMAT_A_8,
rowstride_out,
pixels_out);
g_free (pixels_out);
if (G_UNLIKELY (shadow_material_template == COGL_INVALID_HANDLE))
{
shadow_material_template = cogl_material_new ();
/* We set up the material to blend the shadow texture with the combine
* constant, but defer setting the latter until painting, so that we can
* take the actor's overall opacity into account. */
cogl_material_set_layer_combine (shadow_material_template, 0,
"RGBA = MODULATE (CONSTANT, TEXTURE[A])",
NULL);
}
material = cogl_material_copy (shadow_material_template);
cogl_material_set_layer (material, 0, texture);
cogl_handle_unref (texture);
return material;
}
static void
clutter_gst_yv12_glsl_paint (ClutterActor *actor,
ClutterGstVideoSink *sink)
{
ClutterGstVideoSinkPrivate *priv = sink->priv;
CoglHandle material;
material = clutter_texture_get_cogl_material (CLUTTER_TEXTURE (actor));
/* bind the shader */
cogl_program_use (priv->program);
/* Bind the U and V textures in layers 1 and 2 */
if (priv->u_tex)
cogl_material_set_layer (material, 1, priv->u_tex);
if (priv->v_tex)
cogl_material_set_layer (material, 2, priv->v_tex);
}
static void
mex_tile_style_changed_cb (MexTile *self, MxStyleChangedFlags flags)
{
MexTilePrivate *priv = self->priv;
MxBorderImage *image;
if (priv->header_padding)
{
g_boxed_free (MX_TYPE_PADDING, priv->header_padding);
priv->header_padding = NULL;
}
if (priv->header_background_color)
{
g_boxed_free (CLUTTER_TYPE_COLOR, priv->header_background_color);
priv->header_background_color = NULL;
}
mx_stylable_get (MX_STYLABLE (self),
"x-mex-header-background", &image,
"x-mex-header-background-color", &priv->header_background_color,
"x-mex-header-padding", &priv->header_padding,
NULL);
mx_stylable_apply_clutter_text_attributes (MX_STYLABLE (self),
CLUTTER_TEXT (priv->label));
mx_stylable_apply_clutter_text_attributes (MX_STYLABLE (self),
CLUTTER_TEXT (priv->secondary_label));
if (image && image->uri)
{
CoglObject *background;
background =
mx_texture_cache_get_cogl_texture (mx_texture_cache_get_default (),
image->uri);
cogl_material_set_layer (priv->material, 0, background);
}
else
{
if (cogl_material_get_n_layers (priv->material))
cogl_material_remove_layer (priv->material, 0);
}
if (image)
g_boxed_free (MX_TYPE_BORDER_IMAGE, image);
if (priv->icon1)
mx_stylable_style_changed (MX_STYLABLE (priv->icon1), flags);
if (priv->icon2)
mx_stylable_style_changed (MX_STYLABLE (priv->icon2), flags);
clutter_actor_queue_redraw (CLUTTER_ACTOR (self));
}
static void
set_texture_on_actor (MetaBackgroundActor *self)
{
MetaBackgroundActorPrivate *priv = self->priv;
MetaDisplay *display = meta_screen_get_display (priv->background->screen);
/* This may trigger destruction of an old texture pixmap, which, if
* the underlying X pixmap is already gone has the tendency to trigger
* X errors inside DRI. For safety, trap errors */
meta_error_trap_push (display);
cogl_material_set_layer (priv->material, 0, priv->background->texture);
meta_error_trap_pop (display);
clutter_actor_queue_redraw (CLUTTER_ACTOR (self));
}
G_MODULE_EXPORT int
test_cogl_shader_arbfp_main (int argc, char *argv[])
{
ClutterActor *stage;
char *file;
GError *error;
ClutterColor stage_color = { 0x61, 0x64, 0x8c, 0xff };
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return 1;
stage = clutter_stage_new ();
clutter_stage_set_title (CLUTTER_STAGE (stage), "Assembly Shader Test");
clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color);
file = g_build_filename (TESTS_DATADIR, "redhand.png", NULL);
error = NULL;
redhand = cogl_texture_new_from_file (file, 0, COGL_PIXEL_FORMAT_ANY,
&error);
if (redhand == COGL_INVALID_HANDLE)
g_error ("image load failed: %s", error->message);
material = cogl_material_new ();
cogl_material_set_layer (material, 0, redhand);
set_shader_num (0);
g_signal_connect_after (stage, "paint", G_CALLBACK (paint_cb), NULL);
clutter_actor_set_reactive (stage, TRUE);
g_signal_connect (stage, "button-release-event",
G_CALLBACK (button_release_cb), NULL);
g_signal_connect (stage, "key-release-event",
G_CALLBACK (key_release_cb), NULL);
g_signal_connect (stage, "delete-event",
G_CALLBACK (destroy_window_cb), NULL);
timeout_id = clutter_threads_add_timeout (1000, timeout_cb, NULL);
clutter_threads_add_idle (idle_cb, stage);
clutter_actor_show (stage);
clutter_main ();
return EXIT_SUCCESS;
}
void
meta_background_set_layer (MetaBackground *self,
CoglHandle texture)
{
MetaBackgroundPrivate *priv = self->priv;
MetaDisplay *display = meta_screen_get_display (priv->screen);
/* This may trigger destruction of an old texture pixmap, which, if
* the underlying X pixmap is already gone has the tendency to trigger
* X errors inside DRI. For safety, trap errors */
meta_error_trap_push (display);
cogl_material_set_layer (priv->material, 0, texture);
meta_error_trap_pop (display);
priv->texture_width = cogl_texture_get_width (texture);
priv->texture_height = cogl_texture_get_height (texture);
clutter_actor_queue_redraw (CLUTTER_ACTOR (self));
}
static void
aisleriot_slot_renderer_set_material_for_card (AisleriotSlotRenderer *srend,
CoglHandle tex,
gboolean show_highlight)
{
AisleriotSlotRendererPrivate *priv = srend->priv;
guint8 opacity = clutter_actor_get_paint_opacity (CLUTTER_ACTOR (srend));
if (priv->material == COGL_INVALID_HANDLE)
priv->material = cogl_material_new ();
if (show_highlight)
{
CoglColor color;
/* The previous code for drawing the highlight rendered the
normal card texture and then rendered the card again
multiplied by the highlight color but with 50%
transparency. The blend function is alpha*src+(1-alpha*dst)
where src is effectively the tex times the highlight color
and the dst is the original tex. Therefore the final color is
0.5*tex+0.5*tex*highlight which is the same as
(0.5+highlight/2)*tex. We can precompute that value to avoid
having to draw the card twice */
cogl_color_set_from_4ub (&color,
MIN (priv->highlight_color.red
/ 2 + 128, 0xff),
MIN (priv->highlight_color.green
/ 2 + 128, 0xff),
MIN (priv->highlight_color.blue
/ 2 + 128, 0xff),
opacity);
cogl_color_premultiply (&color);
cogl_material_set_color (priv->material, &color);
}
else
cogl_material_set_color4ub (priv->material,
opacity, opacity, opacity, opacity);
cogl_material_set_layer (priv->material, 0, tex);
cogl_set_source (priv->material);
}
void
glide_image_set_cogl_texture (GlideImage *image,
CoglHandle new_texture)
{
guint width, height;
width = cogl_texture_get_width (new_texture);
height = cogl_texture_get_height (new_texture);
cogl_handle_ref (new_texture);
image_free_gl_resources (image);
cogl_material_set_layer (image->priv->material, 0, new_texture);
image->priv->image_width = width;
image->priv->image_height = height;
cogl_handle_unref (new_texture);
}
static void
mnb_toolbar_shadow_paint (ClutterActor *self)
{
MnbToolbarShadowPrivate *priv = MNB_TOOLBAR_SHADOW (self)->priv;
CoglHandle cogl_texture = COGL_INVALID_HANDLE;
CoglHandle cogl_material = COGL_INVALID_HANDLE;
ClutterActorBox box = { 0, };
gfloat width, height;
gfloat tex_width, tex_height;
gfloat ex, ey;
gfloat tx1, ty1, tx2, ty2;
guint8 opacity;
/* no need to paint stuff if we don't have a texture */
if (G_UNLIKELY (priv->parent_texture == NULL))
return;
/* parent texture may have been hidden, so need to make sure it gets
* realized
*/
if (!CLUTTER_ACTOR_IS_REALIZED (priv->parent_texture))
clutter_actor_realize (CLUTTER_ACTOR (priv->parent_texture));
cogl_texture = clutter_texture_get_cogl_texture (priv->parent_texture);
if (cogl_texture == COGL_INVALID_HANDLE)
return;
cogl_material = clutter_texture_get_cogl_material (priv->parent_texture);
if (cogl_material == COGL_INVALID_HANDLE)
return;
tex_width = cogl_texture_get_width (cogl_texture);
tex_height = cogl_texture_get_height (cogl_texture);
clutter_actor_get_allocation_box (self, &box);
width = box.x2 - box.x1;
height = box.y2 - box.y1;
opacity = clutter_actor_get_paint_opacity (self);
/* Paint using the parent texture's material. It should already have
the cogl texture set as the first layer */
/* NB: for correct blending we need set a preumultiplied color here: */
cogl_material_set_color4ub (cogl_material,
opacity, opacity, opacity, opacity);
#if TOOLBAR_CUT_OUT
selector_texture = mnb_toolbar_get_selector_texture (priv->toolbar);
cogl_material_set_layer (cogl_material, 1, selector_texture);
cogl_material_set_layer_wrap_mode (cogl_material, 1,
COGL_MATERIAL_WRAP_MODE_CLAMP_TO_EDGE);
if (!cogl_material_set_layer_combine (cogl_material, 1,
"RGBA = MODULATE(PREVIOUS,TEXTURE)",
&error))
{
g_warning (G_STRLOC ": Error setting layer combine blend string: %s",
error->message);
g_error_free (error);
}
#endif
cogl_set_source (cogl_material);
/* simple stretch */
if (priv->left == 0 && priv->right == 0 && priv->top == 0
&& priv->bottom == 0)
{
#if TOOLBAR_CUT_OUT
float spot_width, spot_height;
float coords[8] = {
0, 0, 1, 1,
0, 0, 0, 0
};
mnb_toolbar_get_selector_allocation_box (priv->toolbar, &box);
spot_width = box.x2 - box.x1;
spot_height = box.y2 - box.y1;
coords[4] = -(box.x1 / width) * (width / spot_width);
coords[5] = -(box.y1 + SHADOW_CUT_OUT_OFFSET / height) * (height / spot_height);
coords[6] = width / spot_width - (box.x1 / width) * (width / spot_width);
coords[7] = height / spot_height -
(box.y1 + SHADOW_CUT_OUT_OFFSET / height) * (height / spot_height);
cogl_rectangle_with_multitexture_coords (0, 0, width, height, coords, 8);
#else
cogl_rectangle (0, 0, width, height);
#endif /* TOOLBAR_CUT_OUT */
return;
}
tx1 = priv->left / tex_width;
tx2 = (tex_width - priv->right) / tex_width;
ty1 = priv->top / tex_height;
ty2 = (tex_height - priv->bottom) / tex_height;
ex = width - priv->right;
if (ex < priv->left)
ex = priv->left;
ey = height - priv->bottom;
if (ey < priv->top)
ey = priv->top;
{
GLfloat rectangles[] =
{
/* top left corner */
0, 0,
priv->left, priv->top,
0.0, 0.0,
tx1, ty1,
/* top middle */
priv->left, 0,
MAX (priv->left, ex), priv->top,
tx1, 0.0,
tx2, ty1,
/* top right */
ex, 0,
MAX (ex + priv->right, width), priv->top,
tx2, 0.0,
1.0, ty1,
/* mid left */
0, priv->top,
priv->left, ey,
0.0, ty1,
tx1, ty2,
/* center */
priv->left, priv->top,
ex, ey,
tx1, ty1,
tx2, ty2,
/* mid right */
ex, priv->top,
MAX (ex + priv->right, width), ey,
tx2, ty1,
1.0, ty2,
/* bottom left */
0, ey,
priv->left, MAX (ey + priv->bottom, height),
0.0, ty2,
tx1, 1.0,
/* bottom center */
priv->left, ey,
ex, MAX (ey + priv->bottom, height),
tx1, ty2,
tx2, 1.0,
/* bottom right */
ex, ey,
MAX (ex + priv->right, width), MAX (ey + priv->bottom, height),
tx2, ty2,
1.0, 1.0
};
cogl_rectangles_with_texture_coords (rectangles, 9);
}
}
static void
mnb_toolbar_background_paint_background (MxWidget *self,
ClutterActor *background,
const ClutterColor *color)
{
MnbToolbarBackgroundPrivate *priv = TOOLBAR_BACKGROUND_PRIVATE (self);
ClutterActor *actor = (ClutterActor *) self;
CoglHandle cogl_texture, cogl_material;
ClutterActorBox box = { 0, };
gfloat width, height;
gfloat tex_width, tex_height;
gfloat ex, ey;
gfloat tx1, ty1, tx2, ty2;
guint8 opacity;
/* Copied from MxWidget:
*
* Default implementation just draws the background
* colour and the image on top
*/
if (color && color->alpha != 0)
{
ClutterColor bg_color = *color;
bg_color.alpha = clutter_actor_get_paint_opacity (actor)
* bg_color.alpha
/ 255;
clutter_actor_get_allocation_box (actor, &box);
width = box.x2 - box.x1;
height = box.y2 - box.y1;
cogl_set_source_color4ub (bg_color.red,
bg_color.green,
bg_color.blue,
bg_color.alpha);
cogl_rectangle (0, 0, width, height);
}
/*
* Copied from MxTextureFrame
*/
/* no need to paint stuff if we don't have a texture */
if (G_UNLIKELY (priv->parent_texture == NULL))
return;
cogl_texture = clutter_texture_get_cogl_texture (priv->parent_texture);
if (cogl_texture == COGL_INVALID_HANDLE)
return;
cogl_material = clutter_texture_get_cogl_material (priv->parent_texture);
if (cogl_material == COGL_INVALID_HANDLE)
return;
tex_width = cogl_texture_get_width (cogl_texture);
tex_height = cogl_texture_get_height (cogl_texture);
clutter_actor_get_allocation_box (actor, &box);
width = box.x2 - box.x1;
height = box.y2 - box.y1;
opacity = clutter_actor_get_paint_opacity (actor);
/* Paint using the parent texture's material. It should already have
the cogl texture set as the first layer */
/* NB: for correct blending we need set a preumultiplied color here: */
cogl_material_set_color4ub (cogl_material,
opacity, opacity, opacity, opacity);
selector_texture = mnb_toolbar_get_selector_texture (priv->toolbar);
cogl_material_set_layer (cogl_material, 1, selector_texture);
cogl_material_set_layer_wrap_mode (cogl_material, 1,
COGL_MATERIAL_WRAP_MODE_CLAMP_TO_EDGE);
if (!cogl_material_set_layer_combine (cogl_material, 1,
"RGBA = MODULATE(PREVIOUS,TEXTURE)",
&error))
{
g_warning (G_STRLOC ": Error setting layer combine blend string: %s",
error->message);
g_error_free (error);
}
cogl_set_source (cogl_material);
/* simple stretch */
if (priv->left == 0 && priv->right == 0 && priv->top == 0
&& priv->bottom == 0)
{
float spot_width, spot_height;
float coords[8] = {
0, 0, 1, 1,
0, 0, 0, 0
};
mnb_toolbar_get_selector_allocation_box (priv->toolbar, &box);
spot_width = box.x2 - box.x1;
spot_height = box.y2 - box.y1;
coords[4] = -(box.x1 / width) * (width / spot_width);
coords[5] = -(box.y1 / height) * (height / spot_height);
coords[6] = width / spot_width - (box.x1 / width) * (width / spot_width);
coords[7] = height / spot_height - (box.y1 / height) * (height / spot_height);
cogl_rectangle_with_multitexture_coords (0, 0, width, height, coords, 8);
return;
}
tx1 = priv->left / tex_width;
tx2 = (tex_width - priv->right) / tex_width;
ty1 = priv->top / tex_height;
ty2 = (tex_height - priv->bottom) / tex_height;
ex = width - priv->right;
if (ex < priv->left)
ex = priv->left;
ey = height - priv->bottom;
if (ey < priv->top)
ey = priv->top;
{
GLfloat rectangles[] =
{
/* top left corner */
0, 0,
priv->left, priv->top,
0.0, 0.0,
tx1, ty1,
/* top middle */
priv->left, 0,
MAX (priv->left, ex), priv->top,
tx1, 0.0,
tx2, ty1,
/* top right */
ex, 0,
MAX (ex + priv->right, width), priv->top,
tx2, 0.0,
1.0, ty1,
/* mid left */
0, priv->top,
priv->left, ey,
0.0, ty1,
tx1, ty2,
/* center */
priv->left, priv->top,
ex, ey,
tx1, ty1,
tx2, ty2,
/* mid right */
ex, priv->top,
MAX (ex + priv->right, width), ey,
tx2, ty1,
1.0, ty2,
/* bottom left */
0, ey,
priv->left, MAX (ey + priv->bottom, height),
0.0, ty2,
tx1, 1.0,
/* bottom center */
priv->left, ey,
ex, MAX (ey + priv->bottom, height),
tx1, ty2,
tx2, 1.0,
/* bottom right */
ex, ey,
MAX (ex + priv->right, width), MAX (ey + priv->bottom, height),
tx2, ty2,
1.0, 1.0
};
cogl_rectangles_with_texture_coords (rectangles, 9);
}
}
static void
image_free_gl_resources (GlideImage *image)
{
if (image->priv->material != COGL_INVALID_HANDLE)
cogl_material_set_layer (image->priv->material, 0, COGL_INVALID_HANDLE);
}
void
test_cogl_vertex_buffer_contiguous (TestUtilsGTestFixture *fixture,
void *data)
{
TestState state;
ClutterActor *stage;
ClutterColor stage_clr = {0x0, 0x0, 0x0, 0xff};
ClutterActor *group;
unsigned int idle_source;
guchar tex_data[] = {
0xff, 0x00, 0x00, 0xff,
0xff, 0x00, 0x00, 0xff,
0x00, 0xff, 0x00, 0xff,
0x00, 0xff, 0x00, 0xff
};
stage = clutter_stage_get_default ();
clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_clr);
clutter_actor_get_geometry (stage, &state.stage_geom);
group = clutter_group_new ();
clutter_actor_set_size (group,
state.stage_geom.width,
state.stage_geom.height);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), group);
/* We force continuous redrawing incase someone comments out the
* clutter_main_quit and wants visual feedback for the test since we
* wont be doing anything else that will trigger redrawing. */
idle_source = g_idle_add (queue_redraw, stage);
g_signal_connect (group, "paint", G_CALLBACK (on_paint), &state);
state.texture = cogl_texture_new_from_data (2, 2,
COGL_TEXTURE_NO_SLICING,
COGL_PIXEL_FORMAT_RGBA_8888,
COGL_PIXEL_FORMAT_ANY,
0, /* auto calc row stride */
tex_data);
state.material = cogl_material_new ();
cogl_material_set_color4ub (state.material, 0x00, 0xff, 0x00, 0xff);
cogl_material_set_layer (state.material, 0, state.texture);
{
GLfloat triangle_verts[3][2] =
{
{0.0, 0.0},
{100.0, 100.0},
{0.0, 100.0}
};
GLbyte triangle_colors[3][4] =
{
{0x00, 0x00, 0xff, 0xff}, /* blue */
{0x00, 0x00, 0xff, 0x00}, /* transparent blue */
{0x00, 0x00, 0xff, 0x00} /* transparent blue */
};
GLfloat triangle_tex_coords[3][2] =
{
{0.0, 0.0},
{1.0, 1.0},
{0.0, 1.0}
};
state.buffer = cogl_vertex_buffer_new (3 /* n vertices */);
cogl_vertex_buffer_add (state.buffer,
"gl_Vertex",
2, /* n components */
GL_FLOAT,
FALSE, /* normalized */
0, /* stride */
triangle_verts);
cogl_vertex_buffer_add (state.buffer,
"gl_Color::blue",
4, /* n components */
GL_UNSIGNED_BYTE,
FALSE, /* normalized */
0, /* stride */
triangle_colors);
cogl_vertex_buffer_add (state.buffer,
"gl_MultiTexCoord0",
2, /* n components */
GL_FLOAT,
FALSE, /* normalized */
0, /* stride */
triangle_tex_coords);
cogl_vertex_buffer_submit (state.buffer);
}
clutter_actor_show_all (stage);
clutter_main ();
cogl_handle_unref (state.buffer);
cogl_handle_unref (state.material);
cogl_handle_unref (state.texture);
g_source_remove (idle_source);
if (g_test_verbose ())
g_print ("OK\n");
}
static void
on_paint (ClutterActor *actor, TestState *state)
{
CoglHandle tex0, tex1;
CoglHandle material;
gboolean status;
GError *error = NULL;
float tex_coords[] = {
0, 0, 0.5, 0.5, /* tex0 */
0.5, 0.5, 1, 1 /* tex1 */
};
/* XXX:
* We haven't always had good luck with GL drivers implementing glReadPixels
* reliably and skipping the first two frames improves our chances... */
if (state->frame++ <= 2)
{
g_usleep (G_USEC_PER_SEC);
return;
}
tex0 = make_texture (0x00);
tex1 = make_texture (0x11);
material = cogl_material_new ();
/* An arbitrary color which should be replaced by the first texture layer */
cogl_material_set_color4ub (material, 0x80, 0x80, 0x80, 0x80);
cogl_material_set_blend (material, "RGBA = ADD (SRC_COLOR, 0)", NULL);
cogl_material_set_layer (material, 0, tex0);
cogl_material_set_layer_combine (material, 0,
"RGBA = REPLACE (TEXTURE)", NULL);
cogl_material_set_layer (material, 1, tex1);
status = cogl_material_set_layer_combine (material, 1,
"RGBA = ADD (PREVIOUS, TEXTURE)",
&error);
if (!status)
{
/* It's not strictly a test failure; you need a more capable GPU or
* driver to test this texture combine string. */
g_debug ("Failed to setup texture combine string "
"RGBA = ADD (PREVIOUS, TEXTURE): %s",
error->message);
}
cogl_set_source (material);
cogl_rectangle_with_multitexture_coords (0, 0, QUAD_WIDTH, QUAD_WIDTH,
tex_coords, 8);
cogl_handle_unref (material);
cogl_handle_unref (tex0);
cogl_handle_unref (tex1);
/* See what we got... */
assert_region_color (0, 0, QUAD_WIDTH, QUAD_WIDTH,
0x55, 0x55, 0x55, 0x55);
/* Comment this out if you want visual feedback for what this test paints */
#if 1
clutter_main_quit ();
#endif
}
static void rc_prepare_post_process_lut(RendererClutter *rc)
{
PixbufRenderer *pr = rc->pr;
static guchar clut[CLUT_SIZE * CLUT_SIZE * CLUT_SIZE * 3];
guint r, g, b;
GdkPixbuf *tmp_pixbuf;
CoglHandle material;
CoglHandle tex3d;
DEBUG_3("%s clut start", get_exec_time());
for (r = 0; r < CLUT_SIZE; r++)
{
for (g = 0; g < CLUT_SIZE; g++)
{
for (b = 0; b < CLUT_SIZE; b++)
{
guchar *ptr = clut + ((b * CLUT_SIZE + g) * CLUT_SIZE + r) * 3;
ptr[0] = floor ((double) r / (CLUT_SIZE - 1) * 255.0 + 0.5);
ptr[1] = floor ((double) g / (CLUT_SIZE - 1) * 255.0 + 0.5);
ptr[2] = floor ((double) b / (CLUT_SIZE - 1) * 255.0 + 0.5);
}
}
}
tmp_pixbuf = gdk_pixbuf_new_from_data(clut, GDK_COLORSPACE_RGB, FALSE, 8,
CLUT_SIZE * CLUT_SIZE,
CLUT_SIZE,
CLUT_SIZE * CLUT_SIZE * 3,
NULL, NULL);
if (pr->func_post_process)
{
pr->func_post_process(pr, &tmp_pixbuf, 0, 0, CLUT_SIZE * CLUT_SIZE, CLUT_SIZE, pr->post_process_user_data);
}
g_object_unref(tmp_pixbuf);
DEBUG_3("%s clut upload start", get_exec_time());
#if COGL_VERSION_CHECK(1,18,2)
{
CoglContext *ctx = clutter_backend_get_cogl_context(clutter_get_default_backend ());
tex3d = cogl_texture_3d_new_from_data(ctx,
CLUT_SIZE, CLUT_SIZE, CLUT_SIZE,
COGL_PIXEL_FORMAT_RGB_888,
CLUT_SIZE * 3,
CLUT_SIZE * CLUT_SIZE * 3,
clut,
NULL);
}
#elif COGL_VERSION_CHECK(1,10,4)
{
CoglContext *ctx = clutter_backend_get_cogl_context(clutter_get_default_backend ());
tex3d = cogl_texture_3d_new_from_data(ctx,
CLUT_SIZE, CLUT_SIZE, CLUT_SIZE,
COGL_PIXEL_FORMAT_RGB_888,
COGL_PIXEL_FORMAT_RGB_888,
CLUT_SIZE * 3,
CLUT_SIZE * CLUT_SIZE * 3,
clut,
NULL);
}
#else
tex3d = cogl_texture_3d_new_from_data(CLUT_SIZE, CLUT_SIZE, CLUT_SIZE,
COGL_TEXTURE_NONE,
COGL_PIXEL_FORMAT_RGB_888,
COGL_PIXEL_FORMAT_RGB_888,
CLUT_SIZE * 3,
CLUT_SIZE * CLUT_SIZE * 3,
clut,
NULL);
#endif
material = clutter_texture_get_cogl_material(CLUTTER_TEXTURE(rc->texture));
cogl_material_set_layer(material, 1, tex3d);
cogl_handle_unref(tex3d);
DEBUG_3("%s clut end", get_exec_time());
rc->clut_updated = TRUE;
}
static gboolean
setup_framebuffers (StThemeNodeTransition *transition,
const ClutterActorBox *allocation)
{
StThemeNodeTransitionPrivate *priv = transition->priv;
CoglColor clear_color = { 0, 0, 0, 0 };
guint width, height;
/* template material to avoid unnecessary shader compilation */
static CoglHandle material_template = COGL_INVALID_HANDLE;
width = priv->offscreen_box.x2 - priv->offscreen_box.x1;
height = priv->offscreen_box.y2 - priv->offscreen_box.y1;
g_return_val_if_fail (width > 0, FALSE);
g_return_val_if_fail (height > 0, FALSE);
if (priv->old_texture)
cogl_handle_unref (priv->old_texture);
priv->old_texture = cogl_texture_new_with_size (width, height,
COGL_TEXTURE_NO_SLICING,
COGL_PIXEL_FORMAT_ANY);
if (priv->new_texture)
cogl_handle_unref (priv->new_texture);
priv->new_texture = cogl_texture_new_with_size (width, height,
COGL_TEXTURE_NO_SLICING,
COGL_PIXEL_FORMAT_ANY);
g_return_val_if_fail (priv->old_texture != COGL_INVALID_HANDLE, FALSE);
g_return_val_if_fail (priv->new_texture != COGL_INVALID_HANDLE, FALSE);
if (priv->old_offscreen)
cogl_handle_unref (priv->old_offscreen);
priv->old_offscreen = cogl_offscreen_new_to_texture (priv->old_texture);
if (priv->new_offscreen)
cogl_handle_unref (priv->new_offscreen);
priv->new_offscreen = cogl_offscreen_new_to_texture (priv->new_texture);
g_return_val_if_fail (priv->old_offscreen != COGL_INVALID_HANDLE, FALSE);
g_return_val_if_fail (priv->new_offscreen != COGL_INVALID_HANDLE, FALSE);
if (priv->material == NULL)
{
if (G_UNLIKELY (material_template == COGL_INVALID_HANDLE))
{
material_template = cogl_material_new ();
cogl_material_set_layer_combine (material_template, 0,
"RGBA = REPLACE (TEXTURE)",
NULL);
cogl_material_set_layer_combine (material_template, 1,
"RGBA = INTERPOLATE (PREVIOUS, "
"TEXTURE, "
"CONSTANT[A])",
NULL);
cogl_material_set_layer_combine (material_template, 2,
"RGBA = MODULATE (PREVIOUS, "
"PRIMARY)",
NULL);
}
priv->material = cogl_material_copy (material_template);
}
cogl_material_set_layer (priv->material, 0, priv->new_texture);
cogl_material_set_layer (priv->material, 1, priv->old_texture);
cogl_push_framebuffer (priv->old_offscreen);
cogl_clear (&clear_color, COGL_BUFFER_BIT_COLOR);
cogl_ortho (priv->offscreen_box.x1, priv->offscreen_box.x2,
priv->offscreen_box.y2, priv->offscreen_box.y1,
0.0, 1.0);
st_theme_node_paint (priv->old_theme_node, allocation, 255);
cogl_pop_framebuffer ();
cogl_push_framebuffer (priv->new_offscreen);
cogl_clear (&clear_color, COGL_BUFFER_BIT_COLOR);
cogl_ortho (priv->offscreen_box.x1, priv->offscreen_box.x2,
priv->offscreen_box.y2, priv->offscreen_box.y1,
0.0, 1.0);
st_theme_node_paint (priv->new_theme_node, allocation, 255);
cogl_pop_framebuffer ();
return TRUE;
}
static void
on_paint (ClutterActor *actor, TestState *state)
{
CoglHandle tex0, tex1;
CoglHandle material;
gboolean status;
GError *error = NULL;
float tex_coords[] = {
0, 0, 0.5, 0.5, /* tex0 */
0.5, 0.5, 1, 1 /* tex1 */
};
tex0 = make_texture (0x00);
tex1 = make_texture (0x11);
material = cogl_material_new ();
/* An arbitrary color which should be replaced by the first texture layer */
cogl_material_set_color4ub (material, 0x80, 0x80, 0x80, 0x80);
cogl_material_set_blend (material, "RGBA = ADD (SRC_COLOR, 0)", NULL);
cogl_material_set_layer (material, 0, tex0);
cogl_material_set_layer_combine (material, 0,
"RGBA = REPLACE (TEXTURE)", NULL);
/* We'll use nearest filtering mode on the textures, otherwise the
edge of the quad can pull in texels from the neighbouring
quarters of the texture due to imprecision */
cogl_material_set_layer_filters (material, 0,
COGL_MATERIAL_FILTER_NEAREST,
COGL_MATERIAL_FILTER_NEAREST);
cogl_material_set_layer (material, 1, tex1);
cogl_material_set_layer_filters (material, 1,
COGL_MATERIAL_FILTER_NEAREST,
COGL_MATERIAL_FILTER_NEAREST);
status = cogl_material_set_layer_combine (material, 1,
"RGBA = ADD (PREVIOUS, TEXTURE)",
&error);
if (!status)
{
/* It's not strictly a test failure; you need a more capable GPU or
* driver to test this texture combine string. */
g_debug ("Failed to setup texture combine string "
"RGBA = ADD (PREVIOUS, TEXTURE): %s",
error->message);
}
cogl_set_source (material);
cogl_rectangle_with_multitexture_coords (0, 0, QUAD_WIDTH, QUAD_WIDTH,
tex_coords, 8);
cogl_handle_unref (material);
cogl_handle_unref (tex0);
cogl_handle_unref (tex1);
/* See what we got... */
assert_region_color (0, 0, QUAD_WIDTH, QUAD_WIDTH,
0x55, 0x55, 0x55, 0x55);
/* Comment this out if you want visual feedback for what this test paints */
#if 1
clutter_main_quit ();
#endif
}
static void
paint_legacy (TestState *state)
{
CoglHandle material = cogl_material_new ();
CoglTexture *tex;
CoglColor color;
CoglError *error = NULL;
CoglHandle shader, program;
cogl_color_init_from_4ub (&color, 0, 0, 0, 255);
cogl_clear (&color, COGL_BUFFER_BIT_COLOR);
/* Set the primary vertex color as red */
cogl_color_set_from_4ub (&color, 0xff, 0x00, 0x00, 0xff);
cogl_material_set_color (material, &color);
/* Override the vertex color in the texture environment with a
constant green color provided by a texture */
tex = create_dummy_texture ();
cogl_material_set_layer (material, 0, tex);
cogl_object_unref (tex);
if (!cogl_material_set_layer_combine (material, 0,
"RGBA=REPLACE(TEXTURE)",
&error))
{
g_warning ("Error setting layer combine: %s", error->message);
g_assert_not_reached ();
}
/* Set up a dummy vertex shader that does nothing but the usual
fixed function transform */
shader = cogl_create_shader (COGL_SHADER_TYPE_VERTEX);
cogl_shader_source (shader,
"void\n"
"main ()\n"
"{\n"
" cogl_position_out = "
"cogl_modelview_projection_matrix * "
"cogl_position_in;\n"
" cogl_color_out = cogl_color_in;\n"
" cogl_tex_coord_out[0] = cogl_tex_coord_in;\n"
"}\n");
cogl_shader_compile (shader);
if (!cogl_shader_is_compiled (shader))
{
char *log = cogl_shader_get_info_log (shader);
g_warning ("Shader compilation failed:\n%s", log);
g_free (log);
g_assert_not_reached ();
}
program = cogl_create_program ();
cogl_program_attach_shader (program, shader);
cogl_program_link (program);
cogl_handle_unref (shader);
/* Draw something using the material */
cogl_set_source (material);
cogl_rectangle (0, 0, 50, 50);
/* Draw it again using the program. It should look exactly the same */
cogl_program_use (program);
cogl_rectangle (50, 0, 100, 50);
cogl_program_use (COGL_INVALID_HANDLE);
cogl_handle_unref (material);
cogl_handle_unref (program);
}
static void
cd_icc_effect_paint_target (ClutterOffscreenEffect *effect)
{
CdIccEffect *self = CD_ICC_EFFECT (effect);
ClutterOffscreenEffectClass *parent;
CoglHandle material;
CoglHandle color_data;
CoglHandle indirect_texture;
GError *error = NULL;
if (self->program == COGL_INVALID_HANDLE)
goto out;
if (self->main_texture_uniform > -1)
cogl_program_set_uniform_1i (self->program,
self->main_texture_uniform,
0);
if (self->color_data1_uniform > -1)
cogl_program_set_uniform_1i (self->program,
self->color_data1_uniform,
1); /* not the layer number, just co-incidence */
if (self->color_data2_uniform > -1)
cogl_program_set_uniform_1i (self->program,
self->color_data2_uniform,
2);
if (self->indirect_texture_uniform > -1)
cogl_program_set_uniform_1i (self->program,
self->indirect_texture_uniform,
3);
material = clutter_offscreen_effect_get_target (effect);
/* get the color textures */
color_data = cd_icc_effect_generate_cogl_color_data ("/usr/share/color/icc/FakeBRG.icc",
&error);
if (color_data == COGL_INVALID_HANDLE)
{
g_warning ("Error creating lookup texture: %s", error->message);
g_error_free (error);
goto out;
}
/* add the texture into the second layer of the material */
cogl_material_set_layer (material, GCM_FSCM_LAYER_COLOR1, color_data);
/* we want to use linear interpolation for the texture */
cogl_material_set_layer_filters (material, GCM_FSCM_LAYER_COLOR1,
COGL_MATERIAL_FILTER_LINEAR,
COGL_MATERIAL_FILTER_LINEAR);
/* clamp to the maximum values */
cogl_material_set_layer_wrap_mode (material, GCM_FSCM_LAYER_COLOR1,
COGL_MATERIAL_WRAP_MODE_CLAMP_TO_EDGE);
cogl_handle_unref (color_data);
/* get the color textures */
color_data = cd_icc_effect_generate_cogl_color_data ("/usr/share/color/icc/FakeRBG.icc",
&error);
if (color_data == COGL_INVALID_HANDLE)
{
g_warning ("Error creating lookup texture: %s", error->message);
g_error_free (error);
goto out;
}
/* add the texture into the second layer of the material */
cogl_material_set_layer (material, GCM_FSCM_LAYER_COLOR2, color_data);
/* we want to use linear interpolation for the texture */
cogl_material_set_layer_filters (material, GCM_FSCM_LAYER_COLOR2,
COGL_MATERIAL_FILTER_LINEAR,
COGL_MATERIAL_FILTER_LINEAR);
/* clamp to the maximum values */
cogl_material_set_layer_wrap_mode (material, GCM_FSCM_LAYER_COLOR2,
COGL_MATERIAL_WRAP_MODE_CLAMP_TO_EDGE);
cogl_handle_unref (color_data);
/* get the indirect texture */
indirect_texture = cd_icc_effect_generate_indirect_data (self, &error);
if (indirect_texture == COGL_INVALID_HANDLE)
{
g_warning ("Error creating indirect texture: %s", error->message);
g_error_free (error);
goto out;
}
/* add the texture into the second layer of the material */
cogl_material_set_layer (material, GCM_FSCM_LAYER_INDIRECT, indirect_texture);
/* we want to use linear interpolation for the texture */
cogl_material_set_layer_filters (material, GCM_FSCM_LAYER_INDIRECT,
COGL_MATERIAL_FILTER_LINEAR,
COGL_MATERIAL_FILTER_LINEAR);
/* clamp to the maximum values */
cogl_material_set_layer_wrap_mode (material, GCM_FSCM_LAYER_INDIRECT,
COGL_MATERIAL_WRAP_MODE_CLAMP_TO_EDGE);
cogl_handle_unref (indirect_texture);
cogl_material_set_user_program (material, self->program);
out:
parent = CLUTTER_OFFSCREEN_EFFECT_CLASS (cd_icc_effect_parent_class);
parent->paint_target (effect);
}
G_MODULE_EXPORT int
test_cogl_multitexture_main (int argc, char *argv[])
{
GError *error = NULL;
ClutterActor *stage;
ClutterColor stage_color = { 0x61, 0x56, 0x56, 0xff };
TestMultiLayerMaterialState *state = g_new0 (TestMultiLayerMaterialState, 1);
gfloat stage_w, stage_h;
gchar **files;
gfloat tex_coords[] =
{
/* tx1 ty1 tx2 ty2 */
0, 0, 1, 1,
0, 0, 1, 1,
0, 0, 1, 1
};
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return 1;
stage = clutter_stage_new ();
clutter_actor_get_size (stage, &stage_w, &stage_h);
clutter_stage_set_title (CLUTTER_STAGE (stage), "Cogl: Multi-texturing");
clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color);
g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
/* We create a non-descript actor that we know doesn't have a
* default paint handler, so that we can easily control
* painting in a paint signal handler, without having to
* sub-class anything etc. */
state->group = clutter_group_new ();
clutter_actor_set_position (state->group, stage_w / 2, stage_h / 2);
g_signal_connect (state->group, "paint",
G_CALLBACK(material_rectangle_paint), state);
files = g_new (gchar*, 4);
files[0] = g_build_filename (TESTS_DATADIR, "redhand_alpha.png", NULL);
files[1] = g_build_filename (TESTS_DATADIR, "redhand.png", NULL);
files[2] = g_build_filename (TESTS_DATADIR, "light0.png", NULL);
files[3] = NULL;
state->alpha_tex =
cogl_texture_new_from_file (files[0],
COGL_TEXTURE_NO_SLICING,
COGL_PIXEL_FORMAT_ANY,
&error);
if (!state->alpha_tex)
g_critical ("Failed to load redhand_alpha.png: %s", error->message);
state->redhand_tex =
cogl_texture_new_from_file (files[1],
COGL_TEXTURE_NO_SLICING,
COGL_PIXEL_FORMAT_ANY,
&error);
if (!state->redhand_tex)
g_critical ("Failed to load redhand.png: %s", error->message);
state->light_tex0 =
cogl_texture_new_from_file (files[2],
COGL_TEXTURE_NO_SLICING,
COGL_PIXEL_FORMAT_ANY,
&error);
if (!state->light_tex0)
g_critical ("Failed to load light0.png: %s", error->message);
state->light_tex1 =
cogl_texture_new_from_file (files[2],
COGL_TEXTURE_NO_SLICING,
COGL_PIXEL_FORMAT_ANY,
&error);
if (!state->light_tex1)
g_critical ("Failed to load light0.png: %s", error->message);
g_strfreev (files);
state->material0 = cogl_material_new ();
cogl_material_set_layer (state->material0, 0, state->alpha_tex);
cogl_material_set_layer (state->material0, 1, state->redhand_tex);
cogl_material_set_layer (state->material0, 2, state->light_tex0);
state->material1 = cogl_material_new ();
cogl_material_set_layer (state->material1, 0, state->alpha_tex);
cogl_material_set_layer (state->material1, 1, state->redhand_tex);
cogl_material_set_layer (state->material1, 2, state->light_tex1);
state->tex_coords = tex_coords;
cogl_matrix_init_identity (&state->tex_matrix0);
cogl_matrix_init_identity (&state->tex_matrix1);
cogl_matrix_init_identity (&state->rot_matrix0);
cogl_matrix_init_identity (&state->rot_matrix1);
cogl_matrix_translate (&state->rot_matrix0, 0.5, 0.5, 0);
cogl_matrix_rotate (&state->rot_matrix0, 10.0, 0, 0, 1.0);
cogl_matrix_translate (&state->rot_matrix0, -0.5, -0.5, 0);
cogl_matrix_translate (&state->rot_matrix1, 0.5, 0.5, 0);
cogl_matrix_rotate (&state->rot_matrix1, -10.0, 0, 0, 1.0);
cogl_matrix_translate (&state->rot_matrix1, -0.5, -0.5, 0);
clutter_actor_set_anchor_point (state->group, 86, 125);
clutter_container_add_actor (CLUTTER_CONTAINER(stage),
state->group);
state->timeline = clutter_timeline_new (2812);
g_signal_connect (state->timeline, "new-frame", G_CALLBACK (frame_cb), state);
clutter_actor_animate_with_timeline (state->group,
CLUTTER_LINEAR,
state->timeline,
"rotation-angle-y", 30.0,
"signal-after::completed",
animation_completed_cb, state,
NULL);
/* start the timeline and thus the animations */
clutter_timeline_start (state->timeline);
clutter_actor_show_all (stage);
clutter_main();
cogl_handle_unref (state->material1);
cogl_handle_unref (state->material0);
cogl_handle_unref (state->alpha_tex);
cogl_handle_unref (state->redhand_tex);
cogl_handle_unref (state->light_tex0);
cogl_handle_unref (state->light_tex1);
g_free (state);
return 0;
}
static void
st_drawing_area_paint (ClutterActor *self)
{
StDrawingArea *area = ST_DRAWING_AREA (self);
StDrawingAreaPrivate *priv = area->priv;
StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (self));
ClutterActorBox allocation_box;
ClutterActorBox content_box;
int width, height;
CoglColor color;
guint8 paint_opacity;
(CLUTTER_ACTOR_CLASS (st_drawing_area_parent_class))->paint (self);
clutter_actor_get_allocation_box (self, &allocation_box);
st_theme_node_get_content_box (theme_node, &allocation_box, &content_box);
width = (int)(0.5 + content_box.x2 - content_box.x1);
height = (int)(0.5 + content_box.y2 - content_box.y1);
if (priv->material == COGL_INVALID_HANDLE)
priv->material = cogl_material_new ();
if (priv->texture != COGL_INVALID_HANDLE &&
(width != cogl_texture_get_width (priv->texture) ||
height != cogl_texture_get_height (priv->texture)))
{
cogl_handle_unref (priv->texture);
priv->texture = COGL_INVALID_HANDLE;
}
if (width > 0 && height > 0)
{
if (priv->texture == COGL_INVALID_HANDLE)
{
priv->texture = cogl_texture_new_with_size (width, height,
COGL_TEXTURE_NONE,
CLUTTER_CAIRO_FORMAT_ARGB32);
priv->needs_repaint = TRUE;
}
if (priv->needs_repaint)
{
cairo_surface_t *surface;
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
priv->context = cairo_create (surface);
priv->in_repaint = TRUE;
priv->needs_repaint = FALSE;
g_signal_emit ((GObject*)area, st_drawing_area_signals[REPAINT], 0);
priv->in_repaint = FALSE;
cairo_destroy (priv->context);
priv->context = NULL;
cogl_texture_set_region (priv->texture, 0, 0, 0, 0, width, height, width, height,
CLUTTER_CAIRO_FORMAT_ARGB32,
cairo_image_surface_get_stride (surface),
cairo_image_surface_get_data (surface));
cairo_surface_destroy (surface);
}
}
cogl_material_set_layer (priv->material, 0, priv->texture);
if (priv->texture)
{
paint_opacity = clutter_actor_get_paint_opacity (self);
cogl_color_set_from_4ub (&color,
paint_opacity, paint_opacity, paint_opacity, paint_opacity);
cogl_material_set_color (priv->material, &color);
cogl_set_source (priv->material);
cogl_rectangle_with_texture_coords (content_box.x1, content_box.y1,
width, height,
0.0f, 0.0f, 1.0f, 1.0f);
}
}
static void
_clutter_stage_wayland_repair_dirty(ClutterStageWayland *stage_wayland,
ClutterStage *stage)
{
CoglMaterial *outline = NULL;
CoglHandle vbo;
float vertices[8], texcoords[8];
CoglMatrix modelview;
cairo_region_t *dirty;
cairo_rectangle_int_t rect;
int i, count;
float width, height;
dirty = stage_wayland->back_buffer->dirty_region;
stage_wayland->back_buffer->dirty_region = NULL;
cairo_region_subtract (dirty, stage_wayland->repaint_region);
width = stage_wayland->allocation.width;
height = stage_wayland->allocation.height;
/* If this is the first time we render, there is no front buffer to
* copy back from, but then the dirty region not covered by the
* repaint should be empty, because we repaint the entire stage.
*
* assert(stage_wayland->front_buffer != NULL) ||
* cairo_region_is_empty(dirty);
*
* FIXME: in test-rotate, the stage never queues a full repaint
* initially, it's restricted to the paint box of it's rotating
* children.
*/
if (!stage_wayland->front_buffer)
return;
outline = cogl_material_new ();
cogl_material_set_layer (outline, 0, stage_wayland->front_buffer->tex);
count = cairo_region_num_rectangles (dirty);
for (i = 0; i < count; i++)
{
cairo_region_get_rectangle (dirty, i, &rect);
vbo = cogl_vertex_buffer_new (4);
vertices[0] = rect.x - 1;
vertices[1] = rect.y - 1;
vertices[2] = rect.x + rect.width + 1;
vertices[3] = rect.y - 1;
vertices[4] = rect.x + rect.width + 1;
vertices[5] = rect.y + rect.height + 1;
vertices[6] = rect.x - 1;
vertices[7] = rect.y + rect.height + 1;
cogl_vertex_buffer_add (vbo,
"gl_Vertex",
2, /* n_components */
COGL_ATTRIBUTE_TYPE_FLOAT,
FALSE, /* normalized */
0, /* stride */
vertices);
texcoords[0] = vertices[0] / width;
texcoords[1] = vertices[1] / height;
texcoords[2] = vertices[2] / width;
texcoords[3] = vertices[3] / height;
texcoords[4] = vertices[4] / width;
texcoords[5] = vertices[5] / height;
texcoords[6] = vertices[6] / width;
texcoords[7] = vertices[7] / height;
cogl_vertex_buffer_add (vbo,
"gl_MultiTexCoord0",
2, /* n_components */
COGL_ATTRIBUTE_TYPE_FLOAT,
FALSE, /* normalized */
0, /* stride */
texcoords);
cogl_vertex_buffer_submit (vbo);
cogl_push_matrix ();
cogl_matrix_init_identity (&modelview);
_clutter_actor_apply_modelview_transform (CLUTTER_ACTOR (stage),
&modelview);
cogl_set_modelview_matrix (&modelview);
cogl_set_source (outline);
cogl_vertex_buffer_draw (vbo, COGL_VERTICES_MODE_TRIANGLE_FAN,
0 , 4);
cogl_pop_matrix ();
cogl_object_unref (vbo);
}
cairo_region_destroy (dirty);
}
static void
mx_texture_frame_paint_texture_internal (CoglHandle material,
CoglHandle texture,
guint8 opacity,
gfloat top,
gfloat right,
gfloat bottom,
gfloat left,
gfloat width,
gfloat height)
{
gfloat tex_width, tex_height;
gfloat ex, ey;
gfloat tx1, ty1, tx2, ty2;
/* apply opacity */
cogl_material_set_color4ub (material, opacity, opacity, opacity, opacity);
/* add the texture */
cogl_material_set_layer (material, 0, texture);
/* set the source */
cogl_set_source (material);
tex_width = cogl_texture_get_width (texture);
tex_height = cogl_texture_get_height (texture);
/* simple stretch */
if (left == 0 && right == 0 && top == 0
&& bottom == 0)
{
cogl_rectangle (0, 0, width, height);
return;
}
tx1 = left / tex_width;
tx2 = (tex_width - right) / tex_width;
ty1 = top / tex_height;
ty2 = (tex_height - bottom) / tex_height;
ex = width - right;
if (ex < left)
ex = left;
ey = height - bottom;
if (ey < top)
ey = top;
{
float rectangles[] =
{
/* top left corner */
0, 0,
left, top,
0.0, 0.0,
tx1, ty1,
/* top middle */
left, 0,
MAX (left, ex), top,
tx1, 0.0,
tx2, ty1,
/* top right */
ex, 0,
MAX (ex + right, width), top,
tx2, 0.0,
1.0, ty1,
/* mid left */
0, top,
left, ey,
0.0, ty1,
tx1, ty2,
/* center */
left, top,
ex, ey,
tx1, ty1,
tx2, ty2,
/* mid right */
ex, top,
MAX (ex + right, width), ey,
tx2, ty1,
1.0, ty2,
/* bottom left */
0, ey,
left, MAX (ey + bottom, height),
0.0, ty2,
tx1, 1.0,
/* bottom center */
left, ey,
ex, MAX (ey + bottom, height),
tx1, ty2,
tx2, 1.0,
/* bottom right */
ex, ey,
MAX (ex + right, width), MAX (ey + bottom, height),
tx2, ty2,
1.0, 1.0
};
cogl_rectangles_with_texture_coords (rectangles, 9);
}
}