isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-23 08:30:42 -05:00
Code Issues Packages Projects Releases Wiki Activity
229241b875
mutter/clutter/clutter-shader-effect.c

929 lines
28 KiB
C
Raw Normal View History

effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2010 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
* Author:
* Emmanuele Bassi <ebassi@linux.intel.com>
*/
/**
* SECTION:clutter-shader-effect
Fix API docs for ClutterShaderEffects It can implement now both fragment and vertex shaders. http://bugzilla.clutter-project.org/show_bug.cgi?id=2442
2010-11-23 11:06:52 -05:00
* @short_description: Base class for shader effects
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
* @See_Also: #ClutterEffect, #ClutterOffscreenEffect
*
shader-effect: Allow instantiating ShaderEffect ClutterShaderEffect doesn't require to be sub-classed in order to be useful. It is possible to just create an instance, set the source and the uniforms, and attach it to an actor. This should effectively replace ClutterShader for good.
2011-05-25 10:37:45 -04:00
* #ClutterShaderEffect is a class that implements all the plumbing for
* creating #ClutterEffect<!-- -->s using GLSL shaders.
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
*
shader-effect: Allow instantiating ShaderEffect ClutterShaderEffect doesn't require to be sub-classed in order to be useful. It is possible to just create an instance, set the source and the uniforms, and attach it to an actor. This should effectively replace ClutterShader for good.
2011-05-25 10:37:45 -04:00
* #ClutterShaderEffect creates an offscreen buffer and then applies the
* GLSL shader (after checking whether the compilation and linking were
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
* successfull) to the buffer before painting it on screen.
*
* <refsect2 id="ClutterShaderEffect-implementing">
* <title>Implementing a ClutterShaderEffect</title>
* <para>Creating a sub-class of #ClutterShaderEffect requires the
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
* overriding of the <function>paint_target()</function> virtual
* function from the #ClutterOffscreenEffect class as well as the
* <function>get_static_shader_source()</function> virtual from the
* #ClutterShaderEffect class.</para>
* <para>The <function>get_static_shader_source()</function>
* function should return a copy of the shader source to use. This
* function is only called once per subclass of #ClutterShaderEffect
* regardless of how many instances of the effect are created. The
* source for the shader is typically stored in a static const
* string which is returned from this function via
* g_strdup().</para>
* <para>The <function>paint_target()</function> should set the
* shader's uniforms if any. This is done by calling
* clutter_shader_effect_set_uniform_value() or
* clutter_shader_effect_set_uniform(). The sub-class should then
* chain up to the #ClutterShaderEffect implementation.</para>
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
* <example id="ClutterShaderEffect-example-uniforms">
* <title>Setting uniforms on a ClutterShaderEffect</title>
* <para>The example below shows a typical implementation of the
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
* <function>get_static_shader_source()</function> and
* <function>paint_target()</function> phases of a
* #ClutterShaderEffect sub-class.</para>
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
* <programlisting>
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
* static gchar *
* my_effect_get_static_shader_source (ClutterShaderEffect *effect)
* {
* return g_strdup (shader_source);
* }
*
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
* static gboolean
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
* my_effect_paint_target (ClutterOffscreenEffect *effect)
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
* {
* MyEffect *self = MY_EFFECT (effect);
* ClutterShaderEffect *shader = CLUTTER_SHADER_EFFECT (effect);
* ClutterEffectClass *parent_class;
* gfloat component_r, component_g, component_b;
*
* /&ast; the "tex" uniform is declared in the shader as:
* &ast;
* &ast; uniform int tex;
* &ast;
* &ast; and it is passed a constant value of 0
* &ast;/
* clutter_shader_effect_set_uniform (shader, "tex", G_TYPE_INT, 1, 0);
*
* /&ast; the "component" uniform is declared in the shader as:
* &ast;
* &ast; uniform vec3 component;
* &ast;
* &ast; and it's defined to contain the normalized components
* &ast; of a #ClutterColor
* &ast;/
* component_r = self->color.red / 255.0f;
* component_g = self->color.green / 255.0f;
* component_b = self->color.blue / 255.0f;
* clutter_shader_effect_set_uniform (shader, "component",
* G_TYPE_FLOAT, 3,
* component_r,
* component_g,
* component_b);
*
shader-effect: Simplify setting the shader source Sub-classes of ShaderEffect currently have to get the handle for the Cogl shader and call cogl_shader_source(); this makes it awkward to implement a ShaderEffect, and it exposes handles and Cogl API that we might want to change in the future. We should provide a ClutterShaderEffect method that allows to (safely) set the shader source at the right time for sub-classes to use.
2010-05-17 07:55:46 -04:00
* /&ast; chain up to the parent's implementation &ast;/
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
* parent_class = CLUTTER_OFFSCREEN_EFFECT_CLASS (my_effect_parent_class);
* return parent_class->paint_target (effect);
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
* }
* </programlisting>
* </example>
* </refsect2>
*
* #ClutterShaderEffect is available since Clutter 1.4
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
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 10:55:51 -05:00
/* XXX: This file depends on the cogl_program_ api with has been
* removed for Cogl 2.0 so we undef COGL_ENABLE_EXPERIMENTAL_2_0_API
* for this file for now */
#undef COGL_ENABLE_EXPERIMENTAL_2_0_API
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
#include "cogl/cogl.h"
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 10:55:51 -05:00
#include "clutter-shader-effect.h"
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
#include "clutter-debug.h"
shader-effect: Allow creating vertex shaders By default, ShaderEffect creates a fragment shader; in order to be able to deprecate ClutterShader we need a way for ShaderEffect sub-classes to create a vertex shader if needed - By using a write-only, constructor only property. ClutterShader has, internally, a ClutterShaderType enumeration that can be used exactly for this. We just need to expose it and create a GObject property for ClutterShaderEffect.
2010-06-11 09:47:48 -04:00
#include "clutter-enum-types.h"
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
#include "clutter-feature.h"
#include "clutter-private.h"
#include "clutter-shader-types.h"
typedef struct _ShaderUniform
{
gchar *name;
GType type;
GValue value;
GLint location;
} ShaderUniform;
struct _ClutterShaderEffectPrivate
{
ClutterActor *actor;
shader-effect: Allow creating vertex shaders By default, ShaderEffect creates a fragment shader; in order to be able to deprecate ClutterShader we need a way for ShaderEffect sub-classes to create a vertex shader if needed - By using a write-only, constructor only property. ClutterShader has, internally, a ClutterShaderType enumeration that can be used exactly for this. We just need to expose it and create a GObject property for ClutterShaderEffect.
2010-06-11 09:47:48 -04:00
ClutterShaderType shader_type;
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
CoglHandle program;
CoglHandle shader;
GHashTable *uniforms;
};
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
typedef struct _ClutterShaderEffectClassPrivate
{
/* These are the per-class pre-compiled shader and program which is
used when the class implements get_static_shader_source without
calling set_shader_source. They will be shared by all instances
of this class */
CoglHandle program;
CoglHandle shader;
} ClutterShaderEffectClassPrivate;
shader-effect: Allow creating vertex shaders By default, ShaderEffect creates a fragment shader; in order to be able to deprecate ClutterShader we need a way for ShaderEffect sub-classes to create a vertex shader if needed - By using a write-only, constructor only property. ClutterShader has, internally, a ClutterShaderType enumeration that can be used exactly for this. We just need to expose it and create a GObject property for ClutterShaderEffect.
2010-06-11 09:47:48 -04:00
enum
{
PROP_0,
Conditionally use g_object_notify_by_pspec This adds a wrapper macro to clutter-private that will use g_object_notify_by_pspec if it's compiled against a version of GLib that is sufficiently new. Otherwise it will notify by the property name as before by extracting the name from the pspec. The objects can then store a static array of GParamSpecs and notify using those as suggested in the documentation for g_object_notify_by_pspec. Note that the name of the variable used for storing the array of GParamSpecs is obj_props instead of properties as used in the documentation because some places in Clutter uses 'properties' as the name of a local variable. Mose of the classes in Clutter have been converted using the script in the bug report. Some classes have not been modified even though the script picked them up as described here: json-generator: We probably don't want to modify the internal copy of JSON behaviour-depth: rectangle: score: stage-manager: These aren't using the separate GParamSpec* variable style. blur-effect: win32/device-manager: Don't actually define any properties even though it has the enum. box-layout: flow-layout: Have some per-child properties that don't work automatically with the script. clutter-model: The script gets confused with ClutterModelIter stage: Script gets confused because PROP_USER_RESIZE doesn't match "user-resizable" test-layout: Don't really want to modify the tests http://bugzilla.clutter-project.org/show_bug.cgi?id=2150
2010-06-21 05:20:32 -04:00
PROP_SHADER_TYPE,
PROP_LAST
shader-effect: Allow creating vertex shaders By default, ShaderEffect creates a fragment shader; in order to be able to deprecate ClutterShader we need a way for ShaderEffect sub-classes to create a vertex shader if needed - By using a write-only, constructor only property. ClutterShader has, internally, a ClutterShaderType enumeration that can be used exactly for this. We just need to expose it and create a GObject property for ClutterShaderEffect.
2010-06-11 09:47:48 -04:00
};
Conditionally use g_object_notify_by_pspec This adds a wrapper macro to clutter-private that will use g_object_notify_by_pspec if it's compiled against a version of GLib that is sufficiently new. Otherwise it will notify by the property name as before by extracting the name from the pspec. The objects can then store a static array of GParamSpecs and notify using those as suggested in the documentation for g_object_notify_by_pspec. Note that the name of the variable used for storing the array of GParamSpecs is obj_props instead of properties as used in the documentation because some places in Clutter uses 'properties' as the name of a local variable. Mose of the classes in Clutter have been converted using the script in the bug report. Some classes have not been modified even though the script picked them up as described here: json-generator: We probably don't want to modify the internal copy of JSON behaviour-depth: rectangle: score: stage-manager: These aren't using the separate GParamSpec* variable style. blur-effect: win32/device-manager: Don't actually define any properties even though it has the enum. box-layout: flow-layout: Have some per-child properties that don't work automatically with the script. clutter-model: The script gets confused with ClutterModelIter stage: Script gets confused because PROP_USER_RESIZE doesn't match "user-resizable" test-layout: Don't really want to modify the tests http://bugzilla.clutter-project.org/show_bug.cgi?id=2150
2010-06-21 05:20:32 -04:00
static GParamSpec *obj_props[PROP_LAST];
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
G_DEFINE_TYPE_WITH_CODE (ClutterShaderEffect,
clutter_shader_effect,
CLUTTER_TYPE_OFFSCREEN_EFFECT,
g_type_add_class_private (g_define_type_id,
sizeof (ClutterShaderEffectClassPrivate)))
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
static inline void
shader-effect: Attach the program to the target material Instead of calling cogl_program_use() around the paint_target() chain-up, we can use the newly added API in CoglMaterial to attach user-defined shaders to the offscreen target material.
2010-08-11 08:58:29 -04:00
clutter_shader_effect_clear (ClutterShaderEffect *self,
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
gboolean reset_uniforms)
{
shader-effect: Attach the program to the target material Instead of calling cogl_program_use() around the paint_target() chain-up, we can use the newly added API in CoglMaterial to attach user-defined shaders to the offscreen target material.
2010-08-11 08:58:29 -04:00
ClutterShaderEffectPrivate *priv = self->priv;
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
if (priv->shader != COGL_INVALID_HANDLE)
{
cogl_handle_unref (priv->shader);
priv->shader = COGL_INVALID_HANDLE;
}
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
if (priv->program != COGL_INVALID_HANDLE)
{
cogl_handle_unref (priv->program);
shader-effect: Attach the program to the target material Instead of calling cogl_program_use() around the paint_target() chain-up, we can use the newly added API in CoglMaterial to attach user-defined shaders to the offscreen target material.
2010-08-11 08:58:29 -04:00
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
priv->program = COGL_INVALID_HANDLE;
}
if (reset_uniforms && priv->uniforms != NULL)
{
g_hash_table_destroy (priv->uniforms);
priv->uniforms = NULL;
}
priv->actor = NULL;
}
static void
clutter_shader_effect_update_uniforms (ClutterShaderEffect *effect)
{
ClutterShaderEffectPrivate *priv = effect->priv;
GHashTableIter iter;
gpointer key, value;
gsize size;
Remove last uses of cogl_program_uniform* Following the commits: c03544da - clutter-shader: use cogl_program_set_uniform_xyz API a26119b5 - tests: Remove use of cogl_program_use Remove the users of cogl_program_uniform_* and cogl_program_use() in the shader-based effects.
2010-08-12 12:06:29 -04:00
if (priv->program == COGL_INVALID_HANDLE)
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
return;
Remove last uses of cogl_program_uniform* Following the commits: c03544da - clutter-shader: use cogl_program_set_uniform_xyz API a26119b5 - tests: Remove use of cogl_program_use Remove the users of cogl_program_uniform_* and cogl_program_use() in the shader-based effects.
2010-08-12 12:06:29 -04:00
if (priv->uniforms == NULL)
return;
shader-effect: Attach the program to the target material Instead of calling cogl_program_use() around the paint_target() chain-up, we can use the newly added API in CoglMaterial to attach user-defined shaders to the offscreen target material.
2010-08-11 08:58:29 -04:00
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
key = value = NULL;
g_hash_table_iter_init (&iter, priv->uniforms);
while (g_hash_table_iter_next (&iter, &key, &value))
{
ShaderUniform *uniform = value;
if (uniform->location == -1)
uniform->location = cogl_program_get_uniform_location (priv->program,
uniform->name);
if (CLUTTER_VALUE_HOLDS_SHADER_FLOAT (&uniform->value))
{
const GLfloat *floats;
floats = clutter_value_get_shader_float (&uniform->value, &size);
Remove last uses of cogl_program_uniform* Following the commits: c03544da - clutter-shader: use cogl_program_set_uniform_xyz API a26119b5 - tests: Remove use of cogl_program_use Remove the users of cogl_program_uniform_* and cogl_program_use() in the shader-based effects.
2010-08-12 12:06:29 -04:00
cogl_program_set_uniform_float (priv->program, uniform->location,
size, 1,
floats);
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
}
else if (CLUTTER_VALUE_HOLDS_SHADER_INT (&uniform->value))
{
const GLint *ints;
ints = clutter_value_get_shader_int (&uniform->value, &size);
Remove last uses of cogl_program_uniform* Following the commits: c03544da - clutter-shader: use cogl_program_set_uniform_xyz API a26119b5 - tests: Remove use of cogl_program_use Remove the users of cogl_program_uniform_* and cogl_program_use() in the shader-based effects.
2010-08-12 12:06:29 -04:00
cogl_program_set_uniform_int (priv->program, uniform->location,
size, 1,
ints);
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
}
else if (CLUTTER_VALUE_HOLDS_SHADER_MATRIX (&uniform->value))
{
const GLfloat *matrix;
matrix = clutter_value_get_shader_matrix (&uniform->value, &size);
Remove last uses of cogl_program_uniform* Following the commits: c03544da - clutter-shader: use cogl_program_set_uniform_xyz API a26119b5 - tests: Remove use of cogl_program_use Remove the users of cogl_program_uniform_* and cogl_program_use() in the shader-based effects.
2010-08-12 12:06:29 -04:00
cogl_program_set_uniform_matrix (priv->program, uniform->location,
size, 1,
FALSE,
matrix);
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
}
else if (G_VALUE_HOLDS_FLOAT (&uniform->value))
{
const GLfloat float_val = g_value_get_float (&uniform->value);
Make clutter_shader_effect_set_uniform_value accept G_TYPE_DOUBLE For users of gobject-introspection that cannot know which non-integer type to pass. http://bugzilla.clutter-project.org/show_bug.cgi?id=2471
2010-12-07 09:29:05 -05:00
cogl_program_set_uniform_float (priv->program, uniform->location,
1, 1,
&float_val);
}
else if (G_VALUE_HOLDS_DOUBLE (&uniform->value))
{
const GLfloat float_val =
(GLfloat) g_value_get_double (&uniform->value);
Remove last uses of cogl_program_uniform* Following the commits: c03544da - clutter-shader: use cogl_program_set_uniform_xyz API a26119b5 - tests: Remove use of cogl_program_use Remove the users of cogl_program_uniform_* and cogl_program_use() in the shader-based effects.
2010-08-12 12:06:29 -04:00
cogl_program_set_uniform_float (priv->program, uniform->location,
1, 1,
&float_val);
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
}
else if (G_VALUE_HOLDS_INT (&uniform->value))
{
const GLint int_val = g_value_get_int (&uniform->value);
Remove last uses of cogl_program_uniform* Following the commits: c03544da - clutter-shader: use cogl_program_set_uniform_xyz API a26119b5 - tests: Remove use of cogl_program_use Remove the users of cogl_program_uniform_* and cogl_program_use() in the shader-based effects.
2010-08-12 12:06:29 -04:00
cogl_program_set_uniform_int (priv->program, uniform->location,
1, 1,
&int_val);
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
}
else
g_warning ("Invalid uniform of type '%s' for name '%s'",
g_type_name (G_VALUE_TYPE (&uniform->value)),
uniform->name);
}
}
static void
clutter_shader_effect_set_actor (ClutterActorMeta *meta,
ClutterActor *actor)
{
ClutterShaderEffect *self = CLUTTER_SHADER_EFFECT (meta);
ClutterShaderEffectPrivate *priv = self->priv;
ClutterActorMetaClass *parent;
if (!clutter_feature_available (CLUTTER_FEATURE_SHADERS_GLSL))
{
/* if we don't have support for GLSL shaders then we
* forcibly disable the ActorMeta
*/
g_warning ("Unable to use the ShaderEffect: the graphics hardware "
"or the current GL driver does not implement support "
"for the GLSL shading language.");
clutter_actor_meta_set_enabled (meta, FALSE);
return;
}
parent = CLUTTER_ACTOR_META_CLASS (clutter_shader_effect_parent_class);
parent->set_actor (meta, actor);
/* we keep a back pointer here */
priv->actor = clutter_actor_meta_get_actor (meta);
if (priv->actor == NULL)
return;
CLUTTER_NOTE (SHADER, "Preparing shader effect of type '%s'",
G_OBJECT_TYPE_NAME (meta));
}
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
static CoglHandle
clutter_shader_effect_create_shader (ClutterShaderEffect *self)
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
{
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
ClutterShaderEffectPrivate *priv = self->priv;
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
switch (priv->shader_type)
{
case CLUTTER_FRAGMENT_SHADER:
return cogl_create_shader (COGL_SHADER_TYPE_FRAGMENT);
break;
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
case CLUTTER_VERTEX_SHADER:
return cogl_create_shader (COGL_SHADER_TYPE_VERTEX);
break;
shader-effect: Simplify setting the shader source Sub-classes of ShaderEffect currently have to get the handle for the Cogl shader and call cogl_shader_source(); this makes it awkward to implement a ShaderEffect, and it exposes handles and Cogl API that we might want to change in the future. We should provide a ClutterShaderEffect method that allows to (safely) set the shader source at the right time for sub-classes to use.
2010-05-17 07:55:46 -04:00
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
default:
g_assert_not_reached ();
}
}
static void
clutter_shader_effect_try_static_source (ClutterShaderEffect *self)
{
ClutterShaderEffectPrivate *priv = self->priv;
ClutterShaderEffectClass *shader_effect_class =
CLUTTER_SHADER_EFFECT_GET_CLASS (self);
if (shader_effect_class->get_static_shader_source != NULL)
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
{
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
ClutterShaderEffectClassPrivate *class_priv;
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
class_priv =
G_TYPE_CLASS_GET_PRIVATE (shader_effect_class,
CLUTTER_TYPE_SHADER_EFFECT,
ClutterShaderEffectClassPrivate);
if (class_priv->shader == COGL_INVALID_HANDLE)
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
{
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
gchar *source;
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
class_priv->shader = clutter_shader_effect_create_shader (self);
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
source = shader_effect_class->get_static_shader_source (self);
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
cogl_shader_source (class_priv->shader, source);
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
g_free (source);
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
CLUTTER_NOTE (SHADER, "Compiling shader effect");
shader-effect: Attach the program to the target material Instead of calling cogl_program_use() around the paint_target() chain-up, we can use the newly added API in CoglMaterial to attach user-defined shaders to the offscreen target material.
2010-08-11 08:58:29 -04:00
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
cogl_shader_compile (class_priv->shader);
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
if (cogl_shader_is_compiled (class_priv->shader))
{
class_priv->program = cogl_create_program ();
cogl_program_attach_shader (class_priv->program,
class_priv->shader);
cogl_program_link (class_priv->program);
}
else
{
gchar *log_buf = cogl_shader_get_info_log (class_priv->shader);
Currently Clutter only prints out a warning message in case some shader effects fail to compile Clutter-WARNING **: Unable to compile the GLSL shader: Fragment shader failed to compile with the following errors: The attached patch (against current git) should print out more information what makes it easier to answer user feedback. https://bugzilla.gnome.org/show_bug.cgi?id=664252
2011-11-13 15:49:23 -05:00
g_warning (G_STRLOC ": Unable to compile the GLSL shader: %s", log_buf);
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
g_free (log_buf);
}
}
priv->shader = cogl_handle_ref (class_priv->shader);
if (class_priv->program != COGL_INVALID_HANDLE)
priv->program = cogl_handle_ref (class_priv->program);
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
}
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
}
static void
clutter_shader_effect_paint_target (ClutterOffscreenEffect *effect)
{
ClutterShaderEffect *self = CLUTTER_SHADER_EFFECT (effect);
ClutterShaderEffectPrivate *priv = self->priv;
ClutterOffscreenEffectClass *parent;
CoglHandle material;
/* If the source hasn't been set then we'll try to get it from the
static source instead */
if (priv->shader == COGL_INVALID_HANDLE)
clutter_shader_effect_try_static_source (self);
/* we haven't been prepared or we don't have support for
* GLSL shaders in Clutter
*/
if (priv->program == COGL_INVALID_HANDLE)
goto out;
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
CLUTTER_NOTE (SHADER, "Applying the shader effect of type '%s'",
G_OBJECT_TYPE_NAME (effect));
clutter_shader_effect_update_uniforms (CLUTTER_SHADER_EFFECT (effect));
shader-effect: Attach the program to the target material Instead of calling cogl_program_use() around the paint_target() chain-up, we can use the newly added API in CoglMaterial to attach user-defined shaders to the offscreen target material.
2010-08-11 08:58:29 -04:00
/* associate the program to the offscreen target material */
material = clutter_offscreen_effect_get_target (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 10:55:51 -05:00
cogl_pipeline_set_user_program (material, priv->program);
shader-effect: Attach the program to the target material Instead of calling cogl_program_use() around the paint_target() chain-up, we can use the newly added API in CoglMaterial to attach user-defined shaders to the offscreen target material.
2010-08-11 08:58:29 -04:00
out:
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
/* paint the offscreen buffer */
parent = CLUTTER_OFFSCREEN_EFFECT_CLASS (clutter_shader_effect_parent_class);
parent->paint_target (effect);
}
shader-effect: Allow creating vertex shaders By default, ShaderEffect creates a fragment shader; in order to be able to deprecate ClutterShader we need a way for ShaderEffect sub-classes to create a vertex shader if needed - By using a write-only, constructor only property. ClutterShader has, internally, a ClutterShaderType enumeration that can be used exactly for this. We just need to expose it and create a GObject property for ClutterShaderEffect.
2010-06-11 09:47:48 -04:00
static void
clutter_shader_effect_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
ClutterShaderEffectPrivate *priv = CLUTTER_SHADER_EFFECT (gobject)->priv;
switch (prop_id)
{
case PROP_SHADER_TYPE:
priv->shader_type = g_value_get_enum (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
static void
clutter_shader_effect_finalize (GObject *gobject)
{
ClutterShaderEffect *effect = CLUTTER_SHADER_EFFECT (gobject);
clutter_shader_effect_clear (effect, TRUE);
G_OBJECT_CLASS (clutter_shader_effect_parent_class)->finalize (gobject);
}
static void
clutter_shader_effect_class_init (ClutterShaderEffectClass *klass)
{
ClutterActorMetaClass *meta_class = CLUTTER_ACTOR_META_CLASS (klass);
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
ClutterOffscreenEffectClass *offscreen_class;
offscreen_class = CLUTTER_OFFSCREEN_EFFECT_CLASS (klass);
shader-effect: Allow creating vertex shaders By default, ShaderEffect creates a fragment shader; in order to be able to deprecate ClutterShader we need a way for ShaderEffect sub-classes to create a vertex shader if needed - By using a write-only, constructor only property. ClutterShader has, internally, a ClutterShaderType enumeration that can be used exactly for this. We just need to expose it and create a GObject property for ClutterShaderEffect.
2010-06-11 09:47:48 -04:00
g_type_class_add_private (klass, sizeof (ClutterShaderEffectPrivate));
/**
* ClutterShaderEffect:shader-type:
*
* The type of shader that is used by the effect. This property
* should be set by the constructor of #ClutterShaderEffect
* sub-classes.
*
* Since: 1.4
*/
Move more classes to install_properties()
2010-10-15 10:24:27 -04:00
obj_props[PROP_SHADER_TYPE] =
g_param_spec_enum ("shader-type",
P_("Shader Type"),
P_("The type of shader used"),
CLUTTER_TYPE_SHADER_TYPE,
CLUTTER_FRAGMENT_SHADER,
CLUTTER_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY);
gobject_class->set_property = clutter_shader_effect_set_property;
gobject_class->finalize = clutter_shader_effect_finalize;
Remove private helper #define's Finish off the second half of 09a830d294. http://bugzilla.clutter-project.org/show_bug.cgi?id=2596
2011-03-03 06:35:46 -05:00
g_object_class_install_properties (gobject_class,
PROP_LAST,
obj_props);
shader-effect: Allow creating vertex shaders By default, ShaderEffect creates a fragment shader; in order to be able to deprecate ClutterShader we need a way for ShaderEffect sub-classes to create a vertex shader if needed - By using a write-only, constructor only property. ClutterShader has, internally, a ClutterShaderType enumeration that can be used exactly for this. We just need to expose it and create a GObject property for ClutterShaderEffect.
2010-06-11 09:47:48 -04:00
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
meta_class->set_actor = clutter_shader_effect_set_actor;
offscreen_class->paint_target = clutter_shader_effect_paint_target;
}
static void
clutter_shader_effect_init (ClutterShaderEffect *effect)
{
effect->priv = G_TYPE_INSTANCE_GET_PRIVATE (effect,
CLUTTER_TYPE_SHADER_EFFECT,
ClutterShaderEffectPrivate);
}
shader-effect: Allow instantiating ShaderEffect ClutterShaderEffect doesn't require to be sub-classed in order to be useful. It is possible to just create an instance, set the source and the uniforms, and attach it to an actor. This should effectively replace ClutterShader for good.
2011-05-25 10:37:45 -04:00
/**
* clutter_shader_effect_new:
* @shader_type: the type of the shader, either %CLUTTER_FRAGMENT_SHADER,
* or %CLUTTER_VERTEX_SHADER
*
* Creates a new #ClutterShaderEffect, to be applied to an actor using
* clutter_actor_add_effect().
*
* The effect will be empty until clutter_shader_effect_set_shader_source()
* is called.
*
* Return value: (transfer full): the newly created #ClutterShaderEffect.
* Use g_object_unref() when done.
*
* Since: 1.8
*/
ClutterEffect *
clutter_shader_effect_new (ClutterShaderType shader_type)
{
return g_object_new (CLUTTER_TYPE_SHADER_EFFECT,
"shader-type", shader_type,
NULL);
}
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
/**
* clutter_shader_effect_get_shader:
* @effect: a #ClutterShaderEffect
*
* Retrieves a pointer to the shader's handle
*
* Return value: (transfer none): a pointer to the shader's handle,
* or %COGL_INVALID_HANDLE
*
* Since: 1.4
*/
CoglHandle
clutter_shader_effect_get_shader (ClutterShaderEffect *effect)
{
g_return_val_if_fail (CLUTTER_IS_SHADER_EFFECT (effect),
COGL_INVALID_HANDLE);
return effect->priv->shader;
}
/**
* clutter_shader_effect_get_program:
* @effect: a #ClutterShaderEffect
*
* Retrieves a pointer to the program's handle
*
* Return value: (transfer none): a pointer to the program's handle,
* or %COGL_INVALID_HANDLE
*
* Since: 1.4
*/
CoglHandle
clutter_shader_effect_get_program (ClutterShaderEffect *effect)
{
g_return_val_if_fail (CLUTTER_IS_SHADER_EFFECT (effect),
COGL_INVALID_HANDLE);
return effect->priv->program;
}
static void
shader_uniform_free (gpointer data)
{
if (data != NULL)
{
ShaderUniform *uniform = data;
g_value_unset (&uniform->value);
g_free (uniform->name);
g_slice_free (ShaderUniform, uniform);
}
}
static ShaderUniform *
shader_uniform_new (const gchar *name,
const GValue *value)
{
ShaderUniform *retval;
shader-effect: Zero out ShaderUniform Do not use the compiler to zero the first field of the GValue member, since it's apparently non-portable. As we're allocating memory anyway we can let the slice allocator do the zero-ing for us. Mentioned in: http://bugzilla.clutter-project.org/show_bug.cgi?id=2455
2010-11-29 03:55:13 -05:00
retval = g_slice_new0 (ShaderUniform);
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
retval->name = g_strdup (name);
retval->type = G_VALUE_TYPE (value);
retval->location = -1;
g_value_init (&retval->value, retval->type);
g_value_copy (value, &retval->value);
return retval;
}
static void
shader_uniform_update (ShaderUniform *uniform,
const GValue *value)
{
g_value_unset (&uniform->value);
g_value_init (&uniform->value, G_VALUE_TYPE (value));
g_value_copy (value, &uniform->value);
}
static inline void
clutter_shader_effect_add_uniform (ClutterShaderEffect *effect,
const gchar *name,
const GValue *value)
{
ClutterShaderEffectPrivate *priv = effect->priv;
ShaderUniform *uniform;
if (priv->uniforms == NULL)
{
priv->uniforms = g_hash_table_new_full (g_str_hash, g_str_equal,
NULL,
shader_uniform_free);
}
uniform = g_hash_table_lookup (priv->uniforms, name);
if (uniform == NULL)
{
uniform = shader_uniform_new (name, value);
g_hash_table_insert (priv->uniforms, uniform->name, uniform);
}
else
shader_uniform_update (uniform, value);
shader-effect: Allow instantiating ShaderEffect ClutterShaderEffect doesn't require to be sub-classed in order to be useful. It is possible to just create an instance, set the source and the uniforms, and attach it to an actor. This should effectively replace ClutterShader for good.
2011-05-25 10:37:45 -04:00
if (priv->actor != NULL && !CLUTTER_ACTOR_IN_PAINT (priv->actor))
effects: Use effect_queue_repaint instead of actor_queue_redraw The builtin effects ClutterColorizeEffect, ClutterDesaturateEffect and ClutterShaderEffect all have properties which only affect the rendering of the final texture not the contents of it. When these properties are updated we should queue a repaint of the effect not the actor so that we don't waste time repainting the contents of the offscreen buffer. https://bugzilla.gnome.org/show_bug.cgi?id=665052 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 09:19:28 -05:00
clutter_effect_queue_repaint (CLUTTER_EFFECT (effect));
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
}
/**
* clutter_shader_effect_set_uniform_value:
* @effect: a #ClutterShaderEffect
* @name: the name of the uniform to set
* @value: a #GValue with the value of the uniform to set
*
* Sets @value as the payload for the uniform @name inside the shader
* effect
*
* The #GType of the @value must be one of: %G_TYPE_INT, for a single
* integer value; %G_TYPE_FLOAT, for a single floating point value;
* %CLUTTER_TYPE_SHADER_INT, for an array of integer values;
* %CLUTTER_TYPE_SHADER_FLOAT, for an array of floating point values;
* and %CLUTTER_TYPE_SHADER_MATRIX, for a matrix of floating point
Make clutter_shader_effect_set_uniform_value accept G_TYPE_DOUBLE For users of gobject-introspection that cannot know which non-integer type to pass. http://bugzilla.clutter-project.org/show_bug.cgi?id=2471
2010-12-07 09:29:05 -05:00
* values. It also accepts %G_TYPE_DOUBLE for compatibility with other
* languages than C.
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
*
* Since: 1.4
*/
void
clutter_shader_effect_set_uniform_value (ClutterShaderEffect *effect,
const gchar *name,
const GValue *value)
{
g_return_if_fail (CLUTTER_IS_SHADER_EFFECT (effect));
g_return_if_fail (name != NULL);
g_return_if_fail (value != NULL);
clutter_shader_effect_add_uniform (effect, name, value);
}
static void
clutter_shader_effect_set_uniform_valist (ClutterShaderEffect *effect,
const gchar *name,
GType value_type,
gsize n_values,
va_list *args)
{
Use G_VALUE_INIT instead of { 0, } The macro avoids warnings from anal-retentive compilers.
2012-03-17 12:38:06 -04:00
GValue value = G_VALUE_INIT;
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
if (value_type == CLUTTER_TYPE_SHADER_INT)
{
gint *int_values = va_arg (*args, gint*);
g_value_init (&value, CLUTTER_TYPE_SHADER_INT);
clutter_value_set_shader_int (&value, n_values, int_values);
goto add_uniform;
}
if (value_type == CLUTTER_TYPE_SHADER_FLOAT)
{
gfloat *float_values = va_arg (*args, gfloat*);
g_value_init (&value, CLUTTER_TYPE_SHADER_FLOAT);
clutter_value_set_shader_float (&value, n_values, float_values);
goto add_uniform;
}
if (value_type == CLUTTER_TYPE_SHADER_MATRIX)
{
gfloat *float_values = va_arg (*args, gfloat*);
g_value_init (&value, CLUTTER_TYPE_SHADER_MATRIX);
clutter_value_set_shader_matrix (&value, n_values, float_values);
goto add_uniform;
}
if (value_type == G_TYPE_INT)
{
shader-effect: Add a size check Similar to the one in commit 2a354d9650bb8215dd75a90b947fb82734c35b78 that went into clutter_value_set_shader_*. We end up in the same situation, but it's better to fail from within ClutterShaderEffect.
2010-06-16 12:17:27 -04:00
g_return_if_fail (n_values <= 4);
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
/* if we only have one value we can go through the fast path
* of using G_TYPE_INT, otherwise we create a vector of integers
* from the passed values
*/
if (n_values == 1)
{
gint int_val = va_arg (*args, gint);
g_value_init (&value, G_TYPE_INT);
g_value_set_int (&value, int_val);
}
else
{
gint *int_values = g_new (gint, n_values);
gint i;
for (i = 0; i < n_values; i++)
int_values[i] = va_arg (*args, gint);
g_value_init (&value, CLUTTER_TYPE_SHADER_INT);
clutter_value_set_shader_int (&value, n_values, int_values);
g_free (int_values);
}
goto add_uniform;
}
if (value_type == G_TYPE_FLOAT)
{
shader-effect: Add a size check Similar to the one in commit 2a354d9650bb8215dd75a90b947fb82734c35b78 that went into clutter_value_set_shader_*. We end up in the same situation, but it's better to fail from within ClutterShaderEffect.
2010-06-16 12:17:27 -04:00
g_return_if_fail (n_values <= 4);
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
/* if we only have one value we can go through the fast path
* of using G_TYPE_FLOAT, otherwise we create a vector of floats
* from the passed values
*/
if (n_values == 1)
{
gfloat float_val = (gfloat) va_arg (*args, gdouble);
g_value_init (&value, G_TYPE_FLOAT);
g_value_set_float (&value, float_val);
}
else
{
gfloat *float_values = g_new (gfloat, n_values);
gint i;
for (i = 0; i < n_values; i++)
float_values[i] = (gfloat) va_arg (*args, double);
g_value_init (&value, CLUTTER_TYPE_SHADER_FLOAT);
clutter_value_set_shader_float (&value, n_values, float_values);
g_free (float_values);
}
goto add_uniform;
}
g_warning ("Unrecognized type '%s' (values: %d) for uniform name '%s'",
g_type_name (value_type),
(int) n_values,
name);
return;
add_uniform:
clutter_shader_effect_add_uniform (effect, name, &value);
g_value_unset (&value);
}
/**
* clutter_shader_effect_set_uniform:
* @effect: a #ClutterShaderEffect
* @name: the name of the uniform to set
* @gtype: the type of the uniform to set
docs: Effects fixes for the API reference
2010-06-03 09:34:41 -04:00
* @n_values: the number of values
docs: Fixes for building the API reference
2011-07-26 08:43:37 -04:00
* @...: a list of values
effect: Add ShaderEffect The ShaderEffect class is an abstract base type for shader-based effects. GLSL-based effects should be implemented by sub-classing ShaderEffect and overriding ActorMeta::set_actor() to set the source code of the shader, and Effect::pre_paint() to update the uniform values, if any. The ShaderEffect has a generic API for sub-classes to set the values of the uniforms defined by their shaders, and it uses the shader types we defined for ClutterShader, to avoid re-inventing the wheel every time.
2010-04-13 11:40:31 -04:00
*
* Sets a list of values as the payload for the uniform @name inside
* the shader effect
*
* The @gtype must be one of: %G_TYPE_INT, for 1 or more integer values;
* %G_TYPE_FLOAT, for 1 or more floating point values;
* %CLUTTER_TYPE_SHADER_INT, for a pointer to an array of integer values;
* %CLUTTER_TYPE_SHADER_FLOAT, for a pointer to an array of floating point
* values; and %CLUTTER_TYPE_SHADER_MATRIX, for a pointer to an array of
* floating point values mapping a matrix
*
* The number of values interepreted is defined by the @n_value
* argument, and by the @gtype argument. For instance, a uniform named
* "sampler0" and containing a single integer value is set using:
*
* |[
* clutter_shader_effect_set_uniform (effect, "sampler0",
* G_TYPE_INT, 1,
* 0);
* ]|
*
* While a uniform named "components" and containing a 3-elements vector
* of floating point values (a "vec3") can be set using:
*
* |[
* gfloat component_r, component_g, component_b;
*
* clutter_shader_effect_set_uniform (effect, "components",
* G_TYPE_FLOAT, 3,
* component_r,
* component_g,
* component_b);
* ]|
*
* or can be set using:
*
* |[
* gfloat component_vec[3];
*
* clutter_shader_effect_set_uniform (effect, "components",
* CLUTTER_TYPE_SHADER_FLOAT, 3,
* component_vec);
* ]|
*
* Finally, a uniform named "map" and containing a matrix can be set using:
*
* |[
* clutter_shader_effect_set_uniform (effect, "map",
* CLUTTER_TYPE_SHADER_MATRIX, 1,
* cogl_matrix_get_array (&matrix));
* ]|
*
* Since: 1.4
*/
void
clutter_shader_effect_set_uniform (ClutterShaderEffect *effect,
const gchar *name,
GType gtype,
gsize n_values,
...)
{
va_list args;
g_return_if_fail (CLUTTER_IS_SHADER_EFFECT (effect));
g_return_if_fail (name != NULL);
g_return_if_fail (gtype != G_TYPE_INVALID);
g_return_if_fail (n_values > 0);
va_start (args, n_values);
clutter_shader_effect_set_uniform_valist (effect, name,
gtype,
n_values,
&args);
va_end (args);
}
shader-effect: Simplify setting the shader source Sub-classes of ShaderEffect currently have to get the handle for the Cogl shader and call cogl_shader_source(); this makes it awkward to implement a ShaderEffect, and it exposes handles and Cogl API that we might want to change in the future. We should provide a ClutterShaderEffect method that allows to (safely) set the shader source at the right time for sub-classes to use.
2010-05-17 07:55:46 -04:00
/**
* clutter_shader_effect_set_shader_source:
* @effect: a #ClutterShaderEffect
* @source: the source of a GLSL shader
*
* Sets the source of the GLSL shader used by @effect
*
* This function should only be called by implementations of
* the #ClutterShaderEffect class, and not by application code.
*
* This function can only be called once; subsequent calls will
* yield no result.
*
* Return value: %TRUE if the source was set
*
* Since: 1.4
*/
gboolean
clutter_shader_effect_set_shader_source (ClutterShaderEffect *effect,
const gchar *source)
{
ClutterShaderEffectPrivate *priv;
g_return_val_if_fail (CLUTTER_IS_SHADER_EFFECT (effect), FALSE);
g_return_val_if_fail (source != NULL && *source != '\0', FALSE);
priv = effect->priv;
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
if (priv->shader != COGL_INVALID_HANDLE)
shader-effect: Simplify setting the shader source Sub-classes of ShaderEffect currently have to get the handle for the Cogl shader and call cogl_shader_source(); this makes it awkward to implement a ShaderEffect, and it exposes handles and Cogl API that we might want to change in the future. We should provide a ClutterShaderEffect method that allows to (safely) set the shader source at the right time for sub-classes to use.
2010-05-17 07:55:46 -04:00
return TRUE;
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
priv->shader = clutter_shader_effect_create_shader (effect);
ClutterShaderEffect: Don't throw away the program for a new actor Previously when the shader effect is used with a new actor it would end up throwing away the old program. I don't think this is neccessary and it means if you use an effect to temporarily bind to an actor then it will recompile the shader whenever it is applied. http://bugzilla.clutter-project.org/show_bug.cgi?id=2454
2010-11-27 11:26:20 -05:00
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
cogl_shader_source (priv->shader, source);
shader-effect: Remove unused function The reset_uniforms() internal function is not used any more because the CoglProgram cannot be reset post-creation - hence the uniforms cannot change.
2010-11-29 05:59:16 -05:00
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
CLUTTER_NOTE (SHADER, "Compiling shader effect");
shader-effect: Remove unused function The reset_uniforms() internal function is not used any more because the CoglProgram cannot be reset post-creation - hence the uniforms cannot change.
2010-11-29 05:59:16 -05:00
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
cogl_shader_compile (priv->shader);
ClutterShaderEffect: Don't throw away the program for a new actor Previously when the shader effect is used with a new actor it would end up throwing away the old program. I don't think this is neccessary and it means if you use an effect to temporarily bind to an actor then it will recompile the shader whenever it is applied. http://bugzilla.clutter-project.org/show_bug.cgi?id=2454
2010-11-27 11:26:20 -05:00
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
if (cogl_shader_is_compiled (priv->shader))
{
priv->program = cogl_create_program ();
shader-effect: Simplify setting the shader source Sub-classes of ShaderEffect currently have to get the handle for the Cogl shader and call cogl_shader_source(); this makes it awkward to implement a ShaderEffect, and it exposes handles and Cogl API that we might want to change in the future. We should provide a ClutterShaderEffect method that allows to (safely) set the shader source at the right time for sub-classes to use.
2010-05-17 07:55:46 -04:00
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
cogl_program_attach_shader (priv->program, priv->shader);
cogl_program_link (priv->program);
}
else
{
gchar *log_buf = cogl_shader_get_info_log (priv->shader);
shader-effect: Simplify setting the shader source Sub-classes of ShaderEffect currently have to get the handle for the Cogl shader and call cogl_shader_source(); this makes it awkward to implement a ShaderEffect, and it exposes handles and Cogl API that we might want to change in the future. We should provide a ClutterShaderEffect method that allows to (safely) set the shader source at the right time for sub-classes to use.
2010-05-17 07:55:46 -04:00
Currently Clutter only prints out a warning message in case some shader effects fail to compile Clutter-WARNING **: Unable to compile the GLSL shader: Fragment shader failed to compile with the following errors: The attached patch (against current git) should print out more information what makes it easier to answer user feedback. https://bugzilla.gnome.org/show_bug.cgi?id=664252
2011-11-13 15:49:23 -05:00
g_warning (G_STRLOC ": Unable to compile the GLSL shader: %s", log_buf);
clutter-shader-effect: Add a get_static_shader_source virtual This is used as an alternative to calling clutter_shader_effect_set_shader_source. A ClutterShaderEffect subclass is now expected to implement this method to return the source for the effect that will be used for all instances of this subclass. It is only called once regardless of the number of instances created. That way Clutter can avoid recompiling the shader source for every new instance of the effect. https://bugzilla.gnome.org/show_bug.cgi?id=660512 Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-29 15:05:39 -04:00
g_free (log_buf);
}
shader-effect: Simplify setting the shader source Sub-classes of ShaderEffect currently have to get the handle for the Cogl shader and call cogl_shader_source(); this makes it awkward to implement a ShaderEffect, and it exposes handles and Cogl API that we might want to change in the future. We should provide a ClutterShaderEffect method that allows to (safely) set the shader source at the right time for sub-classes to use.
2010-05-17 07:55:46 -04:00
return TRUE;
}
Reference in New Issue Copy Permalink