static void
st_background_effect_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
StBackgroundEffect *self = ST_BACKGROUND_EFFECT (gobject);
switch (prop_id)
{
case PROP_BUMPMAP:
self->bumpmap_location = g_value_dup_string (value);
if (self->bg_bumpmap != NULL)
{
cogl_handle_unref (self->bg_bumpmap);
self->bg_bumpmap = NULL;
}
if (self->bumpmap_location == NULL)
{
break;
}
GFile *file = g_file_new_for_path (g_strdup (self->bumpmap_location));
if (g_file_query_exists (file, NULL))
{
self->bg_bumpmap = cogl_texture_new_from_file (self->bumpmap_location,
COGL_TEXTURE_NO_SLICING,
COGL_PIXEL_FORMAT_RGBA_8888_PRE,
NULL);
}
g_object_unref (file);
if (self->bg_bumpmap != NULL)
{
self->bumptex_width_i = cogl_texture_get_width (self->bg_bumpmap);
self->bumptex_height_i = cogl_texture_get_height (self->bg_bumpmap);
cogl_pipeline_set_layer_texture (self->pipeline0, 1, self->bg_bumpmap);
}
else
{
cogl_pipeline_set_layer_null_texture (self->pipeline0,
1,
COGL_TEXTURE_TYPE_2D);
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
st_background_effect_dispose (GObject *gobject)
{
StBackgroundEffect *self = ST_BACKGROUND_EFFECT (gobject);
if (self->pipeline0 != NULL)
{
cogl_object_unref (self->pipeline0);
self->pipeline0 = NULL;
}
if (self->pipeline1 != NULL)
{
cogl_object_unref (self->pipeline1);
self->pipeline1 = NULL;
}
if (self->pipeline2 != NULL)
{
cogl_object_unref (self->pipeline2);
self->pipeline2 = NULL;
}
if (self->pipeline3 != NULL)
{
cogl_object_unref (self->pipeline3);
self->pipeline3 = NULL;
}
if (self->pipeline4 != NULL)
{
cogl_object_unref (self->pipeline4);
self->pipeline4 = NULL;
}
if (self->bg_texture != NULL)
{
cogl_handle_unref (self->bg_texture);
self->bg_texture = NULL;
}
if (self->bg_sub_texture != NULL)
{
cogl_handle_unref (self->bg_sub_texture);
self->bg_sub_texture = NULL;
}
if (self->bg_bumpmap != NULL)
{
cogl_handle_unref (self->bg_bumpmap);
self->bg_bumpmap = NULL;
}
G_OBJECT_CLASS (st_background_effect_parent_class)->dispose (gobject);
}
static void
st_background_effect_paint_target (ClutterOffscreenEffect *effect)
{
StBackgroundEffect *self = ST_BACKGROUND_EFFECT (effect);
if ((self->bg_texture != NULL) && (self->opacity == 0xff))
{
cogl_push_source (self->pipeline2);
cogl_rectangle (0.0f, 0.0f, (self->fg_width_i), (self->fg_height_i));
cogl_pop_source ();
CoglOffscreen *vertical_FBO;
vertical_FBO = cogl_offscreen_new_to_texture (self->bg_sub_texture);
cogl_push_framebuffer ((CoglFramebuffer*)vertical_FBO);
cogl_push_source (self->pipeline0);
cogl_rectangle (-1.0f, 1.0f, 1.0f, -1.0f);
cogl_pop_source ();
cogl_pop_framebuffer ();
cogl_handle_unref (vertical_FBO);
cogl_pipeline_set_layer_texture (self->pipeline1, 0, self->bg_sub_texture);
cogl_push_source (self->pipeline1);
cogl_rectangle (4.0f, 4.0f, (self->bg_width_i) + 4.0f,
(self->bg_height_i) + 4.0f);
cogl_pop_source ();
}
cogl_pipeline_set_color4ub (self->pipeline3,
0x00,
0x00,
0x00,
0x80);
cogl_push_source (self->pipeline3);
cogl_rectangle (0.0f, 0.0f, (self->fg_width_i), (self->fg_height_i));
cogl_pop_source ();
clutter_actor_queue_redraw (self->actor);
cogl_pipeline_set_color4ub (self->pipeline4,
self->opacity,
self->opacity,
self->opacity,
self->opacity);
cogl_push_source (self->pipeline4);
cogl_rectangle (0.0f, 0.0f, (self->fg_width_i), (self->fg_height_i));
cogl_pop_source ();
clutter_actor_queue_redraw (self->actor);
}
static void
st_background_effect_get_property (GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
StBackgroundEffect *self = ST_BACKGROUND_EFFECT (gobject);
switch (prop_id)
{
case PROP_BUMPMAP:
g_value_set_string (value, self->bumpmap_location);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static gboolean
st_background_effect_pre_paint (ClutterEffect *effect)
{
StBackgroundEffect *self = ST_BACKGROUND_EFFECT (effect);
ClutterEffectClass *parent_class;
gfloat width;
gfloat height;
gfloat posx;
gfloat posy;
guchar *data;
guint size;
guint rowstride;
glong new_time;
gdouble time_used;
ClutterActor *stage;
gfloat stage_width;
gfloat stage_height;
if (self->bg_bumpmap == NULL)
return FALSE;
if (!clutter_actor_meta_get_enabled (CLUTTER_ACTOR_META (effect)))
return FALSE;
self->actor = clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (effect));
if (self->actor == NULL)
return FALSE;
if (!clutter_feature_available (CLUTTER_FEATURE_SHADERS_GLSL))
{
/* if we don't have support for GLSL shaders then we
* forcibly disable the ActorMeta
*/
g_warning ("Unable to use the ShaderEffect: the graphics hardware "
"or the current GL driver does not implement support "
"for the GLSL shading language.");
clutter_actor_meta_set_enabled (CLUTTER_ACTOR_META (effect), FALSE);
return FALSE;
}
new_time = clock();
time_used = ((double) (new_time - self->old_time)*100) / (double) CLOCKS_PER_SEC;
self->old_time = new_time;
posx = 0.0f;
posy = 0.0f;
width = 0.0f;
height = 0.0f;
stage_width = 0.0f;
stage_height = 0.0f;
clutter_actor_get_transformed_position (self->actor, &posx, &posy);
clutter_actor_get_transformed_size (self->actor, &width, &height);
self->opacity = clutter_actor_get_paint_opacity (self->actor);
stage = clutter_actor_get_stage (self->actor);
clutter_actor_get_size (stage, &stage_width, &stage_height);
if ((posx < 0) || (posy < 0) || ((posx + width) > stage_width) || ((posy + height) > stage_height))
return FALSE;
if (( posx != self->posx_old)
|| ( posy != self->posy_old)
|| ( width != self->width_old)
|| ( height != self->height_old)
|| (time_used > 50.0))
{
self->posx_old = posx;
self->posy_old = posy;
self->width_old = width;
self->height_old = height;
self->bg_posx_i = round(posx)+2;
self->bg_posy_i = round(posy)+2;
self->bg_width_i = round(width)-4;
self->bg_height_i = round(height)-4;
size = (self->bg_width_i) * (self->bg_height_i) * 4;
if (((self->opacity == 0xff) || (self->bg_texture == NULL)) && (size > 400))
{
rowstride = (self->bg_width_i) * 4;
data = g_malloc (size);
cogl_read_pixels (self->bg_posx_i,
self->bg_posy_i,
self->bg_width_i,
self->bg_height_i,
COGL_READ_PIXELS_COLOR_BUFFER,
COGL_PIXEL_FORMAT_RGBA_8888_PRE,
data);
if (data != NULL)
{
if (self->bg_texture != NULL)
{
cogl_handle_unref (self->bg_texture);
self->bg_texture = NULL;
}
self->bg_texture = st_cogl_texture_new_from_data_wrapper (self->bg_width_i,
self->bg_height_i,
COGL_TEXTURE_NO_SLICING,
COGL_PIXEL_FORMAT_RGBA_8888_PRE,
COGL_PIXEL_FORMAT_RGBA_8888_PRE,
rowstride,
data);
g_free (data);
}
}
}
parent_class = CLUTTER_EFFECT_CLASS (st_background_effect_parent_class);
if (parent_class->pre_paint (effect))
{
ClutterOffscreenEffect *offscreen_effect = CLUTTER_OFFSCREEN_EFFECT (effect);
CoglHandle fg_texture;
fg_texture = clutter_offscreen_effect_get_texture (offscreen_effect);
if (fg_texture != COGL_INVALID_HANDLE)
{
self->fg_width_i = cogl_texture_get_width (fg_texture);
self->fg_height_i = cogl_texture_get_height (fg_texture);
if ((self->bg_texture != NULL) && (self->opacity == 0xff))
{
if (self->pixel_step_uniform0 > -1)
{
gfloat pixel_step[3];
pixel_step[0] = 1.0f / (self->bg_width_i);
pixel_step[1] = 1.0f / (self->bg_height_i);
pixel_step[2] = 0.0f;
cogl_pipeline_set_uniform_float (self->pipeline0,
self->pixel_step_uniform0,
3,
1,
pixel_step);
}
if (self->BumpTex_uniform > -1)
{
cogl_pipeline_set_uniform_1i (self->pipeline0,
self->BumpTex_uniform,
1);
}
if (self->bump_step_uniform > -1)
{
gfloat bump_step[2];
bump_step[0] = 1.0f / (self->bumptex_width_i);
bump_step[1] = 1.0f / (self->bumptex_height_i);
cogl_pipeline_set_uniform_float (self->pipeline0,
self->bump_step_uniform,
2,
1,
bump_step);
}
if (self->bg_sub_texture != NULL)
{
cogl_handle_unref (self->bg_sub_texture);
self->bg_sub_texture = NULL;
}
self->bg_sub_texture = st_cogl_texture_new_with_size_wrapper (self->bg_width_i, self->bg_height_i,
COGL_TEXTURE_NO_SLICING,
COGL_PIXEL_FORMAT_RGBA_8888_PRE);
cogl_pipeline_set_layer_texture (self->pipeline0, 0, self->bg_texture);
if (self->pixel_step_uniform1 > -1)
{
gfloat pixel_step[3];
pixel_step[0] = 1.0f / (self->bg_width_i);
pixel_step[1] = 1.0f / (self->bg_height_i);
pixel_step[2] = 1.0f;
cogl_pipeline_set_uniform_float (self->pipeline1,
self->pixel_step_uniform1,
3,
1,
pixel_step);
}
if (self->pixel_step_uniform2 > -1)
{
gfloat pixel_step[3];
pixel_step[0] = 1.0f / (self->fg_width_i);
pixel_step[1] = 1.0f / (self->fg_height_i);
pixel_step[2] = 2.0f;
cogl_pipeline_set_uniform_float (self->pipeline3,
self->pixel_step_uniform2,
3,
1,
pixel_step);
}
}
cogl_pipeline_set_layer_texture (self->pipeline2, 0, fg_texture);
cogl_pipeline_set_layer_texture (self->pipeline3, 0, fg_texture);
cogl_pipeline_set_layer_texture (self->pipeline4, 0, fg_texture);
}
return TRUE;
}
else
{
return FALSE;
}
}
