isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-09-20 14:35:48 -04:00
Code Issues Packages Projects Releases Wiki Activity
e058cd4c5f
mutter/clutter/clutter-effect.h

132 lines
4.6 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>
*/
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only <clutter/clutter.h> can be included directly."
#endif
#ifndef __CLUTTER_EFFECT_H__
#define __CLUTTER_EFFECT_H__
#include <clutter/clutter-actor-meta.h>
G_BEGIN_DECLS
#define CLUTTER_TYPE_EFFECT (clutter_effect_get_type ())
#define CLUTTER_EFFECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_EFFECT, ClutterEffect))
#define CLUTTER_IS_EFFECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_EFFECT))
#define CLUTTER_EFFECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_EFFECT, ClutterEffectClass))
#define CLUTTER_IS_EFFECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_EFFECT))
#define CLUTTER_EFFECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_EFFECT, ClutterEffectClass))
typedef struct _ClutterEffectClass ClutterEffectClass;
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
/**
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
* ClutterEffectPaintFlags:
* @CLUTTER_EFFECT_PAINT_ACTOR_DIRTY: The actor or one of its children
* has queued a redraw before this paint. This implies that the effect
* should call clutter_actor_continue_paint() to chain to the next
* effect and can not cache any results from a previous 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
*
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
* Flags passed to the ‘paint’ or ‘pick’ method of #ClutterEffect.
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
*/
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
typedef enum { /*< prefix=CLUTTER_EFFECT_PAINT >*/
CLUTTER_EFFECT_PAINT_ACTOR_DIRTY = (1 << 0)
} ClutterEffectPaintFlags;
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
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
/**
* ClutterEffect:
*
* The #ClutterEffect structure contains only private data and should
* be accessed using the provided API
*
* Since: 1.4
*/
struct _ClutterEffect
{
/*< private >*/
ClutterActorMeta parent_instance;
};
/**
* ClutterEffectClass:
* @pre_paint: virtual function
* @post_paint: virtual function
effect: Fix up the class ABI Landing the paint-box branch accidentally added two slots to the ClutterEffectClass vtable, plus the get_paint_volume() function pointer. This is an ABI break from 1.4.
2010-10-04 06:30:32 -04:00
* @get_paint_volume: virtual function
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: virtual function
docs: Fix up the API reference
2011-06-20 09:26:57 -04:00
* @pick: 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
*
* The #ClutterEffectClass structure contains only private data
*
* Since: 1.4
*/
struct _ClutterEffectClass
{
/*< private >*/
ClutterActorMetaClass parent_class;
/*< public >*/
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
gboolean (* pre_paint) (ClutterEffect *effect);
void (* post_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
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
gboolean (* get_paint_volume) (ClutterEffect *effect,
ClutterPaintVolume *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 11:55:10 -05:00
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 (* paint) (ClutterEffect *effect,
ClutterEffectPaintFlags flags);
void (* 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
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
/*< private >*/
void (* _clutter_effect4) (void);
void (* _clutter_effect5) (void);
void (* _clutter_effect6) (void);
};
GType clutter_effect_get_type (void) G_GNUC_CONST;
docs: Fix up the API reference
2011-06-20 09:26:57 -04:00
void 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
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 API
*/
void clutter_actor_add_effect (ClutterActor *self,
ClutterEffect *effect);
void clutter_actor_add_effect_with_name (ClutterActor *self,
const gchar *name,
ClutterEffect *effect);
void clutter_actor_remove_effect (ClutterActor *self,
ClutterEffect *effect);
void clutter_actor_remove_effect_by_name (ClutterActor *self,
const gchar *name);
GList * clutter_actor_get_effects (ClutterActor *self);
ClutterEffect *clutter_actor_get_effect (ClutterActor *self,
const gchar *name);
void clutter_actor_clear_effects (ClutterActor *self);
G_END_DECLS
#endif /* __CLUTTER_EFFECT_H__ */
Reference in New Issue Copy Permalink