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

379 lines
13 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 09:55:15 +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-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
* #ClutterActor::paint virtual function.
*
* <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 16:55:10 +00:00
* <para>
* Creating a sub-class of #ClutterEffect requires overriding the
* ‘run’ method. The implementation of the function should look
* something like this:
* </para>
* <programlisting>
* void effect_run (ClutterEffect *effect, ClutterEffectRunFlags flags)
* {
* /&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
* ‘run’ on the next effect or just paint the actor if this is
* 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
* painting the cached image. The %CLUTTER_EFFECT_RUN_ACTOR_DIRTY
* 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>
* The ‘run’ virtual was added in Clutter 1.8. Prior to that there
* 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 09:55:15 +00: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 16:55:10 +00: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 09:55:15 +00: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 16:34:48 +00: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 16:55:10 +00: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 09:55:15 +00: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 16:55:10 +00:00
* <para>
* With these two functions it is not possible to skip the rest of
* the paint sequence. The default implementation of the ‘run’
* virtual calls pre_paint(), clutter_actor_continue_paint() and
* then post_paint() so that existing actors that aren't using the
* run virtual will continue to work. New actors using the run
* virtual do not need to implement pre or post paint.
* </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 09:55:15 +00: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 16:55:10 +00:00
* <para>The example below creates two rectangles: one will be
* painted "behind" the actor, while another will be painted "on
* top" of the actor. The <function>set_actor()</function>
* implementation will create the two materials used for the two
* different rectangles; the <function>run()</function> function
* 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 09:55:15 +00: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
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 16:55:10 +00:00
* my_effect_run (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 09:55:15 +00: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 16:55:10 +00: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 09:55:15 +00: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;
*
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 16:55:10 +00:00
* klass-&gt;run = my_effect_run;
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 09:55:15 +00: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 16:00:39 +00: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 09:55:15 +00: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 12:16:55 +00: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 09:55:15 +00: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 17:04:19 +00: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 16:02:15 +00: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 17:04:19 +00: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 16:02:15 +00: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 16:55:10 +00:00
static void
clutter_effect_real_run (ClutterEffect *effect,
ClutterEffectRunFlags flags)
{
ClutterActorMeta *actor_meta = CLUTTER_ACTOR_META (effect);
ClutterActor *actor;
gboolean pre_paint_succeeded;
/* The default implementation provides a compatibility wrapper for
effects that haven't migrated to use the 'run' virtual yet. This
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);
}
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 18:36:55 +00: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 09:55:15 +00: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 18:36:55 +00: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 09:55:15 +00: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 16:02:15 +00:00
klass->get_paint_volume = clutter_effect_real_get_paint_volume;
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 16:55:10 +00:00
klass->run = clutter_effect_real_run;
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 09:55:15 +00: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 16:02:15 +00: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 16:55:10 +00:00
void
_clutter_effect_run (ClutterEffect *effect,
ClutterEffectRunFlags flags)
{
g_return_if_fail (CLUTTER_IS_EFFECT (effect));
CLUTTER_EFFECT_GET_CLASS (effect)->run (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 17:04:19 +00: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 16:02:15 +00: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 17:04:19 +00: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 16:02:15 +00: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 17:04:19 +00: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 16:02:15 +00: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 12:16:55 +00:00
/**
* clutter_effect_queue_rerun:
* @effect: A #ClutterEffect which needs redrawing
*
* Queues a rerun of the effect. The effect can detect when the ‘run’
* method is called as a result of this function because it will not
* have the %CLUTTER_EFFECT_RUN_ACTOR_DIRTY flag set. In that case the
* 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
* effect can call clutter_effect_queue_rerun() to make sure the
* 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
* the actor itself so the %CLUTTER_EFFECT_RUN_ACTOR_DIRTY would still
* 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
* will still be passed the %CLUTTER_EFFECT_RUN_ACTOR_DIRTY flag. If
* 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
* will instead be called with the %CLUTTER_EFFECT_RUN_ACTOR_DIRTY
* flag set.
*
* Since: 1.8
*/
void
clutter_effect_queue_rerun (ClutterEffect *effect)
{
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