isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-23 16:40:41 -05:00
Code Issues Packages Projects Releases Wiki Activity
3f0ac3548f
mutter/clutter/clutter-effect.c

401 lines
14 KiB
C
Raw Normal View History

Add the ClutterEffect abstract class ClutterEffect is an abstract class that should be used to apply effects on generic actors. The ClutterEffect class just defines what an effect should implement; it could be defined as an interface, but we might want to add some default behavior dependent on the internal state at a later point. The effect API applies to any actor, so we need to provide a way to assign an effect to an actor, and let ClutterActor call the Effect methods during the paint sequence. Once an effect is attached to an actor we will perform the paint in this order: • Effect::pre_paint() • Actor::paint signal emission • Effect::post_paint() Since an effect might collide with the Shader class, we either allow a shader or an effect for the time being.
2010-04-08 05:55:15 -04: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-effect
* @short_description: Base class for actor effects
*
* The #ClutterEffect class provides a default type and API for creating
* effects for generic actors.
*
* Effects are a #ClutterActorMeta sub-class that modify the way an actor
* is painted in a way that is not part of the actor's implementation.
*
* Effects should be the preferred way to affect the paint sequence of an
* actor without sub-classing the actor itself and overriding the
Fixes for the API reference Typos, missing symbols, and missing documentation.
2012-04-19 11:00:23 -04:00
* #ClutterActorClass.paint()_ virtual function.
Add the ClutterEffect abstract class ClutterEffect is an abstract class that should be used to apply effects on generic actors. The ClutterEffect class just defines what an effect should implement; it could be defined as an interface, but we might want to add some default behavior dependent on the internal state at a later point. The effect API applies to any actor, so we need to provide a way to assign an effect to an actor, and let ClutterActor call the Effect methods during the paint sequence. Once an effect is attached to an actor we will perform the paint in this order: • Effect::pre_paint() • Actor::paint signal emission • Effect::post_paint() Since an effect might collide with the Shader class, we either allow a shader or an effect for the time being.
2010-04-08 05:55:15 -04:00
*
* <refsect2 id="ClutterEffect-implementation">
* <title>Implementing a ClutterEffect</title>
clutter-effect: Add a 'run' virtual This adds a new virtual to ClutterEffect which is intended to be a more flexible replacement for the pre and post_paint functions. The implementation of a run virtual would look something like this: void effect_run (ClutterEffect *effect, ClutterEffectRunFlags flags) { /* Set up state */ /* ... */ /* Chain to the next item in the paint sequence */ clutter_actor_continue_paint (priv->actor); /* Clean up state */ /* ... */ } ClutterActor now just calls this virtual instead of the pre_paint and post_paint functions. It keeps track of the next effect in the list so that it knows what to do when clutter_actor_continue_paint is called. clutter_actor_continue_paint is a new function added just for implementing effects. The default implementation of the run virtual just calls pre_paint and post_paint so that existing effects will continue to work. An effect is allowed to conditionally skip calling clutter_actor_continue_paint(). This is useful to implement effects that cache the image of an actor. The flags parameter can be used to determine if the actor is dirty since the last paint. ClutterActor sets this flag whenever propagated_one_redraw is TRUE which means that a redraw for this actor or one of its children was queued.
2011-03-02 11:55:10 -05:00
* <para>
* Creating a sub-class of #ClutterEffect requires overriding the
Rename ClutterEffect::run to ClutterEffect::paint In preparation for adding ClutterEffect::pick https://bugzilla.gnome.org/show_bug.cgi?id=651700
2011-06-06 02:44:11 -04:00
* ‘paint’ method. The implementation of the function should look
clutter-effect: Add a 'run' virtual This adds a new virtual to ClutterEffect which is intended to be a more flexible replacement for the pre and post_paint functions. The implementation of a run virtual would look something like this: void effect_run (ClutterEffect *effect, ClutterEffectRunFlags flags) { /* Set up state */ /* ... */ /* Chain to the next item in the paint sequence */ clutter_actor_continue_paint (priv->actor); /* Clean up state */ /* ... */ } ClutterActor now just calls this virtual instead of the pre_paint and post_paint functions. It keeps track of the next effect in the list so that it knows what to do when clutter_actor_continue_paint is called. clutter_actor_continue_paint is a new function added just for implementing effects. The default implementation of the run virtual just calls pre_paint and post_paint so that existing effects will continue to work. An effect is allowed to conditionally skip calling clutter_actor_continue_paint(). This is useful to implement effects that cache the image of an actor. The flags parameter can be used to determine if the actor is dirty since the last paint. ClutterActor sets this flag whenever propagated_one_redraw is TRUE which means that a redraw for this actor or one of its children was queued.
2011-03-02 11:55:10 -05:00
* something like this:
* </para>
* <programlisting>
effect: Rename RunFlags to PaintFlags Since run() was replaced and both paint() and pick() use the enumeration. https://bugzilla.gnome.org/show_bug.cgi?id=651700
2011-06-13 10:58:46 -04:00
* void effect_paint (ClutterEffect *effect, ClutterEffectPaintFlags flags)
clutter-effect: Add a 'run' virtual This adds a new virtual to ClutterEffect which is intended to be a more flexible replacement for the pre and post_paint functions. The implementation of a run virtual would look something like this: void effect_run (ClutterEffect *effect, ClutterEffectRunFlags flags) { /* Set up state */ /* ... */ /* Chain to the next item in the paint sequence */ clutter_actor_continue_paint (priv->actor); /* Clean up state */ /* ... */ } ClutterActor now just calls this virtual instead of the pre_paint and post_paint functions. It keeps track of the next effect in the list so that it knows what to do when clutter_actor_continue_paint is called. clutter_actor_continue_paint is a new function added just for implementing effects. The default implementation of the run virtual just calls pre_paint and post_paint so that existing effects will continue to work. An effect is allowed to conditionally skip calling clutter_actor_continue_paint(). This is useful to implement effects that cache the image of an actor. The flags parameter can be used to determine if the actor is dirty since the last paint. ClutterActor sets this flag whenever propagated_one_redraw is TRUE which means that a redraw for this actor or one of its children was queued.
2011-03-02 11:55:10 -05:00
* {
* /&ast; Set up initialisation of the paint such as binding a
* CoglOffscreen or other operations &ast;/
*
* /&ast; Chain to the next item in the paint sequence. This will either call
Rename ClutterEffect::run to ClutterEffect::paint In preparation for adding ClutterEffect::pick https://bugzilla.gnome.org/show_bug.cgi?id=651700
2011-06-06 02:44:11 -04:00
* ‘paint’ on the next effect or just paint the actor if this is
clutter-effect: Add a 'run' virtual This adds a new virtual to ClutterEffect which is intended to be a more flexible replacement for the pre and post_paint functions. The implementation of a run virtual would look something like this: void effect_run (ClutterEffect *effect, ClutterEffectRunFlags flags) { /* Set up state */ /* ... */ /* Chain to the next item in the paint sequence */ clutter_actor_continue_paint (priv->actor); /* Clean up state */ /* ... */ } ClutterActor now just calls this virtual instead of the pre_paint and post_paint functions. It keeps track of the next effect in the list so that it knows what to do when clutter_actor_continue_paint is called. clutter_actor_continue_paint is a new function added just for implementing effects. The default implementation of the run virtual just calls pre_paint and post_paint so that existing effects will continue to work. An effect is allowed to conditionally skip calling clutter_actor_continue_paint(). This is useful to implement effects that cache the image of an actor. The flags parameter can be used to determine if the actor is dirty since the last paint. ClutterActor sets this flag whenever propagated_one_redraw is TRUE which means that a redraw for this actor or one of its children was queued.
2011-03-02 11:55:10 -05:00
* the last effect. &ast;/
* ClutterActor *actor =
* clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (effect));
* clutter_actor_continue_paint (actor);
*
* /&ast; perform any cleanup of state, such as popping the
* CoglOffscreen &ast;/
* }
* </programlisting>
* <para>
* The effect can optionally avoid calling
* clutter_actor_continue_paint() to skip any further stages of
* the paint sequence. This is useful for example if the effect
* contains a cached image of the actor. In that case it can
* optimise painting by avoiding the actor paint and instead
docs: Fixes for cross-references
2011-09-12 08:12:14 -04:00
* painting the cached image. The %CLUTTER_EFFECT_PAINT_ACTOR_DIRTY
clutter-effect: Add a 'run' virtual This adds a new virtual to ClutterEffect which is intended to be a more flexible replacement for the pre and post_paint functions. The implementation of a run virtual would look something like this: void effect_run (ClutterEffect *effect, ClutterEffectRunFlags flags) { /* Set up state */ /* ... */ /* Chain to the next item in the paint sequence */ clutter_actor_continue_paint (priv->actor); /* Clean up state */ /* ... */ } ClutterActor now just calls this virtual instead of the pre_paint and post_paint functions. It keeps track of the next effect in the list so that it knows what to do when clutter_actor_continue_paint is called. clutter_actor_continue_paint is a new function added just for implementing effects. The default implementation of the run virtual just calls pre_paint and post_paint so that existing effects will continue to work. An effect is allowed to conditionally skip calling clutter_actor_continue_paint(). This is useful to implement effects that cache the image of an actor. The flags parameter can be used to determine if the actor is dirty since the last paint. ClutterActor sets this flag whenever propagated_one_redraw is TRUE which means that a redraw for this actor or one of its children was queued.
2011-03-02 11:55:10 -05:00
* flag is useful in this case. Clutter will set this flag when a
* redraw has been queued on the actor since it was last
* painted. The effect can use this information to decide if the
* cached image is still valid.
* </para>
* <para>
Rename ClutterEffect::run to ClutterEffect::paint In preparation for adding ClutterEffect::pick https://bugzilla.gnome.org/show_bug.cgi?id=651700
2011-06-06 02:44:11 -04:00
* The ‘paint’ virtual was added in Clutter 1.8. Prior to that there
clutter-effect: Add a 'run' virtual This adds a new virtual to ClutterEffect which is intended to be a more flexible replacement for the pre and post_paint functions. The implementation of a run virtual would look something like this: void effect_run (ClutterEffect *effect, ClutterEffectRunFlags flags) { /* Set up state */ /* ... */ /* Chain to the next item in the paint sequence */ clutter_actor_continue_paint (priv->actor); /* Clean up state */ /* ... */ } ClutterActor now just calls this virtual instead of the pre_paint and post_paint functions. It keeps track of the next effect in the list so that it knows what to do when clutter_actor_continue_paint is called. clutter_actor_continue_paint is a new function added just for implementing effects. The default implementation of the run virtual just calls pre_paint and post_paint so that existing effects will continue to work. An effect is allowed to conditionally skip calling clutter_actor_continue_paint(). This is useful to implement effects that cache the image of an actor. The flags parameter can be used to determine if the actor is dirty since the last paint. ClutterActor sets this flag whenever propagated_one_redraw is TRUE which means that a redraw for this actor or one of its children was queued.
2011-03-02 11:55:10 -05:00
* were two separate functions as follows.
* </para>
Add the ClutterEffect abstract class ClutterEffect is an abstract class that should be used to apply effects on generic actors. The ClutterEffect class just defines what an effect should implement; it could be defined as an interface, but we might want to add some default behavior dependent on the internal state at a later point. The effect API applies to any actor, so we need to provide a way to assign an effect to an actor, and let ClutterActor call the Effect methods during the paint sequence. Once an effect is attached to an actor we will perform the paint in this order: • Effect::pre_paint() • Actor::paint signal emission • Effect::post_paint() Since an effect might collide with the Shader class, we either allow a shader or an effect for the time being.
2010-04-08 05:55:15 -04:00
* <itemizedlist>
* <listitem><simpara><function>pre_paint()</function>, which is called
* before painting the #ClutterActor.</simpara></listitem>
* <listitem><simpara><function>post_paint()</function>, which is called
* after painting the #ClutterActor.</simpara></listitem>
* </itemizedlist>
clutter-effect: Add a 'run' virtual This adds a new virtual to ClutterEffect which is intended to be a more flexible replacement for the pre and post_paint functions. The implementation of a run virtual would look something like this: void effect_run (ClutterEffect *effect, ClutterEffectRunFlags flags) { /* Set up state */ /* ... */ /* Chain to the next item in the paint sequence */ clutter_actor_continue_paint (priv->actor); /* Clean up state */ /* ... */ } ClutterActor now just calls this virtual instead of the pre_paint and post_paint functions. It keeps track of the next effect in the list so that it knows what to do when clutter_actor_continue_paint is called. clutter_actor_continue_paint is a new function added just for implementing effects. The default implementation of the run virtual just calls pre_paint and post_paint so that existing effects will continue to work. An effect is allowed to conditionally skip calling clutter_actor_continue_paint(). This is useful to implement effects that cache the image of an actor. The flags parameter can be used to determine if the actor is dirty since the last paint. ClutterActor sets this flag whenever propagated_one_redraw is TRUE which means that a redraw for this actor or one of its children was queued.
2011-03-02 11:55:10 -05:00
* <para>The <function>pre_paint()</function> function was used to set
Add the ClutterEffect abstract class ClutterEffect is an abstract class that should be used to apply effects on generic actors. The ClutterEffect class just defines what an effect should implement; it could be defined as an interface, but we might want to add some default behavior dependent on the internal state at a later point. The effect API applies to any actor, so we need to provide a way to assign an effect to an actor, and let ClutterActor call the Effect methods during the paint sequence. Once an effect is attached to an actor we will perform the paint in this order: • Effect::pre_paint() • Actor::paint signal emission • Effect::post_paint() Since an effect might collide with the Shader class, we either allow a shader or an effect for the time being.
2010-04-08 05:55:15 -04:00
* up the #ClutterEffect right before the #ClutterActor's paint
docs: Fix Effect subclassing section It still mentions the long since removed "prepare" function.
2010-06-10 12:34:48 -04:00
* sequence. This function can fail, and return %FALSE; in that case, no
* <function>post_paint()</function> invocation will follow.</para>
clutter-effect: Add a 'run' virtual This adds a new virtual to ClutterEffect which is intended to be a more flexible replacement for the pre and post_paint functions. The implementation of a run virtual would look something like this: void effect_run (ClutterEffect *effect, ClutterEffectRunFlags flags) { /* Set up state */ /* ... */ /* Chain to the next item in the paint sequence */ clutter_actor_continue_paint (priv->actor); /* Clean up state */ /* ... */ } ClutterActor now just calls this virtual instead of the pre_paint and post_paint functions. It keeps track of the next effect in the list so that it knows what to do when clutter_actor_continue_paint is called. clutter_actor_continue_paint is a new function added just for implementing effects. The default implementation of the run virtual just calls pre_paint and post_paint so that existing effects will continue to work. An effect is allowed to conditionally skip calling clutter_actor_continue_paint(). This is useful to implement effects that cache the image of an actor. The flags parameter can be used to determine if the actor is dirty since the last paint. ClutterActor sets this flag whenever propagated_one_redraw is TRUE which means that a redraw for this actor or one of its children was queued.
2011-03-02 11:55:10 -05:00
* <para>The <function>post_paint()</function> function was called after the
Add the ClutterEffect abstract class ClutterEffect is an abstract class that should be used to apply effects on generic actors. The ClutterEffect class just defines what an effect should implement; it could be defined as an interface, but we might want to add some default behavior dependent on the internal state at a later point. The effect API applies to any actor, so we need to provide a way to assign an effect to an actor, and let ClutterActor call the Effect methods during the paint sequence. Once an effect is attached to an actor we will perform the paint in this order: • Effect::pre_paint() • Actor::paint signal emission • Effect::post_paint() Since an effect might collide with the Shader class, we either allow a shader or an effect for the time being.
2010-04-08 05:55:15 -04:00
* #ClutterActor's paint sequence.</para>
clutter-effect: Add a 'run' virtual This adds a new virtual to ClutterEffect which is intended to be a more flexible replacement for the pre and post_paint functions. The implementation of a run virtual would look something like this: void effect_run (ClutterEffect *effect, ClutterEffectRunFlags flags) { /* Set up state */ /* ... */ /* Chain to the next item in the paint sequence */ clutter_actor_continue_paint (priv->actor); /* Clean up state */ /* ... */ } ClutterActor now just calls this virtual instead of the pre_paint and post_paint functions. It keeps track of the next effect in the list so that it knows what to do when clutter_actor_continue_paint is called. clutter_actor_continue_paint is a new function added just for implementing effects. The default implementation of the run virtual just calls pre_paint and post_paint so that existing effects will continue to work. An effect is allowed to conditionally skip calling clutter_actor_continue_paint(). This is useful to implement effects that cache the image of an actor. The flags parameter can be used to determine if the actor is dirty since the last paint. ClutterActor sets this flag whenever propagated_one_redraw is TRUE which means that a redraw for this actor or one of its children was queued.
2011-03-02 11:55:10 -05:00
* <para>
* With these two functions it is not possible to skip the rest of
Rename ClutterEffect::run to ClutterEffect::paint In preparation for adding ClutterEffect::pick https://bugzilla.gnome.org/show_bug.cgi?id=651700
2011-06-06 02:44:11 -04:00
* the paint sequence. The default implementation of the ‘paint’
Fixes for the API reference Typos, missing symbols, and missing documentation.
2012-04-19 11:00:23 -04:00
* virtual calls #ClutterEffectClass.pre_paint(), clutter_actor_continue_paint()
* and then #ClutterEffectClass.post_paint() so that existing actors that aren't
* using the #ClutterEffectClass.paint() virtual will continue to work. New
* effects using the #ClutterEffectClass.paint() virtual do not need to implement
* pre or post paint.
clutter-effect: Add a 'run' virtual This adds a new virtual to ClutterEffect which is intended to be a more flexible replacement for the pre and post_paint functions. The implementation of a run virtual would look something like this: void effect_run (ClutterEffect *effect, ClutterEffectRunFlags flags) { /* Set up state */ /* ... */ /* Chain to the next item in the paint sequence */ clutter_actor_continue_paint (priv->actor); /* Clean up state */ /* ... */ } ClutterActor now just calls this virtual instead of the pre_paint and post_paint functions. It keeps track of the next effect in the list so that it knows what to do when clutter_actor_continue_paint is called. clutter_actor_continue_paint is a new function added just for implementing effects. The default implementation of the run virtual just calls pre_paint and post_paint so that existing effects will continue to work. An effect is allowed to conditionally skip calling clutter_actor_continue_paint(). This is useful to implement effects that cache the image of an actor. The flags parameter can be used to determine if the actor is dirty since the last paint. ClutterActor sets this flag whenever propagated_one_redraw is TRUE which means that a redraw for this actor or one of its children was queued.
2011-03-02 11:55:10 -05:00
* </para>
Add the ClutterEffect abstract class ClutterEffect is an abstract class that should be used to apply effects on generic actors. The ClutterEffect class just defines what an effect should implement; it could be defined as an interface, but we might want to add some default behavior dependent on the internal state at a later point. The effect API applies to any actor, so we need to provide a way to assign an effect to an actor, and let ClutterActor call the Effect methods during the paint sequence. Once an effect is attached to an actor we will perform the paint in this order: • Effect::pre_paint() • Actor::paint signal emission • Effect::post_paint() Since an effect might collide with the Shader class, we either allow a shader or an effect for the time being.
2010-04-08 05:55:15 -04:00
* <example id="ClutterEffect-example">
* <title>A simple ClutterEffect implementation</title>
clutter-effect: Add a 'run' virtual This adds a new virtual to ClutterEffect which is intended to be a more flexible replacement for the pre and post_paint functions. The implementation of a run virtual would look something like this: void effect_run (ClutterEffect *effect, ClutterEffectRunFlags flags) { /* Set up state */ /* ... */ /* Chain to the next item in the paint sequence */ clutter_actor_continue_paint (priv->actor); /* Clean up state */ /* ... */ } ClutterActor now just calls this virtual instead of the pre_paint and post_paint functions. It keeps track of the next effect in the list so that it knows what to do when clutter_actor_continue_paint is called. clutter_actor_continue_paint is a new function added just for implementing effects. The default implementation of the run virtual just calls pre_paint and post_paint so that existing effects will continue to work. An effect is allowed to conditionally skip calling clutter_actor_continue_paint(). This is useful to implement effects that cache the image of an actor. The flags parameter can be used to determine if the actor is dirty since the last paint. ClutterActor sets this flag whenever propagated_one_redraw is TRUE which means that a redraw for this actor or one of its children was queued.
2011-03-02 11:55:10 -05:00
* <para>The example below creates two rectangles: one will be
* painted "behind" the actor, while another will be painted "on
Fixes for the API reference Typos, missing symbols, and missing documentation.
2012-04-19 11:00:23 -04:00
* top" of the actor. The #ClutterActorMetaClass.set_actor()
clutter-effect: Add a 'run' virtual This adds a new virtual to ClutterEffect which is intended to be a more flexible replacement for the pre and post_paint functions. The implementation of a run virtual would look something like this: void effect_run (ClutterEffect *effect, ClutterEffectRunFlags flags) { /* Set up state */ /* ... */ /* Chain to the next item in the paint sequence */ clutter_actor_continue_paint (priv->actor); /* Clean up state */ /* ... */ } ClutterActor now just calls this virtual instead of the pre_paint and post_paint functions. It keeps track of the next effect in the list so that it knows what to do when clutter_actor_continue_paint is called. clutter_actor_continue_paint is a new function added just for implementing effects. The default implementation of the run virtual just calls pre_paint and post_paint so that existing effects will continue to work. An effect is allowed to conditionally skip calling clutter_actor_continue_paint(). This is useful to implement effects that cache the image of an actor. The flags parameter can be used to determine if the actor is dirty since the last paint. ClutterActor sets this flag whenever propagated_one_redraw is TRUE which means that a redraw for this actor or one of its children was queued.
2011-03-02 11:55:10 -05:00
* implementation will create the two materials used for the two
Fixes for the API reference Typos, missing symbols, and missing documentation.
2012-04-19 11:00:23 -04:00
* different rectangles; the #ClutterEffectClass.paint() implementation
clutter-effect: Add a 'run' virtual This adds a new virtual to ClutterEffect which is intended to be a more flexible replacement for the pre and post_paint functions. The implementation of a run virtual would look something like this: void effect_run (ClutterEffect *effect, ClutterEffectRunFlags flags) { /* Set up state */ /* ... */ /* Chain to the next item in the paint sequence */ clutter_actor_continue_paint (priv->actor); /* Clean up state */ /* ... */ } ClutterActor now just calls this virtual instead of the pre_paint and post_paint functions. It keeps track of the next effect in the list so that it knows what to do when clutter_actor_continue_paint is called. clutter_actor_continue_paint is a new function added just for implementing effects. The default implementation of the run virtual just calls pre_paint and post_paint so that existing effects will continue to work. An effect is allowed to conditionally skip calling clutter_actor_continue_paint(). This is useful to implement effects that cache the image of an actor. The flags parameter can be used to determine if the actor is dirty since the last paint. ClutterActor sets this flag whenever propagated_one_redraw is TRUE which means that a redraw for this actor or one of its children was queued.
2011-03-02 11:55:10 -05:00
* will paint the first material using cogl_rectangle(), before
* continuing and then it will paint paint the second material
* after.</para>
Add the ClutterEffect abstract class ClutterEffect is an abstract class that should be used to apply effects on generic actors. The ClutterEffect class just defines what an effect should implement; it could be defined as an interface, but we might want to add some default behavior dependent on the internal state at a later point. The effect API applies to any actor, so we need to provide a way to assign an effect to an actor, and let ClutterActor call the Effect methods during the paint sequence. Once an effect is attached to an actor we will perform the paint in this order: • Effect::pre_paint() • Actor::paint signal emission • Effect::post_paint() Since an effect might collide with the Shader class, we either allow a shader or an effect for the time being.
2010-04-08 05:55:15 -04:00
* <programlisting>
* typedef struct {
* ClutterEffect parent_instance;
*
* CoglHandle rect_1;
* CoglHandle rect_2;
* } MyEffect;
*
* typedef struct _ClutterEffectClass MyEffectClass;
*
* G_DEFINE_TYPE (MyEffect, my_effect, CLUTTER_TYPE_EFFECT);
*
* static void
* my_effect_set_actor (ClutterActorMeta *meta,
* ClutterActor *actor)
* {
* MyEffect *self = MY_EFFECT (meta);
*
* /&ast; Clear the previous state &ast;/
* if (self-&gt;rect_1)
* {
* cogl_handle_unref (self-&gt;rect_1);
* self-&gt;rect_1 = NULL;
* }
*
* if (self-&gt;rect_2)
* {
* cogl_handle_unref (self-&gt;rect_2);
* self-&gt;rect_2 = NULL;
* }
*
* /&ast; Maintain a pointer to the actor &ast;
* self-&gt;actor = actor;
*
* /&ast; If we've been detached by the actor then we should
* &ast; just bail out here
* &ast;/
* if (self-&gt;actor == NULL)
* return;
*
* /&ast; Create a red material &ast;/
* self-&gt;rect_1 = cogl_material_new ();
* cogl_material_set_color4f (self-&gt;rect_1, 1.0, 0.0, 0.0, 1.0);
*
* /&ast; Create a green material &ast;/
* self-&gt;rect_2 = cogl_material_new ();
* cogl_material_set_color4f (self-&gt;rect_2, 0.0, 1.0, 0.0, 1.0);
* }
*
* static gboolean
Rename ClutterEffect::run to ClutterEffect::paint In preparation for adding ClutterEffect::pick https://bugzilla.gnome.org/show_bug.cgi?id=651700
2011-06-06 02:44:11 -04:00
* my_effect_paint (ClutterEffect *effect)
Add the ClutterEffect abstract class ClutterEffect is an abstract class that should be used to apply effects on generic actors. The ClutterEffect class just defines what an effect should implement; it could be defined as an interface, but we might want to add some default behavior dependent on the internal state at a later point. The effect API applies to any actor, so we need to provide a way to assign an effect to an actor, and let ClutterActor call the Effect methods during the paint sequence. Once an effect is attached to an actor we will perform the paint in this order: • Effect::pre_paint() • Actor::paint signal emission • Effect::post_paint() Since an effect might collide with the Shader class, we either allow a shader or an effect for the time being.
2010-04-08 05:55:15 -04:00
* {
* MyEffect *self = MY_EFFECT (effect);
* gfloat width, height;
*
* clutter_actor_get_size (self-&gt;actor, &amp;width, &amp;height);
*
* /&ast; Paint the first rectangle in the upper left quadrant &ast;/
* cogl_set_source (self-&gt;rect_1);
* cogl_rectangle (0, 0, width / 2, height / 2);
*
clutter-effect: Add a 'run' virtual This adds a new virtual to ClutterEffect which is intended to be a more flexible replacement for the pre and post_paint functions. The implementation of a run virtual would look something like this: void effect_run (ClutterEffect *effect, ClutterEffectRunFlags flags) { /* Set up state */ /* ... */ /* Chain to the next item in the paint sequence */ clutter_actor_continue_paint (priv->actor); /* Clean up state */ /* ... */ } ClutterActor now just calls this virtual instead of the pre_paint and post_paint functions. It keeps track of the next effect in the list so that it knows what to do when clutter_actor_continue_paint is called. clutter_actor_continue_paint is a new function added just for implementing effects. The default implementation of the run virtual just calls pre_paint and post_paint so that existing effects will continue to work. An effect is allowed to conditionally skip calling clutter_actor_continue_paint(). This is useful to implement effects that cache the image of an actor. The flags parameter can be used to determine if the actor is dirty since the last paint. ClutterActor sets this flag whenever propagated_one_redraw is TRUE which means that a redraw for this actor or one of its children was queued.
2011-03-02 11:55:10 -05:00
* /&ast; Continue to the rest of the paint sequence &ast;/
* clutter_actor_continue_paint (self-&gt;actor);
Add the ClutterEffect abstract class ClutterEffect is an abstract class that should be used to apply effects on generic actors. The ClutterEffect class just defines what an effect should implement; it could be defined as an interface, but we might want to add some default behavior dependent on the internal state at a later point. The effect API applies to any actor, so we need to provide a way to assign an effect to an actor, and let ClutterActor call the Effect methods during the paint sequence. Once an effect is attached to an actor we will perform the paint in this order: • Effect::pre_paint() • Actor::paint signal emission • Effect::post_paint() Since an effect might collide with the Shader class, we either allow a shader or an effect for the time being.
2010-04-08 05:55:15 -04:00
*
* /&ast; Paint the second rectangle in the lower right quadrant &ast;/
* cogl_set_source (self-&gt;rect_2);
* cogl_rectangle (width / 2, height / 2, width, height);
* }
*
* static void
* my_effect_class_init (MyEffectClass *klass)
* {
* ClutterActorMetaClas *meta_class = CLUTTER_ACTOR_META_CLASS (klass);
*
* meta_class-&gt;set_actor = my_effect_set_actor;
*
Rename ClutterEffect::run to ClutterEffect::paint In preparation for adding ClutterEffect::pick https://bugzilla.gnome.org/show_bug.cgi?id=651700
2011-06-06 02:44:11 -04:00
* klass-&gt;paint = my_effect_paint;
Add the ClutterEffect abstract class ClutterEffect is an abstract class that should be used to apply effects on generic actors. The ClutterEffect class just defines what an effect should implement; it could be defined as an interface, but we might want to add some default behavior dependent on the internal state at a later point. The effect API applies to any actor, so we need to provide a way to assign an effect to an actor, and let ClutterActor call the Effect methods during the paint sequence. Once an effect is attached to an actor we will perform the paint in this order: • Effect::pre_paint() • Actor::paint signal emission • Effect::post_paint() Since an effect might collide with the Shader class, we either allow a shader or an effect for the time being.
2010-04-08 05:55:15 -04:00
* }
* </programlisting>
* </example>
* </refsect2>
*
* #ClutterEffect is available since Clutter 1.4
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "clutter-effect.h"
#include "clutter-actor-meta-private.h"
#include "clutter-debug.h"
Move ClutterEffect private symbols to a private header No point in cluttering up clutter-private.h even more than necessary.
2011-02-18 11:00:39 -05:00
#include "clutter-effect-private.h"
Add the ClutterEffect abstract class ClutterEffect is an abstract class that should be used to apply effects on generic actors. The ClutterEffect class just defines what an effect should implement; it could be defined as an interface, but we might want to add some default behavior dependent on the internal state at a later point. The effect API applies to any actor, so we need to provide a way to assign an effect to an actor, and let ClutterActor call the Effect methods during the paint sequence. Once an effect is attached to an actor we will perform the paint in this order: • Effect::pre_paint() • Actor::paint signal emission • Effect::post_paint() Since an effect might collide with the Shader class, we either allow a shader or an effect for the time being.
2010-04-08 05:55:15 -04:00
#include "clutter-enum-types.h"
#include "clutter-marshal.h"
#include "clutter-private.h"
clutter-effect: Add clutter_effect_queue_rerun This adds a new public function to queue a rerun of an effect. If nothing else queues a redraw then when the effect's actor is painted the effect will be run without the CLUTTER_EFFECT_RUN_ACTOR_DIRTY flag. This allows parametrised offscreen effects to report that they need to redraw the image without having to redraw the underlying actor. This will be used to implement the 'transparency' effect of ClutterActor. If multiple redraws are queued with different effects then redrawing is started from the one that occurs last in the list of effects. Internally the function is a wrapper around the new function _clutter_actor_queue_redraw_full. This is intended to be the sole point of code for queuing redraws on an actor. It has parameters for the clip and the effect. The other two existing functions to queue a redraw (one with a clip and one without) now wrap around this function by passing a NULL effect.
2011-02-28 07:16:55 -05:00
#include "clutter-actor-private.h"
Add the ClutterEffect abstract class ClutterEffect is an abstract class that should be used to apply effects on generic actors. The ClutterEffect class just defines what an effect should implement; it could be defined as an interface, but we might want to add some default behavior dependent on the internal state at a later point. The effect API applies to any actor, so we need to provide a way to assign an effect to an actor, and let ClutterActor call the Effect methods during the paint sequence. Once an effect is attached to an actor we will perform the paint in this order: • Effect::pre_paint() • Actor::paint signal emission • Effect::post_paint() Since an effect might collide with the Shader class, we either allow a shader or an effect for the time being.
2010-04-08 05:55:15 -04:00
G_DEFINE_ABSTRACT_TYPE (ClutterEffect,
clutter_effect,
CLUTTER_TYPE_ACTOR_META);
static gboolean
clutter_effect_real_pre_paint (ClutterEffect *effect)
{
return TRUE;
}
static void
clutter_effect_real_post_paint (ClutterEffect *effect)
{
}
paint volumes: another pass at the design This is a fairly extensive second pass at exposing paint volumes for actors. The API has changed to allow clutter_actor_get_paint_volume to fail since there are times - such as when an actor isn't a descendent of the stage - when the volume can't be determined. Another example is when something has connected to the "paint" signal of the actor and we simply have no way of knowing what might be drawn in that handler. The API has also be changed to return a const ClutterPaintVolume pointer (transfer none) so we can avoid having to dynamically allocate the volumes in the most common/performance critical code paths. Profiling was showing the slice allocation of volumes taking about 1% of an apps time, for some fairly basic tests. Most volumes can now simply be allocated on the stack; for clutter_actor_get_paint_volume we return a pointer to &priv->paint_volume and if we need a more dynamic allocation there is now a _clutter_stage_paint_volume_stack_allocate() mechanism which lets us allocate data which expires at the start of the next frame. The API has been extended to make it easier to implement get_paint_volume for containers by using clutter_actor_get_transformed_paint_volume and clutter_paint_volume_union. The first allows you to query the paint volume of a child but transformed into parent actor coordinates. The second lets you combine volumes together so you can union all the volumes for a container's children and report that as the container's own volume. The representation of paint volumes has been updated to consider that 2D actors are the most common. The effect apis, clutter-texture and clutter-group have been update accordingly.
2010-09-07 13:04:19 -04:00
static gboolean
effect: Allow any effect to override the paint volume An Effect implementation might override the paint volume of the actor to which it is applied to. The get_paint_volume() virtual function should be added to the Effect class vtable so that any effect can get the current paint volume and update it. The clutter_actor_get_paint_volume() function becomes context aware, and does the right thing if called from within a ClutterEffect pre_paint() or post_paint() implementation, by allowing all effects in the chain up to the caller to modify the paint volume.
2010-08-16 12:02:15 -04:00
clutter_effect_real_get_paint_volume (ClutterEffect *effect,
ClutterPaintVolume *volume)
{
paint volumes: another pass at the design This is a fairly extensive second pass at exposing paint volumes for actors. The API has changed to allow clutter_actor_get_paint_volume to fail since there are times - such as when an actor isn't a descendent of the stage - when the volume can't be determined. Another example is when something has connected to the "paint" signal of the actor and we simply have no way of knowing what might be drawn in that handler. The API has also be changed to return a const ClutterPaintVolume pointer (transfer none) so we can avoid having to dynamically allocate the volumes in the most common/performance critical code paths. Profiling was showing the slice allocation of volumes taking about 1% of an apps time, for some fairly basic tests. Most volumes can now simply be allocated on the stack; for clutter_actor_get_paint_volume we return a pointer to &priv->paint_volume and if we need a more dynamic allocation there is now a _clutter_stage_paint_volume_stack_allocate() mechanism which lets us allocate data which expires at the start of the next frame. The API has been extended to make it easier to implement get_paint_volume for containers by using clutter_actor_get_transformed_paint_volume and clutter_paint_volume_union. The first allows you to query the paint volume of a child but transformed into parent actor coordinates. The second lets you combine volumes together so you can union all the volumes for a container's children and report that as the container's own volume. The representation of paint volumes has been updated to consider that 2D actors are the most common. The effect apis, clutter-texture and clutter-group have been update accordingly.
2010-09-07 13:04:19 -04:00
return TRUE;
effect: Allow any effect to override the paint volume An Effect implementation might override the paint volume of the actor to which it is applied to. The get_paint_volume() virtual function should be added to the Effect class vtable so that any effect can get the current paint volume and update it. The clutter_actor_get_paint_volume() function becomes context aware, and does the right thing if called from within a ClutterEffect pre_paint() or post_paint() implementation, by allowing all effects in the chain up to the caller to modify the paint volume.
2010-08-16 12:02:15 -04:00
}
clutter-effect: Add a 'run' virtual This adds a new virtual to ClutterEffect which is intended to be a more flexible replacement for the pre and post_paint functions. The implementation of a run virtual would look something like this: void effect_run (ClutterEffect *effect, ClutterEffectRunFlags flags) { /* Set up state */ /* ... */ /* Chain to the next item in the paint sequence */ clutter_actor_continue_paint (priv->actor); /* Clean up state */ /* ... */ } ClutterActor now just calls this virtual instead of the pre_paint and post_paint functions. It keeps track of the next effect in the list so that it knows what to do when clutter_actor_continue_paint is called. clutter_actor_continue_paint is a new function added just for implementing effects. The default implementation of the run virtual just calls pre_paint and post_paint so that existing effects will continue to work. An effect is allowed to conditionally skip calling clutter_actor_continue_paint(). This is useful to implement effects that cache the image of an actor. The flags parameter can be used to determine if the actor is dirty since the last paint. ClutterActor sets this flag whenever propagated_one_redraw is TRUE which means that a redraw for this actor or one of its children was queued.
2011-03-02 11:55:10 -05:00
static void
effect: Rename RunFlags to PaintFlags Since run() was replaced and both paint() and pick() use the enumeration. https://bugzilla.gnome.org/show_bug.cgi?id=651700
2011-06-13 10:58:46 -04:00
clutter_effect_real_paint (ClutterEffect *effect,
ClutterEffectPaintFlags flags)
clutter-effect: Add a 'run' virtual This adds a new virtual to ClutterEffect which is intended to be a more flexible replacement for the pre and post_paint functions. The implementation of a run virtual would look something like this: void effect_run (ClutterEffect *effect, ClutterEffectRunFlags flags) { /* Set up state */ /* ... */ /* Chain to the next item in the paint sequence */ clutter_actor_continue_paint (priv->actor); /* Clean up state */ /* ... */ } ClutterActor now just calls this virtual instead of the pre_paint and post_paint functions. It keeps track of the next effect in the list so that it knows what to do when clutter_actor_continue_paint is called. clutter_actor_continue_paint is a new function added just for implementing effects. The default implementation of the run virtual just calls pre_paint and post_paint so that existing effects will continue to work. An effect is allowed to conditionally skip calling clutter_actor_continue_paint(). This is useful to implement effects that cache the image of an actor. The flags parameter can be used to determine if the actor is dirty since the last paint. ClutterActor sets this flag whenever propagated_one_redraw is TRUE which means that a redraw for this actor or one of its children was queued.
2011-03-02 11:55:10 -05:00
{
ClutterActorMeta *actor_meta = CLUTTER_ACTOR_META (effect);
ClutterActor *actor;
gboolean pre_paint_succeeded;
/* The default implementation provides a compatibility wrapper for
Rename ClutterEffect::run to ClutterEffect::paint In preparation for adding ClutterEffect::pick https://bugzilla.gnome.org/show_bug.cgi?id=651700
2011-06-06 02:44:11 -04:00
effects that haven't migrated to use the 'paint' virtual yet. This
clutter-effect: Add a 'run' virtual This adds a new virtual to ClutterEffect which is intended to be a more flexible replacement for the pre and post_paint functions. The implementation of a run virtual would look something like this: void effect_run (ClutterEffect *effect, ClutterEffectRunFlags flags) { /* Set up state */ /* ... */ /* Chain to the next item in the paint sequence */ clutter_actor_continue_paint (priv->actor); /* Clean up state */ /* ... */ } ClutterActor now just calls this virtual instead of the pre_paint and post_paint functions. It keeps track of the next effect in the list so that it knows what to do when clutter_actor_continue_paint is called. clutter_actor_continue_paint is a new function added just for implementing effects. The default implementation of the run virtual just calls pre_paint and post_paint so that existing effects will continue to work. An effect is allowed to conditionally skip calling clutter_actor_continue_paint(). This is useful to implement effects that cache the image of an actor. The flags parameter can be used to determine if the actor is dirty since the last paint. ClutterActor sets this flag whenever propagated_one_redraw is TRUE which means that a redraw for this actor or one of its children was queued.
2011-03-02 11:55:10 -05:00
just calls the old pre and post virtuals before chaining on */
pre_paint_succeeded = _clutter_effect_pre_paint (effect);
actor = clutter_actor_meta_get_actor (actor_meta);
clutter_actor_continue_paint (actor);
if (pre_paint_succeeded)
_clutter_effect_post_paint (effect);
}
Give a chance to effects for running when picking Some effects can change the actor's shape and position, so they need to run when picking. https://bugzilla.gnome.org/show_bug.cgi?id=651700
2011-06-02 08:16:23 -04:00
static void
effect: Rename RunFlags to PaintFlags Since run() was replaced and both paint() and pick() use the enumeration. https://bugzilla.gnome.org/show_bug.cgi?id=651700
2011-06-13 10:58:46 -04:00
clutter_effect_real_pick (ClutterEffect *effect,
ClutterEffectPaintFlags flags)
Give a chance to effects for running when picking Some effects can change the actor's shape and position, so they need to run when picking. https://bugzilla.gnome.org/show_bug.cgi?id=651700
2011-06-02 08:16:23 -04:00
{
ClutterActorMeta *actor_meta = CLUTTER_ACTOR_META (effect);
ClutterActor *actor;
actor = clutter_actor_meta_get_actor (actor_meta);
clutter_actor_continue_paint (actor);
}
effect: Queue a redraw on :enabled changes ClutterEffect should queue a redraw if the :enabled property of its parent class ClutterActorMeta changes. http://bugzilla.clutter-project.org/show_bug.cgi?id=2587
2011-03-01 13:36:55 -05:00
static void
clutter_effect_notify (GObject *gobject,
GParamSpec *pspec)
{
if (strcmp (pspec->name, "enabled") == 0)
{
ClutterActorMeta *meta = CLUTTER_ACTOR_META (gobject);
ClutterActor *actor = clutter_actor_meta_get_actor (meta);
if (actor != NULL)
clutter_actor_queue_redraw (actor);
}
if (G_OBJECT_CLASS (clutter_effect_parent_class)->notify != NULL)
G_OBJECT_CLASS (clutter_effect_parent_class)->notify (gobject, pspec);
}
Add the ClutterEffect abstract class ClutterEffect is an abstract class that should be used to apply effects on generic actors. The ClutterEffect class just defines what an effect should implement; it could be defined as an interface, but we might want to add some default behavior dependent on the internal state at a later point. The effect API applies to any actor, so we need to provide a way to assign an effect to an actor, and let ClutterActor call the Effect methods during the paint sequence. Once an effect is attached to an actor we will perform the paint in this order: • Effect::pre_paint() • Actor::paint signal emission • Effect::post_paint() Since an effect might collide with the Shader class, we either allow a shader or an effect for the time being.
2010-04-08 05:55:15 -04:00
static void
clutter_effect_class_init (ClutterEffectClass *klass)
{
effect: Queue a redraw on :enabled changes ClutterEffect should queue a redraw if the :enabled property of its parent class ClutterActorMeta changes. http://bugzilla.clutter-project.org/show_bug.cgi?id=2587
2011-03-01 13:36:55 -05:00
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
gobject_class->notify = clutter_effect_notify;
Add the ClutterEffect abstract class ClutterEffect is an abstract class that should be used to apply effects on generic actors. The ClutterEffect class just defines what an effect should implement; it could be defined as an interface, but we might want to add some default behavior dependent on the internal state at a later point. The effect API applies to any actor, so we need to provide a way to assign an effect to an actor, and let ClutterActor call the Effect methods during the paint sequence. Once an effect is attached to an actor we will perform the paint in this order: • Effect::pre_paint() • Actor::paint signal emission • Effect::post_paint() Since an effect might collide with the Shader class, we either allow a shader or an effect for the time being.
2010-04-08 05:55:15 -04:00
klass->pre_paint = clutter_effect_real_pre_paint;
klass->post_paint = clutter_effect_real_post_paint;
effect: Allow any effect to override the paint volume An Effect implementation might override the paint volume of the actor to which it is applied to. The get_paint_volume() virtual function should be added to the Effect class vtable so that any effect can get the current paint volume and update it. The clutter_actor_get_paint_volume() function becomes context aware, and does the right thing if called from within a ClutterEffect pre_paint() or post_paint() implementation, by allowing all effects in the chain up to the caller to modify the paint volume.
2010-08-16 12:02:15 -04:00
klass->get_paint_volume = clutter_effect_real_get_paint_volume;
Rename ClutterEffect::run to ClutterEffect::paint In preparation for adding ClutterEffect::pick https://bugzilla.gnome.org/show_bug.cgi?id=651700
2011-06-06 02:44:11 -04:00
klass->paint = clutter_effect_real_paint;
Give a chance to effects for running when picking Some effects can change the actor's shape and position, so they need to run when picking. https://bugzilla.gnome.org/show_bug.cgi?id=651700
2011-06-02 08:16:23 -04:00
klass->pick = clutter_effect_real_pick;
Add the ClutterEffect abstract class ClutterEffect is an abstract class that should be used to apply effects on generic actors. The ClutterEffect class just defines what an effect should implement; it could be defined as an interface, but we might want to add some default behavior dependent on the internal state at a later point. The effect API applies to any actor, so we need to provide a way to assign an effect to an actor, and let ClutterActor call the Effect methods during the paint sequence. Once an effect is attached to an actor we will perform the paint in this order: • Effect::pre_paint() • Actor::paint signal emission • Effect::post_paint() Since an effect might collide with the Shader class, we either allow a shader or an effect for the time being.
2010-04-08 05:55:15 -04:00
}
static void
clutter_effect_init (ClutterEffect *self)
{
}
gboolean
_clutter_effect_pre_paint (ClutterEffect *effect)
{
g_return_val_if_fail (CLUTTER_IS_EFFECT (effect), FALSE);
return CLUTTER_EFFECT_GET_CLASS (effect)->pre_paint (effect);
}
void
_clutter_effect_post_paint (ClutterEffect *effect)
{
g_return_if_fail (CLUTTER_IS_EFFECT (effect));
CLUTTER_EFFECT_GET_CLASS (effect)->post_paint (effect);
}
effect: Allow any effect to override the paint volume An Effect implementation might override the paint volume of the actor to which it is applied to. The get_paint_volume() virtual function should be added to the Effect class vtable so that any effect can get the current paint volume and update it. The clutter_actor_get_paint_volume() function becomes context aware, and does the right thing if called from within a ClutterEffect pre_paint() or post_paint() implementation, by allowing all effects in the chain up to the caller to modify the paint volume.
2010-08-16 12:02:15 -04:00
clutter-effect: Add a 'run' virtual This adds a new virtual to ClutterEffect which is intended to be a more flexible replacement for the pre and post_paint functions. The implementation of a run virtual would look something like this: void effect_run (ClutterEffect *effect, ClutterEffectRunFlags flags) { /* Set up state */ /* ... */ /* Chain to the next item in the paint sequence */ clutter_actor_continue_paint (priv->actor); /* Clean up state */ /* ... */ } ClutterActor now just calls this virtual instead of the pre_paint and post_paint functions. It keeps track of the next effect in the list so that it knows what to do when clutter_actor_continue_paint is called. clutter_actor_continue_paint is a new function added just for implementing effects. The default implementation of the run virtual just calls pre_paint and post_paint so that existing effects will continue to work. An effect is allowed to conditionally skip calling clutter_actor_continue_paint(). This is useful to implement effects that cache the image of an actor. The flags parameter can be used to determine if the actor is dirty since the last paint. ClutterActor sets this flag whenever propagated_one_redraw is TRUE which means that a redraw for this actor or one of its children was queued.
2011-03-02 11:55:10 -05:00
void
effect: Rename RunFlags to PaintFlags Since run() was replaced and both paint() and pick() use the enumeration. https://bugzilla.gnome.org/show_bug.cgi?id=651700
2011-06-13 10:58:46 -04:00
_clutter_effect_paint (ClutterEffect *effect,
ClutterEffectPaintFlags flags)
clutter-effect: Add a 'run' virtual This adds a new virtual to ClutterEffect which is intended to be a more flexible replacement for the pre and post_paint functions. The implementation of a run virtual would look something like this: void effect_run (ClutterEffect *effect, ClutterEffectRunFlags flags) { /* Set up state */ /* ... */ /* Chain to the next item in the paint sequence */ clutter_actor_continue_paint (priv->actor); /* Clean up state */ /* ... */ } ClutterActor now just calls this virtual instead of the pre_paint and post_paint functions. It keeps track of the next effect in the list so that it knows what to do when clutter_actor_continue_paint is called. clutter_actor_continue_paint is a new function added just for implementing effects. The default implementation of the run virtual just calls pre_paint and post_paint so that existing effects will continue to work. An effect is allowed to conditionally skip calling clutter_actor_continue_paint(). This is useful to implement effects that cache the image of an actor. The flags parameter can be used to determine if the actor is dirty since the last paint. ClutterActor sets this flag whenever propagated_one_redraw is TRUE which means that a redraw for this actor or one of its children was queued.
2011-03-02 11:55:10 -05:00
{
g_return_if_fail (CLUTTER_IS_EFFECT (effect));
Rename ClutterEffect::run to ClutterEffect::paint In preparation for adding ClutterEffect::pick https://bugzilla.gnome.org/show_bug.cgi?id=651700
2011-06-06 02:44:11 -04:00
CLUTTER_EFFECT_GET_CLASS (effect)->paint (effect, flags);
clutter-effect: Add a 'run' virtual This adds a new virtual to ClutterEffect which is intended to be a more flexible replacement for the pre and post_paint functions. The implementation of a run virtual would look something like this: void effect_run (ClutterEffect *effect, ClutterEffectRunFlags flags) { /* Set up state */ /* ... */ /* Chain to the next item in the paint sequence */ clutter_actor_continue_paint (priv->actor); /* Clean up state */ /* ... */ } ClutterActor now just calls this virtual instead of the pre_paint and post_paint functions. It keeps track of the next effect in the list so that it knows what to do when clutter_actor_continue_paint is called. clutter_actor_continue_paint is a new function added just for implementing effects. The default implementation of the run virtual just calls pre_paint and post_paint so that existing effects will continue to work. An effect is allowed to conditionally skip calling clutter_actor_continue_paint(). This is useful to implement effects that cache the image of an actor. The flags parameter can be used to determine if the actor is dirty since the last paint. ClutterActor sets this flag whenever propagated_one_redraw is TRUE which means that a redraw for this actor or one of its children was queued.
2011-03-02 11:55:10 -05:00
}
Give a chance to effects for running when picking Some effects can change the actor's shape and position, so they need to run when picking. https://bugzilla.gnome.org/show_bug.cgi?id=651700
2011-06-02 08:16:23 -04:00
void
effect: Rename RunFlags to PaintFlags Since run() was replaced and both paint() and pick() use the enumeration. https://bugzilla.gnome.org/show_bug.cgi?id=651700
2011-06-13 10:58:46 -04:00
_clutter_effect_pick (ClutterEffect *effect,
ClutterEffectPaintFlags flags)
Give a chance to effects for running when picking Some effects can change the actor's shape and position, so they need to run when picking. https://bugzilla.gnome.org/show_bug.cgi?id=651700
2011-06-02 08:16:23 -04:00
{
g_return_if_fail (CLUTTER_IS_EFFECT (effect));
CLUTTER_EFFECT_GET_CLASS (effect)->pick (effect, flags);
}
paint volumes: another pass at the design This is a fairly extensive second pass at exposing paint volumes for actors. The API has changed to allow clutter_actor_get_paint_volume to fail since there are times - such as when an actor isn't a descendent of the stage - when the volume can't be determined. Another example is when something has connected to the "paint" signal of the actor and we simply have no way of knowing what might be drawn in that handler. The API has also be changed to return a const ClutterPaintVolume pointer (transfer none) so we can avoid having to dynamically allocate the volumes in the most common/performance critical code paths. Profiling was showing the slice allocation of volumes taking about 1% of an apps time, for some fairly basic tests. Most volumes can now simply be allocated on the stack; for clutter_actor_get_paint_volume we return a pointer to &priv->paint_volume and if we need a more dynamic allocation there is now a _clutter_stage_paint_volume_stack_allocate() mechanism which lets us allocate data which expires at the start of the next frame. The API has been extended to make it easier to implement get_paint_volume for containers by using clutter_actor_get_transformed_paint_volume and clutter_paint_volume_union. The first allows you to query the paint volume of a child but transformed into parent actor coordinates. The second lets you combine volumes together so you can union all the volumes for a container's children and report that as the container's own volume. The representation of paint volumes has been updated to consider that 2D actors are the most common. The effect apis, clutter-texture and clutter-group have been update accordingly.
2010-09-07 13:04:19 -04:00
gboolean
effect: Allow any effect to override the paint volume An Effect implementation might override the paint volume of the actor to which it is applied to. The get_paint_volume() virtual function should be added to the Effect class vtable so that any effect can get the current paint volume and update it. The clutter_actor_get_paint_volume() function becomes context aware, and does the right thing if called from within a ClutterEffect pre_paint() or post_paint() implementation, by allowing all effects in the chain up to the caller to modify the paint volume.
2010-08-16 12:02:15 -04:00
_clutter_effect_get_paint_volume (ClutterEffect *effect,
ClutterPaintVolume *volume)
{
paint volumes: another pass at the design This is a fairly extensive second pass at exposing paint volumes for actors. The API has changed to allow clutter_actor_get_paint_volume to fail since there are times - such as when an actor isn't a descendent of the stage - when the volume can't be determined. Another example is when something has connected to the "paint" signal of the actor and we simply have no way of knowing what might be drawn in that handler. The API has also be changed to return a const ClutterPaintVolume pointer (transfer none) so we can avoid having to dynamically allocate the volumes in the most common/performance critical code paths. Profiling was showing the slice allocation of volumes taking about 1% of an apps time, for some fairly basic tests. Most volumes can now simply be allocated on the stack; for clutter_actor_get_paint_volume we return a pointer to &priv->paint_volume and if we need a more dynamic allocation there is now a _clutter_stage_paint_volume_stack_allocate() mechanism which lets us allocate data which expires at the start of the next frame. The API has been extended to make it easier to implement get_paint_volume for containers by using clutter_actor_get_transformed_paint_volume and clutter_paint_volume_union. The first allows you to query the paint volume of a child but transformed into parent actor coordinates. The second lets you combine volumes together so you can union all the volumes for a container's children and report that as the container's own volume. The representation of paint volumes has been updated to consider that 2D actors are the most common. The effect apis, clutter-texture and clutter-group have been update accordingly.
2010-09-07 13:04:19 -04:00
g_return_val_if_fail (CLUTTER_IS_EFFECT (effect), FALSE);
g_return_val_if_fail (volume != NULL, FALSE);
effect: Allow any effect to override the paint volume An Effect implementation might override the paint volume of the actor to which it is applied to. The get_paint_volume() virtual function should be added to the Effect class vtable so that any effect can get the current paint volume and update it. The clutter_actor_get_paint_volume() function becomes context aware, and does the right thing if called from within a ClutterEffect pre_paint() or post_paint() implementation, by allowing all effects in the chain up to the caller to modify the paint volume.
2010-08-16 12:02:15 -04:00
paint volumes: another pass at the design This is a fairly extensive second pass at exposing paint volumes for actors. The API has changed to allow clutter_actor_get_paint_volume to fail since there are times - such as when an actor isn't a descendent of the stage - when the volume can't be determined. Another example is when something has connected to the "paint" signal of the actor and we simply have no way of knowing what might be drawn in that handler. The API has also be changed to return a const ClutterPaintVolume pointer (transfer none) so we can avoid having to dynamically allocate the volumes in the most common/performance critical code paths. Profiling was showing the slice allocation of volumes taking about 1% of an apps time, for some fairly basic tests. Most volumes can now simply be allocated on the stack; for clutter_actor_get_paint_volume we return a pointer to &priv->paint_volume and if we need a more dynamic allocation there is now a _clutter_stage_paint_volume_stack_allocate() mechanism which lets us allocate data which expires at the start of the next frame. The API has been extended to make it easier to implement get_paint_volume for containers by using clutter_actor_get_transformed_paint_volume and clutter_paint_volume_union. The first allows you to query the paint volume of a child but transformed into parent actor coordinates. The second lets you combine volumes together so you can union all the volumes for a container's children and report that as the container's own volume. The representation of paint volumes has been updated to consider that 2D actors are the most common. The effect apis, clutter-texture and clutter-group have been update accordingly.
2010-09-07 13:04:19 -04:00
return CLUTTER_EFFECT_GET_CLASS (effect)->get_paint_volume (effect, volume);
effect: Allow any effect to override the paint volume An Effect implementation might override the paint volume of the actor to which it is applied to. The get_paint_volume() virtual function should be added to the Effect class vtable so that any effect can get the current paint volume and update it. The clutter_actor_get_paint_volume() function becomes context aware, and does the right thing if called from within a ClutterEffect pre_paint() or post_paint() implementation, by allowing all effects in the chain up to the caller to modify the paint volume.
2010-08-16 12:02:15 -04:00
}
clutter-effect: Add clutter_effect_queue_rerun This adds a new public function to queue a rerun of an effect. If nothing else queues a redraw then when the effect's actor is painted the effect will be run without the CLUTTER_EFFECT_RUN_ACTOR_DIRTY flag. This allows parametrised offscreen effects to report that they need to redraw the image without having to redraw the underlying actor. This will be used to implement the 'transparency' effect of ClutterActor. If multiple redraws are queued with different effects then redrawing is started from the one that occurs last in the list of effects. Internally the function is a wrapper around the new function _clutter_actor_queue_redraw_full. This is intended to be the sole point of code for queuing redraws on an actor. It has parameters for the clip and the effect. The other two existing functions to queue a redraw (one with a clip and one without) now wrap around this function by passing a NULL effect.
2011-02-28 07:16:55 -05:00
/**
Rename ClutterEffect::run to ClutterEffect::paint In preparation for adding ClutterEffect::pick https://bugzilla.gnome.org/show_bug.cgi?id=651700
2011-06-06 02:44:11 -04:00
* clutter_effect_queue_repaint:
clutter-effect: Add clutter_effect_queue_rerun This adds a new public function to queue a rerun of an effect. If nothing else queues a redraw then when the effect's actor is painted the effect will be run without the CLUTTER_EFFECT_RUN_ACTOR_DIRTY flag. This allows parametrised offscreen effects to report that they need to redraw the image without having to redraw the underlying actor. This will be used to implement the 'transparency' effect of ClutterActor. If multiple redraws are queued with different effects then redrawing is started from the one that occurs last in the list of effects. Internally the function is a wrapper around the new function _clutter_actor_queue_redraw_full. This is intended to be the sole point of code for queuing redraws on an actor. It has parameters for the clip and the effect. The other two existing functions to queue a redraw (one with a clip and one without) now wrap around this function by passing a NULL effect.
2011-02-28 07:16:55 -05:00
* @effect: A #ClutterEffect which needs redrawing
*
Rename ClutterEffect::run to ClutterEffect::paint In preparation for adding ClutterEffect::pick https://bugzilla.gnome.org/show_bug.cgi?id=651700
2011-06-06 02:44:11 -04:00
* Queues a repaint of the effect. The effect can detect when the ‘paint’
clutter-effect: Add clutter_effect_queue_rerun This adds a new public function to queue a rerun of an effect. If nothing else queues a redraw then when the effect's actor is painted the effect will be run without the CLUTTER_EFFECT_RUN_ACTOR_DIRTY flag. This allows parametrised offscreen effects to report that they need to redraw the image without having to redraw the underlying actor. This will be used to implement the 'transparency' effect of ClutterActor. If multiple redraws are queued with different effects then redrawing is started from the one that occurs last in the list of effects. Internally the function is a wrapper around the new function _clutter_actor_queue_redraw_full. This is intended to be the sole point of code for queuing redraws on an actor. It has parameters for the clip and the effect. The other two existing functions to queue a redraw (one with a clip and one without) now wrap around this function by passing a NULL effect.
2011-02-28 07:16:55 -05:00
* method is called as a result of this function because it will not
docs: Fixes for cross-references
2011-09-12 08:12:14 -04:00
* have the %CLUTTER_EFFECT_PAINT_ACTOR_DIRTY flag set. In that case the
clutter-effect: Add clutter_effect_queue_rerun This adds a new public function to queue a rerun of an effect. If nothing else queues a redraw then when the effect's actor is painted the effect will be run without the CLUTTER_EFFECT_RUN_ACTOR_DIRTY flag. This allows parametrised offscreen effects to report that they need to redraw the image without having to redraw the underlying actor. This will be used to implement the 'transparency' effect of ClutterActor. If multiple redraws are queued with different effects then redrawing is started from the one that occurs last in the list of effects. Internally the function is a wrapper around the new function _clutter_actor_queue_redraw_full. This is intended to be the sole point of code for queuing redraws on an actor. It has parameters for the clip and the effect. The other two existing functions to queue a redraw (one with a clip and one without) now wrap around this function by passing a NULL effect.
2011-02-28 07:16:55 -05:00
* effect is free to assume that the actor has not changed its
* appearance since the last time it was painted so it doesn't need to
* call clutter_actor_continue_paint() if it can draw a cached
* image. This is mostly intended for effects that are using a
* %CoglOffscreen to redirect the actor (such as
* %ClutterOffscreenEffect). In that case the effect can save a bit of
* rendering time by painting the cached texture without causing the
* entire actor to be painted.
*
* This function can be used by effects that have their own animatable
* parameters. For example, an effect which adds a varying degree of a
* red tint to an actor by redirecting it through a CoglOffscreen
* might have a property to specify the level of tint. When this value
* changes, the underlying actor doesn't need to be redrawn so the
Rename ClutterEffect::run to ClutterEffect::paint In preparation for adding ClutterEffect::pick https://bugzilla.gnome.org/show_bug.cgi?id=651700
2011-06-06 02:44:11 -04:00
* effect can call clutter_effect_queue_repaint() to make sure the
clutter-effect: Add clutter_effect_queue_rerun This adds a new public function to queue a rerun of an effect. If nothing else queues a redraw then when the effect's actor is painted the effect will be run without the CLUTTER_EFFECT_RUN_ACTOR_DIRTY flag. This allows parametrised offscreen effects to report that they need to redraw the image without having to redraw the underlying actor. This will be used to implement the 'transparency' effect of ClutterActor. If multiple redraws are queued with different effects then redrawing is started from the one that occurs last in the list of effects. Internally the function is a wrapper around the new function _clutter_actor_queue_redraw_full. This is intended to be the sole point of code for queuing redraws on an actor. It has parameters for the clip and the effect. The other two existing functions to queue a redraw (one with a clip and one without) now wrap around this function by passing a NULL effect.
2011-02-28 07:16:55 -05:00
* effect is repainted.
*
* Note however that modifying the position of the parent of an actor
* may change the appearance of the actor because its transformation
* matrix would change. In this case a redraw wouldn't be queued on
docs: Fixes for cross-references
2011-09-12 08:12:14 -04:00
* the actor itself so the %CLUTTER_EFFECT_PAINT_ACTOR_DIRTY would still
clutter-effect: Add clutter_effect_queue_rerun This adds a new public function to queue a rerun of an effect. If nothing else queues a redraw then when the effect's actor is painted the effect will be run without the CLUTTER_EFFECT_RUN_ACTOR_DIRTY flag. This allows parametrised offscreen effects to report that they need to redraw the image without having to redraw the underlying actor. This will be used to implement the 'transparency' effect of ClutterActor. If multiple redraws are queued with different effects then redrawing is started from the one that occurs last in the list of effects. Internally the function is a wrapper around the new function _clutter_actor_queue_redraw_full. This is intended to be the sole point of code for queuing redraws on an actor. It has parameters for the clip and the effect. The other two existing functions to queue a redraw (one with a clip and one without) now wrap around this function by passing a NULL effect.
2011-02-28 07:16:55 -05:00
* not be set. The effect can detect this case by keeping track of the
* last modelview matrix that was used to render the actor and
* veryifying that it remains the same in the next paint.
*
* Any other effects that are layered on top of the passed in effect
docs: Fixes for cross-references
2011-09-12 08:12:14 -04:00
* will still be passed the %CLUTTER_EFFECT_PAINT_ACTOR_DIRTY flag. If
clutter-effect: Add clutter_effect_queue_rerun This adds a new public function to queue a rerun of an effect. If nothing else queues a redraw then when the effect's actor is painted the effect will be run without the CLUTTER_EFFECT_RUN_ACTOR_DIRTY flag. This allows parametrised offscreen effects to report that they need to redraw the image without having to redraw the underlying actor. This will be used to implement the 'transparency' effect of ClutterActor. If multiple redraws are queued with different effects then redrawing is started from the one that occurs last in the list of effects. Internally the function is a wrapper around the new function _clutter_actor_queue_redraw_full. This is intended to be the sole point of code for queuing redraws on an actor. It has parameters for the clip and the effect. The other two existing functions to queue a redraw (one with a clip and one without) now wrap around this function by passing a NULL effect.
2011-02-28 07:16:55 -05:00
* anything queues a redraw on the actor without specifying an effect
* or with an effect that is lower in the chain of effects than this
* one then that will override this call. In that case this effect
docs: Fixes for cross-references
2011-09-12 08:12:14 -04:00
* will instead be called with the %CLUTTER_EFFECT_PAINT_ACTOR_DIRTY
clutter-effect: Add clutter_effect_queue_rerun This adds a new public function to queue a rerun of an effect. If nothing else queues a redraw then when the effect's actor is painted the effect will be run without the CLUTTER_EFFECT_RUN_ACTOR_DIRTY flag. This allows parametrised offscreen effects to report that they need to redraw the image without having to redraw the underlying actor. This will be used to implement the 'transparency' effect of ClutterActor. If multiple redraws are queued with different effects then redrawing is started from the one that occurs last in the list of effects. Internally the function is a wrapper around the new function _clutter_actor_queue_redraw_full. This is intended to be the sole point of code for queuing redraws on an actor. It has parameters for the clip and the effect. The other two existing functions to queue a redraw (one with a clip and one without) now wrap around this function by passing a NULL effect.
2011-02-28 07:16:55 -05:00
* flag set.
*
2.0: Remove all Since: annotations We're starting from scratch.
2012-08-27 04:48:36 -04:00
*
clutter-effect: Add clutter_effect_queue_rerun This adds a new public function to queue a rerun of an effect. If nothing else queues a redraw then when the effect's actor is painted the effect will be run without the CLUTTER_EFFECT_RUN_ACTOR_DIRTY flag. This allows parametrised offscreen effects to report that they need to redraw the image without having to redraw the underlying actor. This will be used to implement the 'transparency' effect of ClutterActor. If multiple redraws are queued with different effects then redrawing is started from the one that occurs last in the list of effects. Internally the function is a wrapper around the new function _clutter_actor_queue_redraw_full. This is intended to be the sole point of code for queuing redraws on an actor. It has parameters for the clip and the effect. The other two existing functions to queue a redraw (one with a clip and one without) now wrap around this function by passing a NULL effect.
2011-02-28 07:16:55 -05:00
*/
void
Rename ClutterEffect::run to ClutterEffect::paint In preparation for adding ClutterEffect::pick https://bugzilla.gnome.org/show_bug.cgi?id=651700
2011-06-06 02:44:11 -04:00
clutter_effect_queue_repaint (ClutterEffect *effect)
clutter-effect: Add clutter_effect_queue_rerun This adds a new public function to queue a rerun of an effect. If nothing else queues a redraw then when the effect's actor is painted the effect will be run without the CLUTTER_EFFECT_RUN_ACTOR_DIRTY flag. This allows parametrised offscreen effects to report that they need to redraw the image without having to redraw the underlying actor. This will be used to implement the 'transparency' effect of ClutterActor. If multiple redraws are queued with different effects then redrawing is started from the one that occurs last in the list of effects. Internally the function is a wrapper around the new function _clutter_actor_queue_redraw_full. This is intended to be the sole point of code for queuing redraws on an actor. It has parameters for the clip and the effect. The other two existing functions to queue a redraw (one with a clip and one without) now wrap around this function by passing a NULL effect.
2011-02-28 07:16:55 -05:00
{
ClutterActor *actor;
g_return_if_fail (CLUTTER_IS_EFFECT (effect));
actor = clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (effect));
/* If the effect has no actor then nothing needs to be done */
if (actor != NULL)
_clutter_actor_queue_redraw_full (actor,
0, /* flags */
NULL, /* clip volume */
effect /* effect */);
}
Reference in New Issue Copy Permalink