static void
mx_deform_bow_tie_dispose (GObject *object)
{
MxDeformBowTiePrivate *priv = MX_DEFORM_BOW_TIE (object)->priv;
if (priv->back_id && priv->back)
{
g_signal_handler_disconnect (priv->back, priv->back_id);
priv->back_id = 0;
}
if (priv->back)
{
CoglHandle material;
/* Reset layer matrix */
material = clutter_texture_get_cogl_material (priv->back);
if (material)
{
CoglMatrix matrix;
cogl_matrix_init_identity (&matrix);
cogl_material_set_layer_matrix (material, 0, &matrix);
}
g_object_remove_weak_pointer (G_OBJECT (priv->back),
(gpointer *)&priv->back);
priv->back = NULL;
}
G_OBJECT_CLASS (mx_deform_bow_tie_parent_class)->dispose (object);
}
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);
}
/* initialize shader for transparency background checker */
static void renderer_clutter_init_checker_shader(RendererClutter *rc)
{
const RendererClutterShaderInfo info = {
16.0, /* checker size */
{0.6, 0.6, 0.6}, /* color 0 */
{0.4, 0.4, 0.4} /* color 1 */
};
rc_set_shader(clutter_texture_get_cogl_material(CLUTTER_TEXTURE(rc->texture)), &info);
}
static void
penge_magic_texture_paint (ClutterActor *actor)
{
ClutterActorBox box;
CoglHandle *material, *tex;
float bw, bh;
float aw, ah;
float v;
float tx1, tx2, ty1, ty2;
guint8 alpha;
clutter_actor_get_allocation_box (actor, &box);
material = clutter_texture_get_cogl_material (CLUTTER_TEXTURE (actor));
tex = clutter_texture_get_cogl_texture (CLUTTER_TEXTURE (actor));
bw = (float) cogl_texture_get_width (tex); /* base texture width */
bh = (float) cogl_texture_get_height (tex); /* base texture height */
aw = (float) (box.x2 - box.x1); /* allocation width */
ah = (float) (box.y2 - box.y1); /* allocation height */
/* no comment */
if ((float)bw/bh < (float)aw/ah)
{
/* fit width */
v = (((float)ah * bw) / ((float)aw * bh)) / 2;
tx1 = 0;
tx2 = 1;
ty1 = (0.5 - v);
ty2 = (0.5 + v);
} else {
/* fit height */
v = (((float)aw * bh) / ((float)ah * bw)) / 2;
tx1 = (0.5 - v);
tx2 = (0.5 + v);
ty1 = 0;
ty2 = 1;
}
alpha = clutter_actor_get_paint_opacity (actor);
cogl_material_set_color4ub (material,
alpha,
alpha,
alpha,
alpha);
cogl_set_source (material);
cogl_rectangle_with_texture_coords (0, 0,
aw, ah,
tx1, ty1,
tx2, ty2);
}
static void
clutter_gst_yv12_glsl_post_paint (ClutterActor *actor,
ClutterGstVideoSink *sink)
{
CoglHandle material;
/* Remove the extra layers */
material = clutter_texture_get_cogl_material (CLUTTER_TEXTURE (actor));
cogl_material_remove_layer (material, 1);
cogl_material_remove_layer (material, 2);
/* disable the shader */
cogl_program_use (COGL_INVALID_HANDLE);
}
static void
mx_deform_bow_tie_texture_reset (ClutterTexture *texture)
{
CoglHandle material;
material = clutter_texture_get_cogl_material (texture);
if (material)
{
CoglMatrix matrix;
cogl_matrix_init_identity (&matrix);
cogl_material_set_layer_matrix (material, 0, &matrix);
}
}
static void
mnb_spinner_paint (ClutterActor *self)
{
MnbSpinnerPrivate *priv = MNB_SPINNER (self)->priv;
MxWidget *widget = MX_WIDGET (self);
ClutterTexture *background;
/*
* This paints border-image.
*/
CLUTTER_ACTOR_CLASS (mnb_spinner_parent_class)->paint (self);
if ((background = (ClutterTexture *) mx_widget_get_background_image (widget)))
{
gint tx_w, tx_h;
gfloat tf_x, tf_y, tf_w, tf_h;
guint8 opacity;
ClutterActorBox box = { 0, };
CoglHandle material;
if (!CLUTTER_IS_TEXTURE (background))
return;
opacity = clutter_actor_get_paint_opacity (self);
if (opacity == 0)
return;
clutter_texture_get_base_size (background, &tx_w, &tx_h);
material = clutter_texture_get_cogl_material (background);
cogl_material_set_color4ub (material, opacity, opacity, opacity, opacity);
clutter_actor_get_allocation_box (self, &box);
tf_x = (gfloat)priv->frame / (gfloat) priv->n_frames;
tf_y = 0.0;
tf_w = tf_x + 1.0 / priv->n_frames;
tf_h = 1.0;
/* Paint will have translated us */
cogl_set_source (material);
cogl_rectangle_with_texture_coords (0.0, 0.0,
box.x2 - box.x1,
box.y2 - box.y1,
tf_x, tf_y, tf_w, tf_h);
}
}
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
mx_deform_bow_tie_texture_vflip (ClutterTexture *texture)
{
CoglHandle material;
material = clutter_texture_get_cogl_material (texture);
if (material)
{
CoglMatrix matrix;
cogl_matrix_init_identity (&matrix);
/* Vflip */
cogl_matrix_scale (&matrix, 1.f, -1.f, 1.f);
cogl_matrix_translate (&matrix, 0.f, 1.f, 0.f);
cogl_material_set_layer_matrix (material, 0, &matrix);
}
}
static void
clutter_gst_yv12_fp_post_paint (ClutterActor *actor,
ClutterGstVideoSink *sink)
{
CoglHandle material;
/* 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 ();
/* Remove the extra layers */
material = clutter_texture_get_cogl_material (CLUTTER_TEXTURE (actor));
cogl_material_remove_layer (material, 1);
cogl_material_remove_layer (material, 2);
/* Disable the shader */
glDisable (GL_FRAGMENT_PROGRAM_ARB);
}
static void trickplay_webgl_canvas_paint (ClutterActor *self)
{
ClutterTexture *texture = CLUTTER_TEXTURE (self);
guint8 paint_opacity = clutter_actor_get_paint_opacity (self);
CoglMaterial * material = ( CoglMaterial * ) clutter_texture_get_cogl_material( texture );
cogl_material_set_color4ub (material,
paint_opacity,
paint_opacity,
paint_opacity,
paint_opacity);
cogl_set_source (material);
ClutterActorBox box;
clutter_actor_get_allocation_box (self, &box);
cogl_rectangle_with_texture_coords ( 0 , 0 , box.x2 - box.x1 , box.y2 - box.y1 ,
0, 1, 1, 0);
}
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 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 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);
}
}
/*
* Paints the provided texture frame trimming to the area indicated by padding.
*
* (Basically, we have one asset that gets split into two parts: an border area
* that matches the padding, and the inside; MplPanelBackground paints the
* latter, while the border is painted by the compositor as the window shadow.)
*/
static void
mpl_panel_background_paint_border_image (CoglHandle *frame,
MxPadding *padding)
{
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;
gfloat left = 4, right = 4 , top = 4, bottom =4;
guint8 opacity;
ClutterTexture *parent_texture;
gfloat margin_l, margin_r, margin_t, margin_b;
parent_texture = mx_texture_frame_get_parent_texture (frame);
mx_texture_frame_get_border_values (frame, &top, &right, &bottom, &left);
/* no need to paint stuff if we don't have a texture */
if (G_UNLIKELY (parent_texture == NULL))
return;
/* parent texture may have been hidden, so need to make sure it gets
* realized
*/
if (!CLUTTER_ACTOR_IS_REALIZED (parent_texture))
clutter_actor_realize (CLUTTER_ACTOR (parent_texture));
cogl_texture = clutter_texture_get_cogl_texture (parent_texture);
if (cogl_texture == COGL_INVALID_HANDLE)
return;
cogl_material = clutter_texture_get_cogl_material (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 ((ClutterActor*) frame, &box);
width = box.x2 - box.x1;
height = box.y2 - box.y1;
/*
* These are the margins we are to trim expressed in texture coordinates.
*/
margin_l = padding->left / tex_width;
margin_r = padding->right / tex_width;
margin_t = padding->top / tex_height;
margin_b = padding->bottom / tex_height;
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 < 0)
ex = right;
ey = height - bottom;
if (ey < 0)
ey = bottom;
opacity = clutter_actor_get_paint_opacity ((ClutterActor*)frame);
cogl_material_set_color4ub (cogl_material,
opacity, opacity, opacity, opacity);
cogl_set_source (cogl_material);
cogl_material_set_layer_filters (cogl_material,
0,
COGL_MATERIAL_FILTER_NEAREST,
COGL_MATERIAL_FILTER_NEAREST);
{
GLfloat rectangles[] =
{
/* top left corner */
0.0, 0.0, left, top,
margin_l, margin_t,
tx1, ty1,
/* top middle */
left, 0.0, ex, top,
tx1, margin_t,
tx2, ty1,
/* top right */
ex, 0.0, width, top,
tx2, margin_t,
1.0 - margin_r, ty1,
/* mid left */
0.0, top, left, ey,
margin_l, ty1,
tx1, ty2,
/* center */
left, top, ex, ey,
tx1, ty1,
tx2, ty2,
/* mid right */
ex, top, width, ey,
tx2, ty1,
1.0 - margin_r, ty2,
/* bottom left */
0.0, ey, left, height,
margin_l, ty2,
tx1, 1.0 - margin_b,
/* bottom center */
left, ey, ex, height,
tx1, ty2,
tx2, 1.0 - margin_b,
/* bottom right */
ex, ey, width, height,
tx2, ty2,
1.0 - margin_r, 1.0 - margin_b
};
cogl_rectangles_with_texture_coords (rectangles, 9);
}
}
static void _clone_paint_cb (ClutterActor *actor) {
ClutterActor *source;
ClutterActorBox box;
CoglHandle material;
gfloat width, height;
guint8 opacity;
CoglColor color_1, color_2;
CoglTextureVertex vertices[4];
/* if we don't have a source actor, don't paint */
source = clutter_clone_get_source (CLUTTER_CLONE (actor));
if (source == NULL)
goto out;
/* if the source texture does not have any content, don't paint */
material = clutter_texture_get_cogl_material (CLUTTER_TEXTURE (source));
if (material == NULL)
goto out;
/* get the size of the reflection */
clutter_actor_get_allocation_box (actor, &box);
clutter_actor_box_get_size (&box, &width, &height);
/* get the composite opacity of the actor */
opacity = clutter_actor_get_paint_opacity (actor);
/* figure out the two colors for the reflection: the first is
* full color and the second is the same, but at 0 opacity
*/
cogl_color_init_from_4f (&color_1, 1.0, 1.0, 1.0, opacity / 255.0);
cogl_color_premultiply (&color_1);
cogl_color_init_from_4f (&color_2, 1.0, 1.0, 1.0, 0.0);
cogl_color_premultiply (&color_2);
/* now describe the four vertices of the quad; since it has
* to be a reflection, we need to invert it as well
*/
vertices[0].x = 0; vertices[0].y = 0; vertices[0].z = 0;
vertices[0].tx = 0.0; vertices[0].ty = 1.0;
vertices[0].color = color_1;
vertices[1].x = width; vertices[1].y = 0; vertices[1].z = 0;
vertices[1].tx = 1.0; vertices[1].ty = 1.0;
vertices[1].color = color_1;
vertices[2].x = width; vertices[2].y = height; vertices[2].z = 0;
vertices[2].tx = 1.0; vertices[2].ty = 0.0;
vertices[2].color = color_2;
vertices[3].x = 0; vertices[3].y = height; vertices[3].z = 0;
vertices[3].tx = 0.0; vertices[3].ty = 0.0;
vertices[3].color = color_2;
/* paint the same texture but with a different geometry */
cogl_set_source (material);
cogl_polygon (vertices, 4, TRUE);
out:
/* prevent the default clone handler from running */
g_signal_stop_emission_by_name (actor, "paint");
}
