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
0f04a1cd11
mutter/clutter/clutter-offscreen-effect.c

591 lines
20 KiB
C
Raw Normal View History

effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -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/>.
*
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
* Authors:
effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -04:00
* Emmanuele Bassi <ebassi@linux.intel.com>
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
* Robert Bragg <robert@linux.intel.com>
effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -04:00
*/
/**
* SECTION:clutter-offscreen-effect
* @short_description: Base class for effects using offscreen buffers
* @see_also: #ClutterBlurEffect, #ClutterEffect
*
* #ClutterOffscreenEffect is an abstract class that can be used by
* #ClutterEffect sub-classes requiring access to an offscreen buffer.
*
* Some effects, like the fragment shader based effects, can only use GL
* textures, and in order to apply those effects to any kind of actor they
* require that all drawing operations are applied to an offscreen framebuffer
* that gets redirected to a texture.
*
* #ClutterOffscreenEffect provides all the heavy-lifting for creating the
* offscreen framebuffer, the redirection and the final paint of the texture on
* the desired stage.
*
* <refsect2 id="ClutterOffscreenEffect-implementing">
* <title>Implementing a ClutterOffscreenEffect</title>
* <para>Creating a sub-class of #ClutterOffscreenEffect requires, in case
* of overriding the #ClutterEffect virtual functions, to chain up to the
* #ClutterOffscreenEffect's implementation.</para>
* <para>On top of the #ClutterEffect's virtual functions,
* #ClutterOffscreenEffect also provides a <function>paint_target()</function>
* function, which encapsulates the effective painting of the texture that
* contains the result of the offscreen redirection.</para>
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
* <para>The size of the target material is defined to be as big as the
* transformed size of the #ClutterActor using the offscreen effect.
* Sub-classes of #ClutterOffscreenEffect can change the texture creation
* code to provide bigger textures by overriding the
offscreen-effect: Rename create_target to create_buffer *** This is an API change *** The create_target() virtual function should return a CoglHandle to a texture; clutter_offscreen_effect_get_target(), instead, returns a CoglMaterial to be painted in the implementation of the paint_target() virtual function. Instead of equating textures with materials, and confusing the user of the API, we should mark the difference more prominently. First of all, we should return a CoglMaterial* (now that we have that as a public type) in get_target(); having handles all over the place does not make it easier to distinguish the semantics of the virtual functions. Then we should rename create_target() to create_texture(), to make it clear that what should be returned is a texture that is used as the backing for the offscreen framebuffer.
2010-09-01 12:56:15 -04:00
* <function>create_texture()</function> virtual function; no chain up
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
* to the #ClutterOffscreenEffect implementation is required in this
* case.</para>
effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -04:00
* </refsect2>
*
* #ClutterOffscreenEffect is available since Clutter 1.4
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "clutter-offscreen-effect.h"
#include "cogl/cogl.h"
Clean up clutter-private.h/6 Move all Actor private API to a separate file.
2010-10-21 07:16:05 -04:00
#include "clutter-actor-private.h"
effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -04:00
#include "clutter-debug.h"
#include "clutter-private.h"
Clean up clutter-private.h/3 Move Stage private API to a separate header.
2010-10-21 06:29:09 -04:00
#include "clutter-stage-private.h"
effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -04:00
struct _ClutterOffscreenEffectPrivate
{
CoglHandle offscreen;
offscreen-effect: Rename create_target to create_buffer *** This is an API change *** The create_target() virtual function should return a CoglHandle to a texture; clutter_offscreen_effect_get_target(), instead, returns a CoglMaterial to be painted in the implementation of the paint_target() virtual function. Instead of equating textures with materials, and confusing the user of the API, we should mark the difference more prominently. First of all, we should return a CoglMaterial* (now that we have that as a public type) in get_target(); having handles all over the place does not make it easier to distinguish the semantics of the virtual functions. Then we should rename create_target() to create_texture(), to make it clear that what should be returned is a texture that is used as the backing for the offscreen framebuffer.
2010-09-01 12:56:15 -04:00
CoglMaterial *target;
effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -04:00
ClutterActor *actor;
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
ClutterActor *stage;
gfloat x_offset;
gfloat y_offset;
offscreen-effect: Track the size of the actor separately Previously the offscreen effect was keeping track of the size of the texture so that it could detect when a different size is requested and create a new texture. However this breaks if a subclass overrides create_texture to make the texture bigger because in that case the size of the texture will always be different from the calculated size of the actor. This patch makes it also track the size of the fbo that was requested before being passed through create_texture() and it instead uses that to detect when a new FBO is needed. https://bugzilla.gnome.org/show_bug.cgi?id=665040 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 08:08:57 -05:00
/* The size of the texture */
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
gfloat target_width;
gfloat target_height;
clutter-offscreen-effect: Preserve the old opacity override When removing the opacity override in the post_paint implementation, ClutterOffscreenEffect would always set the override back to -1. This ends up cancelling out the effect of any overrides from outer effects which means that if any actor has multiple effects attached then it would apply the opacity multiple times. To fix this, the effect now preserves the old value of the opacity override and restores that instead of setting -1. http://bugzilla.clutter-project.org/show_bug.cgi?id=2541
2011-03-03 11:46:26 -05:00
offscreen-effect: Track the size of the actor separately Previously the offscreen effect was keeping track of the size of the texture so that it could detect when a different size is requested and create a new texture. However this breaks if a subclass overrides create_texture to make the texture bigger because in that case the size of the texture will always be different from the calculated size of the actor. This patch makes it also track the size of the fbo that was requested before being passed through create_texture() and it instead uses that to detect when a new FBO is needed. https://bugzilla.gnome.org/show_bug.cgi?id=665040 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 08:08:57 -05:00
/* This is the calculated size of the fbo before being passed
through create_texture(). This needs to be tracked separately so
that we can detect when a different size is calculated and
regenerate the fbo */
int fbo_width;
int fbo_height;
clutter-offscreen-effect: Preserve the old opacity override When removing the opacity override in the post_paint implementation, ClutterOffscreenEffect would always set the override back to -1. This ends up cancelling out the effect of any overrides from outer effects which means that if any actor has multiple effects attached then it would apply the opacity multiple times. To fix this, the effect now preserves the old value of the opacity override and restores that instead of setting -1. http://bugzilla.clutter-project.org/show_bug.cgi?id=2541
2011-03-03 11:46:26 -05:00
gint old_opacity_override;
clutter-offscreen-effect: Don't redraw the actor if cached offscreen When painting an actor, it now tries to determine if the last paint of the offscreen was using the same matrix and the actor isn't dirty. If so, it can skip calling clutter_actor_continue_paint and avoid actually painting the actor. Instead just the offscreen image will be painted.
2011-02-25 06:24:23 -05:00
/* The matrix that was current the last time the fbo was updated. We
need to keep track of this to detect when we can reuse the
contents of the fbo without redrawing the actor. We need the
actual matrix rather than just detecting queued redraws on the
actor because any change in the parent hierarchy (even just a
translation) could cause the actor to look completely different
and it won't cause a redraw to be queued on the parent's
children. */
CoglMatrix last_matrix_drawn;
effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -04:00
};
G_DEFINE_ABSTRACT_TYPE (ClutterOffscreenEffect,
clutter_offscreen_effect,
CLUTTER_TYPE_EFFECT);
static void
clutter_offscreen_effect_set_actor (ClutterActorMeta *meta,
ClutterActor *actor)
{
ClutterOffscreenEffect *self = CLUTTER_OFFSCREEN_EFFECT (meta);
ClutterOffscreenEffectPrivate *priv = self->priv;
ClutterActorMetaClass *meta_class;
meta_class = CLUTTER_ACTOR_META_CLASS (clutter_offscreen_effect_parent_class);
meta_class->set_actor (meta, actor);
/* clear out the previous state */
if (priv->offscreen != COGL_INVALID_HANDLE)
{
cogl_handle_unref (priv->offscreen);
priv->offscreen = COGL_INVALID_HANDLE;
}
/* we keep a back pointer here, to avoid going through the ActorMeta */
priv->actor = clutter_actor_meta_get_actor (meta);
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
}
static CoglHandle
offscreen-effect: Rename create_target to create_buffer *** This is an API change *** The create_target() virtual function should return a CoglHandle to a texture; clutter_offscreen_effect_get_target(), instead, returns a CoglMaterial to be painted in the implementation of the paint_target() virtual function. Instead of equating textures with materials, and confusing the user of the API, we should mark the difference more prominently. First of all, we should return a CoglMaterial* (now that we have that as a public type) in get_target(); having handles all over the place does not make it easier to distinguish the semantics of the virtual functions. Then we should rename create_target() to create_texture(), to make it clear that what should be returned is a texture that is used as the backing for the offscreen framebuffer.
2010-09-01 12:56:15 -04:00
clutter_offscreen_effect_real_create_texture (ClutterOffscreenEffect *effect,
gfloat width,
gfloat height)
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
{
return cogl_texture_new_with_size (MAX (width, 1), MAX (height, 1),
COGL_TEXTURE_NO_SLICING,
COGL_PIXEL_FORMAT_RGBA_8888_PRE);
}
effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -04:00
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
static gboolean
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
update_fbo (ClutterEffect *effect, int fbo_width, int fbo_height)
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
{
ClutterOffscreenEffect *self = CLUTTER_OFFSCREEN_EFFECT (effect);
ClutterOffscreenEffectPrivate *priv = self->priv;
CoglHandle texture;
priv->stage = clutter_actor_get_stage (priv->actor);
if (priv->stage == NULL)
effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -04:00
{
CLUTTER_NOTE (MISC, "The actor '%s' is not part of a stage",
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
clutter_actor_get_name (priv->actor) == NULL
? G_OBJECT_TYPE_NAME (priv->actor)
: clutter_actor_get_name (priv->actor));
return FALSE;
effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -04:00
}
offscreen-effect: Track the size of the actor separately Previously the offscreen effect was keeping track of the size of the texture so that it could detect when a different size is requested and create a new texture. However this breaks if a subclass overrides create_texture to make the texture bigger because in that case the size of the texture will always be different from the calculated size of the actor. This patch makes it also track the size of the fbo that was requested before being passed through create_texture() and it instead uses that to detect when a new FBO is needed. https://bugzilla.gnome.org/show_bug.cgi?id=665040 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 08:08:57 -05:00
if (priv->fbo_width == fbo_width &&
priv->fbo_height == fbo_height &&
Don't bail out from creating the FBO if we don't have it yet. This happens when reattaching an effect to another actor. http://bugzilla.clutter-project.org/show_bug.cgi?id=2453
2010-11-27 10:07:01 -05:00
priv->offscreen != COGL_INVALID_HANDLE)
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
return TRUE;
effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -04:00
clutter-offscreen-effect: Don't recreate the material when FBO changes Previously whenever the size of the FBO changes it would create a new material and attach the texture to it. This is not good for Cogl because it throws away any cached state for the material. In test-rotate the size of the FBO changes constantly so it effectively uses a new material every paint. For shader effects this also ends up relinking the shader every paint because the linked programs are part of the material state.
2010-11-25 05:56:50 -05:00
if (priv->target == COGL_INVALID_HANDLE)
clutter-offscreen-effect: Paint with 'nearest' texture filter mode The texture containing the image for the redirected actor will always be painted at a 1:1 texel:pixel ratio so there's no need to use linear filtering. This should also counteract some of the effects of rounding errors when calculating the geometry for the quad.
2011-03-15 12:20:34 -04:00
{
priv->target = cogl_material_new ();
/* We're always going to render the texture at a 1:1 texel:pixel
ratio so we can use 'nearest' filtering to decrease the
effects of rounding errors in the geometry calculation */
cogl_material_set_layer_filters (priv->target,
0, /* layer_index */
COGL_MATERIAL_FILTER_NEAREST,
COGL_MATERIAL_FILTER_NEAREST);
}
effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -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
texture =
clutter_offscreen_effect_create_texture (self, fbo_width, fbo_height);
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
if (texture == COGL_INVALID_HANDLE)
return FALSE;
effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -04:00
cogl_material_set_layer (priv->target, 0, texture);
cogl_handle_unref (texture);
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
/* we need to use the size of the texture target and not the minimum
offscreen-effect: Rename create_target to create_buffer *** This is an API change *** The create_target() virtual function should return a CoglHandle to a texture; clutter_offscreen_effect_get_target(), instead, returns a CoglMaterial to be painted in the implementation of the paint_target() virtual function. Instead of equating textures with materials, and confusing the user of the API, we should mark the difference more prominently. First of all, we should return a CoglMaterial* (now that we have that as a public type) in get_target(); having handles all over the place does not make it easier to distinguish the semantics of the virtual functions. Then we should rename create_target() to create_texture(), to make it clear that what should be returned is a texture that is used as the backing for the offscreen framebuffer.
2010-09-01 12:56:15 -04:00
* size we passed to the create_texture() vfunc, as any sub-class might
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
* give use a bigger texture
*/
priv->target_width = cogl_texture_get_width (texture);
priv->target_height = cogl_texture_get_height (texture);
effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -04:00
offscreen-effect: Track the size of the actor separately Previously the offscreen effect was keeping track of the size of the texture so that it could detect when a different size is requested and create a new texture. However this breaks if a subclass overrides create_texture to make the texture bigger because in that case the size of the texture will always be different from the calculated size of the actor. This patch makes it also track the size of the fbo that was requested before being passed through create_texture() and it instead uses that to detect when a new FBO is needed. https://bugzilla.gnome.org/show_bug.cgi?id=665040 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 08:08:57 -05:00
priv->fbo_width = fbo_width;
priv->fbo_height = fbo_height;
clutter-offscreen-effect: Don't recreate the material when FBO changes Previously whenever the size of the FBO changes it would create a new material and attach the texture to it. This is not good for Cogl because it throws away any cached state for the material. In test-rotate the size of the FBO changes constantly so it effectively uses a new material every paint. For shader effects this also ends up relinking the shader every paint because the linked programs are part of the material state.
2010-11-25 05:56:50 -05:00
if (priv->offscreen != COGL_INVALID_HANDLE)
cogl_handle_unref (priv->offscreen);
effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -04:00
priv->offscreen = cogl_offscreen_new_to_texture (texture);
if (priv->offscreen == COGL_INVALID_HANDLE)
{
g_warning ("%s: Unable to create an Offscreen buffer", G_STRLOC);
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
cogl_handle_unref (priv->target);
priv->target = COGL_INVALID_HANDLE;
priv->target_width = 0;
priv->target_height = 0;
offscreen-effect: Track the size of the actor separately Previously the offscreen effect was keeping track of the size of the texture so that it could detect when a different size is requested and create a new texture. However this breaks if a subclass overrides create_texture to make the texture bigger because in that case the size of the texture will always be different from the calculated size of the actor. This patch makes it also track the size of the fbo that was requested before being passed through create_texture() and it instead uses that to detect when a new FBO is needed. https://bugzilla.gnome.org/show_bug.cgi?id=665040 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 08:08:57 -05:00
priv->fbo_width = 0;
priv->fbo_height = 0;
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
return FALSE;
effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -04:00
}
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
return TRUE;
}
effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -04:00
static gboolean
clutter_offscreen_effect_pre_paint (ClutterEffect *effect)
{
ClutterOffscreenEffect *self = CLUTTER_OFFSCREEN_EFFECT (effect);
ClutterOffscreenEffectPrivate *priv = self->priv;
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
ClutterActorBox box;
offscreen-effect: Update handling of transforms In line with the changes made in f5f066df9ce7 to clean up how Clutter deals with transformations of actors this patch updates the code in clutter-offscreen-effect.c. We now query the projection matrix from the stage instead of the perspective and instead of duplicating the logic to setup the stage view transform we now use _clutter_actor_apply_modelview_transform for the stage instead.
2010-09-16 07:58:42 -04:00
CoglMatrix projection;
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
CoglColor transparent;
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
gfloat fbo_width, fbo_height;
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
gfloat width, height;
offscreen: Fix partially off-stage actors being clipped in the fbo If an actor was partially off of the stage, it would be clipped because of the stage viewport. This produces problems if you use an offscreen effect that relies on the entire actor being rendered (e.g. shadows). Expand the viewport in this scenario so that the offscreen-rendering isn't clipped. This fixes http://bugzilla.clutter-project.org/show_bug.cgi?id=2550
2011-02-11 10:18:08 -05:00
gfloat xexpand, yexpand;
effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -04:00
if (!clutter_actor_meta_get_enabled (CLUTTER_ACTOR_META (effect)))
return FALSE;
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
if (priv->actor == NULL)
return FALSE;
effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -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
/* The paint box is the bounding box of the actor's paint volume in
* stage coordinates. This will give us the size for the framebuffer
* we need to redirect its rendering offscreen and its position will
* be used to setup an offset viewport */
if (clutter_actor_get_paint_box (priv->actor, &box))
clutter-offscreen-effect: Use 0,0 as the offset if no actor box clutter_offscreen_effect_pre_paint was using the unitialized value of the ‘box’ variable whenever the actor doesn't have a paint volume. This patch makes it just set the offset to 0,0 instead.
2011-03-04 12:04:02 -05:00
{
clutter_actor_box_get_size (&box, &fbo_width, &fbo_height);
clutter_actor_box_get_origin (&box, &priv->x_offset, &priv->y_offset);
}
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
else
{
/* If we can't get a valid paint box then we fallback to
* creating a full stage size fbo. */
ClutterActor *stage = _clutter_actor_get_stage_internal (priv->actor);
clutter_actor_get_size (stage, &fbo_width, &fbo_height);
clutter-offscreen-effect: Use 0,0 as the offset if no actor box clutter_offscreen_effect_pre_paint was using the unitialized value of the ‘box’ variable whenever the actor doesn't have a paint volume. This patch makes it just set the offset to 0,0 instead.
2011-03-04 12:04:02 -05:00
priv->x_offset = 0.0f;
priv->y_offset = 0.0f;
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
}
/* First assert that the framebuffer is the right size... */
if (!update_fbo (effect, fbo_width, fbo_height))
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
return FALSE;
effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -04:00
clutter-offscreen-effect: Apply matrix expansion to proj not mv When the viewport gets expanded because the actor extends off the edge of the screen, instead of applying the transformation to the root of the modelview transformation it is now applied to the end of the projection transformation. This should end up with the same transformation. This fixes a problem when the offscreen effects are nested and the inner effect would try to pick up the current modelview transformation to rescale it to fit the new viewport size. In this case the modelview would have already been scaled for the size of the outer viewport so it would end up wrong. https://bugzilla.gnome.org/show_bug.cgi?id=659601 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-09-21 11:36:30 -04:00
/* get the current modelview matrix so that we can copy it to the
* framebuffer. We also store the matrix that was last used when we
* updated the FBO so that we can detect when we don't need to
* update the FBO to paint a second time */
cogl_get_modelview_matrix (&priv->last_matrix_drawn);
clutter-offscreen-effect: Don't redraw the actor if cached offscreen When painting an actor, it now tries to determine if the last paint of the offscreen was using the same matrix and the actor isn't dirty. If so, it can skip calling clutter_actor_continue_paint and avoid actually painting the actor. Instead just the offscreen image will be painted.
2011-02-25 06:24:23 -05:00
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
/* let's draw offscreen */
cogl_push_framebuffer (priv->offscreen);
clutter-offscreen-effect: Apply matrix expansion to proj not mv When the viewport gets expanded because the actor extends off the edge of the screen, instead of applying the transformation to the root of the modelview transformation it is now applied to the end of the projection transformation. This should end up with the same transformation. This fixes a problem when the offscreen effects are nested and the inner effect would try to pick up the current modelview transformation to rescale it to fit the new viewport size. In this case the modelview would have already been scaled for the size of the outer viewport so it would end up wrong. https://bugzilla.gnome.org/show_bug.cgi?id=659601 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-09-21 11:36:30 -04:00
/* Copy the modelview that would have been used if rendering onscreen */
cogl_set_modelview_matrix (&priv->last_matrix_drawn);
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
/* Set up the viewport so that it has the same size as the stage,
* but offset it so that the actor of interest lands on our
* framebuffer. */
offscreen-effect: Update handling of transforms In line with the changes made in f5f066df9ce7 to clean up how Clutter deals with transformations of actors this patch updates the code in clutter-offscreen-effect.c. We now query the projection matrix from the stage instead of the perspective and instead of duplicating the logic to setup the stage view transform we now use _clutter_actor_apply_modelview_transform for the stage instead.
2010-09-16 07:58:42 -04:00
clutter_actor_get_size (priv->stage, &width, &height);
offscreen: Fix partially off-stage actors being clipped in the fbo If an actor was partially off of the stage, it would be clipped because of the stage viewport. This produces problems if you use an offscreen effect that relies on the entire actor being rendered (e.g. shadows). Expand the viewport in this scenario so that the offscreen-rendering isn't clipped. This fixes http://bugzilla.clutter-project.org/show_bug.cgi?id=2550
2011-02-11 10:18:08 -05:00
/* Expand the viewport if the actor is partially off-stage,
* otherwise the actor will end up clipped to the stage viewport
*/
xexpand = 0.f;
if (priv->x_offset < 0.f)
xexpand = -priv->x_offset;
clutter-offscreen-effect: use target size when setting up the viewport https://bugzilla.gnome.org/show_bug.cgi?id=650650
2011-05-20 05:15:07 -04:00
if (priv->x_offset + priv->target_width > width)
xexpand = MAX (xexpand, (priv->x_offset + priv->target_width) - width);
offscreen: Fix partially off-stage actors being clipped in the fbo If an actor was partially off of the stage, it would be clipped because of the stage viewport. This produces problems if you use an offscreen effect that relies on the entire actor being rendered (e.g. shadows). Expand the viewport in this scenario so that the offscreen-rendering isn't clipped. This fixes http://bugzilla.clutter-project.org/show_bug.cgi?id=2550
2011-02-11 10:18:08 -05:00
yexpand = 0.f;
if (priv->y_offset < 0.f)
yexpand = -priv->y_offset;
clutter-offscreen-effect: use target size when setting up the viewport https://bugzilla.gnome.org/show_bug.cgi?id=650650
2011-05-20 05:15:07 -04:00
if (priv->y_offset + priv->target_height > height)
yexpand = MAX (yexpand, (priv->y_offset + priv->target_height) - height);
offscreen: Fix partially off-stage actors being clipped in the fbo If an actor was partially off of the stage, it would be clipped because of the stage viewport. This produces problems if you use an offscreen effect that relies on the entire actor being rendered (e.g. shadows). Expand the viewport in this scenario so that the offscreen-rendering isn't clipped. This fixes http://bugzilla.clutter-project.org/show_bug.cgi?id=2550
2011-02-11 10:18:08 -05:00
/* Set the viewport */
cogl_set_viewport (-(priv->x_offset + xexpand), -(priv->y_offset + yexpand),
width + (2 * xexpand), height + (2 * yexpand));
offscreen-effect: Update handling of transforms In line with the changes made in f5f066df9ce7 to clean up how Clutter deals with transformations of actors this patch updates the code in clutter-offscreen-effect.c. We now query the projection matrix from the stage instead of the perspective and instead of duplicating the logic to setup the stage view transform we now use _clutter_actor_apply_modelview_transform for the stage instead.
2010-09-16 07:58:42 -04:00
/* Copy the stage's projection matrix across to the framebuffer */
_clutter_stage_get_projection_matrix (CLUTTER_STAGE (priv->stage),
&projection);
clutter-offscreen-effect: Apply matrix expansion to proj not mv When the viewport gets expanded because the actor extends off the edge of the screen, instead of applying the transformation to the root of the modelview transformation it is now applied to the end of the projection transformation. This should end up with the same transformation. This fixes a problem when the offscreen effects are nested and the inner effect would try to pick up the current modelview transformation to rescale it to fit the new viewport size. In this case the modelview would have already been scaled for the size of the outer viewport so it would end up wrong. https://bugzilla.gnome.org/show_bug.cgi?id=659601 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-09-21 11:36:30 -04:00
/* If we've expanded the viewport, make sure to scale the projection
offscreen: Fix partially off-stage actors being clipped in the fbo If an actor was partially off of the stage, it would be clipped because of the stage viewport. This produces problems if you use an offscreen effect that relies on the entire actor being rendered (e.g. shadows). Expand the viewport in this scenario so that the offscreen-rendering isn't clipped. This fixes http://bugzilla.clutter-project.org/show_bug.cgi?id=2550
2011-02-11 10:18:08 -05:00
* matrix accordingly (as it's been initialised to work with the
* original viewport and not our expanded one).
*/
if (xexpand > 0.f || yexpand > 0.f)
{
gfloat new_width, new_height;
new_width = width + (2 * xexpand);
new_height = height + (2 * yexpand);
clutter-offscreen-effect: Apply matrix expansion to proj not mv When the viewport gets expanded because the actor extends off the edge of the screen, instead of applying the transformation to the root of the modelview transformation it is now applied to the end of the projection transformation. This should end up with the same transformation. This fixes a problem when the offscreen effects are nested and the inner effect would try to pick up the current modelview transformation to rescale it to fit the new viewport size. In this case the modelview would have already been scaled for the size of the outer viewport so it would end up wrong. https://bugzilla.gnome.org/show_bug.cgi?id=659601 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-09-21 11:36:30 -04:00
cogl_matrix_scale (&projection,
offscreen: Fix partially off-stage actors being clipped in the fbo If an actor was partially off of the stage, it would be clipped because of the stage viewport. This produces problems if you use an offscreen effect that relies on the entire actor being rendered (e.g. shadows). Expand the viewport in this scenario so that the offscreen-rendering isn't clipped. This fixes http://bugzilla.clutter-project.org/show_bug.cgi?id=2550
2011-02-11 10:18:08 -05:00
width / new_width,
height / new_height,
1);
}
clutter-offscreen-effect: Apply matrix expansion to proj not mv When the viewport gets expanded because the actor extends off the edge of the screen, instead of applying the transformation to the root of the modelview transformation it is now applied to the end of the projection transformation. This should end up with the same transformation. This fixes a problem when the offscreen effects are nested and the inner effect would try to pick up the current modelview transformation to rescale it to fit the new viewport size. In this case the modelview would have already been scaled for the size of the outer viewport so it would end up wrong. https://bugzilla.gnome.org/show_bug.cgi?id=659601 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-09-21 11:36:30 -04:00
cogl_set_projection_matrix (&projection);
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
Replace cogl_color_set_from_* with cogl_color_init_from_* The former is not yet "officially" deprecated by the latter, but it's confusing to have them both in the code base.
2010-09-03 11:55:12 -04:00
cogl_color_init_from_4ub (&transparent, 0, 0, 0, 0);
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
cogl_clear (&transparent,
COGL_BUFFER_BIT_COLOR |
COGL_BUFFER_BIT_DEPTH);
effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -04:00
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
cogl_push_matrix ();
offscreen-effect: Use actor's opacity_override when redirecting painting Override the actor's paint opacity so that it will appear fully opaque in the offscreen surface. This avoids multiple multiplications of an actor's opacity. Fixes http://bugzilla.clutter-project.org/show_bug.cgi?id=2541
2011-02-03 09:36:55 -05:00
/* Override the actor's opacity to fully opaque - we paint the offscreen
* texture with the actor's paint opacity, so we need to do this to avoid
* multiplying the opacity twice.
*/
clutter-offscreen-effect: Preserve the old opacity override When removing the opacity override in the post_paint implementation, ClutterOffscreenEffect would always set the override back to -1. This ends up cancelling out the effect of any overrides from outer effects which means that if any actor has multiple effects attached then it would apply the opacity multiple times. To fix this, the effect now preserves the old value of the opacity override and restores that instead of setting -1. http://bugzilla.clutter-project.org/show_bug.cgi?id=2541
2011-03-03 11:46:26 -05:00
priv->old_opacity_override =
_clutter_actor_get_opacity_override (priv->actor);
offscreen-effect: Use actor's opacity_override when redirecting painting Override the actor's paint opacity so that it will appear fully opaque in the offscreen surface. This avoids multiple multiplications of an actor's opacity. Fixes http://bugzilla.clutter-project.org/show_bug.cgi?id=2541
2011-02-03 09:36:55 -05:00
_clutter_actor_set_opacity_override (priv->actor, 0xff);
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
return TRUE;
effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -04:00
}
static void
clutter_offscreen_effect_real_paint_target (ClutterOffscreenEffect *effect)
{
ClutterOffscreenEffectPrivate *priv = effect->priv;
guint8 paint_opacity;
paint_opacity = clutter_actor_get_paint_opacity (priv->actor);
cogl_material_set_color4ub (priv->target,
paint_opacity,
paint_opacity,
paint_opacity,
paint_opacity);
cogl_set_source (priv->target);
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -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
/* At this point we are in stage coordinates translated so if
* we draw our texture using a textured quad the size of the paint
* box then we will overlay where the actor would have drawn if it
* hadn't been redirected offscreen.
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
*/
offscreen-effect: Traslate the modelview with the offsets Instead of using the stage offsets when painting we can simply traslate the current modelview. This allows sub-classes to fully override the paint_target() virtual function without chaining up.
2010-06-10 12:35:56 -04:00
cogl_rectangle_with_texture_coords (0, 0,
priv->target_width,
priv->target_height,
effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -04:00
0.0, 0.0,
1.0, 1.0);
}
static void
clutter-offscreen-effect: Don't redraw the actor if cached offscreen When painting an actor, it now tries to determine if the last paint of the offscreen was using the same matrix and the actor isn't dirty. If so, it can skip calling clutter_actor_continue_paint and avoid actually painting the actor. Instead just the offscreen image will be painted.
2011-02-25 06:24:23 -05:00
clutter_offscreen_effect_paint_texture (ClutterOffscreenEffect *effect)
effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -04:00
{
clutter-offscreen-effect: Don't redraw the actor if cached offscreen When painting an actor, it now tries to determine if the last paint of the offscreen was using the same matrix and the actor isn't dirty. If so, it can skip calling clutter_actor_continue_paint and avoid actually painting the actor. Instead just the offscreen image will be painted.
2011-02-25 06:24:23 -05:00
ClutterOffscreenEffectPrivate *priv = effect->priv;
offscreen-effect: Update handling of transforms In line with the changes made in f5f066df9ce7 to clean up how Clutter deals with transformations of actors this patch updates the code in clutter-offscreen-effect.c. We now query the projection matrix from the stage instead of the perspective and instead of duplicating the logic to setup the stage view transform we now use _clutter_actor_apply_modelview_transform for the stage instead.
2010-09-16 07:58:42 -04:00
CoglMatrix modelview;
effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -04:00
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
cogl_push_matrix ();
offscreen-effect: Update handling of transforms In line with the changes made in f5f066df9ce7 to clean up how Clutter deals with transformations of actors this patch updates the code in clutter-offscreen-effect.c. We now query the projection matrix from the stage instead of the perspective and instead of duplicating the logic to setup the stage view transform we now use _clutter_actor_apply_modelview_transform for the stage instead.
2010-09-16 07:58:42 -04:00
/* Now reset the modelview to put us in stage coordinates so
* we can drawn the result of our offscreen render as a textured
* quad... */
cogl_matrix_init_identity (&modelview);
_clutter_actor_apply_modelview_transform (priv->stage, &modelview);
cogl_matrix_translate (&modelview, priv->x_offset, priv->y_offset, 0.0f);
cogl_set_modelview_matrix (&modelview);
offscreen-effect: Traslate the modelview with the offsets Instead of using the stage offsets when painting we can simply traslate the current modelview. This allows sub-classes to fully override the paint_target() virtual function without chaining up.
2010-06-10 12:35:56 -04:00
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
/* paint the target material; this is virtualized for
* sub-classes that require special hand-holding
*/
clutter-offscreen-effect: Don't redraw the actor if cached offscreen When painting an actor, it now tries to determine if the last paint of the offscreen was using the same matrix and the actor isn't dirty. If so, it can skip calling clutter_actor_continue_paint and avoid actually painting the actor. Instead just the offscreen image will be painted.
2011-02-25 06:24:23 -05:00
clutter_offscreen_effect_paint_target (effect);
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
cogl_pop_matrix ();
effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -04:00
}
clutter-offscreen-effect: Don't redraw the actor if cached offscreen When painting an actor, it now tries to determine if the last paint of the offscreen was using the same matrix and the actor isn't dirty. If so, it can skip calling clutter_actor_continue_paint and avoid actually painting the actor. Instead just the offscreen image will be painted.
2011-02-25 06:24:23 -05:00
static void
clutter_offscreen_effect_post_paint (ClutterEffect *effect)
{
ClutterOffscreenEffect *self = CLUTTER_OFFSCREEN_EFFECT (effect);
ClutterOffscreenEffectPrivate *priv = self->priv;
if (priv->offscreen == COGL_INVALID_HANDLE ||
priv->target == COGL_INVALID_HANDLE ||
priv->actor == NULL)
return;
/* Restore the previous opacity override */
_clutter_actor_set_opacity_override (priv->actor, priv->old_opacity_override);
cogl_pop_matrix ();
cogl_pop_framebuffer ();
clutter_offscreen_effect_paint_texture (self);
}
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_offscreen_effect_paint (ClutterEffect *effect,
ClutterEffectPaintFlags flags)
clutter-offscreen-effect: Don't redraw the actor if cached offscreen When painting an actor, it now tries to determine if the last paint of the offscreen was using the same matrix and the actor isn't dirty. If so, it can skip calling clutter_actor_continue_paint and avoid actually painting the actor. Instead just the offscreen image will be painted.
2011-02-25 06:24:23 -05:00
{
ClutterOffscreenEffect *self = CLUTTER_OFFSCREEN_EFFECT (effect);
ClutterOffscreenEffectPrivate *priv = self->priv;
CoglMatrix matrix;
cogl_get_modelview_matrix (&matrix);
/* If we've already got a cached image for the same matrix and the
actor hasn't been redrawn then we can just use the cached image
in the fbo */
if (priv->offscreen == NULL ||
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
(flags & CLUTTER_EFFECT_PAINT_ACTOR_DIRTY) ||
clutter-offscreen-effect: Don't redraw the actor if cached offscreen When painting an actor, it now tries to determine if the last paint of the offscreen was using the same matrix and the actor isn't dirty. If so, it can skip calling clutter_actor_continue_paint and avoid actually painting the actor. Instead just the offscreen image will be painted.
2011-02-25 06:24:23 -05:00
!cogl_matrix_equal (&matrix, &priv->last_matrix_drawn))
{
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
/* Chain up to the parent paint method which will call the pre and
clutter-offscreen-effect: Don't redraw the actor if cached offscreen When painting an actor, it now tries to determine if the last paint of the offscreen was using the same matrix and the actor isn't dirty. If so, it can skip calling clutter_actor_continue_paint and avoid actually painting the actor. Instead just the offscreen image will be painted.
2011-02-25 06:24:23 -05:00
post paint functions to update the image */
CLUTTER_EFFECT_CLASS (clutter_offscreen_effect_parent_class)->
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 (effect, flags);
clutter-offscreen-effect: Don't redraw the actor if cached offscreen When painting an actor, it now tries to determine if the last paint of the offscreen was using the same matrix and the actor isn't dirty. If so, it can skip calling clutter_actor_continue_paint and avoid actually painting the actor. Instead just the offscreen image will be painted.
2011-02-25 06:24:23 -05:00
}
else
clutter_offscreen_effect_paint_texture (self);
}
effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -04:00
static void
clutter_offscreen_effect_finalize (GObject *gobject)
{
ClutterOffscreenEffect *self = CLUTTER_OFFSCREEN_EFFECT (gobject);
ClutterOffscreenEffectPrivate *priv = self->priv;
if (priv->offscreen)
cogl_handle_unref (priv->offscreen);
if (priv->target)
cogl_handle_unref (priv->target);
G_OBJECT_CLASS (clutter_offscreen_effect_parent_class)->finalize (gobject);
}
static void
clutter_offscreen_effect_class_init (ClutterOffscreenEffectClass *klass)
{
ClutterActorMetaClass *meta_class = CLUTTER_ACTOR_META_CLASS (klass);
ClutterEffectClass *effect_class = CLUTTER_EFFECT_CLASS (klass);
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
g_type_class_add_private (klass, sizeof (ClutterOffscreenEffectPrivate));
offscreen-effect: Rename create_target to create_buffer *** This is an API change *** The create_target() virtual function should return a CoglHandle to a texture; clutter_offscreen_effect_get_target(), instead, returns a CoglMaterial to be painted in the implementation of the paint_target() virtual function. Instead of equating textures with materials, and confusing the user of the API, we should mark the difference more prominently. First of all, we should return a CoglMaterial* (now that we have that as a public type) in get_target(); having handles all over the place does not make it easier to distinguish the semantics of the virtual functions. Then we should rename create_target() to create_texture(), to make it clear that what should be returned is a texture that is used as the backing for the offscreen framebuffer.
2010-09-01 12:56:15 -04:00
klass->create_texture = clutter_offscreen_effect_real_create_texture;
effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -04:00
klass->paint_target = clutter_offscreen_effect_real_paint_target;
meta_class->set_actor = clutter_offscreen_effect_set_actor;
effect_class->pre_paint = clutter_offscreen_effect_pre_paint;
effect_class->post_paint = clutter_offscreen_effect_post_paint;
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_class->paint = clutter_offscreen_effect_paint;
effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -04:00
gobject_class->finalize = clutter_offscreen_effect_finalize;
}
static void
clutter_offscreen_effect_init (ClutterOffscreenEffect *self)
{
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
CLUTTER_TYPE_OFFSCREEN_EFFECT,
ClutterOffscreenEffectPrivate);
}
/**
* clutter_offscreen_effect_get_target:
* @effect: a #ClutterOffscreenEffect
*
* Retrieves the material used as a render target for the offscreen
* buffer created by @effect
*
offscreen-effect: Rename create_target to create_buffer *** This is an API change *** The create_target() virtual function should return a CoglHandle to a texture; clutter_offscreen_effect_get_target(), instead, returns a CoglMaterial to be painted in the implementation of the paint_target() virtual function. Instead of equating textures with materials, and confusing the user of the API, we should mark the difference more prominently. First of all, we should return a CoglMaterial* (now that we have that as a public type) in get_target(); having handles all over the place does not make it easier to distinguish the semantics of the virtual functions. Then we should rename create_target() to create_texture(), to make it clear that what should be returned is a texture that is used as the backing for the offscreen framebuffer.
2010-09-01 12:56:15 -04:00
* You should only use the returned #CoglMaterial when painting. The
* returned material might change between different frames.
*
* Return value: (transfer none): a #CoglMaterial or %NULL. The
* returned material is owned by Clutter and it should not be
* modified or freed
effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -04:00
*
* Since: 1.4
*/
offscreen-effect: Rename create_target to create_buffer *** This is an API change *** The create_target() virtual function should return a CoglHandle to a texture; clutter_offscreen_effect_get_target(), instead, returns a CoglMaterial to be painted in the implementation of the paint_target() virtual function. Instead of equating textures with materials, and confusing the user of the API, we should mark the difference more prominently. First of all, we should return a CoglMaterial* (now that we have that as a public type) in get_target(); having handles all over the place does not make it easier to distinguish the semantics of the virtual functions. Then we should rename create_target() to create_texture(), to make it clear that what should be returned is a texture that is used as the backing for the offscreen framebuffer.
2010-09-01 12:56:15 -04:00
CoglMaterial *
effect: Add OffscreenEffect The OffscreenEffect class is meant to be used to implement Effect sub-classes that create an offscreen framebuffer and redirect the actor's paint sequence there. The OffscreenEffect is useful for effects using fragment shaders. Any shader-based effect being applied to an actor through an offscreen buffer should be used before painting the resulting target material and not for every actor. This means that doing: pre_paint: cogl_program_use(program) set up offscreen buffer paint: [ actors ] → offscreen buffer → target material post_paint: paint target material cogl_program_use(null) Is not correct. Unfortunately, we cannot really do: post_paint: cogl_program_use(program) paint target material cogl_program_use(null) Because the OffscreenEffect::post_paint() implementation also pops the offscreen buffer and re-instates the previous framebuffer: post_paint: cogl_program_use(program) change frame buffer ← ouch! paint target material cogl_program_use(null) One way to fix it is to allow using the shader right before painting the target material - which means adding a new virtual inside the OffscreenEffect class vtable in additions to the ones defined by the parent Effect class. The newly-added paint_target() virtual allows the correct sequence of actions by adding an entry point for sub-classes to wrap the "paint target material" operation with custom code, in order to implement the case above correctly as: post_paint: change frame buffer cogl_program_use(program) paint target material cogl_program_use(null) The added upside is that sub-classes of OffscreenEffect involving shaders really just need to override the prepare() and paint_target() virtuals, since the pre_paint() and post_paint() do all that's needed.
2010-05-17 06:39:27 -04:00
clutter_offscreen_effect_get_target (ClutterOffscreenEffect *effect)
{
g_return_val_if_fail (CLUTTER_IS_OFFSCREEN_EFFECT (effect),
COGL_INVALID_HANDLE);
return effect->priv->target;
}
/**
* clutter_offscreen_effect_paint_target:
* @effect: a #ClutterOffscreenEffect
*
* Calls the paint_target() virtual function of the @effect
*
* Since: 1.4
*/
void
clutter_offscreen_effect_paint_target (ClutterOffscreenEffect *effect)
{
g_return_if_fail (CLUTTER_IS_OFFSCREEN_EFFECT (effect));
CLUTTER_OFFSCREEN_EFFECT_GET_CLASS (effect)->paint_target (effect);
}
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
/**
offscreen-effect: Rename create_target to create_buffer *** This is an API change *** The create_target() virtual function should return a CoglHandle to a texture; clutter_offscreen_effect_get_target(), instead, returns a CoglMaterial to be painted in the implementation of the paint_target() virtual function. Instead of equating textures with materials, and confusing the user of the API, we should mark the difference more prominently. First of all, we should return a CoglMaterial* (now that we have that as a public type) in get_target(); having handles all over the place does not make it easier to distinguish the semantics of the virtual functions. Then we should rename create_target() to create_texture(), to make it clear that what should be returned is a texture that is used as the backing for the offscreen framebuffer.
2010-09-01 12:56:15 -04:00
* clutter_offscreen_effect_create_texture:
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
* @effect: a #ClutterOffscreenEffect
* @width: the minimum width of the target texture
* @height: the minimum height of the target texture
*
offscreen-effect: Rename create_target to create_buffer *** This is an API change *** The create_target() virtual function should return a CoglHandle to a texture; clutter_offscreen_effect_get_target(), instead, returns a CoglMaterial to be painted in the implementation of the paint_target() virtual function. Instead of equating textures with materials, and confusing the user of the API, we should mark the difference more prominently. First of all, we should return a CoglMaterial* (now that we have that as a public type) in get_target(); having handles all over the place does not make it easier to distinguish the semantics of the virtual functions. Then we should rename create_target() to create_texture(), to make it clear that what should be returned is a texture that is used as the backing for the offscreen framebuffer.
2010-09-01 12:56:15 -04:00
* Calls the create_texture() virtual function of the @effect
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
*
Add some more introspection annotations
2010-09-06 11:11:46 -04:00
* Return value: (transfer full): a handle to a Cogl texture, or
* %COGL_INVALID_HANDLE. The returned handle has its reference
* count increased.
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
*
* Since: 1.4
*/
CoglHandle
offscreen-effect: Rename create_target to create_buffer *** This is an API change *** The create_target() virtual function should return a CoglHandle to a texture; clutter_offscreen_effect_get_target(), instead, returns a CoglMaterial to be painted in the implementation of the paint_target() virtual function. Instead of equating textures with materials, and confusing the user of the API, we should mark the difference more prominently. First of all, we should return a CoglMaterial* (now that we have that as a public type) in get_target(); having handles all over the place does not make it easier to distinguish the semantics of the virtual functions. Then we should rename create_target() to create_texture(), to make it clear that what should be returned is a texture that is used as the backing for the offscreen framebuffer.
2010-09-01 12:56:15 -04:00
clutter_offscreen_effect_create_texture (ClutterOffscreenEffect *effect,
gfloat width,
gfloat height)
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
{
g_return_val_if_fail (CLUTTER_IS_OFFSCREEN_EFFECT (effect),
COGL_INVALID_HANDLE);
offscreen-effect: Rename create_target to create_buffer *** This is an API change *** The create_target() virtual function should return a CoglHandle to a texture; clutter_offscreen_effect_get_target(), instead, returns a CoglMaterial to be painted in the implementation of the paint_target() virtual function. Instead of equating textures with materials, and confusing the user of the API, we should mark the difference more prominently. First of all, we should return a CoglMaterial* (now that we have that as a public type) in get_target(); having handles all over the place does not make it easier to distinguish the semantics of the virtual functions. Then we should rename create_target() to create_texture(), to make it clear that what should be returned is a texture that is used as the backing for the offscreen framebuffer.
2010-09-01 12:56:15 -04:00
return CLUTTER_OFFSCREEN_EFFECT_GET_CLASS (effect)->create_texture (effect,
width,
height);
effect: Rework the OffscreenEffect painting The OffscreenEffect should set up the off screen draw buffer so that it has the same projection and modelview as if it where on screen; we achieve that by setting up the viewport to be the same size of the stage but with an initial offset given by the left-most vertex of the actor. When we paint the texture attached to the FBO we then set up the modelview matrix of the on screen draw buffer so that it's the same as the stage one: this way, the texture will be painted in screen coordinates and it will occupy the same area as the actor would have had.
2010-04-16 07:33:20 -04:00
}
offscreen-effect: Add private API for getting the target size Since the FBO target might have a different size than the mere paint box of the actor, we need API to get it out of the ClutterOffscreenEffect private data structure and on to sub-classes. Since we cannot add new API in a stable cycle, we need a private function; we'll leave it there even when opening 1.7, since it's useful for internal purposes.
2011-02-19 04:15:34 -05:00
offscreen-effect: Add public accessor for target size The OffscreenEffect class needs to expose a way for sub-classes to track the size of FBO it creates, in case it has to do some geometry deformations like the DeformEffect sub-classes. Let's move the private symbol we used internally in 1.6 to fix DeformEffect to the list of public symbols of OffscreenEffect. http://bugzilla.clutter-project.org/show_bug.cgi?id=2570
2011-02-28 09:31:59 -05:00
/**
* clutter_offscreen_effect_get_target_size:
* @effect: a #ClutterOffscreenEffect
* @width: (out): return location for the target width, or %NULL
* @height: (out): return location for the target height, or %NULL
*
* Retrieves the size of the offscreen buffer used by @effect to
* paint the actor to which it has been applied.
*
* This function should only be called by #ClutterOffscreenEffect
* implementations, from within the <function>paint_target()</function>
* virtual function.
*
* Return value: %TRUE if the offscreen buffer has a valid size,
* and %FALSE otherwise
*
* Since: 1.8
*/
offscreen-effect: Add private API for getting the target size Since the FBO target might have a different size than the mere paint box of the actor, we need API to get it out of the ClutterOffscreenEffect private data structure and on to sub-classes. Since we cannot add new API in a stable cycle, we need a private function; we'll leave it there even when opening 1.7, since it's useful for internal purposes.
2011-02-19 04:15:34 -05:00
gboolean
offscreen-effect: Add public accessor for target size The OffscreenEffect class needs to expose a way for sub-classes to track the size of FBO it creates, in case it has to do some geometry deformations like the DeformEffect sub-classes. Let's move the private symbol we used internally in 1.6 to fix DeformEffect to the list of public symbols of OffscreenEffect. http://bugzilla.clutter-project.org/show_bug.cgi?id=2570
2011-02-28 09:31:59 -05:00
clutter_offscreen_effect_get_target_size (ClutterOffscreenEffect *effect,
gfloat *width,
gfloat *height)
offscreen-effect: Add private API for getting the target size Since the FBO target might have a different size than the mere paint box of the actor, we need API to get it out of the ClutterOffscreenEffect private data structure and on to sub-classes. Since we cannot add new API in a stable cycle, we need a private function; we'll leave it there even when opening 1.7, since it's useful for internal purposes.
2011-02-19 04:15:34 -05:00
{
offscreen-effect: Add public accessor for target size The OffscreenEffect class needs to expose a way for sub-classes to track the size of FBO it creates, in case it has to do some geometry deformations like the DeformEffect sub-classes. Let's move the private symbol we used internally in 1.6 to fix DeformEffect to the list of public symbols of OffscreenEffect. http://bugzilla.clutter-project.org/show_bug.cgi?id=2570
2011-02-28 09:31:59 -05:00
ClutterOffscreenEffectPrivate *priv;
g_return_val_if_fail (CLUTTER_IS_OFFSCREEN_EFFECT (effect), FALSE);
priv = effect->priv;
offscreen-effect: Add private API for getting the target size Since the FBO target might have a different size than the mere paint box of the actor, we need API to get it out of the ClutterOffscreenEffect private data structure and on to sub-classes. Since we cannot add new API in a stable cycle, we need a private function; we'll leave it there even when opening 1.7, since it's useful for internal purposes.
2011-02-19 04:15:34 -05:00
if (priv->target == NULL)
return FALSE;
if (width)
*width = priv->target_width;
if (height)
*height = priv->target_height;
return TRUE;
}
Reference in New Issue Copy Permalink