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

738 lines
25 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 10:39:27 +00:00
/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2010 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
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 11:33:20 +00: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 10:39:27 +00: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 11:33:20 +00: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 10:39:27 +00: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.
*
* #ClutterOffscreenEffect is available since Clutter 1.4
docs: Move to markdown We're removing docbook tags in favour of the markdown syntax.
2014-03-17 23:07:58 +00:00
*
* ## Implementing a ClutterOffscreenEffect
*
* Creating a sub-class of #ClutterOffscreenEffect requires, in case
* of overriding the #ClutterEffect virtual functions, to chain up to the
* #ClutterOffscreenEffect's implementation.
*
* On top of the #ClutterEffect's virtual functions,
* #ClutterOffscreenEffect also provides a #ClutterOffscreenEffectClass.paint_target()
* function, which encapsulates the effective painting of the texture that
* contains the result of the offscreen redirection.
*
* 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
* #ClutterOffscreenEffectClass.create_texture() virtual function; no chain up
* to the #ClutterOffscreenEffect implementation is required in this
* case.
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 10:39:27 +00:00
*/
Don't use config.h in clutter and cogl In cogl use cogl-config.h and in clutter use clutter-build-config.h. We can't use clutter-config.h in clutter because its already used and installed. https://bugzilla.gnome.org/show_bug.cgi?id=768976
2016-05-05 14:21:51 +00:00
#include "clutter-build-config.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 10:39:27 +00:00
#include "clutter-offscreen-effect.h"
clutter/offscreen-effect: Support adding effect to resource scaled actors At this level we use ceiled resource-scale when painting fractional value When using fractional scaling we still need to create an integer-sized texture and then we should paint it using a size which is proportional to the real actor size ratio, and only paint a subsample of it, but this doesn't seem to work properly with some weird scaling values. Then, it's just better to draw the texture ceiled and then we scale it down to match the proper actor scaling at paint level. https://bugzilla.gnome.org/show_bug.cgi?id=765011 https://gitlab.gnome.org/GNOME/mutter/merge_requests/3
2017-09-07 20:59:50 +00:00
#include <math.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 10:39:27 +00:00
#include "cogl/cogl.h"
Clean up clutter-private.h/6 Move all Actor private API to a separate file.
2010-10-21 11:16:05 +00: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 10:39:27 +00: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 10:29:09 +00:00
#include "clutter-stage-private.h"
clutter, core: Stop using the Cogl framebuffer stack The Cogl framebuffer stack is going away; replace all its uses by the framebuffer stack carried by the paint context. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-22 10:41:04 +00:00
#include "clutter-paint-context-private.h"
clutter: Fix offscreen-effect painting of clones `ClutterOffscreenEffect` had been getting the wrong bounding box in the case of clones and descendents of clones, causing visibly incorrect clipping. This was due to `clutter_actor_get_paint_box` only ever being given the source actor during a paint (which is correct) and not the clone. Even if we weren't painting a clone but an offscreened descendent of a clone (like in gnome-shell's desktop zoom), we would get the wrong result. Fortunately we don't need to know the actual clone/actor being painted so don't need to call the problematic `clutter_actor_get_paint_box` at all. The solution is to only keep untransformed rendering in the FBO and leave the correct transformation for later. The correct clone/actor's transformation is already set for us as the current cogl modelview matrix by `clutter_actor_paint`. Bonus optimization: This all means we don't need to keep `last_matrix_drawn` or force a full repaint every time some part of the transformation changes. Because the FBO contents are no longer affected by transformations. As it should be. In other words, offscreen-effected actors can now move around on screen without themselves being repainted. Special thanks to Mai Lavelle for identifying the cause of the problem. Fixes: https://bugzilla.gnome.org/show_bug.cgi?id=789050, https://bugzilla.gnome.org/show_bug.cgi?id=659523#c9, https://gitlab.gnome.org/GNOME/mutter/issues/196, https://gitlab.gnome.org/GNOME/mutter/issues/282, https://gitlab.gnome.org/GNOME/gnome-shell/issues/387, https://launchpad.net/bugs/1767648, https://launchpad.net/bugs/1779615
2018-05-24 09:51:22 +00:00
#include "clutter-paint-volume-private.h"
#include "clutter-actor-box-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 10:39:27 +00:00
struct _ClutterOffscreenEffectPrivate
{
CoglHandle offscreen;
clutter/offscreen-effect: Rename CoglPipeline field to 'pipeline' This is the same case of the layer node: a CoglPipeline field that is not called 'pipeline' makes it harder to figure out what it really is. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1167
2020-03-31 01:26:18 +00:00
CoglPipeline *pipeline;
offscreen-effect: Add clutter_offscreen_effect_get_texture Sometimes a subclass of ClutterOffscreenEffect wants to paint with a completely custom material. In that case it is awkward to modify the material returned owned by ClutterOffscreenEffect so it makes more sense to just get the texture and manage its own material. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 11:53:54 +00:00
CoglHandle 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 10:39:27 +00: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 11:33:20 +00:00
ClutterActor *stage;
Replace ClutterVertex by graphene_point3d_t Pretty direct and straightforward port. This requires a GNOME Shell counterpart. In addition to that, include a progress function. https://gitlab.gnome.org/GNOME/mutter/merge_requests/458
2019-02-20 13:18:48 +00:00
graphene_point3d_t position;
clutter: Fix offscreen-effect painting of clones `ClutterOffscreenEffect` had been getting the wrong bounding box in the case of clones and descendents of clones, causing visibly incorrect clipping. This was due to `clutter_actor_get_paint_box` only ever being given the source actor during a paint (which is correct) and not the clone. Even if we weren't painting a clone but an offscreened descendent of a clone (like in gnome-shell's desktop zoom), we would get the wrong result. Fortunately we don't need to know the actual clone/actor being painted so don't need to call the problematic `clutter_actor_get_paint_box` at all. The solution is to only keep untransformed rendering in the FBO and leave the correct transformation for later. The correct clone/actor's transformation is already set for us as the current cogl modelview matrix by `clutter_actor_paint`. Bonus optimization: This all means we don't need to keep `last_matrix_drawn` or force a full repaint every time some part of the transformation changes. Because the FBO contents are no longer affected by transformations. As it should be. In other words, offscreen-effected actors can now move around on screen without themselves being repainted. Special thanks to Mai Lavelle for identifying the cause of the problem. Fixes: https://bugzilla.gnome.org/show_bug.cgi?id=789050, https://bugzilla.gnome.org/show_bug.cgi?id=659523#c9, https://gitlab.gnome.org/GNOME/mutter/issues/196, https://gitlab.gnome.org/GNOME/mutter/issues/282, https://gitlab.gnome.org/GNOME/gnome-shell/issues/387, https://launchpad.net/bugs/1767648, https://launchpad.net/bugs/1779615
2018-05-24 09:51:22 +00:00
int fbo_offset_x;
int fbo_offset_y;
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 11:33:20 +00: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 13:08:57 +00: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 */
clutter/offscreen-effect: Support adding effect to resource scaled actors At this level we use ceiled resource-scale when painting fractional value When using fractional scaling we still need to create an integer-sized texture and then we should paint it using a size which is proportional to the real actor size ratio, and only paint a subsample of it, but this doesn't seem to work properly with some weird scaling values. Then, it's just better to draw the texture ceiled and then we scale it down to match the proper actor scaling at paint level. https://bugzilla.gnome.org/show_bug.cgi?id=765011 https://gitlab.gnome.org/GNOME/mutter/merge_requests/3
2017-09-07 20:59:50 +00:00
int target_width;
int target_height;
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 13:08:57 +00:00
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 16:46:26 +00:00
gint old_opacity_override;
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 10:39:27 +00:00
};
Use the new macros for adding private data
2013-07-03 13:14:01 +00:00
G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (ClutterOffscreenEffect,
clutter_offscreen_effect,
CLUTTER_TYPE_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 10:39:27 +00:00
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 */
clutter/offscreen-effect: Use g_clear_pointer for cleanup It does the exact same checks, and saves us a few lines of code. https://gitlab.gnome.org/GNOME/mutter/merge_requests/992
2020-01-07 14:57:02 +00:00
g_clear_pointer (&priv->offscreen, cogl_object_unref);
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 10:39:27 +00:00
/* 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 11:33:20 +00: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 16:56:15 +00: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 11:33:20 +00:00
{
Revert "clutter-offscreen-effect: Allocate the cogl texture directly" This reverts commit 180e7d74f3325731ac5e91350233c26200a44fd7. The lazy texture allocation is gone in Cogl 1.15.9.
2013-09-02 16:06:49 +00:00
return cogl_texture_new_with_size (MAX (width, 1), MAX (height, 1),
COGL_TEXTURE_NO_SLICING,
COGL_PIXEL_FORMAT_RGBA_8888_PRE);
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 11:33:20 +00:00
}
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 10:39:27 +00:00
clutter/offscreen-effect: Make sure we use linear filter for fractional scaling When we try to update the FB, we might face the case in which the effect target framebuffer does not need any redraw, because it's already properly sized and scaled, but the filter applied to the pipeline is not, because it has been computed for a non-fractional scaling. This is happens for example to clutter actors with a flattening effect (i.e. override redirect mode set), that might have been generated properly for a celied scaling level, but when we go fractional we need to ensure to use a linear filter, as the 1:1 texel:pixel assumption is not true anymore. https://bugzilla.gnome.org/show_bug.cgi?id=765011 https://gitlab.gnome.org/GNOME/mutter/merge_requests/3
2018-11-22 07:13:43 +00:00
static void
ensure_pipeline_filter_for_scale (ClutterOffscreenEffect *self,
float resource_scale)
{
CoglPipelineFilter filter;
clutter/offscreen-effect: Rename CoglPipeline field to 'pipeline' This is the same case of the layer node: a CoglPipeline field that is not called 'pipeline' makes it harder to figure out what it really is. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1167
2020-03-31 01:26:18 +00:00
if (!self->priv->pipeline)
clutter/offscreen-effect: Make sure we use linear filter for fractional scaling When we try to update the FB, we might face the case in which the effect target framebuffer does not need any redraw, because it's already properly sized and scaled, but the filter applied to the pipeline is not, because it has been computed for a non-fractional scaling. This is happens for example to clutter actors with a flattening effect (i.e. override redirect mode set), that might have been generated properly for a celied scaling level, but when we go fractional we need to ensure to use a linear filter, as the 1:1 texel:pixel assumption is not true anymore. https://bugzilla.gnome.org/show_bug.cgi?id=765011 https://gitlab.gnome.org/GNOME/mutter/merge_requests/3
2018-11-22 07:13:43 +00:00
return;
/* If no fractional scaling is set, we're always going to render the texture
at a 1:1 texel:pixel ratio so, in such case we can use 'nearest' filtering
to decrease the effects of rounding errors in the geometry calculation;
if instead we we're using a global fractional scaling we need to make sure
that we're using the default linear effect, not to create artifacts when
scaling down the texture */
if (fmodf (resource_scale, 1.0f) == 0)
filter = COGL_PIPELINE_FILTER_NEAREST;
else
filter = COGL_PIPELINE_FILTER_LINEAR;
clutter/offscreen-effect: Rename CoglPipeline field to 'pipeline' This is the same case of the layer node: a CoglPipeline field that is not called 'pipeline' makes it harder to figure out what it really is. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1167
2020-03-31 01:26:18 +00:00
cogl_pipeline_set_layer_filters (self->priv->pipeline, 0 /* layer_index */,
clutter/offscreen-effect: Make sure we use linear filter for fractional scaling When we try to update the FB, we might face the case in which the effect target framebuffer does not need any redraw, because it's already properly sized and scaled, but the filter applied to the pipeline is not, because it has been computed for a non-fractional scaling. This is happens for example to clutter actors with a flattening effect (i.e. override redirect mode set), that might have been generated properly for a celied scaling level, but when we go fractional we need to ensure to use a linear filter, as the 1:1 texel:pixel assumption is not true anymore. https://bugzilla.gnome.org/show_bug.cgi?id=765011 https://gitlab.gnome.org/GNOME/mutter/merge_requests/3
2018-11-22 07:13:43 +00:00
filter, filter);
}
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 11:33:20 +00:00
static gboolean
clutter/offscreen-effect: Support adding effect to resource scaled actors At this level we use ceiled resource-scale when painting fractional value When using fractional scaling we still need to create an integer-sized texture and then we should paint it using a size which is proportional to the real actor size ratio, and only paint a subsample of it, but this doesn't seem to work properly with some weird scaling values. Then, it's just better to draw the texture ceiled and then we scale it down to match the proper actor scaling at paint level. https://bugzilla.gnome.org/show_bug.cgi?id=765011 https://gitlab.gnome.org/GNOME/mutter/merge_requests/3
2017-09-07 20:59:50 +00:00
update_fbo (ClutterEffect *effect,
int target_width,
int target_height,
float resource_scale)
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 11:33:20 +00:00
{
ClutterOffscreenEffect *self = CLUTTER_OFFSCREEN_EFFECT (effect);
ClutterOffscreenEffectPrivate *priv = self->priv;
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 10:39:27 +00: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 11:33:20 +00: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 10:39:27 +00:00
}
clutter/offscreen-effect: Support adding effect to resource scaled actors At this level we use ceiled resource-scale when painting fractional value When using fractional scaling we still need to create an integer-sized texture and then we should paint it using a size which is proportional to the real actor size ratio, and only paint a subsample of it, but this doesn't seem to work properly with some weird scaling values. Then, it's just better to draw the texture ceiled and then we scale it down to match the proper actor scaling at paint level. https://bugzilla.gnome.org/show_bug.cgi?id=765011 https://gitlab.gnome.org/GNOME/mutter/merge_requests/3
2017-09-07 20:59:50 +00:00
if (priv->target_width == target_width &&
priv->target_height == target_height &&
Reduce our internal dependence on the Cogl 1.x api Since Cogl has started restricting what cogl 1.x api is exposed when COGL_ENABLE_EXPERIMENTAL_2_0_API is defined and since we build all Clutter internals with COGL_ENABLE_EXPERIMENTAL_2_0_API defined this patch makes a first pass at reducing our internal use of the Cogl 1.x api. The most notable api that's no longer exposed to us internally is the cogl_material_ api so this switches all Clutter internals to use the cogl_pipeline_ api instead. This patch also makes quite a bit of progress removing internal uses of CoglHandle although there is still more to go.
2012-02-21 15:55:51 +00:00
priv->offscreen != NULL)
clutter/offscreen-effect: Make sure we use linear filter for fractional scaling When we try to update the FB, we might face the case in which the effect target framebuffer does not need any redraw, because it's already properly sized and scaled, but the filter applied to the pipeline is not, because it has been computed for a non-fractional scaling. This is happens for example to clutter actors with a flattening effect (i.e. override redirect mode set), that might have been generated properly for a celied scaling level, but when we go fractional we need to ensure to use a linear filter, as the 1:1 texel:pixel assumption is not true anymore. https://bugzilla.gnome.org/show_bug.cgi?id=765011 https://gitlab.gnome.org/GNOME/mutter/merge_requests/3
2018-11-22 07:13:43 +00:00
{
ensure_pipeline_filter_for_scale (self, resource_scale);
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 11:33:20 +00:00
return TRUE;
clutter/offscreen-effect: Make sure we use linear filter for fractional scaling When we try to update the FB, we might face the case in which the effect target framebuffer does not need any redraw, because it's already properly sized and scaled, but the filter applied to the pipeline is not, because it has been computed for a non-fractional scaling. This is happens for example to clutter actors with a flattening effect (i.e. override redirect mode set), that might have been generated properly for a celied scaling level, but when we go fractional we need to ensure to use a linear filter, as the 1:1 texel:pixel assumption is not true anymore. https://bugzilla.gnome.org/show_bug.cgi?id=765011 https://gitlab.gnome.org/GNOME/mutter/merge_requests/3
2018-11-22 07:13:43 +00:00
}
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 10:39:27 +00:00
clutter/offscreen-effect: Rename CoglPipeline field to 'pipeline' This is the same case of the layer node: a CoglPipeline field that is not called 'pipeline' makes it harder to figure out what it really is. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1167
2020-03-31 01:26:18 +00:00
if (priv->pipeline == NULL)
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 16:20:34 +00:00
{
Pass a CoglContext when calling cogl_pipeline_new The experimental cogl_pipeline_new() api was recently changed so it explicitly takes a CoglContext. This updates all calls to cogl_pipeline_new() in clutter accordingly.
2012-02-21 13:22:17 +00:00
CoglContext *ctx =
clutter_backend_get_cogl_context (clutter_get_default_backend ());
clutter/offscreen-effect: Rename CoglPipeline field to 'pipeline' This is the same case of the layer node: a CoglPipeline field that is not called 'pipeline' makes it harder to figure out what it really is. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1167
2020-03-31 01:26:18 +00:00
priv->pipeline = cogl_pipeline_new (ctx);
clutter/offscreen-effect: Make sure we use linear filter for fractional scaling When we try to update the FB, we might face the case in which the effect target framebuffer does not need any redraw, because it's already properly sized and scaled, but the filter applied to the pipeline is not, because it has been computed for a non-fractional scaling. This is happens for example to clutter actors with a flattening effect (i.e. override redirect mode set), that might have been generated properly for a celied scaling level, but when we go fractional we need to ensure to use a linear filter, as the 1:1 texel:pixel assumption is not true anymore. https://bugzilla.gnome.org/show_bug.cgi?id=765011 https://gitlab.gnome.org/GNOME/mutter/merge_requests/3
2018-11-22 07:13:43 +00:00
ensure_pipeline_filter_for_scale (self, resource_scale);
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 16:20:34 +00:00
}
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 10:39:27 +00:00
clutter/offscreen-effect: Use g_clear_pointer for cleanup It does the exact same checks, and saves us a few lines of code. https://gitlab.gnome.org/GNOME/mutter/merge_requests/992
2020-01-07 14:57:02 +00:00
g_clear_pointer (&priv->texture, cogl_object_unref);
g_clear_pointer (&priv->offscreen, cogl_object_unref);
clutter-offscreen-effect: Disable if no texture If texture allocation fails (e.g. on an old GPU with size limit 2048) then `update_fbo` would return `FALSE` but leaves `priv->offscreen` as non-NULL. So the next paint will try to use the offscreen with a `NULL` texture and crashes. The solution is simply to ensure that `priv->offscreen` is NULL if there is no `priv->texture`, so the default (non-offscreen) paint path gets used instead. Bug reported and fix provided by Gert van de Kraats. https://launchpad.net/bugs/1795774
2018-10-11 07:02:05 +00:00
offscreen-effect: Add clutter_offscreen_effect_get_texture Sometimes a subclass of ClutterOffscreenEffect wants to paint with a completely custom material. In that case it is awkward to modify the material returned owned by ClutterOffscreenEffect so it makes more sense to just get the texture and manage its own material. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 11:53:54 +00:00
priv->texture =
clutter/offscreen-effect: Support adding effect to resource scaled actors At this level we use ceiled resource-scale when painting fractional value When using fractional scaling we still need to create an integer-sized texture and then we should paint it using a size which is proportional to the real actor size ratio, and only paint a subsample of it, but this doesn't seem to work properly with some weird scaling values. Then, it's just better to draw the texture ceiled and then we scale it down to match the proper actor scaling at paint level. https://bugzilla.gnome.org/show_bug.cgi?id=765011 https://gitlab.gnome.org/GNOME/mutter/merge_requests/3
2017-09-07 20:59:50 +00:00
clutter_offscreen_effect_create_texture (self, target_width, target_height);
Reduce our internal dependence on the Cogl 1.x api Since Cogl has started restricting what cogl 1.x api is exposed when COGL_ENABLE_EXPERIMENTAL_2_0_API is defined and since we build all Clutter internals with COGL_ENABLE_EXPERIMENTAL_2_0_API defined this patch makes a first pass at reducing our internal use of the Cogl 1.x api. The most notable api that's no longer exposed to us internally is the cogl_material_ api so this switches all Clutter internals to use the cogl_pipeline_ api instead. This patch also makes quite a bit of progress removing internal uses of CoglHandle although there is still more to go.
2012-02-21 15:55:51 +00:00
if (priv->texture == NULL)
offscreen-effect: Add clutter_offscreen_effect_get_texture Sometimes a subclass of ClutterOffscreenEffect wants to paint with a completely custom material. In that case it is awkward to modify the material returned owned by ClutterOffscreenEffect so it makes more sense to just get the texture and manage its own material. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 11:53:54 +00: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 10:39:27 +00:00
clutter/offscreen-effect: Rename CoglPipeline field to 'pipeline' This is the same case of the layer node: a CoglPipeline field that is not called 'pipeline' makes it harder to figure out what it really is. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1167
2020-03-31 01:26:18 +00:00
cogl_pipeline_set_layer_texture (priv->pipeline, 0, priv->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 10:39:27 +00:00
clutter/offscreen-effect: Support adding effect to resource scaled actors At this level we use ceiled resource-scale when painting fractional value When using fractional scaling we still need to create an integer-sized texture and then we should paint it using a size which is proportional to the real actor size ratio, and only paint a subsample of it, but this doesn't seem to work properly with some weird scaling values. Then, it's just better to draw the texture ceiled and then we scale it down to match the proper actor scaling at paint level. https://bugzilla.gnome.org/show_bug.cgi?id=765011 https://gitlab.gnome.org/GNOME/mutter/merge_requests/3
2017-09-07 20:59:50 +00:00
priv->target_width = target_width;
priv->target_height = target_height;
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 13:08:57 +00:00
offscreen-effect: Add clutter_offscreen_effect_get_texture Sometimes a subclass of ClutterOffscreenEffect wants to paint with a completely custom material. In that case it is awkward to modify the material returned owned by ClutterOffscreenEffect so it makes more sense to just get the texture and manage its own material. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 11:53:54 +00:00
priv->offscreen = cogl_offscreen_new_to_texture (priv->texture);
Reduce our internal dependence on the Cogl 1.x api Since Cogl has started restricting what cogl 1.x api is exposed when COGL_ENABLE_EXPERIMENTAL_2_0_API is defined and since we build all Clutter internals with COGL_ENABLE_EXPERIMENTAL_2_0_API defined this patch makes a first pass at reducing our internal use of the Cogl 1.x api. The most notable api that's no longer exposed to us internally is the cogl_material_ api so this switches all Clutter internals to use the cogl_pipeline_ api instead. This patch also makes quite a bit of progress removing internal uses of CoglHandle although there is still more to go.
2012-02-21 15:55:51 +00:00
if (priv->offscreen == 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 10:39:27 +00:00
{
g_warning ("%s: Unable to create an Offscreen buffer", G_STRLOC);
clutter/offscreen-effect: Rename CoglPipeline field to 'pipeline' This is the same case of the layer node: a CoglPipeline field that is not called 'pipeline' makes it harder to figure out what it really is. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1167
2020-03-31 01:26:18 +00:00
cogl_object_unref (priv->pipeline);
priv->pipeline = NULL;
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 11:33:20 +00:00
clutter/offscreen-effect: Support adding effect to resource scaled actors At this level we use ceiled resource-scale when painting fractional value When using fractional scaling we still need to create an integer-sized texture and then we should paint it using a size which is proportional to the real actor size ratio, and only paint a subsample of it, but this doesn't seem to work properly with some weird scaling values. Then, it's just better to draw the texture ceiled and then we scale it down to match the proper actor scaling at paint level. https://bugzilla.gnome.org/show_bug.cgi?id=765011 https://gitlab.gnome.org/GNOME/mutter/merge_requests/3
2017-09-07 20:59:50 +00:00
priv->target_width = 0;
priv->target_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 11:33:20 +00: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 10:39:27 +00: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 11:33:20 +00: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 10:39:27 +00:00
static gboolean
clutter: Introduce paint contexts When painting, actors rely on semi global state tracked by the state to get various things needed for painting, such as the current draw framebuffer. Having state hidden in such ways can be very deceiving as it's hard to follow changes spread out, and adding more and more state that should be tracked during a paint gets annoying as they will not change in isolation but one by one in their own places. To do this better, introduce a paint context that is passed along in paint calls that contains the necessary state needed during painting. The paint context implements a framebuffer stack just as Cogl works, which is currently needed for offscreen rendering used by clutter. The same context is passed around for paint nodes, contents and effects as well. In this commit, the context is only introduced, but not used. It aims to replace the Cogl framebuffer stack, and will allow actors to know what view it is currently painted on. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-13 21:21:58 +00:00
clutter_offscreen_effect_pre_paint (ClutterEffect *effect,
ClutterPaintContext *paint_context)
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 10:39:27 +00:00
{
ClutterOffscreenEffect *self = CLUTTER_OFFSCREEN_EFFECT (effect);
ClutterOffscreenEffectPrivate *priv = self->priv;
clutter: Fix offscreen-effect painting of clones `ClutterOffscreenEffect` had been getting the wrong bounding box in the case of clones and descendents of clones, causing visibly incorrect clipping. This was due to `clutter_actor_get_paint_box` only ever being given the source actor during a paint (which is correct) and not the clone. Even if we weren't painting a clone but an offscreened descendent of a clone (like in gnome-shell's desktop zoom), we would get the wrong result. Fortunately we don't need to know the actual clone/actor being painted so don't need to call the problematic `clutter_actor_get_paint_box` at all. The solution is to only keep untransformed rendering in the FBO and leave the correct transformation for later. The correct clone/actor's transformation is already set for us as the current cogl modelview matrix by `clutter_actor_paint`. Bonus optimization: This all means we don't need to keep `last_matrix_drawn` or force a full repaint every time some part of the transformation changes. Because the FBO contents are no longer affected by transformations. As it should be. In other words, offscreen-effected actors can now move around on screen without themselves being repainted. Special thanks to Mai Lavelle for identifying the cause of the problem. Fixes: https://bugzilla.gnome.org/show_bug.cgi?id=789050, https://bugzilla.gnome.org/show_bug.cgi?id=659523#c9, https://gitlab.gnome.org/GNOME/mutter/issues/196, https://gitlab.gnome.org/GNOME/mutter/issues/282, https://gitlab.gnome.org/GNOME/gnome-shell/issues/387, https://launchpad.net/bugs/1767648, https://launchpad.net/bugs/1779615
2018-05-24 09:51:22 +00:00
ClutterActorBox raw_box, box;
offscreen-effect: limit offscreen fbo size to the stage's size When using a ClutterOffscreenEffect, the size of the offscreen buffer allocated to perform the effect is currently computed using the paint volume of the actor it's attached to and in the case the paint volume cannot be computed, the effect falls back to using the stage's size. If you scale an actor enough so its paint volume is much bigger that the size of the stage, you can end up running out of memory (which leads to your application crashing). https://bugzilla.gnome.org/show_bug.cgi?id=699675
2013-05-04 16:37:33 +00:00
ClutterActor *stage;
clutter: Fix offscreen-effect painting of clones `ClutterOffscreenEffect` had been getting the wrong bounding box in the case of clones and descendents of clones, causing visibly incorrect clipping. This was due to `clutter_actor_get_paint_box` only ever being given the source actor during a paint (which is correct) and not the clone. Even if we weren't painting a clone but an offscreened descendent of a clone (like in gnome-shell's desktop zoom), we would get the wrong result. Fortunately we don't need to know the actual clone/actor being painted so don't need to call the problematic `clutter_actor_get_paint_box` at all. The solution is to only keep untransformed rendering in the FBO and leave the correct transformation for later. The correct clone/actor's transformation is already set for us as the current cogl modelview matrix by `clutter_actor_paint`. Bonus optimization: This all means we don't need to keep `last_matrix_drawn` or force a full repaint every time some part of the transformation changes. Because the FBO contents are no longer affected by transformations. As it should be. In other words, offscreen-effected actors can now move around on screen without themselves being repainted. Special thanks to Mai Lavelle for identifying the cause of the problem. Fixes: https://bugzilla.gnome.org/show_bug.cgi?id=789050, https://bugzilla.gnome.org/show_bug.cgi?id=659523#c9, https://gitlab.gnome.org/GNOME/mutter/issues/196, https://gitlab.gnome.org/GNOME/mutter/issues/282, https://gitlab.gnome.org/GNOME/gnome-shell/issues/387, https://launchpad.net/bugs/1767648, https://launchpad.net/bugs/1779615
2018-05-24 09:51:22 +00:00
CoglMatrix projection, old_modelview, modelview;
const ClutterPaintVolume *volume;
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 11:33:20 +00:00
CoglColor transparent;
offscreen-effect: limit offscreen fbo size to the stage's size When using a ClutterOffscreenEffect, the size of the offscreen buffer allocated to perform the effect is currently computed using the paint volume of the actor it's attached to and in the case the paint volume cannot be computed, the effect falls back to using the stage's size. If you scale an actor enough so its paint volume is much bigger that the size of the stage, you can end up running out of memory (which leads to your application crashing). https://bugzilla.gnome.org/show_bug.cgi?id=699675
2013-05-04 16:37:33 +00:00
gfloat stage_width, stage_height;
clutter/offscreen-effect: Support adding effect to resource scaled actors At this level we use ceiled resource-scale when painting fractional value When using fractional scaling we still need to create an integer-sized texture and then we should paint it using a size which is proportional to the real actor size ratio, and only paint a subsample of it, but this doesn't seem to work properly with some weird scaling values. Then, it's just better to draw the texture ceiled and then we scale it down to match the proper actor scaling at paint level. https://bugzilla.gnome.org/show_bug.cgi?id=765011 https://gitlab.gnome.org/GNOME/mutter/merge_requests/3
2017-09-07 20:59:50 +00:00
gfloat target_width = -1, target_height = -1;
clutter/offscreen-effect: Don't use implicit framebuffer Cogl APIs While we still push and pop to the Cogl framebuffer stack, as so is still needed to render the actors correctly, don't use the API using the implicit framebuffer stack ourself in the offscreen effect code. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-22 10:18:35 +00:00
CoglFramebuffer *framebuffer;
clutter/offscreen-effect: Support adding effect to resource scaled actors At this level we use ceiled resource-scale when painting fractional value When using fractional scaling we still need to create an integer-sized texture and then we should paint it using a size which is proportional to the real actor size ratio, and only paint a subsample of it, but this doesn't seem to work properly with some weird scaling values. Then, it's just better to draw the texture ceiled and then we scale it down to match the proper actor scaling at paint level. https://bugzilla.gnome.org/show_bug.cgi?id=765011 https://gitlab.gnome.org/GNOME/mutter/merge_requests/3
2017-09-07 20:59:50 +00:00
gfloat resource_scale;
gfloat ceiled_resource_scale;
Replace ClutterVertex by graphene_point3d_t Pretty direct and straightforward port. This requires a GNOME Shell counterpart. In addition to that, include a progress function. https://gitlab.gnome.org/GNOME/mutter/merge_requests/458
2019-02-20 13:18:48 +00:00
graphene_point3d_t local_offset;
clutter: Fix offscreen-effect painting of clones `ClutterOffscreenEffect` had been getting the wrong bounding box in the case of clones and descendents of clones, causing visibly incorrect clipping. This was due to `clutter_actor_get_paint_box` only ever being given the source actor during a paint (which is correct) and not the clone. Even if we weren't painting a clone but an offscreened descendent of a clone (like in gnome-shell's desktop zoom), we would get the wrong result. Fortunately we don't need to know the actual clone/actor being painted so don't need to call the problematic `clutter_actor_get_paint_box` at all. The solution is to only keep untransformed rendering in the FBO and leave the correct transformation for later. The correct clone/actor's transformation is already set for us as the current cogl modelview matrix by `clutter_actor_paint`. Bonus optimization: This all means we don't need to keep `last_matrix_drawn` or force a full repaint every time some part of the transformation changes. Because the FBO contents are no longer affected by transformations. As it should be. In other words, offscreen-effected actors can now move around on screen without themselves being repainted. Special thanks to Mai Lavelle for identifying the cause of the problem. Fixes: https://bugzilla.gnome.org/show_bug.cgi?id=789050, https://bugzilla.gnome.org/show_bug.cgi?id=659523#c9, https://gitlab.gnome.org/GNOME/mutter/issues/196, https://gitlab.gnome.org/GNOME/mutter/issues/282, https://gitlab.gnome.org/GNOME/gnome-shell/issues/387, https://launchpad.net/bugs/1767648, https://launchpad.net/bugs/1779615
2018-05-24 09:51:22 +00:00
gfloat old_viewport[4];
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 10:39:27 +00:00
Replace ClutterVertex by graphene_point3d_t Pretty direct and straightforward port. This requires a GNOME Shell counterpart. In addition to that, include a progress function. https://gitlab.gnome.org/GNOME/mutter/merge_requests/458
2019-02-20 13:18:48 +00:00
local_offset = GRAPHENE_POINT3D_INIT (0.0f, 0.0f, 0.0f);
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 10:39:27 +00: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 11:33:20 +00: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 10:39:27 +00:00
offscreen-effect: limit offscreen fbo size to the stage's size When using a ClutterOffscreenEffect, the size of the offscreen buffer allocated to perform the effect is currently computed using the paint volume of the actor it's attached to and in the case the paint volume cannot be computed, the effect falls back to using the stage's size. If you scale an actor enough so its paint volume is much bigger that the size of the stage, you can end up running out of memory (which leads to your application crashing). https://bugzilla.gnome.org/show_bug.cgi?id=699675
2013-05-04 16:37:33 +00:00
stage = _clutter_actor_get_stage_internal (priv->actor);
clutter_actor_get_size (stage, &stage_width, &stage_height);
clutter/offscreen-effect: Support adding effect to resource scaled actors At this level we use ceiled resource-scale when painting fractional value When using fractional scaling we still need to create an integer-sized texture and then we should paint it using a size which is proportional to the real actor size ratio, and only paint a subsample of it, but this doesn't seem to work properly with some weird scaling values. Then, it's just better to draw the texture ceiled and then we scale it down to match the proper actor scaling at paint level. https://bugzilla.gnome.org/show_bug.cgi?id=765011 https://gitlab.gnome.org/GNOME/mutter/merge_requests/3
2017-09-07 20:59:50 +00:00
if (_clutter_actor_get_real_resource_scale (priv->actor, &resource_scale))
{
ceiled_resource_scale = ceilf (resource_scale);
stage_width *= ceiled_resource_scale;
stage_height *= ceiled_resource_scale;
}
else
{
/* We are sure we have a resource scale set to a good value at paint */
g_assert_not_reached ();
}
clutter: Fix offscreen-effect painting of clones `ClutterOffscreenEffect` had been getting the wrong bounding box in the case of clones and descendents of clones, causing visibly incorrect clipping. This was due to `clutter_actor_get_paint_box` only ever being given the source actor during a paint (which is correct) and not the clone. Even if we weren't painting a clone but an offscreened descendent of a clone (like in gnome-shell's desktop zoom), we would get the wrong result. Fortunately we don't need to know the actual clone/actor being painted so don't need to call the problematic `clutter_actor_get_paint_box` at all. The solution is to only keep untransformed rendering in the FBO and leave the correct transformation for later. The correct clone/actor's transformation is already set for us as the current cogl modelview matrix by `clutter_actor_paint`. Bonus optimization: This all means we don't need to keep `last_matrix_drawn` or force a full repaint every time some part of the transformation changes. Because the FBO contents are no longer affected by transformations. As it should be. In other words, offscreen-effected actors can now move around on screen without themselves being repainted. Special thanks to Mai Lavelle for identifying the cause of the problem. Fixes: https://bugzilla.gnome.org/show_bug.cgi?id=789050, https://bugzilla.gnome.org/show_bug.cgi?id=659523#c9, https://gitlab.gnome.org/GNOME/mutter/issues/196, https://gitlab.gnome.org/GNOME/mutter/issues/282, https://gitlab.gnome.org/GNOME/gnome-shell/issues/387, https://launchpad.net/bugs/1767648, https://launchpad.net/bugs/1779615
2018-05-24 09:51:22 +00:00
/* Get the minimal bounding box for what we want to paint, relative to the
* parent of priv->actor. Note that we may actually be painting a clone of
* priv->actor so we need to be careful to avoid querying the transformation
* of priv->actor (like clutter_actor_get_paint_box would). Just stay in
* local coordinates for now...
*/
volume = clutter_actor_get_paint_volume (priv->actor);
if (volume)
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 17:04:02 +00:00
{
clutter: Fix offscreen-effect painting of clones `ClutterOffscreenEffect` had been getting the wrong bounding box in the case of clones and descendents of clones, causing visibly incorrect clipping. This was due to `clutter_actor_get_paint_box` only ever being given the source actor during a paint (which is correct) and not the clone. Even if we weren't painting a clone but an offscreened descendent of a clone (like in gnome-shell's desktop zoom), we would get the wrong result. Fortunately we don't need to know the actual clone/actor being painted so don't need to call the problematic `clutter_actor_get_paint_box` at all. The solution is to only keep untransformed rendering in the FBO and leave the correct transformation for later. The correct clone/actor's transformation is already set for us as the current cogl modelview matrix by `clutter_actor_paint`. Bonus optimization: This all means we don't need to keep `last_matrix_drawn` or force a full repaint every time some part of the transformation changes. Because the FBO contents are no longer affected by transformations. As it should be. In other words, offscreen-effected actors can now move around on screen without themselves being repainted. Special thanks to Mai Lavelle for identifying the cause of the problem. Fixes: https://bugzilla.gnome.org/show_bug.cgi?id=789050, https://bugzilla.gnome.org/show_bug.cgi?id=659523#c9, https://gitlab.gnome.org/GNOME/mutter/issues/196, https://gitlab.gnome.org/GNOME/mutter/issues/282, https://gitlab.gnome.org/GNOME/gnome-shell/issues/387, https://launchpad.net/bugs/1767648, https://launchpad.net/bugs/1779615
2018-05-24 09:51:22 +00:00
ClutterPaintVolume mutable_volume;
offscreen-effect: limit offscreen fbo size to the stage's size When using a ClutterOffscreenEffect, the size of the offscreen buffer allocated to perform the effect is currently computed using the paint volume of the actor it's attached to and in the case the paint volume cannot be computed, the effect falls back to using the stage's size. If you scale an actor enough so its paint volume is much bigger that the size of the stage, you can end up running out of memory (which leads to your application crashing). https://bugzilla.gnome.org/show_bug.cgi?id=699675
2013-05-04 16:37:33 +00:00
clutter: Fix offscreen-effect painting of clones `ClutterOffscreenEffect` had been getting the wrong bounding box in the case of clones and descendents of clones, causing visibly incorrect clipping. This was due to `clutter_actor_get_paint_box` only ever being given the source actor during a paint (which is correct) and not the clone. Even if we weren't painting a clone but an offscreened descendent of a clone (like in gnome-shell's desktop zoom), we would get the wrong result. Fortunately we don't need to know the actual clone/actor being painted so don't need to call the problematic `clutter_actor_get_paint_box` at all. The solution is to only keep untransformed rendering in the FBO and leave the correct transformation for later. The correct clone/actor's transformation is already set for us as the current cogl modelview matrix by `clutter_actor_paint`. Bonus optimization: This all means we don't need to keep `last_matrix_drawn` or force a full repaint every time some part of the transformation changes. Because the FBO contents are no longer affected by transformations. As it should be. In other words, offscreen-effected actors can now move around on screen without themselves being repainted. Special thanks to Mai Lavelle for identifying the cause of the problem. Fixes: https://bugzilla.gnome.org/show_bug.cgi?id=789050, https://bugzilla.gnome.org/show_bug.cgi?id=659523#c9, https://gitlab.gnome.org/GNOME/mutter/issues/196, https://gitlab.gnome.org/GNOME/mutter/issues/282, https://gitlab.gnome.org/GNOME/gnome-shell/issues/387, https://launchpad.net/bugs/1767648, https://launchpad.net/bugs/1779615
2018-05-24 09:51:22 +00:00
_clutter_paint_volume_copy_static (volume, &mutable_volume);
_clutter_paint_volume_get_bounding_box (&mutable_volume, &raw_box);
clutter_paint_volume_free (&mutable_volume);
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 17:04:02 +00:00
}
paint volumes: another pass at the design This is a fairly extensive second pass at exposing paint volumes for actors. The API has changed to allow clutter_actor_get_paint_volume to fail since there are times - such as when an actor isn't a descendent of the stage - when the volume can't be determined. Another example is when something has connected to the "paint" signal of the actor and we simply have no way of knowing what might be drawn in that handler. The API has also be changed to return a const ClutterPaintVolume pointer (transfer none) so we can avoid having to dynamically allocate the volumes in the most common/performance critical code paths. Profiling was showing the slice allocation of volumes taking about 1% of an apps time, for some fairly basic tests. Most volumes can now simply be allocated on the stack; for clutter_actor_get_paint_volume we return a pointer to &priv->paint_volume and if we need a more dynamic allocation there is now a _clutter_stage_paint_volume_stack_allocate() mechanism which lets us allocate data which expires at the start of the next frame. The API has been extended to make it easier to implement get_paint_volume for containers by using clutter_actor_get_transformed_paint_volume and clutter_paint_volume_union. The first allows you to query the paint volume of a child but transformed into parent actor coordinates. The second lets you combine volumes together so you can union all the volumes for a container's children and report that as the container's own volume. The representation of paint volumes has been updated to consider that 2D actors are the most common. The effect apis, clutter-texture and clutter-group have been update accordingly.
2010-09-07 17:04:19 +00:00
else
{
clutter: Fix offscreen-effect painting of clones `ClutterOffscreenEffect` had been getting the wrong bounding box in the case of clones and descendents of clones, causing visibly incorrect clipping. This was due to `clutter_actor_get_paint_box` only ever being given the source actor during a paint (which is correct) and not the clone. Even if we weren't painting a clone but an offscreened descendent of a clone (like in gnome-shell's desktop zoom), we would get the wrong result. Fortunately we don't need to know the actual clone/actor being painted so don't need to call the problematic `clutter_actor_get_paint_box` at all. The solution is to only keep untransformed rendering in the FBO and leave the correct transformation for later. The correct clone/actor's transformation is already set for us as the current cogl modelview matrix by `clutter_actor_paint`. Bonus optimization: This all means we don't need to keep `last_matrix_drawn` or force a full repaint every time some part of the transformation changes. Because the FBO contents are no longer affected by transformations. As it should be. In other words, offscreen-effected actors can now move around on screen without themselves being repainted. Special thanks to Mai Lavelle for identifying the cause of the problem. Fixes: https://bugzilla.gnome.org/show_bug.cgi?id=789050, https://bugzilla.gnome.org/show_bug.cgi?id=659523#c9, https://gitlab.gnome.org/GNOME/mutter/issues/196, https://gitlab.gnome.org/GNOME/mutter/issues/282, https://gitlab.gnome.org/GNOME/gnome-shell/issues/387, https://launchpad.net/bugs/1767648, https://launchpad.net/bugs/1779615
2018-05-24 09:51:22 +00:00
clutter_actor_get_allocation_box (priv->actor, &raw_box);
paint volumes: another pass at the design This is a fairly extensive second pass at exposing paint volumes for actors. The API has changed to allow clutter_actor_get_paint_volume to fail since there are times - such as when an actor isn't a descendent of the stage - when the volume can't be determined. Another example is when something has connected to the "paint" signal of the actor and we simply have no way of knowing what might be drawn in that handler. The API has also be changed to return a const ClutterPaintVolume pointer (transfer none) so we can avoid having to dynamically allocate the volumes in the most common/performance critical code paths. Profiling was showing the slice allocation of volumes taking about 1% of an apps time, for some fairly basic tests. Most volumes can now simply be allocated on the stack; for clutter_actor_get_paint_volume we return a pointer to &priv->paint_volume and if we need a more dynamic allocation there is now a _clutter_stage_paint_volume_stack_allocate() mechanism which lets us allocate data which expires at the start of the next frame. The API has been extended to make it easier to implement get_paint_volume for containers by using clutter_actor_get_transformed_paint_volume and clutter_paint_volume_union. The first allows you to query the paint volume of a child but transformed into parent actor coordinates. The second lets you combine volumes together so you can union all the volumes for a container's children and report that as the container's own volume. The representation of paint volumes has been updated to consider that 2D actors are the most common. The effect apis, clutter-texture and clutter-group have been update accordingly.
2010-09-07 17:04:19 +00:00
}
clutter: Fix offscreen-effect painting of clones `ClutterOffscreenEffect` had been getting the wrong bounding box in the case of clones and descendents of clones, causing visibly incorrect clipping. This was due to `clutter_actor_get_paint_box` only ever being given the source actor during a paint (which is correct) and not the clone. Even if we weren't painting a clone but an offscreened descendent of a clone (like in gnome-shell's desktop zoom), we would get the wrong result. Fortunately we don't need to know the actual clone/actor being painted so don't need to call the problematic `clutter_actor_get_paint_box` at all. The solution is to only keep untransformed rendering in the FBO and leave the correct transformation for later. The correct clone/actor's transformation is already set for us as the current cogl modelview matrix by `clutter_actor_paint`. Bonus optimization: This all means we don't need to keep `last_matrix_drawn` or force a full repaint every time some part of the transformation changes. Because the FBO contents are no longer affected by transformations. As it should be. In other words, offscreen-effected actors can now move around on screen without themselves being repainted. Special thanks to Mai Lavelle for identifying the cause of the problem. Fixes: https://bugzilla.gnome.org/show_bug.cgi?id=789050, https://bugzilla.gnome.org/show_bug.cgi?id=659523#c9, https://gitlab.gnome.org/GNOME/mutter/issues/196, https://gitlab.gnome.org/GNOME/mutter/issues/282, https://gitlab.gnome.org/GNOME/gnome-shell/issues/387, https://launchpad.net/bugs/1767648, https://launchpad.net/bugs/1779615
2018-05-24 09:51:22 +00:00
box = raw_box;
_clutter_actor_box_enlarge_for_effects (&box);
priv->fbo_offset_x = box.x1 - raw_box.x1;
priv->fbo_offset_y = box.y1 - raw_box.y1;
clutter/offscreen-effect: Support adding effect to resource scaled actors At this level we use ceiled resource-scale when painting fractional value When using fractional scaling we still need to create an integer-sized texture and then we should paint it using a size which is proportional to the real actor size ratio, and only paint a subsample of it, but this doesn't seem to work properly with some weird scaling values. Then, it's just better to draw the texture ceiled and then we scale it down to match the proper actor scaling at paint level. https://bugzilla.gnome.org/show_bug.cgi?id=765011 https://gitlab.gnome.org/GNOME/mutter/merge_requests/3
2017-09-07 20:59:50 +00:00
clutter_actor_box_scale (&box, ceiled_resource_scale);
clutter_actor_box_get_size (&box, &target_width, &target_height);
target_width = ceilf (target_width);
target_height = ceilf (target_height);
offscreen-effect: limit offscreen fbo size to the stage's size When using a ClutterOffscreenEffect, the size of the offscreen buffer allocated to perform the effect is currently computed using the paint volume of the actor it's attached to and in the case the paint volume cannot be computed, the effect falls back to using the stage's size. If you scale an actor enough so its paint volume is much bigger that the size of the stage, you can end up running out of memory (which leads to your application crashing). https://bugzilla.gnome.org/show_bug.cgi?id=699675
2013-05-04 16:37:33 +00:00
paint volumes: another pass at the design This is a fairly extensive second pass at exposing paint volumes for actors. The API has changed to allow clutter_actor_get_paint_volume to fail since there are times - such as when an actor isn't a descendent of the stage - when the volume can't be determined. Another example is when something has connected to the "paint" signal of the actor and we simply have no way of knowing what might be drawn in that handler. The API has also be changed to return a const ClutterPaintVolume pointer (transfer none) so we can avoid having to dynamically allocate the volumes in the most common/performance critical code paths. Profiling was showing the slice allocation of volumes taking about 1% of an apps time, for some fairly basic tests. Most volumes can now simply be allocated on the stack; for clutter_actor_get_paint_volume we return a pointer to &priv->paint_volume and if we need a more dynamic allocation there is now a _clutter_stage_paint_volume_stack_allocate() mechanism which lets us allocate data which expires at the start of the next frame. The API has been extended to make it easier to implement get_paint_volume for containers by using clutter_actor_get_transformed_paint_volume and clutter_paint_volume_union. The first allows you to query the paint volume of a child but transformed into parent actor coordinates. The second lets you combine volumes together so you can union all the volumes for a container's children and report that as the container's own volume. The representation of paint volumes has been updated to consider that 2D actors are the most common. The effect apis, clutter-texture and clutter-group have been update accordingly.
2010-09-07 17:04:19 +00:00
/* First assert that the framebuffer is the right size... */
clutter/offscreen-effect: Support adding effect to resource scaled actors At this level we use ceiled resource-scale when painting fractional value When using fractional scaling we still need to create an integer-sized texture and then we should paint it using a size which is proportional to the real actor size ratio, and only paint a subsample of it, but this doesn't seem to work properly with some weird scaling values. Then, it's just better to draw the texture ceiled and then we scale it down to match the proper actor scaling at paint level. https://bugzilla.gnome.org/show_bug.cgi?id=765011 https://gitlab.gnome.org/GNOME/mutter/merge_requests/3
2017-09-07 20:59:50 +00:00
if (!update_fbo (effect, target_width, target_height, resource_scale))
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 11:33:20 +00: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 10:39:27 +00:00
clutter/offscreen-effect: Don't use implicit framebuffer Cogl APIs While we still push and pop to the Cogl framebuffer stack, as so is still needed to render the actors correctly, don't use the API using the implicit framebuffer stack ourself in the offscreen effect code. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-22 10:18:35 +00:00
framebuffer = clutter_paint_context_get_framebuffer (paint_context);
cogl_framebuffer_get_modelview_matrix (framebuffer, &old_modelview);
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 11:24:23 +00:00
clutter, core: Stop using the Cogl framebuffer stack The Cogl framebuffer stack is going away; replace all its uses by the framebuffer stack carried by the paint context. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-22 10:41:04 +00:00
clutter_paint_context_push_framebuffer (paint_context, priv->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 11:33:20 +00:00
clutter: Fix offscreen-effect painting of clones `ClutterOffscreenEffect` had been getting the wrong bounding box in the case of clones and descendents of clones, causing visibly incorrect clipping. This was due to `clutter_actor_get_paint_box` only ever being given the source actor during a paint (which is correct) and not the clone. Even if we weren't painting a clone but an offscreened descendent of a clone (like in gnome-shell's desktop zoom), we would get the wrong result. Fortunately we don't need to know the actual clone/actor being painted so don't need to call the problematic `clutter_actor_get_paint_box` at all. The solution is to only keep untransformed rendering in the FBO and leave the correct transformation for later. The correct clone/actor's transformation is already set for us as the current cogl modelview matrix by `clutter_actor_paint`. Bonus optimization: This all means we don't need to keep `last_matrix_drawn` or force a full repaint every time some part of the transformation changes. Because the FBO contents are no longer affected by transformations. As it should be. In other words, offscreen-effected actors can now move around on screen without themselves being repainted. Special thanks to Mai Lavelle for identifying the cause of the problem. Fixes: https://bugzilla.gnome.org/show_bug.cgi?id=789050, https://bugzilla.gnome.org/show_bug.cgi?id=659523#c9, https://gitlab.gnome.org/GNOME/mutter/issues/196, https://gitlab.gnome.org/GNOME/mutter/issues/282, https://gitlab.gnome.org/GNOME/gnome-shell/issues/387, https://launchpad.net/bugs/1767648, https://launchpad.net/bugs/1779615
2018-05-24 09:51:22 +00:00
/* We don't want the FBO contents to be transformed. That could waste memory
* (e.g. during zoom), or result in something that's not rectangular (clipped
* incorrectly). So drop the modelview matrix of the current paint chain.
* This is fine since paint_texture runs with the same modelview matrix,
* so it will come out correctly whenever that is used to put the FBO
* contents on screen...
*/
clutter_actor_get_transform (priv->stage, &modelview);
clutter/offscreen-effect: Don't use implicit framebuffer Cogl APIs While we still push and pop to the Cogl framebuffer stack, as so is still needed to render the actors correctly, don't use the API using the implicit framebuffer stack ourself in the offscreen effect code. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-22 10:18:35 +00:00
cogl_framebuffer_set_modelview_matrix (priv->offscreen, &modelview);
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 15:36:30 +00:00
clutter: Fix offscreen-effect painting of clones `ClutterOffscreenEffect` had been getting the wrong bounding box in the case of clones and descendents of clones, causing visibly incorrect clipping. This was due to `clutter_actor_get_paint_box` only ever being given the source actor during a paint (which is correct) and not the clone. Even if we weren't painting a clone but an offscreened descendent of a clone (like in gnome-shell's desktop zoom), we would get the wrong result. Fortunately we don't need to know the actual clone/actor being painted so don't need to call the problematic `clutter_actor_get_paint_box` at all. The solution is to only keep untransformed rendering in the FBO and leave the correct transformation for later. The correct clone/actor's transformation is already set for us as the current cogl modelview matrix by `clutter_actor_paint`. Bonus optimization: This all means we don't need to keep `last_matrix_drawn` or force a full repaint every time some part of the transformation changes. Because the FBO contents are no longer affected by transformations. As it should be. In other words, offscreen-effected actors can now move around on screen without themselves being repainted. Special thanks to Mai Lavelle for identifying the cause of the problem. Fixes: https://bugzilla.gnome.org/show_bug.cgi?id=789050, https://bugzilla.gnome.org/show_bug.cgi?id=659523#c9, https://gitlab.gnome.org/GNOME/mutter/issues/196, https://gitlab.gnome.org/GNOME/mutter/issues/282, https://gitlab.gnome.org/GNOME/gnome-shell/issues/387, https://launchpad.net/bugs/1767648, https://launchpad.net/bugs/1779615
2018-05-24 09:51:22 +00:00
/* Save the original viewport for calculating priv->position */
_clutter_stage_get_viewport (CLUTTER_STAGE (priv->stage),
&old_viewport[0],
&old_viewport[1],
&old_viewport[2],
&old_viewport[3]);
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 15:18:08 +00:00
clutter: Fix offscreen-effect painting of clones `ClutterOffscreenEffect` had been getting the wrong bounding box in the case of clones and descendents of clones, causing visibly incorrect clipping. This was due to `clutter_actor_get_paint_box` only ever being given the source actor during a paint (which is correct) and not the clone. Even if we weren't painting a clone but an offscreened descendent of a clone (like in gnome-shell's desktop zoom), we would get the wrong result. Fortunately we don't need to know the actual clone/actor being painted so don't need to call the problematic `clutter_actor_get_paint_box` at all. The solution is to only keep untransformed rendering in the FBO and leave the correct transformation for later. The correct clone/actor's transformation is already set for us as the current cogl modelview matrix by `clutter_actor_paint`. Bonus optimization: This all means we don't need to keep `last_matrix_drawn` or force a full repaint every time some part of the transformation changes. Because the FBO contents are no longer affected by transformations. As it should be. In other words, offscreen-effected actors can now move around on screen without themselves being repainted. Special thanks to Mai Lavelle for identifying the cause of the problem. Fixes: https://bugzilla.gnome.org/show_bug.cgi?id=789050, https://bugzilla.gnome.org/show_bug.cgi?id=659523#c9, https://gitlab.gnome.org/GNOME/mutter/issues/196, https://gitlab.gnome.org/GNOME/mutter/issues/282, https://gitlab.gnome.org/GNOME/gnome-shell/issues/387, https://launchpad.net/bugs/1767648, https://launchpad.net/bugs/1779615
2018-05-24 09:51:22 +00:00
/* Set up the viewport so that it has the same size as the stage (avoid
* distortion), but translated to account for the FBO offset...
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 15:18:08 +00:00
*/
clutter/offscreen-effect: Don't use implicit framebuffer Cogl APIs While we still push and pop to the Cogl framebuffer stack, as so is still needed to render the actors correctly, don't use the API using the implicit framebuffer stack ourself in the offscreen effect code. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-22 10:18:35 +00:00
cogl_framebuffer_set_viewport (priv->offscreen,
-priv->fbo_offset_x,
-priv->fbo_offset_y,
stage_width,
stage_height);
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 11:58:42 +00:00
/* Copy the stage's projection matrix across to the framebuffer */
_clutter_stage_get_projection_matrix (CLUTTER_STAGE (priv->stage),
&projection);
clutter: Fix offscreen-effect painting of clones `ClutterOffscreenEffect` had been getting the wrong bounding box in the case of clones and descendents of clones, causing visibly incorrect clipping. This was due to `clutter_actor_get_paint_box` only ever being given the source actor during a paint (which is correct) and not the clone. Even if we weren't painting a clone but an offscreened descendent of a clone (like in gnome-shell's desktop zoom), we would get the wrong result. Fortunately we don't need to know the actual clone/actor being painted so don't need to call the problematic `clutter_actor_get_paint_box` at all. The solution is to only keep untransformed rendering in the FBO and leave the correct transformation for later. The correct clone/actor's transformation is already set for us as the current cogl modelview matrix by `clutter_actor_paint`. Bonus optimization: This all means we don't need to keep `last_matrix_drawn` or force a full repaint every time some part of the transformation changes. Because the FBO contents are no longer affected by transformations. As it should be. In other words, offscreen-effected actors can now move around on screen without themselves being repainted. Special thanks to Mai Lavelle for identifying the cause of the problem. Fixes: https://bugzilla.gnome.org/show_bug.cgi?id=789050, https://bugzilla.gnome.org/show_bug.cgi?id=659523#c9, https://gitlab.gnome.org/GNOME/mutter/issues/196, https://gitlab.gnome.org/GNOME/mutter/issues/282, https://gitlab.gnome.org/GNOME/gnome-shell/issues/387, https://launchpad.net/bugs/1767648, https://launchpad.net/bugs/1779615
2018-05-24 09:51:22 +00:00
/* Now save the global position of the effect (not just of the actor).
* It doesn't appear anyone actually uses this yet, but get_target_rect is
* documented as returning it. So we should...
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 15:18:08 +00:00
*/
clutter: Fix offscreen-effect painting of clones `ClutterOffscreenEffect` had been getting the wrong bounding box in the case of clones and descendents of clones, causing visibly incorrect clipping. This was due to `clutter_actor_get_paint_box` only ever being given the source actor during a paint (which is correct) and not the clone. Even if we weren't painting a clone but an offscreened descendent of a clone (like in gnome-shell's desktop zoom), we would get the wrong result. Fortunately we don't need to know the actual clone/actor being painted so don't need to call the problematic `clutter_actor_get_paint_box` at all. The solution is to only keep untransformed rendering in the FBO and leave the correct transformation for later. The correct clone/actor's transformation is already set for us as the current cogl modelview matrix by `clutter_actor_paint`. Bonus optimization: This all means we don't need to keep `last_matrix_drawn` or force a full repaint every time some part of the transformation changes. Because the FBO contents are no longer affected by transformations. As it should be. In other words, offscreen-effected actors can now move around on screen without themselves being repainted. Special thanks to Mai Lavelle for identifying the cause of the problem. Fixes: https://bugzilla.gnome.org/show_bug.cgi?id=789050, https://bugzilla.gnome.org/show_bug.cgi?id=659523#c9, https://gitlab.gnome.org/GNOME/mutter/issues/196, https://gitlab.gnome.org/GNOME/mutter/issues/282, https://gitlab.gnome.org/GNOME/gnome-shell/issues/387, https://launchpad.net/bugs/1767648, https://launchpad.net/bugs/1779615
2018-05-24 09:51:22 +00:00
_clutter_util_fully_transform_vertices (&old_modelview,
&projection,
old_viewport,
&local_offset,
&priv->position,
1);
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 15:18:08 +00:00
clutter/offscreen-effect: Don't use implicit framebuffer Cogl APIs While we still push and pop to the Cogl framebuffer stack, as so is still needed to render the actors correctly, don't use the API using the implicit framebuffer stack ourself in the offscreen effect code. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-22 10:18:35 +00:00
cogl_framebuffer_set_projection_matrix (priv->offscreen, &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 11:33:20 +00: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 15:55:12 +00:00
cogl_color_init_from_4ub (&transparent, 0, 0, 0, 0);
clutter/offscreen-effect: Don't use implicit framebuffer Cogl APIs While we still push and pop to the Cogl framebuffer stack, as so is still needed to render the actors correctly, don't use the API using the implicit framebuffer stack ourself in the offscreen effect code. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-22 10:18:35 +00:00
cogl_framebuffer_clear (priv->offscreen,
COGL_BUFFER_BIT_COLOR |
COGL_BUFFER_BIT_DEPTH,
&transparent);
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 10:39:27 +00:00
clutter/offscreen-effect: Don't use implicit framebuffer Cogl APIs While we still push and pop to the Cogl framebuffer stack, as so is still needed to render the actors correctly, don't use the API using the implicit framebuffer stack ourself in the offscreen effect code. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-22 10:18:35 +00:00
cogl_framebuffer_push_matrix (priv->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 11:33:20 +00:00
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 14:36:55 +00: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 16:46:26 +00:00
priv->old_opacity_override =
ClutterActor: expose setter for the opacity override Toolkits may need to paint actors internally outside the normal tree (for example to create a shadow shape), in which case they need to control the opacity directly. https://bugzilla.gnome.org/show_bug.cgi?id=677412 Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2012-06-04 21:42:04 +00:00
clutter_actor_get_opacity_override (priv->actor);
clutter_actor_set_opacity_override (priv->actor, 0xff);
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 14:36:55 +00: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 11:33:20 +00: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 10:39:27 +00:00
}
static void
clutter: Introduce paint contexts When painting, actors rely on semi global state tracked by the state to get various things needed for painting, such as the current draw framebuffer. Having state hidden in such ways can be very deceiving as it's hard to follow changes spread out, and adding more and more state that should be tracked during a paint gets annoying as they will not change in isolation but one by one in their own places. To do this better, introduce a paint context that is passed along in paint calls that contains the necessary state needed during painting. The paint context implements a framebuffer stack just as Cogl works, which is currently needed for offscreen rendering used by clutter. The same context is passed around for paint nodes, contents and effects as well. In this commit, the context is only introduced, but not used. It aims to replace the Cogl framebuffer stack, and will allow actors to know what view it is currently painted on. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-13 21:21:58 +00:00
clutter_offscreen_effect_real_paint_target (ClutterOffscreenEffect *effect,
ClutterPaintContext *paint_context)
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 10:39:27 +00:00
{
ClutterOffscreenEffectPrivate *priv = effect->priv;
clutter, core: Stop using the Cogl framebuffer stack The Cogl framebuffer stack is going away; replace all its uses by the framebuffer stack carried by the paint context. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-22 10:41:04 +00:00
CoglFramebuffer *framebuffer =
clutter_paint_context_get_framebuffer (paint_context);
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 10:39:27 +00:00
guint8 paint_opacity;
paint_opacity = clutter_actor_get_paint_opacity (priv->actor);
clutter/offscreen-effect: Rename CoglPipeline field to 'pipeline' This is the same case of the layer node: a CoglPipeline field that is not called 'pipeline' makes it harder to figure out what it really is. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1167
2020-03-31 01:26:18 +00:00
cogl_pipeline_set_color4ub (priv->pipeline,
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 10:39:27 +00:00
paint_opacity,
paint_opacity,
paint_opacity,
paint_opacity);
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 11:33:20 +00:00
paint volumes: another pass at the design This is a fairly extensive second pass at exposing paint volumes for actors. The API has changed to allow clutter_actor_get_paint_volume to fail since there are times - such as when an actor isn't a descendent of the stage - when the volume can't be determined. Another example is when something has connected to the "paint" signal of the actor and we simply have no way of knowing what might be drawn in that handler. The API has also be changed to return a const ClutterPaintVolume pointer (transfer none) so we can avoid having to dynamically allocate the volumes in the most common/performance critical code paths. Profiling was showing the slice allocation of volumes taking about 1% of an apps time, for some fairly basic tests. Most volumes can now simply be allocated on the stack; for clutter_actor_get_paint_volume we return a pointer to &priv->paint_volume and if we need a more dynamic allocation there is now a _clutter_stage_paint_volume_stack_allocate() mechanism which lets us allocate data which expires at the start of the next frame. The API has been extended to make it easier to implement get_paint_volume for containers by using clutter_actor_get_transformed_paint_volume and clutter_paint_volume_union. The first allows you to query the paint volume of a child but transformed into parent actor coordinates. The second lets you combine volumes together so you can union all the volumes for a container's children and report that as the container's own volume. The representation of paint volumes has been updated to consider that 2D actors are the most common. The effect apis, clutter-texture and clutter-group have been update accordingly.
2010-09-07 17:04:19 +00:00
/* 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 11:33:20 +00:00
*/
clutter-*-effect: Remove cogl_rectangle() All those effects have the same basic pattern of setting a color of a pipeline, then drawing a rect with cogl_rectangle(). Thus, replacing those was as easy as retrieving the draw framebuffer and calling cogl_framebuffer_draw_rectangle() on it.
2018-11-08 22:26:02 +00:00
cogl_framebuffer_draw_textured_rectangle (framebuffer,
clutter/offscreen-effect: Rename CoglPipeline field to 'pipeline' This is the same case of the layer node: a CoglPipeline field that is not called 'pipeline' makes it harder to figure out what it really is. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1167
2020-03-31 01:26:18 +00:00
priv->pipeline,
clutter-*-effect: Remove cogl_rectangle() All those effects have the same basic pattern of setting a color of a pipeline, then drawing a rect with cogl_rectangle(). Thus, replacing those was as easy as retrieving the draw framebuffer and calling cogl_framebuffer_draw_rectangle() on it.
2018-11-08 22:26:02 +00:00
0, 0,
cogl_texture_get_width (priv->texture),
cogl_texture_get_height (priv->texture),
0.0, 0.0,
1.0, 1.0);
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 10:39:27 +00:00
}
static void
clutter: Introduce paint contexts When painting, actors rely on semi global state tracked by the state to get various things needed for painting, such as the current draw framebuffer. Having state hidden in such ways can be very deceiving as it's hard to follow changes spread out, and adding more and more state that should be tracked during a paint gets annoying as they will not change in isolation but one by one in their own places. To do this better, introduce a paint context that is passed along in paint calls that contains the necessary state needed during painting. The paint context implements a framebuffer stack just as Cogl works, which is currently needed for offscreen rendering used by clutter. The same context is passed around for paint nodes, contents and effects as well. In this commit, the context is only introduced, but not used. It aims to replace the Cogl framebuffer stack, and will allow actors to know what view it is currently painted on. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-13 21:21:58 +00:00
clutter_offscreen_effect_paint_texture (ClutterOffscreenEffect *effect,
ClutterPaintContext *paint_context)
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 10:39:27 +00: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 11:24:23 +00:00
ClutterOffscreenEffectPrivate *priv = effect->priv;
clutter, core: Stop using the Cogl framebuffer stack The Cogl framebuffer stack is going away; replace all its uses by the framebuffer stack carried by the paint context. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-22 10:41:04 +00:00
CoglFramebuffer *framebuffer =
clutter_paint_context_get_framebuffer (paint_context);
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 11:58:42 +00:00
CoglMatrix modelview;
clutter/offscreen-effect: Support adding effect to resource scaled actors At this level we use ceiled resource-scale when painting fractional value When using fractional scaling we still need to create an integer-sized texture and then we should paint it using a size which is proportional to the real actor size ratio, and only paint a subsample of it, but this doesn't seem to work properly with some weird scaling values. Then, it's just better to draw the texture ceiled and then we scale it down to match the proper actor scaling at paint level. https://bugzilla.gnome.org/show_bug.cgi?id=765011 https://gitlab.gnome.org/GNOME/mutter/merge_requests/3
2017-09-07 20:59:50 +00:00
float resource_scale;
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 10:39:27 +00:00
clutter/offscreen-effect: Don't use implicit framebuffer Cogl APIs While we still push and pop to the Cogl framebuffer stack, as so is still needed to render the actors correctly, don't use the API using the implicit framebuffer stack ourself in the offscreen effect code. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-22 10:18:35 +00:00
cogl_framebuffer_push_matrix (framebuffer);
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 11:33:20 +00:00
clutter: Fix offscreen-effect painting of clones `ClutterOffscreenEffect` had been getting the wrong bounding box in the case of clones and descendents of clones, causing visibly incorrect clipping. This was due to `clutter_actor_get_paint_box` only ever being given the source actor during a paint (which is correct) and not the clone. Even if we weren't painting a clone but an offscreened descendent of a clone (like in gnome-shell's desktop zoom), we would get the wrong result. Fortunately we don't need to know the actual clone/actor being painted so don't need to call the problematic `clutter_actor_get_paint_box` at all. The solution is to only keep untransformed rendering in the FBO and leave the correct transformation for later. The correct clone/actor's transformation is already set for us as the current cogl modelview matrix by `clutter_actor_paint`. Bonus optimization: This all means we don't need to keep `last_matrix_drawn` or force a full repaint every time some part of the transformation changes. Because the FBO contents are no longer affected by transformations. As it should be. In other words, offscreen-effected actors can now move around on screen without themselves being repainted. Special thanks to Mai Lavelle for identifying the cause of the problem. Fixes: https://bugzilla.gnome.org/show_bug.cgi?id=789050, https://bugzilla.gnome.org/show_bug.cgi?id=659523#c9, https://gitlab.gnome.org/GNOME/mutter/issues/196, https://gitlab.gnome.org/GNOME/mutter/issues/282, https://gitlab.gnome.org/GNOME/gnome-shell/issues/387, https://launchpad.net/bugs/1767648, https://launchpad.net/bugs/1779615
2018-05-24 09:51:22 +00:00
/* The current modelview matrix is *almost* perfect already. It's only
* missing a correction for the expanded FBO and offset rendering within...
*/
clutter/offscreen-effect: Don't use implicit framebuffer Cogl APIs While we still push and pop to the Cogl framebuffer stack, as so is still needed to render the actors correctly, don't use the API using the implicit framebuffer stack ourself in the offscreen effect code. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-22 10:18:35 +00:00
cogl_framebuffer_get_modelview_matrix (framebuffer, &modelview);
clutter/offscreen-effect: Support adding effect to resource scaled actors At this level we use ceiled resource-scale when painting fractional value When using fractional scaling we still need to create an integer-sized texture and then we should paint it using a size which is proportional to the real actor size ratio, and only paint a subsample of it, but this doesn't seem to work properly with some weird scaling values. Then, it's just better to draw the texture ceiled and then we scale it down to match the proper actor scaling at paint level. https://bugzilla.gnome.org/show_bug.cgi?id=765011 https://gitlab.gnome.org/GNOME/mutter/merge_requests/3
2017-09-07 20:59:50 +00:00
if (clutter_actor_get_resource_scale (priv->actor, &resource_scale) &&
resource_scale != 1.0f)
{
float paint_scale = 1.0f / resource_scale;
cogl_matrix_scale (&modelview, paint_scale, paint_scale, 1);
}
clutter: Fix offscreen-effect painting of clones `ClutterOffscreenEffect` had been getting the wrong bounding box in the case of clones and descendents of clones, causing visibly incorrect clipping. This was due to `clutter_actor_get_paint_box` only ever being given the source actor during a paint (which is correct) and not the clone. Even if we weren't painting a clone but an offscreened descendent of a clone (like in gnome-shell's desktop zoom), we would get the wrong result. Fortunately we don't need to know the actual clone/actor being painted so don't need to call the problematic `clutter_actor_get_paint_box` at all. The solution is to only keep untransformed rendering in the FBO and leave the correct transformation for later. The correct clone/actor's transformation is already set for us as the current cogl modelview matrix by `clutter_actor_paint`. Bonus optimization: This all means we don't need to keep `last_matrix_drawn` or force a full repaint every time some part of the transformation changes. Because the FBO contents are no longer affected by transformations. As it should be. In other words, offscreen-effected actors can now move around on screen without themselves being repainted. Special thanks to Mai Lavelle for identifying the cause of the problem. Fixes: https://bugzilla.gnome.org/show_bug.cgi?id=789050, https://bugzilla.gnome.org/show_bug.cgi?id=659523#c9, https://gitlab.gnome.org/GNOME/mutter/issues/196, https://gitlab.gnome.org/GNOME/mutter/issues/282, https://gitlab.gnome.org/GNOME/gnome-shell/issues/387, https://launchpad.net/bugs/1767648, https://launchpad.net/bugs/1779615
2018-05-24 09:51:22 +00:00
cogl_matrix_translate (&modelview,
priv->fbo_offset_x,
priv->fbo_offset_y,
0.0f);
clutter/offscreen-effect: Don't use implicit framebuffer Cogl APIs While we still push and pop to the Cogl framebuffer stack, as so is still needed to render the actors correctly, don't use the API using the implicit framebuffer stack ourself in the offscreen effect code. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-22 10:18:35 +00:00
cogl_framebuffer_set_modelview_matrix (framebuffer, &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 16:35:56 +00: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 11:33:20 +00:00
/* paint the target material; this is virtualized for
* sub-classes that require special hand-holding
*/
clutter: Introduce paint contexts When painting, actors rely on semi global state tracked by the state to get various things needed for painting, such as the current draw framebuffer. Having state hidden in such ways can be very deceiving as it's hard to follow changes spread out, and adding more and more state that should be tracked during a paint gets annoying as they will not change in isolation but one by one in their own places. To do this better, introduce a paint context that is passed along in paint calls that contains the necessary state needed during painting. The paint context implements a framebuffer stack just as Cogl works, which is currently needed for offscreen rendering used by clutter. The same context is passed around for paint nodes, contents and effects as well. In this commit, the context is only introduced, but not used. It aims to replace the Cogl framebuffer stack, and will allow actors to know what view it is currently painted on. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-13 21:21:58 +00:00
clutter_offscreen_effect_paint_target (effect, paint_context);
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 11:33:20 +00:00
clutter/offscreen-effect: Don't use implicit framebuffer Cogl APIs While we still push and pop to the Cogl framebuffer stack, as so is still needed to render the actors correctly, don't use the API using the implicit framebuffer stack ourself in the offscreen effect code. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-22 10:18:35 +00:00
cogl_framebuffer_pop_matrix (framebuffer);
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 10:39:27 +00: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 11:24:23 +00:00
static void
clutter: Introduce paint contexts When painting, actors rely on semi global state tracked by the state to get various things needed for painting, such as the current draw framebuffer. Having state hidden in such ways can be very deceiving as it's hard to follow changes spread out, and adding more and more state that should be tracked during a paint gets annoying as they will not change in isolation but one by one in their own places. To do this better, introduce a paint context that is passed along in paint calls that contains the necessary state needed during painting. The paint context implements a framebuffer stack just as Cogl works, which is currently needed for offscreen rendering used by clutter. The same context is passed around for paint nodes, contents and effects as well. In this commit, the context is only introduced, but not used. It aims to replace the Cogl framebuffer stack, and will allow actors to know what view it is currently painted on. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-13 21:21:58 +00:00
clutter_offscreen_effect_post_paint (ClutterEffect *effect,
ClutterPaintContext *paint_context)
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 11:24:23 +00:00
{
ClutterOffscreenEffect *self = CLUTTER_OFFSCREEN_EFFECT (effect);
ClutterOffscreenEffectPrivate *priv = self->priv;
clutter/offscreen-effect: Don't use implicit framebuffer Cogl APIs While we still push and pop to the Cogl framebuffer stack, as so is still needed to render the actors correctly, don't use the API using the implicit framebuffer stack ourself in the offscreen effect code. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-22 10:18:35 +00:00
CoglFramebuffer *framebuffer;
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 11:24:23 +00:00
clutter/offscreen-effect: Don't ever early out out of post paint If we would, we'd miss popping the framebuffer from the pant context framebuffer stack. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1166
2020-03-31 17:42:47 +00:00
g_warn_if_fail (priv->offscreen);
clutter/offscreen-effect: Rename CoglPipeline field to 'pipeline' This is the same case of the layer node: a CoglPipeline field that is not called 'pipeline' makes it harder to figure out what it really is. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1167
2020-03-31 01:26:18 +00:00
g_warn_if_fail (priv->pipeline);
clutter/offscreen-effect: Don't ever early out out of post paint If we would, we'd miss popping the framebuffer from the pant context framebuffer stack. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1166
2020-03-31 17:42:47 +00:00
g_warn_if_fail (priv->actor);
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 11:24:23 +00:00
/* Restore the previous opacity override */
clutter/offscreen-effect: Don't ever early out out of post paint If we would, we'd miss popping the framebuffer from the pant context framebuffer stack. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1166
2020-03-31 17:42:47 +00:00
if (priv->actor)
{
clutter_actor_set_opacity_override (priv->actor,
priv->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 11:24:23 +00:00
clutter, core: Stop using the Cogl framebuffer stack The Cogl framebuffer stack is going away; replace all its uses by the framebuffer stack carried by the paint context. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-22 10:41:04 +00:00
framebuffer = clutter_paint_context_get_framebuffer (paint_context);
clutter/offscreen-effect: Don't use implicit framebuffer Cogl APIs While we still push and pop to the Cogl framebuffer stack, as so is still needed to render the actors correctly, don't use the API using the implicit framebuffer stack ourself in the offscreen effect code. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-22 10:18:35 +00:00
cogl_framebuffer_pop_matrix (framebuffer);
clutter, core: Stop using the Cogl framebuffer stack The Cogl framebuffer stack is going away; replace all its uses by the framebuffer stack carried by the paint context. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-22 10:41:04 +00:00
clutter_paint_context_pop_framebuffer (paint_context);
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 11:24:23 +00:00
clutter: Introduce paint contexts When painting, actors rely on semi global state tracked by the state to get various things needed for painting, such as the current draw framebuffer. Having state hidden in such ways can be very deceiving as it's hard to follow changes spread out, and adding more and more state that should be tracked during a paint gets annoying as they will not change in isolation but one by one in their own places. To do this better, introduce a paint context that is passed along in paint calls that contains the necessary state needed during painting. The paint context implements a framebuffer stack just as Cogl works, which is currently needed for offscreen rendering used by clutter. The same context is passed around for paint nodes, contents and effects as well. In this commit, the context is only introduced, but not used. It aims to replace the Cogl framebuffer stack, and will allow actors to know what view it is currently painted on. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-13 21:21:58 +00:00
clutter_offscreen_effect_paint_texture (self, paint_context);
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 11:24:23 +00:00
}
static void
effect: Rename RunFlags to PaintFlags Since run() was replaced and both paint() and pick() use the enumeration. https://bugzilla.gnome.org/show_bug.cgi?id=651700
2011-06-13 14:58:46 +00:00
clutter_offscreen_effect_paint (ClutterEffect *effect,
clutter: Introduce paint contexts When painting, actors rely on semi global state tracked by the state to get various things needed for painting, such as the current draw framebuffer. Having state hidden in such ways can be very deceiving as it's hard to follow changes spread out, and adding more and more state that should be tracked during a paint gets annoying as they will not change in isolation but one by one in their own places. To do this better, introduce a paint context that is passed along in paint calls that contains the necessary state needed during painting. The paint context implements a framebuffer stack just as Cogl works, which is currently needed for offscreen rendering used by clutter. The same context is passed around for paint nodes, contents and effects as well. In this commit, the context is only introduced, but not used. It aims to replace the Cogl framebuffer stack, and will allow actors to know what view it is currently painted on. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-13 21:21:58 +00:00
ClutterPaintContext *paint_context,
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 14:58:46 +00:00
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 11:24:23 +00:00
{
ClutterOffscreenEffect *self = CLUTTER_OFFSCREEN_EFFECT (effect);
ClutterOffscreenEffectPrivate *priv = self->priv;
clutter/actor: Add CLUTTER_OFFSCREEN_REDIRECT_ON_IDLE Which offscreens actor rendering only in cases where it hasn't changed for 2 frames or more. This avoids the performance penalty of offscreening an actor whose content is trying to animate at full frame rate. It will switch automatically. https://gitlab.gnome.org/GNOME/mutter/merge_requests/1069
2020-02-19 06:05:57 +00:00
if (flags & CLUTTER_EFFECT_PAINT_BYPASS_EFFECT)
{
clutter_actor_continue_paint (priv->actor, paint_context);
cogl_clear_object (&priv->offscreen);
return;
}
clutter: Fix offscreen-effect painting of clones `ClutterOffscreenEffect` had been getting the wrong bounding box in the case of clones and descendents of clones, causing visibly incorrect clipping. This was due to `clutter_actor_get_paint_box` only ever being given the source actor during a paint (which is correct) and not the clone. Even if we weren't painting a clone but an offscreened descendent of a clone (like in gnome-shell's desktop zoom), we would get the wrong result. Fortunately we don't need to know the actual clone/actor being painted so don't need to call the problematic `clutter_actor_get_paint_box` at all. The solution is to only keep untransformed rendering in the FBO and leave the correct transformation for later. The correct clone/actor's transformation is already set for us as the current cogl modelview matrix by `clutter_actor_paint`. Bonus optimization: This all means we don't need to keep `last_matrix_drawn` or force a full repaint every time some part of the transformation changes. Because the FBO contents are no longer affected by transformations. As it should be. In other words, offscreen-effected actors can now move around on screen without themselves being repainted. Special thanks to Mai Lavelle for identifying the cause of the problem. Fixes: https://bugzilla.gnome.org/show_bug.cgi?id=789050, https://bugzilla.gnome.org/show_bug.cgi?id=659523#c9, https://gitlab.gnome.org/GNOME/mutter/issues/196, https://gitlab.gnome.org/GNOME/mutter/issues/282, https://gitlab.gnome.org/GNOME/gnome-shell/issues/387, https://launchpad.net/bugs/1767648, https://launchpad.net/bugs/1779615
2018-05-24 09:51:22 +00:00
/* If we've already got a cached image and the actor hasn't been redrawn
* then we can just use the cached image in the FBO.
*/
if (priv->offscreen == NULL || (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 11:24:23 +00:00
{
clutter/offscreen-effect: Clear offscreen when pre-paint fails Some ClutterOffscreenEffect subclasses, such as ClutterBrightnessContrastEffect, early-return FALSE in pre-paint before chaining up. It's an important optimization that avoids creating or updating the offscreen framebuffer. However, if an offscreen framebuffer already exists by the time pre-paint fails, it will be used *without* repaint the actor over it. That causes an old picture of the actor to be displayed. Fix that by always clearing the offscreen framebuffer when pre-paint fails. Fixes https://gitlab.gnome.org/GNOME/mutter/issues/810 https://gitlab.gnome.org/GNOME/mutter/merge_requests/992
2020-01-07 16:17:56 +00:00
ClutterEffectClass *effect_class = CLUTTER_EFFECT_GET_CLASS (effect);
gboolean pre_paint_succeeded;
pre_paint_succeeded = effect_class->pre_paint (effect, paint_context);
clutter_actor_continue_paint (priv->actor, paint_context);
if (pre_paint_succeeded)
effect_class->post_paint (effect, paint_context);
else
g_clear_pointer (&priv->offscreen, cogl_object_unref);
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 11:24:23 +00:00
}
else
clutter: Introduce paint contexts When painting, actors rely on semi global state tracked by the state to get various things needed for painting, such as the current draw framebuffer. Having state hidden in such ways can be very deceiving as it's hard to follow changes spread out, and adding more and more state that should be tracked during a paint gets annoying as they will not change in isolation but one by one in their own places. To do this better, introduce a paint context that is passed along in paint calls that contains the necessary state needed during painting. The paint context implements a framebuffer stack just as Cogl works, which is currently needed for offscreen rendering used by clutter. The same context is passed around for paint nodes, contents and effects as well. In this commit, the context is only introduced, but not used. It aims to replace the Cogl framebuffer stack, and will allow actors to know what view it is currently painted on. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-13 21:21:58 +00:00
clutter_offscreen_effect_paint_texture (self, paint_context);
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 11:24:23 +00:00
}
clutter/offscreen-effect: Clear offscreen framebuffer when disabling When changing the 'enabled' property and disabling the offscreen effect, it doesn't make sense to preserve the offscreen framebuffer. It's not drawing, after all. Furthermore, because ClutterOffscreenEffect only checks if the offscreen framebuffer exists to decide whether or not to redraw, keeping the fbo alive is a waste of resources. Clear the offscreen framebuffer when the effect is disabled or enabled. Fixes https://gitlab.gnome.org/GNOME/mutter/issues/810 https://gitlab.gnome.org/GNOME/mutter/merge_requests/992
2020-01-07 14:58:54 +00:00
static void
clutter/offscreen-effect: Override ClutterActorMeta.set_enabled Again, the same case of the previous commits. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1187
2020-04-08 15:09:36 +00:00
clutter_offscreen_effect_set_enabled (ClutterActorMeta *meta,
gboolean is_enabled)
clutter/offscreen-effect: Clear offscreen framebuffer when disabling When changing the 'enabled' property and disabling the offscreen effect, it doesn't make sense to preserve the offscreen framebuffer. It's not drawing, after all. Furthermore, because ClutterOffscreenEffect only checks if the offscreen framebuffer exists to decide whether or not to redraw, keeping the fbo alive is a waste of resources. Clear the offscreen framebuffer when the effect is disabled or enabled. Fixes https://gitlab.gnome.org/GNOME/mutter/issues/810 https://gitlab.gnome.org/GNOME/mutter/merge_requests/992
2020-01-07 14:58:54 +00:00
{
clutter/offscreen-effect: Override ClutterActorMeta.set_enabled Again, the same case of the previous commits. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1187
2020-04-08 15:09:36 +00:00
ClutterActorMetaClass *parent_class =
CLUTTER_ACTOR_META_CLASS (clutter_offscreen_effect_parent_class);
ClutterOffscreenEffect *offscreen_effect = CLUTTER_OFFSCREEN_EFFECT (meta);
clutter/offscreen-effect: Clear offscreen framebuffer when disabling When changing the 'enabled' property and disabling the offscreen effect, it doesn't make sense to preserve the offscreen framebuffer. It's not drawing, after all. Furthermore, because ClutterOffscreenEffect only checks if the offscreen framebuffer exists to decide whether or not to redraw, keeping the fbo alive is a waste of resources. Clear the offscreen framebuffer when the effect is disabled or enabled. Fixes https://gitlab.gnome.org/GNOME/mutter/issues/810 https://gitlab.gnome.org/GNOME/mutter/merge_requests/992
2020-01-07 14:58:54 +00:00
ClutterOffscreenEffectPrivate *priv = offscreen_effect->priv;
clutter/offscreen-effect: Override ClutterActorMeta.set_enabled Again, the same case of the previous commits. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1187
2020-04-08 15:09:36 +00:00
g_clear_pointer (&priv->offscreen, cogl_object_unref);
clutter/offscreen-effect: Clear offscreen framebuffer when disabling When changing the 'enabled' property and disabling the offscreen effect, it doesn't make sense to preserve the offscreen framebuffer. It's not drawing, after all. Furthermore, because ClutterOffscreenEffect only checks if the offscreen framebuffer exists to decide whether or not to redraw, keeping the fbo alive is a waste of resources. Clear the offscreen framebuffer when the effect is disabled or enabled. Fixes https://gitlab.gnome.org/GNOME/mutter/issues/810 https://gitlab.gnome.org/GNOME/mutter/merge_requests/992
2020-01-07 14:58:54 +00:00
clutter/offscreen-effect: Override ClutterActorMeta.set_enabled Again, the same case of the previous commits. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1187
2020-04-08 15:09:36 +00:00
parent_class->set_enabled (meta, is_enabled);
clutter/offscreen-effect: Clear offscreen framebuffer when disabling When changing the 'enabled' property and disabling the offscreen effect, it doesn't make sense to preserve the offscreen framebuffer. It's not drawing, after all. Furthermore, because ClutterOffscreenEffect only checks if the offscreen framebuffer exists to decide whether or not to redraw, keeping the fbo alive is a waste of resources. Clear the offscreen framebuffer when the effect is disabled or enabled. Fixes https://gitlab.gnome.org/GNOME/mutter/issues/810 https://gitlab.gnome.org/GNOME/mutter/merge_requests/992
2020-01-07 14:58:54 +00:00
}
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 10:39:27 +00:00
static void
clutter_offscreen_effect_finalize (GObject *gobject)
{
ClutterOffscreenEffect *self = CLUTTER_OFFSCREEN_EFFECT (gobject);
ClutterOffscreenEffectPrivate *priv = self->priv;
clutter/offscreen-effect: Use g_clear_pointer for cleanup It does the exact same checks, and saves us a few lines of code. https://gitlab.gnome.org/GNOME/mutter/merge_requests/992
2020-01-07 14:57:02 +00:00
g_clear_pointer (&priv->offscreen, cogl_object_unref);
g_clear_pointer (&priv->texture, cogl_object_unref);
clutter/offscreen-effect: Rename CoglPipeline field to 'pipeline' This is the same case of the layer node: a CoglPipeline field that is not called 'pipeline' makes it harder to figure out what it really is. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1167
2020-03-31 01:26:18 +00:00
g_clear_pointer (&priv->pipeline, cogl_object_unref);
offscreen-effect: Add clutter_offscreen_effect_get_texture Sometimes a subclass of ClutterOffscreenEffect wants to paint with a completely custom material. In that case it is awkward to modify the material returned owned by ClutterOffscreenEffect so it makes more sense to just get the texture and manage its own material. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 11:53:54 +00:00
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 10:39:27 +00:00
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);
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 16:56:15 +00: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 10:39:27 +00:00
klass->paint_target = clutter_offscreen_effect_real_paint_target;
meta_class->set_actor = clutter_offscreen_effect_set_actor;
clutter/offscreen-effect: Override ClutterActorMeta.set_enabled Again, the same case of the previous commits. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1187
2020-04-08 15:09:36 +00:00
meta_class->set_enabled = clutter_offscreen_effect_set_enabled;
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 10:39:27 +00:00
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 06:44:11 +00: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 10:39:27 +00:00
gobject_class->finalize = clutter_offscreen_effect_finalize;
}
static void
clutter_offscreen_effect_init (ClutterOffscreenEffect *self)
{
Use the new macros for adding private data
2013-07-03 13:14:01 +00:00
self->priv = clutter_offscreen_effect_get_instance_private (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 10:39:27 +00:00
}
offscreen-effect: Add clutter_offscreen_effect_get_texture Sometimes a subclass of ClutterOffscreenEffect wants to paint with a completely custom material. In that case it is awkward to modify the material returned owned by ClutterOffscreenEffect so it makes more sense to just get the texture and manage its own material. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 11:53:54 +00:00
/**
* clutter_offscreen_effect_get_texture:
* @effect: a #ClutterOffscreenEffect
*
* Retrieves the texture used as a render target for the offscreen
* buffer created by @effect
*
* You should only use the returned texture when painting. The texture
* may change after ClutterEffect::pre_paint is called so the effect
* implementation should update any references to the texture after
* chaining-up to the parent's pre_paint implementation. This can be
* used instead of clutter_offscreen_effect_get_target() when the
* effect subclass wants to paint using its own material.
*
cogl: Remove COGL_INVALID_HANDLE Just use `NULL`, which is the normal C convention https://gitlab.gnome.org/GNOME/mutter/merge_requests/451
2019-02-20 13:53:01 +00:00
* Return value: (transfer none): a #CoglHandle or %NULL. The
offscreen-effect: Add clutter_offscreen_effect_get_texture Sometimes a subclass of ClutterOffscreenEffect wants to paint with a completely custom material. In that case it is awkward to modify the material returned owned by ClutterOffscreenEffect so it makes more sense to just get the texture and manage its own material. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 11:53:54 +00:00
* returned texture is owned by Clutter and it should not be
* modified or freed
*
* Since: 1.10
*/
CoglHandle
clutter_offscreen_effect_get_texture (ClutterOffscreenEffect *effect)
{
g_return_val_if_fail (CLUTTER_IS_OFFSCREEN_EFFECT (effect),
Reduce our internal dependence on the Cogl 1.x api Since Cogl has started restricting what cogl 1.x api is exposed when COGL_ENABLE_EXPERIMENTAL_2_0_API is defined and since we build all Clutter internals with COGL_ENABLE_EXPERIMENTAL_2_0_API defined this patch makes a first pass at reducing our internal use of the Cogl 1.x api. The most notable api that's no longer exposed to us internally is the cogl_material_ api so this switches all Clutter internals to use the cogl_pipeline_ api instead. This patch also makes quite a bit of progress removing internal uses of CoglHandle although there is still more to go.
2012-02-21 15:55:51 +00:00
NULL);
offscreen-effect: Add clutter_offscreen_effect_get_texture Sometimes a subclass of ClutterOffscreenEffect wants to paint with a completely custom material. In that case it is awkward to modify the material returned owned by ClutterOffscreenEffect so it makes more sense to just get the texture and manage its own material. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 11:53:54 +00:00
return effect->priv->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 10:39:27 +00:00
/**
Remove cogl-1.0 vs cogl-2.0 vs cogl experimental API split Mutter (and libmutter users) are the only users of this version of cogl, and will more or less only use the cogl-1.0, cogl-2.0 and cogl experimental API variants, and having the possibility of having different API versions of the same API depending on what file includes it is error prone and confusing. Lets just remove the possibility of having different versions of the same API. https://bugzilla.gnome.org/show_bug.cgi?id=768977
2016-06-16 19:04:40 +00:00
* clutter_offscreen_effect_get_target: (skip)
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 10:39:27 +00:00
* @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 16:56:15 +00: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 10:39:27 +00: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 16:56:15 +00: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 10:39:27 +00:00
clutter_offscreen_effect_get_target (ClutterOffscreenEffect *effect)
{
g_return_val_if_fail (CLUTTER_IS_OFFSCREEN_EFFECT (effect),
Pass a CoglContext when calling cogl_pipeline_new The experimental cogl_pipeline_new() api was recently changed so it explicitly takes a CoglContext. This updates all calls to cogl_pipeline_new() in clutter accordingly.
2012-02-21 13:22:17 +00:00
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 10:39:27 +00:00
clutter/offscreen-effect: Rename CoglPipeline field to 'pipeline' This is the same case of the layer node: a CoglPipeline field that is not called 'pipeline' makes it harder to figure out what it really is. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1167
2020-03-31 01:26:18 +00:00
return (CoglMaterial *)effect->priv->pipeline;
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 10:39:27 +00:00
}
/**
* clutter_offscreen_effect_paint_target:
* @effect: a #ClutterOffscreenEffect
clutter: Introduce paint contexts When painting, actors rely on semi global state tracked by the state to get various things needed for painting, such as the current draw framebuffer. Having state hidden in such ways can be very deceiving as it's hard to follow changes spread out, and adding more and more state that should be tracked during a paint gets annoying as they will not change in isolation but one by one in their own places. To do this better, introduce a paint context that is passed along in paint calls that contains the necessary state needed during painting. The paint context implements a framebuffer stack just as Cogl works, which is currently needed for offscreen rendering used by clutter. The same context is passed around for paint nodes, contents and effects as well. In this commit, the context is only introduced, but not used. It aims to replace the Cogl framebuffer stack, and will allow actors to know what view it is currently painted on. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-13 21:21:58 +00:00
* @paint_context: a #ClutterPaintContext
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 10:39:27 +00:00
*
* Calls the paint_target() virtual function of the @effect
*
* Since: 1.4
*/
void
clutter: Introduce paint contexts When painting, actors rely on semi global state tracked by the state to get various things needed for painting, such as the current draw framebuffer. Having state hidden in such ways can be very deceiving as it's hard to follow changes spread out, and adding more and more state that should be tracked during a paint gets annoying as they will not change in isolation but one by one in their own places. To do this better, introduce a paint context that is passed along in paint calls that contains the necessary state needed during painting. The paint context implements a framebuffer stack just as Cogl works, which is currently needed for offscreen rendering used by clutter. The same context is passed around for paint nodes, contents and effects as well. In this commit, the context is only introduced, but not used. It aims to replace the Cogl framebuffer stack, and will allow actors to know what view it is currently painted on. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-13 21:21:58 +00:00
clutter_offscreen_effect_paint_target (ClutterOffscreenEffect *effect,
ClutterPaintContext *paint_context)
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 10:39:27 +00:00
{
g_return_if_fail (CLUTTER_IS_OFFSCREEN_EFFECT (effect));
clutter: Introduce paint contexts When painting, actors rely on semi global state tracked by the state to get various things needed for painting, such as the current draw framebuffer. Having state hidden in such ways can be very deceiving as it's hard to follow changes spread out, and adding more and more state that should be tracked during a paint gets annoying as they will not change in isolation but one by one in their own places. To do this better, introduce a paint context that is passed along in paint calls that contains the necessary state needed during painting. The paint context implements a framebuffer stack just as Cogl works, which is currently needed for offscreen rendering used by clutter. The same context is passed around for paint nodes, contents and effects as well. In this commit, the context is only introduced, but not used. It aims to replace the Cogl framebuffer stack, and will allow actors to know what view it is currently painted on. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-13 21:21:58 +00:00
CLUTTER_OFFSCREEN_EFFECT_GET_CLASS (effect)->paint_target (effect,
paint_context);
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 10:39:27 +00: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 11:33:20 +00: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 16:56:15 +00: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 11:33:20 +00: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 16:56:15 +00: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 11:33:20 +00:00
*
Add some more introspection annotations
2010-09-06 15:11:46 +00:00
* Return value: (transfer full): a handle to a Cogl texture, or
cogl: Remove COGL_INVALID_HANDLE Just use `NULL`, which is the normal C convention https://gitlab.gnome.org/GNOME/mutter/merge_requests/451
2019-02-20 13:53:01 +00:00
* %NULL. The returned handle has its reference
Add some more introspection annotations
2010-09-06 15:11:46 +00:00
* 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 11:33:20 +00: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 16:56:15 +00: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 11:33:20 +00:00
{
g_return_val_if_fail (CLUTTER_IS_OFFSCREEN_EFFECT (effect),
Reduce our internal dependence on the Cogl 1.x api Since Cogl has started restricting what cogl 1.x api is exposed when COGL_ENABLE_EXPERIMENTAL_2_0_API is defined and since we build all Clutter internals with COGL_ENABLE_EXPERIMENTAL_2_0_API defined this patch makes a first pass at reducing our internal use of the Cogl 1.x api. The most notable api that's no longer exposed to us internally is the cogl_material_ api so this switches all Clutter internals to use the cogl_pipeline_ api instead. This patch also makes quite a bit of progress removing internal uses of CoglHandle although there is still more to go.
2012-02-21 15:55:51 +00:00
NULL);
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 11:33:20 +00: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 16:56:15 +00: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 11:33:20 +00: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 09:15:34 +00: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 14:31:59 +00: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
docs: Move to markdown We're removing docbook tags in favour of the markdown syntax.
2014-03-17 23:07:58 +00:00
* implementations, from within the #ClutterOffscreenEffectClass.paint_target()
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 14:31:59 +00:00
* virtual function.
*
* Return value: %TRUE if the offscreen buffer has a valid size,
* and %FALSE otherwise
*
* Since: 1.8
offscreen-effect: Add a method to get the target area The target size is not always enough, there are cases where the offset used to paint the target must also be available for developers implementing an OffscreenEffect. The get_target_rect() method returns the rectangle used to paint the target, with the offsets in the ClutterRect:origin and the texture size in the ClutterRect:size fields, respectively. The get_target_size() method should be deprecated, given that its replacement is generally more useful. https://bugzilla.gnome.org/show_bug.cgi?id=670004
2013-02-21 13:01:58 +00:00
*
* Deprecated: 1.14: Use clutter_offscreen_effect_get_target_rect() instead
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 14:31:59 +00: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 09:15:34 +00: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 14:31:59 +00: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 09:15:34 +00: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 14:31:59 +00:00
ClutterOffscreenEffectPrivate *priv;
g_return_val_if_fail (CLUTTER_IS_OFFSCREEN_EFFECT (effect), FALSE);
offscreen-effect: Add clutter_offscreen_effect_get_texture Sometimes a subclass of ClutterOffscreenEffect wants to paint with a completely custom material. In that case it is awkward to modify the material returned owned by ClutterOffscreenEffect so it makes more sense to just get the texture and manage its own material. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 11:53:54 +00: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 14:31:59 +00:00
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 09:15:34 +00:00
Reduce our internal dependence on the Cogl 1.x api Since Cogl has started restricting what cogl 1.x api is exposed when COGL_ENABLE_EXPERIMENTAL_2_0_API is defined and since we build all Clutter internals with COGL_ENABLE_EXPERIMENTAL_2_0_API defined this patch makes a first pass at reducing our internal use of the Cogl 1.x api. The most notable api that's no longer exposed to us internally is the cogl_material_ api so this switches all Clutter internals to use the cogl_pipeline_ api instead. This patch also makes quite a bit of progress removing internal uses of CoglHandle although there is still more to go.
2012-02-21 15:55:51 +00:00
if (priv->texture == NULL)
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 09:15:34 +00:00
return FALSE;
if (width)
offscreen-effect: Add clutter_offscreen_effect_get_texture Sometimes a subclass of ClutterOffscreenEffect wants to paint with a completely custom material. In that case it is awkward to modify the material returned owned by ClutterOffscreenEffect so it makes more sense to just get the texture and manage its own material. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 11:53:54 +00:00
*width = cogl_texture_get_width (priv->texture);
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 09:15:34 +00:00
if (height)
offscreen-effect: Add clutter_offscreen_effect_get_texture Sometimes a subclass of ClutterOffscreenEffect wants to paint with a completely custom material. In that case it is awkward to modify the material returned owned by ClutterOffscreenEffect so it makes more sense to just get the texture and manage its own material. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 11:53:54 +00:00
*height = cogl_texture_get_height (priv->texture);
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 09:15:34 +00:00
return TRUE;
}
offscreen-effect: Add a method to get the target area The target size is not always enough, there are cases where the offset used to paint the target must also be available for developers implementing an OffscreenEffect. The get_target_rect() method returns the rectangle used to paint the target, with the offsets in the ClutterRect:origin and the texture size in the ClutterRect:size fields, respectively. The get_target_size() method should be deprecated, given that its replacement is generally more useful. https://bugzilla.gnome.org/show_bug.cgi?id=670004
2013-02-21 13:01:58 +00:00
/**
* clutter_offscreen_effect_get_target_rect:
* @effect: a #ClutterOffscreenEffect
* @rect: (out caller-allocates): return location for the target area
*
* Retrieves the origin and 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
docs: Move to markdown We're removing docbook tags in favour of the markdown syntax.
2014-03-17 23:07:58 +00:00
* implementations, from within the #ClutterOffscreenEffectClass.paint_target()
offscreen-effect: Add a method to get the target area The target size is not always enough, there are cases where the offset used to paint the target must also be available for developers implementing an OffscreenEffect. The get_target_rect() method returns the rectangle used to paint the target, with the offsets in the ClutterRect:origin and the texture size in the ClutterRect:size fields, respectively. The get_target_size() method should be deprecated, given that its replacement is generally more useful. https://bugzilla.gnome.org/show_bug.cgi?id=670004
2013-02-21 13:01:58 +00:00
* virtual function.
*
* Return value: %TRUE if the offscreen buffer has a valid rectangle,
* and %FALSE otherwise
*
* Since: 1.14
*/
gboolean
clutter_offscreen_effect_get_target_rect (ClutterOffscreenEffect *effect,
Replace ClutterRect by graphene_rect_t https://gitlab.gnome.org/GNOME/mutter/merge_requests/458
2019-02-20 15:23:04 +00:00
graphene_rect_t *rect)
offscreen-effect: Add a method to get the target area The target size is not always enough, there are cases where the offset used to paint the target must also be available for developers implementing an OffscreenEffect. The get_target_rect() method returns the rectangle used to paint the target, with the offsets in the ClutterRect:origin and the texture size in the ClutterRect:size fields, respectively. The get_target_size() method should be deprecated, given that its replacement is generally more useful. https://bugzilla.gnome.org/show_bug.cgi?id=670004
2013-02-21 13:01:58 +00:00
{
ClutterOffscreenEffectPrivate *priv;
g_return_val_if_fail (CLUTTER_IS_OFFSCREEN_EFFECT (effect), FALSE);
g_return_val_if_fail (rect != NULL, FALSE);
priv = effect->priv;
if (priv->texture == NULL)
return FALSE;
Replace ClutterRect by graphene_rect_t https://gitlab.gnome.org/GNOME/mutter/merge_requests/458
2019-02-20 15:23:04 +00:00
graphene_rect_init (rect,
priv->position.x,
priv->position.y,
cogl_texture_get_width (priv->texture),
cogl_texture_get_height (priv->texture));
offscreen-effect: Add a method to get the target area The target size is not always enough, there are cases where the offset used to paint the target must also be available for developers implementing an OffscreenEffect. The get_target_rect() method returns the rectangle used to paint the target, with the offsets in the ClutterRect:origin and the texture size in the ClutterRect:size fields, respectively. The get_target_size() method should be deprecated, given that its replacement is generally more useful. https://bugzilla.gnome.org/show_bug.cgi?id=670004
2013-02-21 13:01:58 +00:00
return TRUE;
}
Reference in New Issue Copy Permalink