brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
c129c563f5
mutter/clutter/clutter-desaturate-effect.c

394 lines
11 KiB
C
Raw Normal View History

effect: Add DesaturateEffect A simple shader-based effect that desaturates an actor and its contents based on a controllable factor.
2010-04-09 15:14:21 +00:00
/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2010 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
* Author:
* Emmanuele Bassi <ebassi@linux.intel.com>
*/
/**
* SECTION:clutter-desaturate-effect
* @short_description: A desaturation effect
* @see_also: #ClutterEffect, #ClutterOffscreenEffect
*
* #ClutterDesaturateEffect is a sub-class of #ClutterEffect that
* desaturates the color of an actor and its contents. The strenght
* of the desaturation effect is controllable and animatable through
* the #ClutterDesaturateEffect:factor property.
*
* #ClutterDesaturateEffect is available since Clutter 1.4
*/
#define CLUTTER_DESATURATE_EFFECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_DESATURATE_EFFECT, ClutterDesaturateEffectClass))
#define CLUTTER_IS_DESATURATE_EFFECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_DESATURATE_EFFECT))
#define CLUTTER_DESATURATE_EFFECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_DESATURATE_EFFECT, ClutterDesaturateEffectClass))
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "clutter-desaturate-effect.h"
#include "cogl/cogl.h"
#include "clutter-debug.h"
#include "clutter-enum-types.h"
desaturate-effect: Do not inherit from ShaderEffect Hide the fact that we're using a fragment shader, in case we're able in the future to use a material layer combine function when painting the offscreen target texture.
2010-08-11 13:19:48 +00:00
#include "clutter-offscreen-effect.h"
effect: Add DesaturateEffect A simple shader-based effect that desaturates an actor and its contents based on a controllable factor.
2010-04-09 15:14:21 +00:00
#include "clutter-private.h"
typedef struct _ClutterDesaturateEffectClass ClutterDesaturateEffectClass;
struct _ClutterDesaturateEffect
{
desaturate-effect: Do not inherit from ShaderEffect Hide the fact that we're using a fragment shader, in case we're able in the future to use a material layer combine function when painting the offscreen target texture.
2010-08-11 13:19:48 +00:00
ClutterOffscreenEffect parent_instance;
effect: Add DesaturateEffect A simple shader-based effect that desaturates an actor and its contents based on a controllable factor.
2010-04-09 15:14:21 +00:00
/* a back pointer to our actor, so that we can query it */
ClutterActor *actor;
/* the desaturation factor, also known as "strength" */
gdouble factor;
desaturate-effect: Do not inherit from ShaderEffect Hide the fact that we're using a fragment shader, in case we're able in the future to use a material layer combine function when painting the offscreen target texture.
2010-08-11 13:19:48 +00:00
CoglHandle shader;
CoglHandle program;
gint tex_uniform;
gint factor_uniform;
guint is_compiled : 1;
effect: Add DesaturateEffect A simple shader-based effect that desaturates an actor and its contents based on a controllable factor.
2010-04-09 15:14:21 +00:00
};
struct _ClutterDesaturateEffectClass
{
desaturate-effect: Do not inherit from ShaderEffect Hide the fact that we're using a fragment shader, in case we're able in the future to use a material layer combine function when painting the offscreen target texture.
2010-08-11 13:19:48 +00:00
ClutterOffscreenEffectClass parent_class;
effect: Add DesaturateEffect A simple shader-based effect that desaturates an actor and its contents based on a controllable factor.
2010-04-09 15:14:21 +00:00
};
/* the magic gray vec3 has been taken from the NTSC conversion weights
* as defined by:
*
* "OpenGL Superbible, 4th edition"
* -- Richard S. Wright Jr, Benjamin Lipchak, Nicholas Haemel
* Addison-Wesley
*/
static const gchar *desaturate_glsl_shader =
"uniform sampler2D tex;\n"
"uniform float factor;\n"
"\n"
"vec3 desaturate (const vec3 color, const float desaturation)\n"
"{\n"
" const vec3 gray_conv = vec3 (0.299, 0.587, 0.114);\n"
" vec3 gray = vec3 (dot (gray_conv, color));\n"
" return vec3 (mix (color.rgb, gray, desaturation));\n"
"}\n"
"\n"
"void main ()\n"
"{\n"
" vec4 color = gl_Color * texture2D (tex, vec2 (gl_TexCoord[0].xy));\n"
" color.rgb = desaturate (color.rgb, factor);\n"
" gl_FragColor = color;\n"
"}\n";
enum
{
PROP_0,
Conditionally use g_object_notify_by_pspec This adds a wrapper macro to clutter-private that will use g_object_notify_by_pspec if it's compiled against a version of GLib that is sufficiently new. Otherwise it will notify by the property name as before by extracting the name from the pspec. The objects can then store a static array of GParamSpecs and notify using those as suggested in the documentation for g_object_notify_by_pspec. Note that the name of the variable used for storing the array of GParamSpecs is obj_props instead of properties as used in the documentation because some places in Clutter uses 'properties' as the name of a local variable. Mose of the classes in Clutter have been converted using the script in the bug report. Some classes have not been modified even though the script picked them up as described here: json-generator: We probably don't want to modify the internal copy of JSON behaviour-depth: rectangle: score: stage-manager: These aren't using the separate GParamSpec* variable style. blur-effect: win32/device-manager: Don't actually define any properties even though it has the enum. box-layout: flow-layout: Have some per-child properties that don't work automatically with the script. clutter-model: The script gets confused with ClutterModelIter stage: Script gets confused because PROP_USER_RESIZE doesn't match "user-resizable" test-layout: Don't really want to modify the tests http://bugzilla.clutter-project.org/show_bug.cgi?id=2150
2010-06-21 09:20:32 +00:00
PROP_FACTOR,
PROP_LAST
effect: Add DesaturateEffect A simple shader-based effect that desaturates an actor and its contents based on a controllable factor.
2010-04-09 15:14:21 +00:00
};
Conditionally use g_object_notify_by_pspec This adds a wrapper macro to clutter-private that will use g_object_notify_by_pspec if it's compiled against a version of GLib that is sufficiently new. Otherwise it will notify by the property name as before by extracting the name from the pspec. The objects can then store a static array of GParamSpecs and notify using those as suggested in the documentation for g_object_notify_by_pspec. Note that the name of the variable used for storing the array of GParamSpecs is obj_props instead of properties as used in the documentation because some places in Clutter uses 'properties' as the name of a local variable. Mose of the classes in Clutter have been converted using the script in the bug report. Some classes have not been modified even though the script picked them up as described here: json-generator: We probably don't want to modify the internal copy of JSON behaviour-depth: rectangle: score: stage-manager: These aren't using the separate GParamSpec* variable style. blur-effect: win32/device-manager: Don't actually define any properties even though it has the enum. box-layout: flow-layout: Have some per-child properties that don't work automatically with the script. clutter-model: The script gets confused with ClutterModelIter stage: Script gets confused because PROP_USER_RESIZE doesn't match "user-resizable" test-layout: Don't really want to modify the tests http://bugzilla.clutter-project.org/show_bug.cgi?id=2150
2010-06-21 09:20:32 +00:00
static GParamSpec *obj_props[PROP_LAST];
effect: Add DesaturateEffect A simple shader-based effect that desaturates an actor and its contents based on a controllable factor.
2010-04-09 15:14:21 +00:00
G_DEFINE_TYPE (ClutterDesaturateEffect,
clutter_desaturate_effect,
desaturate-effect: Do not inherit from ShaderEffect Hide the fact that we're using a fragment shader, in case we're able in the future to use a material layer combine function when painting the offscreen target texture.
2010-08-11 13:19:48 +00:00
CLUTTER_TYPE_OFFSCREEN_EFFECT);
effect: Add DesaturateEffect A simple shader-based effect that desaturates an actor and its contents based on a controllable factor.
2010-04-09 15:14:21 +00:00
static gboolean
clutter_desaturate_effect_pre_paint (ClutterEffect *effect)
{
ClutterDesaturateEffect *self = CLUTTER_DESATURATE_EFFECT (effect);
ClutterEffectClass *parent_class;
float factor;
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;
effects: Check before using the cogl_shader_* API Since BlurEffect and DesaturateEffect are using the shader API implicitly and not using ClutterShaderEffect, we need to check if the underlying GL implementation supports the GLSL shading language and warn if not.
2010-08-11 16:25:17 +00:00
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;
}
desaturate-effect: Do not inherit from ShaderEffect Hide the fact that we're using a fragment shader, in case we're able in the future to use a material layer combine function when painting the offscreen target texture.
2010-08-11 13:19:48 +00:00
factor = (float) self->factor;
effect: Add DesaturateEffect A simple shader-based effect that desaturates an actor and its contents based on a controllable factor.
2010-04-09 15:14:21 +00:00
desaturate-effect: Do not inherit from ShaderEffect Hide the fact that we're using a fragment shader, in case we're able in the future to use a material layer combine function when painting the offscreen target texture.
2010-08-11 13:19:48 +00:00
if (self->shader == COGL_INVALID_HANDLE)
{
self->shader = cogl_create_shader (COGL_SHADER_TYPE_FRAGMENT);
cogl_shader_source (self->shader, desaturate_glsl_shader);
effect: Add DesaturateEffect A simple shader-based effect that desaturates an actor and its contents based on a controllable factor.
2010-04-09 15:14:21 +00:00
desaturate-effect: Do not inherit from ShaderEffect Hide the fact that we're using a fragment shader, in case we're able in the future to use a material layer combine function when painting the offscreen target texture.
2010-08-11 13:19:48 +00:00
self->is_compiled = FALSE;
self->tex_uniform = -1;
self->factor_uniform = -1;
}
effect: Add DesaturateEffect A simple shader-based effect that desaturates an actor and its contents based on a controllable factor.
2010-04-09 15:14:21 +00:00
desaturate-effect: Do not inherit from ShaderEffect Hide the fact that we're using a fragment shader, in case we're able in the future to use a material layer combine function when painting the offscreen target texture.
2010-08-11 13:19:48 +00:00
if (self->program == COGL_INVALID_HANDLE)
self->program = cogl_create_program ();
if (!self->is_compiled)
{
g_assert (self->shader != COGL_INVALID_HANDLE);
g_assert (self->program != COGL_INVALID_HANDLE);
cogl_shader_compile (self->shader);
if (!cogl_shader_is_compiled (self->shader))
{
gchar *log_buf = cogl_shader_get_info_log (self->shader);
g_warning (G_STRLOC ": Unable to compile the desaturate shader: %s",
log_buf);
g_free (log_buf);
cogl_handle_unref (self->shader);
cogl_handle_unref (self->program);
self->shader = COGL_INVALID_HANDLE;
self->program = COGL_INVALID_HANDLE;
}
else
{
cogl_program_attach_shader (self->program, self->shader);
cogl_program_link (self->program);
cogl_handle_unref (self->shader);
self->is_compiled = TRUE;
self->tex_uniform =
cogl_program_get_uniform_location (self->program, "tex");
self->factor_uniform =
cogl_program_get_uniform_location (self->program, "factor");
}
}
effect: Add DesaturateEffect A simple shader-based effect that desaturates an actor and its contents based on a controllable factor.
2010-04-09 15:14:21 +00:00
parent_class = CLUTTER_EFFECT_CLASS (clutter_desaturate_effect_parent_class);
return parent_class->pre_paint (effect);
}
static void
desaturate-effect: Do not inherit from ShaderEffect Hide the fact that we're using a fragment shader, in case we're able in the future to use a material layer combine function when painting the offscreen target texture.
2010-08-11 13:19:48 +00:00
clutter_desaturate_effect_paint_target (ClutterOffscreenEffect *effect)
effect: Add DesaturateEffect A simple shader-based effect that desaturates an actor and its contents based on a controllable factor.
2010-04-09 15:14:21 +00:00
{
desaturate-effect: Do not inherit from ShaderEffect Hide the fact that we're using a fragment shader, in case we're able in the future to use a material layer combine function when painting the offscreen target texture.
2010-08-11 13:19:48 +00:00
ClutterDesaturateEffect *self = CLUTTER_DESATURATE_EFFECT (effect);
ClutterOffscreenEffectClass *parent;
CoglHandle material;
if (self->program == COGL_INVALID_HANDLE)
goto out;
cogl_program_use (self->program);
if (self->tex_uniform > -1)
cogl_program_uniform_1i (self->tex_uniform, 0);
if (self->factor_uniform > -1)
cogl_program_uniform_1f (self->factor_uniform, self->factor);
cogl_program_use (COGL_INVALID_HANDLE);
material = clutter_offscreen_effect_get_target (effect);
cogl_material_set_user_program (material, self->program);
out:
parent = CLUTTER_OFFSCREEN_EFFECT_CLASS (clutter_desaturate_effect_parent_class);
parent->paint_target (effect);
}
static void
clutter_desaturate_effect_dispose (GObject *gobject)
{
ClutterDesaturateEffect *self = CLUTTER_DESATURATE_EFFECT (gobject);
if (self->program != COGL_INVALID_HANDLE)
{
cogl_handle_unref (self->program);
self->program = COGL_INVALID_HANDLE;
self->shader = COGL_INVALID_HANDLE;
}
G_OBJECT_CLASS (clutter_desaturate_effect_parent_class)->dispose (gobject);
effect: Add DesaturateEffect A simple shader-based effect that desaturates an actor and its contents based on a controllable factor.
2010-04-09 15:14:21 +00:00
}
static void
clutter_desaturate_effect_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
ClutterDesaturateEffect *effect = CLUTTER_DESATURATE_EFFECT (gobject);
switch (prop_id)
{
case PROP_FACTOR:
clutter_desaturate_effect_set_factor (effect,
g_value_get_double (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
clutter_desaturate_effect_get_property (GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
ClutterDesaturateEffect *effect = CLUTTER_DESATURATE_EFFECT (gobject);
switch (prop_id)
{
case PROP_FACTOR:
g_value_set_double (value, effect->factor);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
clutter_desaturate_effect_class_init (ClutterDesaturateEffectClass *klass)
{
ClutterEffectClass *effect_class = CLUTTER_EFFECT_CLASS (klass);
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
desaturate-effect: Do not inherit from ShaderEffect Hide the fact that we're using a fragment shader, in case we're able in the future to use a material layer combine function when painting the offscreen target texture.
2010-08-11 13:19:48 +00:00
ClutterOffscreenEffectClass *offscreen_class;
effect: Add DesaturateEffect A simple shader-based effect that desaturates an actor and its contents based on a controllable factor.
2010-04-09 15:14:21 +00:00
GParamSpec *pspec;
desaturate-effect: Do not inherit from ShaderEffect Hide the fact that we're using a fragment shader, in case we're able in the future to use a material layer combine function when painting the offscreen target texture.
2010-08-11 13:19:48 +00:00
offscreen_class = CLUTTER_OFFSCREEN_EFFECT_CLASS (klass);
offscreen_class->paint_target = clutter_desaturate_effect_paint_target;
effect: Add DesaturateEffect A simple shader-based effect that desaturates an actor and its contents based on a controllable factor.
2010-04-09 15:14:21 +00:00
effect_class->pre_paint = clutter_desaturate_effect_pre_paint;
gobject_class->set_property = clutter_desaturate_effect_set_property;
gobject_class->get_property = clutter_desaturate_effect_get_property;
desaturate-effect: Do not inherit from ShaderEffect Hide the fact that we're using a fragment shader, in case we're able in the future to use a material layer combine function when painting the offscreen target texture.
2010-08-11 13:19:48 +00:00
gobject_class->dispose = clutter_desaturate_effect_dispose;
effect: Add DesaturateEffect A simple shader-based effect that desaturates an actor and its contents based on a controllable factor.
2010-04-09 15:14:21 +00:00
/**
* ClutterDesaturateEffect:factor:
*
* The desaturation factor, between 0.0 (no desaturation) and 1.0 (full
* desaturation).
*
* Since: 1.4
*/
pspec = g_param_spec_double ("factor",
Mark property strings for translation Both the nick and the blurb fields should be translatable, for UI builders and other introspection-based tools.
2010-06-03 11:57:50 +00:00
P_("Factor"),
P_("The desaturation factor"),
effect: Add DesaturateEffect A simple shader-based effect that desaturates an actor and its contents based on a controllable factor.
2010-04-09 15:14:21 +00:00
0.0, 1.0,
1.0,
CLUTTER_PARAM_READWRITE);
Conditionally use g_object_notify_by_pspec This adds a wrapper macro to clutter-private that will use g_object_notify_by_pspec if it's compiled against a version of GLib that is sufficiently new. Otherwise it will notify by the property name as before by extracting the name from the pspec. The objects can then store a static array of GParamSpecs and notify using those as suggested in the documentation for g_object_notify_by_pspec. Note that the name of the variable used for storing the array of GParamSpecs is obj_props instead of properties as used in the documentation because some places in Clutter uses 'properties' as the name of a local variable. Mose of the classes in Clutter have been converted using the script in the bug report. Some classes have not been modified even though the script picked them up as described here: json-generator: We probably don't want to modify the internal copy of JSON behaviour-depth: rectangle: score: stage-manager: These aren't using the separate GParamSpec* variable style. blur-effect: win32/device-manager: Don't actually define any properties even though it has the enum. box-layout: flow-layout: Have some per-child properties that don't work automatically with the script. clutter-model: The script gets confused with ClutterModelIter stage: Script gets confused because PROP_USER_RESIZE doesn't match "user-resizable" test-layout: Don't really want to modify the tests http://bugzilla.clutter-project.org/show_bug.cgi?id=2150
2010-06-21 09:20:32 +00:00
obj_props[PROP_FACTOR] = pspec;
effect: Add DesaturateEffect A simple shader-based effect that desaturates an actor and its contents based on a controllable factor.
2010-04-09 15:14:21 +00:00
g_object_class_install_property (gobject_class, PROP_FACTOR, pspec);
}
static void
clutter_desaturate_effect_init (ClutterDesaturateEffect *self)
{
self->factor = 1.0;
}
/**
* clutter_desaturate_effect_new:
* @factor: the desaturation factor, between 0.0 and 1.0
*
* Creates a new #ClutterDesaturateEffect to be used with
docs: Effects fixes for the API reference
2010-06-03 13:34:41 +00:00
* clutter_actor_add_effect()
effect: Add DesaturateEffect A simple shader-based effect that desaturates an actor and its contents based on a controllable factor.
2010-04-09 15:14:21 +00:00
*
* Return value: the newly created #ClutterDesaturateEffect or %NULL
*
* Since: 1.4
*/
ClutterEffect *
clutter_desaturate_effect_new (gdouble factor)
{
g_return_val_if_fail (factor >= 0.0 && factor <= 1.0, NULL);
return g_object_new (CLUTTER_TYPE_DESATURATE_EFFECT,
"factor", factor,
NULL);
}
/**
* clutter_desaturate_effect_set_factor:
* @effect: a #ClutterDesaturateEffect
* @factor: the desaturation factor, between 0.0 and 1.0
*
* Sets the desaturation factor for @effect, with 0.0 being "do not desaturate"
* and 1.0 being "fully desaturate"
*
* Since: 1.4
*/
void
clutter_desaturate_effect_set_factor (ClutterDesaturateEffect *effect,
gdouble factor)
{
g_return_if_fail (CLUTTER_IS_DESATURATE_EFFECT (effect));
g_return_if_fail (factor >= 0.0 && factor <= 1.0);
if (fabsf (effect->factor - factor) >= 0.00001)
{
effect->factor = factor;
if (effect->actor != NULL)
clutter_actor_queue_redraw (effect->actor);
Conditionally use g_object_notify_by_pspec This adds a wrapper macro to clutter-private that will use g_object_notify_by_pspec if it's compiled against a version of GLib that is sufficiently new. Otherwise it will notify by the property name as before by extracting the name from the pspec. The objects can then store a static array of GParamSpecs and notify using those as suggested in the documentation for g_object_notify_by_pspec. Note that the name of the variable used for storing the array of GParamSpecs is obj_props instead of properties as used in the documentation because some places in Clutter uses 'properties' as the name of a local variable. Mose of the classes in Clutter have been converted using the script in the bug report. Some classes have not been modified even though the script picked them up as described here: json-generator: We probably don't want to modify the internal copy of JSON behaviour-depth: rectangle: score: stage-manager: These aren't using the separate GParamSpec* variable style. blur-effect: win32/device-manager: Don't actually define any properties even though it has the enum. box-layout: flow-layout: Have some per-child properties that don't work automatically with the script. clutter-model: The script gets confused with ClutterModelIter stage: Script gets confused because PROP_USER_RESIZE doesn't match "user-resizable" test-layout: Don't really want to modify the tests http://bugzilla.clutter-project.org/show_bug.cgi?id=2150
2010-06-21 09:20:32 +00:00
_clutter_notify_by_pspec (G_OBJECT (effect), obj_props[PROP_FACTOR]);
effect: Add DesaturateEffect A simple shader-based effect that desaturates an actor and its contents based on a controllable factor.
2010-04-09 15:14:21 +00:00
}
}
/**
* clutter_desaturate_effect_get_factor:
* @effect: a #ClutterDesaturateEffect
*
* Retrieves the desaturation factor of @effect
*
* Return value: the desaturation factor
*
* Since: 1.4
*/
gdouble
clutter_desaturate_effect_get_factor (ClutterDesaturateEffect *effect)
{
g_return_val_if_fail (CLUTTER_IS_DESATURATE_EFFECT (effect), 0.0);
return effect->factor;
}
Reference in New Issue Copy Permalink