static void
set_focal_parameters (CoglPipeline *pipeline,
float focal_distance,
float depth_of_field)
{
int location;
float distance;
/* I want to have the focal distance as positive when it's in front of the
* camera (it seems more natural, but as, in OpenGL, the camera is facing
* the negative Ys, the actual value to give to the shader has to be
* negated */
distance = -focal_distance;
location = cogl_pipeline_get_uniform_location (pipeline,
"dof_focal_distance");
cogl_pipeline_set_uniform_float (pipeline,
location,
1 /* n_components */, 1 /* count */,
&distance);
location = cogl_pipeline_get_uniform_location (pipeline,
"dof_depth_of_field");
cogl_pipeline_set_uniform_float (pipeline,
location,
1 /* n_components */, 1 /* count */,
&depth_of_field);
}
static void
paint_vector_pipeline (CoglPipeline *pipeline)
{
float vector_array_values[] = { 1.0f, 0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f };
float short_vector_values[] = { 0.0f, 0.0f, 1.0f };
int uniform_location;
uniform_location =
cogl_pipeline_get_uniform_location (pipeline, "vector_array");
cogl_pipeline_set_uniform_float (pipeline,
uniform_location,
4, /* n_components */
2, /* count */
vector_array_values);
uniform_location =
cogl_pipeline_get_uniform_location (pipeline, "short_vector");
cogl_pipeline_set_uniform_float (pipeline,
uniform_location,
3, /* n_components */
1, /* count */
short_vector_values);
paint_pipeline (pipeline, 13);
}
static void
update_unshaded_uniform (ShellGridDesaturateEffect *self)
{
float values[4] = { 0., 0., 0., 0.};
ClutterOffscreenEffect *offscreen_effect = CLUTTER_OFFSCREEN_EFFECT (self);
CoglHandle texture;
float width, height;
if (self->unshaded_uniform == -1)
return;
texture = clutter_offscreen_effect_get_texture (offscreen_effect);
if (texture == COGL_INVALID_HANDLE)
goto out;
width = cogl_texture_get_width (texture);
height = cogl_texture_get_height (texture);
values[0] = MIN (1.0, self->unshaded_rect->origin.x / width);
values[1] = MIN (1.0, self->unshaded_rect->origin.y / height);
values[2] = MIN (1.0, (self->unshaded_rect->origin.x + self->unshaded_rect->size.width) / width);
values[3] = MIN (1.0, (self->unshaded_rect->origin.y + self->unshaded_rect->size.height) / height);
self->unshaded_uniform_dirty = FALSE;
out:
cogl_pipeline_set_uniform_float (self->pipeline,
self->unshaded_uniform,
4, 1,
values);
}
static void
set_blurrer_pipeline_texture (CoglPipeline *pipeline,
CoglTexture *source,
float x_pixel_step,
float y_pixel_step)
{
float pixel_step[2];
int pixel_step_location;
/* our input in the source texture */
cogl_pipeline_set_layer_texture (pipeline,
0, /* layer_num */
source);
pixel_step[0] = x_pixel_step;
pixel_step[1] = y_pixel_step;
pixel_step_location =
cogl_pipeline_get_uniform_location (pipeline, "pixel_step");
g_assert (pixel_step_location);
cogl_pipeline_set_uniform_float (pipeline,
pixel_step_location,
2, /* n_components */
1, /* count */
pixel_step);
}
static void
set_blurrer_pipeline_factors (CoglPipeline *pipeline, int n_taps)
{
int i, radius;
float *factors, sigma;
int location;
float sum;
float scale;
radius = n_taps / 2; /* which is (n_taps - 1) / 2 as well */
factors = g_alloca (n_taps * sizeof (float));
sigma = n_taps_to_sigma (n_taps);
sum = 0;
for (i = -radius; i <= radius; i++)
{
factors[i + radius] = gaussian (sigma, i);
sum += factors[i + radius];
}
/* So that we don't loose any brightness when blurring, we
* normalized the factors... */
scale = 1.0 / sum;
for (i = -radius; i <= radius; i++)
factors[i + radius] *= scale;
location = cogl_pipeline_get_uniform_location (pipeline, "factors");
cogl_pipeline_set_uniform_float (pipeline,
location,
1 /* n_components */,
n_taps /* count */,
factors);
}
void
rut_light_set_uniforms (RutLight *light,
CoglPipeline *pipeline)
{
RutComponentableProps *component =
rut_object_get_properties (light, RUT_INTERFACE_ID_COMPONENTABLE);
RutEntity *entity = component->entity;
float origin[3] = {0, 0, 0};
float norm_direction[3] = {0, 0, 1};
int location;
rut_entity_get_transformed_position (entity, origin);
rut_entity_get_transformed_position (entity, norm_direction);
cogl_vector3_subtract (norm_direction, norm_direction, origin);
cogl_vector3_normalize (norm_direction);
location = cogl_pipeline_get_uniform_location (pipeline,
"light0_direction_norm");
cogl_pipeline_set_uniform_float (pipeline,
location,
3, 1,
norm_direction);
location = cogl_pipeline_get_uniform_location (pipeline,
"light0_ambient");
cogl_pipeline_set_uniform_float (pipeline,
location,
4, 1,
get_color_array (&light->ambient));
location = cogl_pipeline_get_uniform_location (pipeline,
"light0_diffuse");
cogl_pipeline_set_uniform_float (pipeline,
location,
4, 1,
get_color_array (&light->diffuse));
location = cogl_pipeline_get_uniform_location (pipeline,
"light0_specular");
cogl_pipeline_set_uniform_float (pipeline,
location,
4, 1,
get_color_array (&light->specular));
}
/**
* shell_glsl_quad_set_uniform_float:
* @quad: a #ShellGLSLQuad
* @uniform: the uniform location (as returned by shell_glsl_quad_get_uniform_location())
* @n_components: the number of components in the uniform (eg. 3 for a vec3)
* @total_count: the total number of floats in @value
* @value: (array length=total_count): the array of floats to set @uniform
*/
void
shell_glsl_quad_set_uniform_float (ShellGLSLQuad *quad,
int uniform,
int n_components,
int total_count,
const float *value)
{
cogl_pipeline_set_uniform_float (quad->priv->pipeline, uniform,
n_components, total_count / n_components,
value);
}
/**
* shell_glsl_quad_set_uniform_float:
* @quad: a #ShellGLSLQuad
* @uniform: the uniform location (as returned by shell_glsl_quad_get_uniform_location())
* @n_components: the number of components in the uniform (eg. 3 for a vec3)
* @total_count: the total number of floats in @value
* @value: (array length=total_count): the array of floats to set @uniform
*/
void
shell_glsl_quad_set_uniform_float (ShellGLSLQuad *quad,
int uniform,
int n_components,
int total_count,
const float *value)
{
ShellGLSLQuadPrivate *priv = shell_glsl_quad_get_instance_private (quad);
cogl_pipeline_set_uniform_float (priv->pipeline, uniform,
n_components, total_count / n_components,
value);
}
static void
paint (CoglFramebuffer *fb,
const CoglGstRectangle *video_output,
void *user_data)
{
Data *data = user_data;
CoglPipeline *pipeline;
pipeline = cogl_pipeline_copy (data->pipeline);
cogl_gst_video_sink_attach_frame (data->sink, pipeline);
cogl_object_unref (data->pipeline);
data->pipeline = pipeline;
if (data->last_output_width != video_output->width ||
data->last_output_height != video_output->height)
{
int location =
cogl_pipeline_get_uniform_location (pipeline, "pixel_step");
if (location != -1)
{
float value[2] =
{
1.0f / video_output->width,
1.0f / video_output->height
};
cogl_pipeline_set_uniform_float (pipeline,
location,
2, /* n_components */
1, /* count */
value);
}
data->last_output_width = video_output->width;
data->last_output_height = video_output->height;
}
borders_draw (data->borders, fb, video_output);
cogl_framebuffer_draw_rectangle (fb,
pipeline,
video_output->x,
video_output->y,
video_output->x +
video_output->width,
video_output->y +
video_output->height);
}
static void
update_tint_uniform (ClutterColorizeEffect *self)
{
if (self->tint_uniform > -1)
{
float tint[3] = {
self->tint.red / 255.0,
self->tint.green / 255.0,
self->tint.blue / 255.0
};
cogl_pipeline_set_uniform_float (self->pipeline,
self->tint_uniform,
3, /* n_components */
1, /* count */
tint);
}
}
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;
}
}
