mutter/clutter/clutter-shader.c
2007-12-04 09:13:06 +00:00

435 lines
13 KiB
C

/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By Matthew Allum <mallum@openedhand.com>
* Øyvind Kolås <pippin@o-hand.com>
*
* Copyright (C) 2007 OpenedHand
*
* 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, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#include "clutter.h"
#include "clutter-private.h"
#include "clutter-shader.h"
#include <unistd.h>
#include <glib.h>
#include <cogl/cogl.h>
#include <string.h>
#include <stdlib.h>
#define CLUTTER_SHADER_GET_PRIVATE(obj) \
(G_TYPE_INSTANCE_GET_PRIVATE ((obj), \
CLUTTER_TYPE_SHADER, ClutterShaderPrivate))
static GList *shader_list;
static void clutter_shader_class_init (ClutterShaderClass *klass);
static void clutter_shader_init (ClutterShader *sp);
static void clutter_shader_finalize (GObject *object);
static GObject *clutter_shader_constructor (GType type,
guint n_params,
GObjectConstructParam *params);
static void clutter_shader_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec);
static void clutter_shader_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec);
struct _ClutterShaderPrivate
{
gboolean glsl; /* The shader is a GLSL shader */
gboolean bound; /* The shader is bound to the GL context */
gchar *vertex_shader_source; /* source (or asm) for vertex shader */
gchar *fragment_shader_source;/* source (or asm) for fragment shader*/
COGLint program;
COGLint vertex_shader;
COGLint fragment_shader;
};
enum
{
PROP_0,
PROP_VERTEX_SOURCE,
PROP_FRAGMENT_SOURCE
};
G_DEFINE_TYPE (ClutterShader, clutter_shader, G_TYPE_OBJECT);
static void
clutter_shader_class_init (ClutterShaderClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
clutter_shader_parent_class = g_type_class_peek_parent (klass);
object_class->finalize = clutter_shader_finalize;
object_class->set_property = clutter_shader_set_property;
object_class->get_property = clutter_shader_get_property;
object_class->constructor = clutter_shader_constructor;
g_type_class_add_private (klass, sizeof (ClutterShaderPrivate));
g_object_class_install_property (object_class,
PROP_VERTEX_SOURCE,
g_param_spec_string ("vertex-source",
"Vertex Source",
"Source of vertex shader",
NULL,
CLUTTER_PARAM_READWRITE|
G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property (object_class,
PROP_FRAGMENT_SOURCE,
g_param_spec_string ("fragment-source",
"Fragment Source",
"Source of fragment shader",
NULL,
CLUTTER_PARAM_READWRITE|
G_PARAM_CONSTRUCT_ONLY));
}
static void
clutter_shader_init (ClutterShader *self)
{
ClutterShaderPrivate *priv;
priv = self->priv = CLUTTER_SHADER_GET_PRIVATE (self);
priv->glsl = FALSE;
priv->bound = FALSE;
priv->vertex_shader_source = NULL;
priv->fragment_shader_source = NULL;
priv->program = 0;
priv->vertex_shader = 0;
priv->fragment_shader = 0;
}
static gboolean bind_glsl_shader (ClutterShader *self)
{
ClutterShaderPrivate *priv;
priv = self->priv;
cogl_enable (CGL_FRAGMENT_SHADER);
cogl_enable (CGL_VERTEX_SHADER);
priv->glsl = TRUE;
priv->program = cogl_create_program ();
if (priv->vertex_shader_source)
{
priv->vertex_shader = cogl_create_shader (CGL_VERTEX_SHADER);
cogl_shader_source (priv->vertex_shader, priv->vertex_shader_source);
cogl_shader_compile (priv->vertex_shader);
cogl_program_attach_shader (priv->program, priv->vertex_shader);
}
if (priv->fragment_shader_source)
{
GLint compiled = CGL_FALSE;
priv->fragment_shader = cogl_create_shader (CGL_FRAGMENT_SHADER);
cogl_shader_source (priv->fragment_shader, priv->fragment_shader_source);
cogl_shader_compile (priv->fragment_shader);
cogl_shader_get_parameteriv (priv->fragment_shader,
CGL_OBJECT_COMPILE_STATUS,
&compiled);
if (compiled != CGL_TRUE)
{
gchar *buffer;
gint max_length = 512;
buffer = g_malloc (max_length);
cogl_shader_get_info_log (priv->fragment_shader, max_length, buffer);
g_print ("Shader compilation failed:\n%s", buffer);
g_free (buffer);
g_object_unref (self);
return FALSE;
}
cogl_program_attach_shader (priv->program, priv->fragment_shader);
}
cogl_program_link (priv->program);
return TRUE;
}
gboolean
clutter_shader_bind (ClutterShader *self)
{
ClutterShaderPrivate *priv;
priv = self->priv;
if (priv->bound)
return priv->bound;
if (priv->glsl)
{
priv->bound = bind_glsl_shader (self);
}
return priv->bound;
}
void
clutter_shader_release (ClutterShader *self)
{
ClutterShaderPrivate *priv;
priv = self->priv;
if (!priv->bound)
return;
g_assert (priv->program);
if (priv->glsl)
{
if (priv->vertex_shader)
cogl_shader_destroy (priv->vertex_shader);
if (priv->fragment_shader)
cogl_shader_destroy (priv->fragment_shader);
if (priv->program)
cogl_program_destroy (priv->program);
priv->vertex_shader = 0;
priv->fragment_shader = 0;
priv->program = 0;
}
priv->bound = FALSE;
}
static void
clutter_shader_finalize (GObject *object)
{
ClutterShader *shader;
ClutterShaderPrivate *priv;
shader = CLUTTER_SHADER (object);
priv = shader->priv;
clutter_shader_release (shader);
shader_list = g_list_remove (shader_list, object);
if (priv->fragment_shader_source)
g_free (priv->fragment_shader_source);
if (priv->vertex_shader_source)
g_free (priv->vertex_shader_source);
G_OBJECT_CLASS (clutter_shader_parent_class)->finalize (object);
}
void
clutter_shader_enable (ClutterShader *self)
{
ClutterShaderPrivate *priv = self->priv;
clutter_shader_bind (self);
cogl_program_use (priv->program);
}
void
clutter_shader_disable (ClutterShader *self)
{
cogl_program_use (0);
}
void
clutter_shader_set_uniform_1f (ClutterShader *self,
const gchar *name,
gfloat value)
{
ClutterShaderPrivate *priv = self->priv;
GLint location = 0;
GLfloat foo = value;
location =cogl_program_get_uniform_location (priv->program, name);
cogl_program_uniform_1f (location, foo);
}
void
clutter_shader_release_all (void)
{
GList *iter;
for (iter = shader_list; iter; iter = g_list_next (iter))
{
clutter_shader_release (iter->data);
}
}
static void
clutter_shader_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
ClutterShader *shader;
ClutterShaderPrivate *priv;
shader = CLUTTER_SHADER(object);
priv = shader->priv;
switch (prop_id)
{
case PROP_VERTEX_SOURCE:
if (priv->vertex_shader_source)
{
g_free (priv->vertex_shader_source);
priv->vertex_shader_source = NULL;
}
priv->vertex_shader_source = g_value_dup_string (value);
break;
case PROP_FRAGMENT_SOURCE:
if (priv->fragment_shader_source)
{
g_free (priv->fragment_shader_source);
priv->fragment_shader_source = NULL;
}
priv->fragment_shader_source = g_value_dup_string (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
clutter_shader_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
ClutterShader *shader;
ClutterShaderPrivate *priv;
shader = CLUTTER_SHADER(object);
priv = shader->priv;
switch (prop_id)
{
case PROP_VERTEX_SOURCE:
g_value_set_string (value, priv->vertex_shader_source);
break;
case PROP_FRAGMENT_SOURCE:
g_value_set_string (value, priv->fragment_shader_source);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static GObject *
clutter_shader_constructor (GType type,
guint n_params,
GObjectConstructParam *params)
{
GObject *object;
ClutterShader *shader;
ClutterShaderPrivate *priv;
object = G_OBJECT_CLASS (clutter_shader_parent_class)->constructor (
type, n_params, params);
shader = CLUTTER_SHADER (object);
priv = shader->priv;
priv->glsl = !((priv->vertex_shader_source &&
g_str_has_prefix (priv->vertex_shader_source, "!!ARBvp")) ||
(priv->fragment_shader_source &&
g_str_has_prefix (priv->fragment_shader_source, "!!ARBfp")));
if (!priv->glsl)
{
g_warning ("ASM shader support not available");
g_object_unref (object);
return NULL;
}
if (priv->glsl && !clutter_feature_available (CLUTTER_FEATURE_SHADERS_GLSL))
{
g_warning ("GLSL shaders not supported\n");
g_object_unref (object);
return NULL;
}
shader_list = g_list_prepend (shader_list, object);
return object;
}
ClutterShader *
clutter_shader_new_from_strings (const gchar *vertex_shader_program,
const gchar *fragment_shader_program)
{
/* evil hack, since g_object_new would interpret a NULL passed as
* a argument termination
*/
if (vertex_shader_program &&
fragment_shader_program)
return g_object_new (CLUTTER_TYPE_SHADER,
"vertex-source", vertex_shader_program,
"fragment-source", fragment_shader_program,
NULL);
else if (fragment_shader_program)
return g_object_new (CLUTTER_TYPE_SHADER,
"fragment-source", fragment_shader_program,
NULL);
else if (vertex_shader_program)
return g_object_new (CLUTTER_TYPE_SHADER,
"vertex-source", vertex_shader_program,
NULL);
else {
g_warning ("neither fragment nor vertex shader provided");
return NULL;
}
}
ClutterShader *
clutter_shader_new_from_files (const gchar *vertex_file,
const gchar *fragment_file)
{
ClutterShader *shader;
gchar *vertex_shader_program = NULL;
gchar *fragment_shader_program = NULL;
g_assert (vertex_file != NULL ||
fragment_file != NULL);
if (vertex_file)
{
g_file_get_contents (vertex_file, &vertex_shader_program,
NULL, NULL);
}
if (fragment_file)
{
g_file_get_contents (fragment_file, &fragment_shader_program,
NULL, NULL);
}
shader = clutter_shader_new_from_strings (vertex_shader_program,
fragment_shader_program);
if (vertex_shader_program)
{
g_free (vertex_shader_program);
}
if (fragment_shader_program)
{
g_free (fragment_shader_program);
}
return shader;
}