$(srcdir)/cogl-matrix-stack.h \
$(srcdir)/cogl-material.c \
$(srcdir)/cogl-material-private.h \
+ $(srcdir)/cogl-material-glsl.c \
+ $(srcdir)/cogl-material-glsl-private.h \
+ $(srcdir)/cogl-material-arbfp.c \
+ $(srcdir)/cogl-material-arbfp-private.h \
+ $(srcdir)/cogl-material-fixed.c \
+ $(srcdir)/cogl-material-fixed-private.h \
$(srcdir)/cogl-blend-string.c \
$(srcdir)/cogl-blend-string.h \
$(srcdir)/cogl-debug.c \
--- /dev/null
+/*
+ * Cogl
+ *
+ * An object oriented GL/GLES Abstraction/Utility Layer
+ *
+ * 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/>.
+ *
+ *
+ *
+ * Authors:
+ * Robert Bragg <robert@linux.intel.com>
+ */
+
+#ifndef __COGL_MATERIAL_ARBFP_PRIVATE_H
+#define __COGL_MATERIAL_ARBFP_PRIVATE_H
+
+#include "cogl-material-private.h"
+
+const CoglMaterialBackend _cogl_material_arbfp_backend;
+
+#endif /* __COGL_MATERIAL_ARBFP_PRIVATE_H */
+
--- /dev/null
+/*
+ * Cogl
+ *
+ * An object oriented GL/GLES Abstraction/Utility Layer
+ *
+ * Copyright (C) 2008,2009,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/>.
+ *
+ *
+ *
+ * Authors:
+ * Robert Bragg <robert@linux.intel.com>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "cogl.h"
+#include "cogl-internal.h"
+#include "cogl-context.h"
+#include "cogl-handle.h"
+
+#include "cogl-material-private.h"
+#include "cogl-texture-private.h"
+#include "cogl-blend-string.h"
+#include "cogl-journal-private.h"
+#include "cogl-color-private.h"
+#include "cogl-profile.h"
+#ifndef HAVE_COGL_GLES
+#include "cogl-program.h"
+#endif
+
+#include <glib.h>
+#include <glib/gprintf.h>
+#include <string.h>
+
+/*
+ * GL/GLES compatability defines for material thingies:
+ */
+
+#ifdef HAVE_COGL_GLES2
+#include "../gles/cogl-gles2-wrapper.h"
+#endif
+
+#ifdef HAVE_COGL_GL
+#define glProgramString ctx->drv.pf_glProgramString
+#define glBindProgram ctx->drv.pf_glBindProgram
+#define glDeletePrograms ctx->drv.pf_glDeletePrograms
+#define glGenPrograms ctx->drv.pf_glGenPrograms
+#define glProgramLocalParameter4fv ctx->drv.pf_glProgramLocalParameter4fv
+#define glUseProgram ctx->drv.pf_glUseProgram
+#endif
+
+typedef struct _CoglMaterialBackendARBfpPrivate
+{
+ CoglMaterial *authority_cache;
+ unsigned long authority_cache_age;
+
+ GString *source;
+ GLuint gl_program;
+ gboolean *sampled;
+ int next_constant_id;
+} CoglMaterialBackendARBfpPrivate;
+
+static int
+_cogl_material_backend_arbfp_get_max_texture_units (void)
+{
+ return _cogl_get_max_texture_image_units ();
+}
+
+typedef struct
+{
+ int i;
+ CoglMaterialLayer **layers;
+} AddLayersToArrayState;
+
+static gboolean
+add_layer_to_array_cb (CoglMaterialLayer *layer,
+ void *user_data)
+{
+ AddLayersToArrayState *state = user_data;
+ state->layers[state->i++] = layer;
+ return TRUE;
+}
+
+static gboolean
+layers_arbfp_would_differ (CoglMaterialLayer **material0_layers,
+ CoglMaterialLayer **material1_layers,
+ int n_layers)
+{
+ int i;
+ /* The layer state that affects arbfp codegen... */
+ unsigned long arbfp_codegen_modifiers =
+ COGL_MATERIAL_LAYER_STATE_COMBINE |
+ COGL_MATERIAL_LAYER_STATE_COMBINE_CONSTANT |
+ COGL_MATERIAL_LAYER_STATE_UNIT |
+ COGL_MATERIAL_LAYER_STATE_TEXTURE;
+
+ for (i = 0; i < n_layers; i++)
+ {
+ CoglMaterialLayer *layer0 = material0_layers[i];
+ CoglMaterialLayer *layer1 = material1_layers[i];
+ unsigned long layer_differences;
+
+ if (layer0 == layer1)
+ continue;
+
+ layer_differences =
+ _cogl_material_layer_compare_differences (layer0, layer1);
+
+ if (layer_differences & arbfp_codegen_modifiers)
+ {
+ /* When it comes to texture differences the only thing that
+ * affects the arbfp is the target enum... */
+ if (layer_differences == COGL_MATERIAL_LAYER_STATE_TEXTURE)
+ {
+ CoglHandle tex0 = _cogl_material_layer_get_texture (layer0);
+ CoglHandle tex1 = _cogl_material_layer_get_texture (layer1);
+ GLenum gl_target0;
+ GLenum gl_target1;
+
+ cogl_texture_get_gl_texture (tex0, NULL, &gl_target0);
+ cogl_texture_get_gl_texture (tex1, NULL, &gl_target1);
+ if (gl_target0 == gl_target1)
+ continue;
+ }
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
+
+/* This tries to find the oldest ancestor whos state would generate
+ * the same arbfp program as the current material. This is a simple
+ * mechanism for reducing the number of arbfp programs we have to
+ * generate.
+ */
+static CoglMaterial *
+find_arbfp_authority (CoglMaterial *material)
+{
+ CoglMaterial *authority0;
+ CoglMaterial *authority1;
+ int n_layers;
+ CoglMaterialLayer **authority0_layers;
+ CoglMaterialLayer **authority1_layers;
+
+ /* XXX: we'll need to update this when we add fog support to the
+ * arbfp codegen */
+
+ /* Find the first material that modifies state that affects the
+ * arbfp codegen... */
+ authority0 = _cogl_material_get_authority (material,
+ COGL_MATERIAL_STATE_LAYERS);
+
+ /* Find the next ancestor after that, that also modifies state
+ * affecting arbfp codegen... */
+ if (authority0->parent)
+ authority1 = _cogl_material_get_authority (authority0->parent,
+ COGL_MATERIAL_STATE_LAYERS);
+ else
+ return authority0;
+
+ n_layers = authority0->n_layers;
+
+ for (;;)
+ {
+ AddLayersToArrayState state;
+
+ if (authority0->n_layers != authority1->n_layers)
+ return authority0;
+
+ authority0_layers =
+ g_alloca (sizeof (CoglMaterialLayer *) * n_layers);
+ state.i = 0;
+ state.layers = authority0_layers;
+ _cogl_material_foreach_layer (authority0,
+ add_layer_to_array_cb,
+ &state);
+
+ authority1_layers =
+ g_alloca (sizeof (CoglMaterialLayer *) * n_layers);
+ state.i = 0;
+ state.layers = authority1_layers;
+ _cogl_material_foreach_layer (authority1,
+ add_layer_to_array_cb,
+ &state);
+
+ if (layers_arbfp_would_differ (authority0_layers, authority1_layers,
+ n_layers))
+ return authority0;
+
+ /* Find the next ancestor after that, that also modifies state
+ * affecting arbfp codegen... */
+
+ if (!authority1->parent)
+ break;
+
+ authority0 = authority1;
+ authority1 = _cogl_material_get_authority (authority1->parent,
+ COGL_MATERIAL_STATE_LAYERS);
+ if (authority1 == authority0)
+ break;
+ }
+
+ return authority1;
+}
+
+static void
+invalidate_arbfp_authority_cache (CoglMaterial *material)
+{
+ if (material->backend_priv_set_mask & COGL_MATERIAL_BACKEND_ARBFP_MASK)
+ {
+ CoglMaterialBackendARBfpPrivate *priv =
+ material->backend_privs[COGL_MATERIAL_BACKEND_ARBFP];
+ priv->authority_cache = NULL;
+ priv->authority_cache_age = 0;
+ }
+}
+
+static gboolean
+_cogl_material_backend_arbfp_start (CoglMaterial *material,
+ int n_layers,
+ unsigned long materials_difference)
+{
+ CoglMaterial *authority;
+ CoglMaterialBackendARBfpPrivate *priv;
+ CoglMaterialBackendARBfpPrivate *authority_priv;
+
+ _COGL_GET_CONTEXT (ctx, FALSE);
+
+ if (!_cogl_features_available_private (COGL_FEATURE_PRIVATE_ARB_FP))
+ return FALSE;
+
+ /* TODO: support fog */
+ if (ctx->fog_enabled)
+ return FALSE;
+
+ /* Note: we allocate ARBfp private state for both the given material
+ * and the authority. (The oldest ancestor whos state will result in
+ * the same program being generated) The former will simply cache a
+ * pointer to the authority and the later will track the arbfp
+ * program that we will generate.
+ */
+
+ if (!(material->backend_priv_set_mask & COGL_MATERIAL_BACKEND_ARBFP_MASK))
+ {
+ material->backend_privs[COGL_MATERIAL_BACKEND_ARBFP] =
+ g_slice_new0 (CoglMaterialBackendARBfpPrivate);
+ material->backend_priv_set_mask |= COGL_MATERIAL_BACKEND_ARBFP_MASK;
+ }
+ priv = material->backend_privs[COGL_MATERIAL_BACKEND_ARBFP];
+
+ /* XXX: We are making assumptions that we don't yet support
+ * modification of ancestors to optimize the sharing of state in the
+ * material graph. When we start to support this then the arbfp
+ * backend will somehow need to be notified of graph changes that
+ * may invalidate authority_cache pointers.
+ */
+
+ if (priv->authority_cache &&
+ priv->authority_cache_age != _cogl_material_get_age (material))
+ invalidate_arbfp_authority_cache (material);
+
+ if (!priv->authority_cache)
+ {
+ priv->authority_cache = find_arbfp_authority (material);
+ priv->authority_cache_age = _cogl_material_get_age (material);
+ }
+
+ authority = priv->authority_cache;
+ if (!(authority->backend_priv_set_mask & COGL_MATERIAL_BACKEND_ARBFP_MASK))
+ {
+ authority->backend_privs[COGL_MATERIAL_BACKEND_ARBFP] =
+ g_slice_new0 (CoglMaterialBackendARBfpPrivate);
+ authority->backend_priv_set_mask |= COGL_MATERIAL_BACKEND_ARBFP_MASK;
+ }
+ authority_priv = authority->backend_privs[COGL_MATERIAL_BACKEND_ARBFP];
+
+ if (authority_priv->gl_program == 0)
+ {
+ /* We reuse a single grow-only GString for ARBfp code-gen */
+ g_string_set_size (ctx->arbfp_source_buffer, 0);
+ authority_priv->source = ctx->arbfp_source_buffer;
+ g_string_append (authority_priv->source,
+ "!!ARBfp1.0\n"
+ "TEMP output;\n"
+ "TEMP tmp0, tmp1, tmp2, tmp3, tmp4;\n"
+ "PARAM half = {.5, .5, .5, .5};\n"
+ "PARAM one = {1, 1, 1, 1};\n"
+ "PARAM two = {2, 2, 2, 2};\n"
+ "PARAM minus_one = {-1, -1, -1, -1};\n");
+ authority_priv->sampled = g_new0 (gboolean, n_layers);
+ }
+
+ return TRUE;
+}
+
+static CoglMaterial *
+get_arbfp_authority (CoglMaterial *material)
+{
+ CoglMaterialBackendARBfpPrivate *priv =
+ material->backend_privs[COGL_MATERIAL_BACKEND_ARBFP];
+
+ g_return_val_if_fail (priv != NULL, NULL);
+
+ return priv->authority_cache;
+}
+
+/* Determines if we need to handle the RGB and A texture combining
+ * separately or is the same function used for both channel masks and
+ * with the same arguments...
+ */
+static gboolean
+need_texture_combine_separate (CoglMaterialLayer *combine_authority)
+{
+ CoglMaterialLayerBigState *big_state = combine_authority->big_state;
+ int n_args;
+ int i;
+
+ if (big_state->texture_combine_rgb_func !=
+ big_state->texture_combine_alpha_func)
+ return TRUE;
+
+ n_args = _cogl_get_n_args_for_combine_func (big_state->texture_combine_rgb_func);
+
+ for (i = 0; i < n_args; i++)
+ {
+ if (big_state->texture_combine_rgb_src[i] !=
+ big_state->texture_combine_alpha_src[i])
+ return TRUE;
+
+ /*
+ * We can allow some variation of the source operands without
+ * needing a separation...
+ *
+ * "A = REPLACE (CONSTANT[A])" + either of the following...
+ * "RGB = REPLACE (CONSTANT[RGB])"
+ * "RGB = REPLACE (CONSTANT[A])"
+ *
+ * can be combined as:
+ * "RGBA = REPLACE (CONSTANT)" or
+ * "RGBA = REPLACE (CONSTANT[A])" or
+ *
+ * And "A = REPLACE (1-CONSTANT[A])" + either of the following...
+ * "RGB = REPLACE (1-CONSTANT)" or
+ * "RGB = REPLACE (1-CONSTANT[A])"
+ *
+ * can be combined as:
+ * "RGBA = REPLACE (1-CONSTANT)" or
+ * "RGBA = REPLACE (1-CONSTANT[A])"
+ */
+ switch (big_state->texture_combine_alpha_op[i])
+ {
+ case GL_SRC_ALPHA:
+ switch (big_state->texture_combine_rgb_op[i])
+ {
+ case GL_SRC_COLOR:
+ case GL_SRC_ALPHA:
+ break;
+ default:
+ return FALSE;
+ }
+ break;
+ case GL_ONE_MINUS_SRC_ALPHA:
+ switch (big_state->texture_combine_rgb_op[i])
+ {
+ case GL_ONE_MINUS_SRC_COLOR:
+ case GL_ONE_MINUS_SRC_ALPHA:
+ break;
+ default:
+ return FALSE;
+ }
+ break;
+ default:
+ return FALSE; /* impossible */
+ }
+ }
+
+ return FALSE;
+}
+
+static const char *
+gl_target_to_arbfp_string (GLenum gl_target)
+{
+#ifndef HAVE_COGL_GLES2
+ if (gl_target == GL_TEXTURE_1D)
+ return "1D";
+ else
+#endif
+ if (gl_target == GL_TEXTURE_2D)
+ return "2D";
+#ifdef GL_ARB_texture_rectangle
+ else if (gl_target == GL_TEXTURE_RECTANGLE_ARB)
+ return "RECT";
+#endif
+ else
+ return "2D";
+}
+
+static void
+setup_texture_source (CoglMaterialBackendARBfpPrivate *priv,
+ int unit_index,
+ GLenum gl_target)
+{
+ if (!priv->sampled[unit_index])
+ {
+ g_string_append_printf (priv->source,
+ "TEMP texel%d;\n"
+ "TEX texel%d,fragment.texcoord[%d],"
+ "texture[%d],%s;\n",
+ unit_index,
+ unit_index,
+ unit_index,
+ unit_index,
+ gl_target_to_arbfp_string (gl_target));
+ priv->sampled[unit_index] = TRUE;
+ }
+}
+
+typedef enum _CoglMaterialBackendARBfpArgType
+{
+ COGL_MATERIAL_BACKEND_ARBFP_ARG_TYPE_SIMPLE,
+ COGL_MATERIAL_BACKEND_ARBFP_ARG_TYPE_CONSTANT,
+ COGL_MATERIAL_BACKEND_ARBFP_ARG_TYPE_TEXTURE
+} CoglMaterialBackendARBfpArgType;
+
+typedef struct _CoglMaterialBackendARBfpArg
+{
+ const char *name;
+
+ CoglMaterialBackendARBfpArgType type;
+
+ /* for type = TEXTURE */
+ int texture_unit;
+ GLenum texture_target;
+
+ /* for type = CONSTANT */
+ int constant_id;
+
+ const char *swizzle;
+
+} CoglMaterialBackendARBfpArg;
+
+static void
+append_arg (GString *source, const CoglMaterialBackendARBfpArg *arg)
+{
+ switch (arg->type)
+ {
+ case COGL_MATERIAL_BACKEND_ARBFP_ARG_TYPE_TEXTURE:
+ g_string_append_printf (source, "texel%d%s",
+ arg->texture_unit, arg->swizzle);
+ break;
+ case COGL_MATERIAL_BACKEND_ARBFP_ARG_TYPE_CONSTANT:
+ g_string_append_printf (source, "constant%d%s",
+ arg->constant_id, arg->swizzle);
+ break;
+ case COGL_MATERIAL_BACKEND_ARBFP_ARG_TYPE_SIMPLE:
+ g_string_append_printf (source, "%s%s",
+ arg->name, arg->swizzle);
+ break;
+ }
+}
+
+/* Note: we are trying to avoid duplicating strings during codegen
+ * which is why we have the slightly awkward
+ * CoglMaterialBackendARBfpArg mechanism. */
+static void
+setup_arg (CoglMaterial *material,
+ CoglMaterialLayer *layer,
+ CoglBlendStringChannelMask mask,
+ int arg_index,
+ GLint src,
+ GLint op,
+ CoglMaterialBackendARBfpArg *arg)
+{
+ CoglMaterial *arbfp_authority = get_arbfp_authority (material);
+ CoglMaterialBackendARBfpPrivate *priv =
+ arbfp_authority->backend_privs[COGL_MATERIAL_BACKEND_ARBFP];
+ static const char *tmp_name[3] = { "tmp0", "tmp1", "tmp2" };
+ GLenum gl_target;
+ CoglHandle texture;
+
+ switch (src)
+ {
+ case GL_TEXTURE:
+ arg->type = COGL_MATERIAL_BACKEND_ARBFP_ARG_TYPE_TEXTURE;
+ arg->name = "texel%d";
+ arg->texture_unit = _cogl_material_layer_get_unit_index (layer);
+ texture = _cogl_material_layer_get_texture (layer);
+ cogl_texture_get_gl_texture (texture, NULL, &gl_target);
+ setup_texture_source (priv, arg->texture_unit, gl_target);
+ break;
+ case GL_CONSTANT:
+ {
+ unsigned long state = COGL_MATERIAL_LAYER_STATE_COMBINE_CONSTANT;
+ CoglMaterialLayer *authority =
+ _cogl_material_layer_get_authority (layer, state);
+ CoglMaterialLayerBigState *big_state = authority->big_state;
+
+ arg->type = COGL_MATERIAL_BACKEND_ARBFP_ARG_TYPE_CONSTANT;
+ arg->name = "constant%d";
+ arg->constant_id = priv->next_constant_id++;
+ g_string_append_printf (priv->source,
+ "PARAM constant%d = "
+ " {%f, %f, %f, %f};\n",
+ arg->constant_id,
+ big_state->texture_combine_constant[0],
+ big_state->texture_combine_constant[1],
+ big_state->texture_combine_constant[2],
+ big_state->texture_combine_constant[3]);
+ break;
+ }
+ case GL_PRIMARY_COLOR:
+ arg->type = COGL_MATERIAL_BACKEND_ARBFP_ARG_TYPE_SIMPLE;
+ arg->name = "fragment.color.primary";
+ break;
+ case GL_PREVIOUS:
+ arg->type = COGL_MATERIAL_BACKEND_ARBFP_ARG_TYPE_SIMPLE;
+ if (_cogl_material_layer_get_unit_index (layer) == 0)
+ arg->name = "fragment.color.primary";
+ else
+ arg->name = "output";
+ break;
+ default: /* GL_TEXTURE0..N */
+ arg->type = COGL_MATERIAL_BACKEND_ARBFP_ARG_TYPE_TEXTURE;
+ arg->name = "texture[%d]";
+ arg->texture_unit = src - GL_TEXTURE0;
+ texture = _cogl_material_layer_get_texture (layer);
+ cogl_texture_get_gl_texture (texture, NULL, &gl_target);
+ setup_texture_source (priv, arg->texture_unit, gl_target);
+ }
+
+ arg->swizzle = "";
+
+ switch (op)
+ {
+ case GL_SRC_COLOR:
+ break;
+ case GL_ONE_MINUS_SRC_COLOR:
+ g_string_append_printf (priv->source,
+ "SUB tmp%d, one, ",
+ arg_index);
+ append_arg (priv->source, arg);
+ g_string_append_printf (priv->source, ";\n");
+ arg->type = COGL_MATERIAL_BACKEND_ARBFP_ARG_TYPE_SIMPLE;
+ arg->name = tmp_name[arg_index];
+ arg->swizzle = "";
+ break;
+ case GL_SRC_ALPHA:
+ /* avoid a swizzle if we know RGB are going to be masked
+ * in the end anyway */
+ if (mask != COGL_BLEND_STRING_CHANNEL_MASK_ALPHA)
+ arg->swizzle = ".a";
+ break;
+ case GL_ONE_MINUS_SRC_ALPHA:
+ g_string_append_printf (priv->source,
+ "SUB tmp%d, one, ",
+ arg_index);
+ append_arg (priv->source, arg);
+ /* avoid a swizzle if we know RGB are going to be masked
+ * in the end anyway */
+ if (mask != COGL_BLEND_STRING_CHANNEL_MASK_ALPHA)
+ g_string_append_printf (priv->source, ".a;\n");
+ else
+ g_string_append_printf (priv->source, ";\n");
+ arg->type = COGL_MATERIAL_BACKEND_ARBFP_ARG_TYPE_SIMPLE;
+ arg->name = tmp_name[arg_index];
+ break;
+ default:
+ g_error ("Unknown texture combine operator %d", op);
+ break;
+ }
+}
+
+static gboolean
+backend_arbfp_args_equal (CoglMaterialBackendARBfpArg *arg0,
+ CoglMaterialBackendARBfpArg *arg1)
+{
+ if (arg0->type != arg1->type)
+ return FALSE;
+
+ if (arg0->name != arg1->name &&
+ strcmp (arg0->name, arg1->name) != 0)
+ return FALSE;
+
+ if (arg0->type == COGL_MATERIAL_BACKEND_ARBFP_ARG_TYPE_TEXTURE &&
+ arg0->texture_unit != arg1->texture_unit)
+ return FALSE;
+ /* Note we don't have to check the target; a texture unit can only
+ * have one target enabled at a time. */
+
+ if (arg0->type == COGL_MATERIAL_BACKEND_ARBFP_ARG_TYPE_CONSTANT &&
+ arg0->constant_id != arg0->constant_id)
+ return FALSE;
+
+ if (arg0->swizzle != arg1->swizzle &&
+ strcmp (arg0->swizzle, arg1->swizzle) != 0)
+ return FALSE;
+
+ return TRUE;
+}
+
+static void
+append_function (CoglMaterial *material,
+ CoglBlendStringChannelMask mask,
+ GLint function,
+ CoglMaterialBackendARBfpArg *args,
+ int n_args)
+{
+ CoglMaterial *arbfp_authority = get_arbfp_authority (material);
+ CoglMaterialBackendARBfpPrivate *priv =
+ arbfp_authority->backend_privs[COGL_MATERIAL_BACKEND_ARBFP];
+ const char *mask_name;
+
+ switch (mask)
+ {
+ case COGL_BLEND_STRING_CHANNEL_MASK_RGB:
+ mask_name = ".rgb";
+ break;
+ case COGL_BLEND_STRING_CHANNEL_MASK_ALPHA:
+ mask_name = ".a";
+ break;
+ case COGL_BLEND_STRING_CHANNEL_MASK_RGBA:
+ mask_name = "";
+ break;
+ default:
+ g_error ("Unknown channel mask %d", mask);
+ mask_name = "";
+ }
+
+ switch (function)
+ {
+ case GL_ADD:
+ g_string_append_printf (priv->source, "ADD_SAT output%s, ",
+ mask_name);
+ break;
+ case GL_MODULATE:
+ /* Note: no need to saturate since we can assume operands
+ * have values in the range [0,1] */
+ g_string_append_printf (priv->source, "MUL output%s, ",
+ mask_name);
+ break;
+ case GL_REPLACE:
+ /* Note: no need to saturate since we can assume operand
+ * has a value in the range [0,1] */
+ g_string_append_printf (priv->source, "MOV output%s, ",
+ mask_name);
+ break;
+ case GL_SUBTRACT:
+ g_string_append_printf (priv->source, "SUB_SAT output%s, ",
+ mask_name);
+ break;
+ case GL_ADD_SIGNED:
+ g_string_append_printf (priv->source, "ADD tmp3%s, ",
+ mask_name);
+ append_arg (priv->source, &args[0]);
+ g_string_append (priv->source, ", ");
+ append_arg (priv->source, &args[1]);
+ g_string_append (priv->source, ";\n");
+ g_string_append_printf (priv->source, "SUB_SAT output%s, tmp3, half",
+ mask_name);
+ n_args = 0;
+ break;
+ case GL_DOT3_RGB:
+ /* These functions are the same except that GL_DOT3_RGB never
+ * updates the alpha channel.
+ *
+ * NB: GL_DOT3_RGBA is a bit special because it effectively forces
+ * an RGBA mask and we end up ignoring any separate alpha channel
+ * function.
+ */
+ case GL_DOT3_RGBA:
+ {
+ const char *tmp4 = "tmp4";
+
+ /* The maths for this was taken from Mesa;
+ * apparently:
+ *
+ * tmp3 = 2*src0 - 1
+ * tmp4 = 2*src1 - 1
+ * output = DP3 (tmp3, tmp4)
+ *
+ * is the same as:
+ *
+ * output = 4 * DP3 (src0 - 0.5, src1 - 0.5)
+ */
+
+ g_string_append (priv->source, "MAD tmp3, two, ");
+ append_arg (priv->source, &args[0]);
+ g_string_append (priv->source, ", minus_one;\n");
+
+ if (!backend_arbfp_args_equal (&args[0], &args[1]))
+ {
+ g_string_append (priv->source, "MAD tmp4, two, ");
+ append_arg (priv->source, &args[1]);
+ g_string_append (priv->source, ", minus_one;\n");
+ }
+ else
+ tmp4 = "tmp3";
+
+ g_string_append_printf (priv->source,
+ "DP3_SAT output%s, tmp3, %s",
+ mask_name, tmp4);
+ n_args = 0;
+ }
+ break;
+ case GL_INTERPOLATE:
+ /* Note: no need to saturate since we can assume operands
+ * have values in the range [0,1] */
+
+ /* NB: GL_INTERPOLATE = arg0*arg2 + arg1*(1-arg2)
+ * but LRP dst, a, b, c = b*a + c*(1-a) */
+ g_string_append_printf (priv->source, "LRP output%s, ",
+ mask_name);
+ append_arg (priv->source, &args[2]);
+ g_string_append (priv->source, ", ");
+ append_arg (priv->source, &args[0]);
+ g_string_append (priv->source, ", ");
+ append_arg (priv->source, &args[1]);
+ n_args = 0;
+ break;
+ default:
+ g_error ("Unknown texture combine function %d", function);
+ g_string_append_printf (priv->source, "MUL_SAT output%s, ",
+ mask_name);
+ n_args = 2;
+ break;
+ }
+
+ if (n_args > 0)
+ append_arg (priv->source, &args[0]);
+ if (n_args > 1)
+ {
+ g_string_append (priv->source, ", ");
+ append_arg (priv->source, &args[1]);
+ }
+ g_string_append (priv->source, ";\n");
+}
+
+static void
+append_masked_combine (CoglMaterial *arbfp_authority,
+ CoglMaterialLayer *layer,
+ CoglBlendStringChannelMask mask,
+ GLint function,
+ GLint *src,
+ GLint *op)
+{
+ int i;
+ int n_args;
+ CoglMaterialBackendARBfpArg args[3];
+
+ n_args = _cogl_get_n_args_for_combine_func (function);
+
+ for (i = 0; i < n_args; i++)
+ {
+ setup_arg (arbfp_authority,
+ layer,
+ mask,
+ i,
+ src[i],
+ op[i],
+ &args[i]);
+ }
+
+ append_function (arbfp_authority,
+ mask,
+ function,
+ args,
+ n_args);
+}
+
+static gboolean
+_cogl_material_backend_arbfp_add_layer (CoglMaterial *material,
+ CoglMaterialLayer *layer,
+ unsigned long layers_difference)
+{
+ CoglMaterial *arbfp_authority = get_arbfp_authority (material);
+ CoglMaterialBackendARBfpPrivate *priv =
+ arbfp_authority->backend_privs[COGL_MATERIAL_BACKEND_ARBFP];
+ CoglMaterialLayer *combine_authority =
+ _cogl_material_layer_get_authority (layer,
+ COGL_MATERIAL_LAYER_STATE_COMBINE);
+ CoglMaterialLayerBigState *big_state = combine_authority->big_state;
+
+ /* Notes...
+ *
+ * We are ignoring the issue of texture indirection limits until
+ * someone complains (Ref Section 3.11.6 in the ARB_fragment_program
+ * spec)
+ *
+ * There always five TEMPs named tmp0, tmp1 and tmp2, tmp3 and tmp4
+ * available and these constants: 'one' = {1, 1, 1, 1}, 'half'
+ * {.5, .5, .5, .5}, 'two' = {2, 2, 2, 2}, 'minus_one' = {-1, -1,
+ * -1, -1}
+ *
+ * tmp0-2 are intended for dealing with some of the texture combine
+ * operands (e.g. GL_ONE_MINUS_SRC_COLOR) tmp3/4 are for dealing
+ * with the GL_ADD_SIGNED texture combine and the GL_DOT3_RGB[A]
+ * functions.
+ *
+ * Each layer outputs to the TEMP called "output", and reads from
+ * output if it needs to refer to GL_PREVIOUS. (we detect if we are
+ * layer0 so we will read fragment.color for GL_PREVIOUS in that
+ * case)
+ *
+ * We aim to do all the channels together if the same function is
+ * used for RGB as for A.
+ *
+ * We aim to avoid string duplication / allocations during codegen.
+ *
+ * We are careful to only saturate when writing to output.
+ */
+
+ if (!priv->source)
+ return TRUE;
+
+ if (!need_texture_combine_separate (combine_authority))
+ {
+ append_masked_combine (material,
+ layer,
+ COGL_BLEND_STRING_CHANNEL_MASK_RGBA,
+ big_state->texture_combine_rgb_func,
+ big_state->texture_combine_rgb_src,
+ big_state->texture_combine_rgb_op);
+ }
+ else if (big_state->texture_combine_rgb_func == GL_DOT3_RGBA)
+ {
+ /* GL_DOT3_RGBA Is a bit weird as a GL_COMBINE_RGB function
+ * since if you use it, it overrides your ALPHA function...
+ */
+ append_masked_combine (material,
+ layer,
+ COGL_BLEND_STRING_CHANNEL_MASK_RGBA,
+ big_state->texture_combine_rgb_func,
+ big_state->texture_combine_rgb_src,
+ big_state->texture_combine_rgb_op);
+ }
+ else
+ {
+ append_masked_combine (material,
+ layer,
+ COGL_BLEND_STRING_CHANNEL_MASK_RGB,
+ big_state->texture_combine_rgb_func,
+ big_state->texture_combine_rgb_src,
+ big_state->texture_combine_rgb_op);
+ append_masked_combine (material,
+ layer,
+ COGL_BLEND_STRING_CHANNEL_MASK_ALPHA,
+ big_state->texture_combine_alpha_func,
+ big_state->texture_combine_alpha_src,
+ big_state->texture_combine_alpha_op);
+ }
+
+ return TRUE;
+}
+
+gboolean
+_cogl_material_backend_arbfp_passthrough (CoglMaterial *material)
+{
+ CoglMaterial *arbfp_authority = get_arbfp_authority (material);
+ CoglMaterialBackendARBfpPrivate *priv =
+ arbfp_authority->backend_privs[COGL_MATERIAL_BACKEND_ARBFP];
+
+ if (!priv->source)
+ return TRUE;
+
+ g_string_append (priv->source, "MOV output, fragment.color.primary;\n");
+ return TRUE;
+}
+
+static gboolean
+_cogl_material_backend_arbfp_end (CoglMaterial *material,
+ unsigned long materials_difference)
+{
+ CoglMaterial *arbfp_authority = get_arbfp_authority (material);
+ CoglMaterialBackendARBfpPrivate *priv =
+ arbfp_authority->backend_privs[COGL_MATERIAL_BACKEND_ARBFP];
+
+ _COGL_GET_CONTEXT (ctx, FALSE);
+
+ if (priv->source)
+ {
+ GLenum gl_error;
+ COGL_STATIC_COUNTER (backend_arbfp_compile_counter,
+ "arbfp compile counter",
+ "Increments each time a new ARBfp "
+ "program is compiled",
+ 0 /* no application private data */);
+
+ COGL_COUNTER_INC (_cogl_uprof_context, backend_arbfp_compile_counter);
+
+ g_string_append (priv->source, "MOV result.color,output;\n");
+ g_string_append (priv->source, "END\n");
+
+ if (G_UNLIKELY (cogl_debug_flags & COGL_DEBUG_SHOW_SOURCE))
+ g_message ("material program:\n%s", priv->source->str);
+
+ GE (glGenPrograms (1, &priv->gl_program));
+
+ GE (glBindProgram (GL_FRAGMENT_PROGRAM_ARB, priv->gl_program));
+
+ while ((gl_error = glGetError ()) != GL_NO_ERROR)
+ ;
+ glProgramString (GL_FRAGMENT_PROGRAM_ARB,
+ GL_PROGRAM_FORMAT_ASCII_ARB,
+ priv->source->len,
+ priv->source->str);
+ if (glGetError () != GL_NO_ERROR)
+ {
+ g_warning ("\n%s\n%s",
+ priv->source->str,
+ glGetString (GL_PROGRAM_ERROR_STRING_ARB));
+ }
+
+ priv->source = NULL;
+
+ g_free (priv->sampled);
+ priv->sampled = NULL;
+ }
+ else
+ GE (glBindProgram (GL_FRAGMENT_PROGRAM_ARB, priv->gl_program));
+
+ _cogl_use_program (COGL_INVALID_HANDLE, COGL_MATERIAL_PROGRAM_TYPE_ARBFP);
+
+ return TRUE;
+}
+
+static void
+_cogl_material_backend_arbfp_material_pre_change_notify (
+ CoglMaterial *material,
+ CoglMaterialState change,
+ const CoglColor *new_color)
+{
+ CoglMaterialBackendARBfpPrivate *priv =
+ material->backend_privs[COGL_MATERIAL_BACKEND_ARBFP];
+ static const unsigned long fragment_op_changes =
+ COGL_MATERIAL_STATE_LAYERS;
+ /* TODO: COGL_MATERIAL_STATE_FOG */
+
+ _COGL_GET_CONTEXT (ctx, NO_RETVAL);
+
+ if (material->backend_priv_set_mask & COGL_MATERIAL_BACKEND_ARBFP_MASK &&
+ priv->gl_program &&
+ change & fragment_op_changes)
+ {
+ GE (glDeletePrograms (1, &priv->gl_program));
+ priv->gl_program = 0;
+ }
+}
+
+static gboolean
+invalidate_arbfp_authority_cache_cb (CoglMaterial *material,
+ void *user_data)
+{
+ invalidate_arbfp_authority_cache (material);
+ return TRUE;
+}
+
+static void
+_cogl_material_backend_arbfp_material_set_parent_notify (
+ CoglMaterial *material)
+{
+ /* Any arbfp authority cache associated with this material or
+ * any of its descendants will now be invalid. */
+ invalidate_arbfp_authority_cache (material);
+
+ _cogl_material_foreach_child (material,
+ invalidate_arbfp_authority_cache_cb,
+ NULL);
+}
+
+static void
+_cogl_material_backend_arbfp_layer_pre_change_notify (
+ CoglMaterialLayer *layer,
+ CoglMaterialLayerState changes)
+{
+ /* TODO: we could be saving snippets of texture combine code along
+ * with each layer and then when a layer changes we would just free
+ * the snippet. */
+ return;
+}
+
+static void
+_cogl_material_backend_arbfp_free_priv (CoglMaterial *material)
+{
+ _COGL_GET_CONTEXT (ctx, NO_RETVAL);
+
+ if (material->backend_priv_set_mask & COGL_MATERIAL_BACKEND_ARBFP_MASK)
+ {
+ CoglMaterialBackendARBfpPrivate *priv =
+ material->backend_privs[COGL_MATERIAL_BACKEND_ARBFP];
+
+ glDeletePrograms (1, &priv->gl_program);
+ if (priv->sampled)
+ g_free (priv->sampled);
+ g_slice_free (CoglMaterialBackendARBfpPrivate, priv);
+ material->backend_priv_set_mask &= ~COGL_MATERIAL_BACKEND_ARBFP_MASK;
+ }
+}
+
+const CoglMaterialBackend _cogl_material_arbfp_backend =
+{
+ _cogl_material_backend_arbfp_get_max_texture_units,
+ _cogl_material_backend_arbfp_start,
+ _cogl_material_backend_arbfp_add_layer,
+ _cogl_material_backend_arbfp_passthrough,
+ _cogl_material_backend_arbfp_end,
+ _cogl_material_backend_arbfp_material_pre_change_notify,
+ _cogl_material_backend_arbfp_material_set_parent_notify,
+ _cogl_material_backend_arbfp_layer_pre_change_notify,
+ _cogl_material_backend_arbfp_free_priv,
+ NULL
+};
+
--- /dev/null
+/*
+ * Cogl
+ *
+ * An object oriented GL/GLES Abstraction/Utility Layer
+ *
+ * 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/>.
+ *
+ *
+ *
+ * Authors:
+ * Robert Bragg <robert@linux.intel.com>
+ */
+
+#ifndef __COGL_MATERIAL_FIXED_PRIVATE_H
+#define __COGL_MATERIAL_FIXED_PRIVATE_H
+
+#include "cogl-material-private.h"
+
+const CoglMaterialBackend _cogl_material_fixed_backend;
+
+#endif /* __COGL_MATERIAL_FIXED_PRIVATE_H */
+
--- /dev/null
+/*
+ * Cogl
+ *
+ * An object oriented GL/GLES Abstraction/Utility Layer
+ *
+ * Copyright (C) 2008,2009,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/>.
+ *
+ *
+ *
+ * Authors:
+ * Robert Bragg <robert@linux.intel.com>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "cogl.h"
+#include "cogl-internal.h"
+#include "cogl-context.h"
+#include "cogl-handle.h"
+
+#include "cogl-material-private.h"
+#include "cogl-texture-private.h"
+#include "cogl-blend-string.h"
+#include "cogl-profile.h"
+#ifndef HAVE_COGL_GLES
+#include "cogl-program.h"
+#endif
+
+#include <glib.h>
+#include <glib/gprintf.h>
+#include <string.h>
+
+#ifdef HAVE_COGL_GLES2
+#include "../gles/cogl-gles2-wrapper.h"
+#endif
+
+static int
+_cogl_material_backend_fixed_get_max_texture_units (void)
+{
+ _COGL_GET_CONTEXT (ctx, 0);
+
+ /* This function is called quite often so we cache the value to
+ avoid too many GL calls */
+ if (ctx->max_texture_units == -1)
+ {
+ ctx->max_texture_units = 1;
+ GE (glGetIntegerv (GL_MAX_TEXTURE_UNITS,
+ &ctx->max_texture_units));
+ }
+
+ return ctx->max_texture_units;
+}
+
+static gboolean
+_cogl_material_backend_fixed_start (CoglMaterial *material,
+ int n_layers,
+ unsigned long materials_difference)
+{
+ _cogl_use_program (COGL_INVALID_HANDLE, COGL_MATERIAL_PROGRAM_TYPE_FIXED);
+ return TRUE;
+}
+
+static gboolean
+_cogl_material_backend_fixed_add_layer (CoglMaterial *material,
+ CoglMaterialLayer *layer,
+ unsigned long layers_difference)
+{
+ CoglTextureUnit *unit =
+ _cogl_get_texture_unit (_cogl_material_layer_get_unit_index (layer));
+ int unit_index = unit->index;
+ int n_rgb_func_args;
+ int n_alpha_func_args;
+
+ _COGL_GET_CONTEXT (ctx, FALSE);
+
+ /* XXX: Beware that since we are changing the active texture unit we
+ * must make sure we don't call into other Cogl components that may
+ * temporarily bind texture objects to query/modify parameters since
+ * they will end up binding texture unit 1. See
+ * _cogl_bind_gl_texture_transient for more details.
+ */
+ _cogl_set_active_texture_unit (unit_index);
+
+ if (layers_difference & COGL_MATERIAL_LAYER_STATE_COMBINE)
+ {
+ CoglMaterialLayer *authority =
+ _cogl_material_layer_get_authority (layer,
+ COGL_MATERIAL_LAYER_STATE_COMBINE);
+ CoglMaterialLayerBigState *big_state = authority->big_state;
+
+ GE (glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE));
+
+ /* Set the combiner functions... */
+ GE (glTexEnvi (GL_TEXTURE_ENV,
+ GL_COMBINE_RGB,
+ big_state->texture_combine_rgb_func));
+ GE (glTexEnvi (GL_TEXTURE_ENV,
+ GL_COMBINE_ALPHA,
+ big_state->texture_combine_alpha_func));
+
+ /*
+ * Setup the function arguments...
+ */
+
+ /* For the RGB components... */
+ n_rgb_func_args =
+ _cogl_get_n_args_for_combine_func (big_state->texture_combine_rgb_func);
+
+ GE (glTexEnvi (GL_TEXTURE_ENV, GL_SRC0_RGB,
+ big_state->texture_combine_rgb_src[0]));
+ GE (glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_RGB,
+ big_state->texture_combine_rgb_op[0]));
+ if (n_rgb_func_args > 1)
+ {
+ GE (glTexEnvi (GL_TEXTURE_ENV, GL_SRC1_RGB,
+ big_state->texture_combine_rgb_src[1]));
+ GE (glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_RGB,
+ big_state->texture_combine_rgb_op[1]));
+ }
+ if (n_rgb_func_args > 2)
+ {
+ GE (glTexEnvi (GL_TEXTURE_ENV, GL_SRC2_RGB,
+ big_state->texture_combine_rgb_src[2]));
+ GE (glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND2_RGB,
+ big_state->texture_combine_rgb_op[2]));
+ }
+
+ /* For the Alpha component */
+ n_alpha_func_args =
+ _cogl_get_n_args_for_combine_func (big_state->texture_combine_alpha_func);
+
+ GE (glTexEnvi (GL_TEXTURE_ENV, GL_SRC0_ALPHA,
+ big_state->texture_combine_alpha_src[0]));
+ GE (glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA,
+ big_state->texture_combine_alpha_op[0]));
+ if (n_alpha_func_args > 1)
+ {
+ GE (glTexEnvi (GL_TEXTURE_ENV, GL_SRC1_ALPHA,
+ big_state->texture_combine_alpha_src[1]));
+ GE (glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_ALPHA,
+ big_state->texture_combine_alpha_op[1]));
+ }
+ if (n_alpha_func_args > 2)
+ {
+ GE (glTexEnvi (GL_TEXTURE_ENV, GL_SRC2_ALPHA,
+ big_state->texture_combine_alpha_src[2]));
+ GE (glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND2_ALPHA,
+ big_state->texture_combine_alpha_op[2]));
+ }
+ }
+
+ if (layers_difference & COGL_MATERIAL_LAYER_STATE_COMBINE)
+ {
+ CoglMaterialLayer *authority =
+ _cogl_material_layer_get_authority (layer,
+ COGL_MATERIAL_LAYER_STATE_COMBINE);
+ CoglMaterialLayerBigState *big_state = authority->big_state;
+
+ GE (glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR,
+ big_state->texture_combine_constant));
+ }
+
+ return TRUE;
+}
+
+static gboolean
+_cogl_material_backend_fixed_end (CoglMaterial *material,
+ unsigned long materials_difference)
+{
+ return TRUE;
+}
+
+const CoglMaterialBackend _cogl_material_fixed_backend =
+{
+ _cogl_material_backend_fixed_get_max_texture_units,
+ _cogl_material_backend_fixed_start,
+ _cogl_material_backend_fixed_add_layer,
+ NULL, /* passthrough */
+ _cogl_material_backend_fixed_end,
+ NULL, /* material_change_notify */
+ NULL, /* material_set_parent_notify */
+ NULL, /* layer_change_notify */
+ NULL /* free_priv */
+};
+
--- /dev/null
+/*
+ * Cogl
+ *
+ * An object oriented GL/GLES Abstraction/Utility Layer
+ *
+ * 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/>.
+ *
+ *
+ *
+ * Authors:
+ * Robert Bragg <robert@linux.intel.com>
+ */
+
+#ifndef __COGL_MATERIAL_GLSL_PRIVATE_H
+#define __COGL_MATERIAL_GLSL_PRIVATE_H
+
+#include "cogl-material-private.h"
+
+const CoglMaterialBackend _cogl_material_glsl_backend;
+
+#endif /* __COGL_MATERIAL_GLSL_PRIVATE_H */
+
--- /dev/null
+/*
+ * Cogl
+ *
+ * An object oriented GL/GLES Abstraction/Utility Layer
+ *
+ * Copyright (C) 2008,2009,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/>.
+ *
+ *
+ *
+ * Authors:
+ * Robert Bragg <robert@linux.intel.com>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "cogl.h"
+#include "cogl-internal.h"
+#include "cogl-context.h"
+#include "cogl-handle.h"
+
+#include "cogl-material-private.h"
+#ifndef HAVE_COGL_GLES
+#include "cogl-program.h"
+#endif
+
+#include <glib.h>
+
+/*
+ * GL/GLES compatability defines for material thingies:
+ */
+
+#ifdef HAVE_COGL_GLES2
+#include "../gles/cogl-gles2-wrapper.h"
+#endif
+
+static int
+_cogl_material_backend_glsl_get_max_texture_units (void)
+{
+ return _cogl_get_max_texture_image_units ();
+}
+
+static gboolean
+_cogl_material_backend_glsl_start (CoglMaterial *material,
+ int n_layers,
+ unsigned long materials_difference)
+{
+ _COGL_GET_CONTEXT (ctx, FALSE);
+
+ if (!cogl_features_available (COGL_FEATURE_SHADERS_GLSL))
+ return FALSE;
+
+ /* FIXME: This will likely conflict with the GLES 2 backends use of
+ * glUseProgram.
+ */
+ if (materials_difference & COGL_MATERIAL_STATE_USER_SHADER)
+ {
+ CoglMaterial *authority =
+ _cogl_material_get_authority (material,
+ COGL_MATERIAL_STATE_USER_SHADER);
+ CoglHandle program = authority->big_state->user_program;
+
+ if (program == COGL_INVALID_HANDLE)
+ return FALSE; /* XXX: change me when we support code generation here */
+
+ _cogl_use_program (program, COGL_MATERIAL_PROGRAM_TYPE_GLSL);
+ return TRUE;
+ }
+
+ /* TODO: also support code generation */
+
+ return FALSE;
+}
+
+gboolean
+_cogl_material_backend_glsl_add_layer (CoglMaterial *material,
+ CoglMaterialLayer *layer,
+ unsigned long layers_difference)
+{
+ return TRUE;
+}
+
+gboolean
+_cogl_material_backend_glsl_passthrough (CoglMaterial *material)
+{
+ return TRUE;
+}
+
+gboolean
+_cogl_material_backend_glsl_end (CoglMaterial *material,
+ unsigned long materials_difference)
+{
+ return TRUE;
+}
+
+const CoglMaterialBackend _cogl_material_glsl_backend =
+{
+ _cogl_material_backend_glsl_get_max_texture_units,
+ _cogl_material_backend_glsl_start,
+ _cogl_material_backend_glsl_add_layer,
+ _cogl_material_backend_glsl_passthrough,
+ _cogl_material_backend_glsl_end,
+ NULL, /* material_state_change_notify */
+ NULL, /* material_set_parent_notify */
+ NULL, /* layer_state_change_notify */
+ NULL, /* free_priv */
+};
+
gboolean is_foreign);
#if defined (HAVE_COGL_GL)
-/* glsl, arbfp, fixed */
+
+/* NB: material->backend is currently a 3bit unsigned int bitfield */
+#define COGL_MATERIAL_BACKEND_GLSL 0
+#define COGL_MATERIAL_BACKEND_GLSL_MASK (1L<<0)
+#define COGL_MATERIAL_BACKEND_ARBFP 1
+#define COGL_MATERIAL_BACKEND_ARBFP_MASK (1L<<1)
+#define COGL_MATERIAL_BACKEND_FIXED 2
+#define COGL_MATERIAL_BACKEND_FIXED_MASK (1L<<2)
+
#define COGL_MATERIAL_N_BACKENDS 3
+
#elif defined (HAVE_COGL_GLES2)
-/* glsl, fixed */
+
+#define COGL_MATERIAL_BACKEND_GLSL 0
+#define COGL_MATERIAL_BACKEND_GLSL_MASK (1L<<0)
+#define COGL_MATERIAL_BACKEND_FIXED 1
+#define COGL_MATERIAL_BACKEND_FIXED_MASK (1L<<1)
+
#define COGL_MATERIAL_N_BACKENDS 2
+
#else /* HAVE_COGL_GLES */
-/* fixed */
+
+#define COGL_MATERIAL_BACKEND_FIXED 0
+#define COGL_MATERIAL_BACKEND_FIXED_MASK (1L<<0)
+
#define COGL_MATERIAL_N_BACKENDS 1
+
#endif
+#define COGL_MATERIAL_BACKEND_DEFAULT 0
+#define COGL_MATERIAL_BACKEND_UNDEFINED 3
+
typedef enum
{
COGL_MATERIAL_LAYER_STATE_UNIT = 1L<<0,
CoglMaterialWrapModeOverrides wrap_mode_overrides;
} CoglMaterialFlushOptions;
+
+void
+_cogl_set_active_texture_unit (int unit_index);
+
+void
+_cogl_delete_gl_texture (GLuint gl_texture);
+
+int
+_cogl_get_max_texture_image_units (void);
+
+
+void
+_cogl_use_program (CoglHandle program_handle, CoglMaterialProgramType type);
+
+unsigned int
+_cogl_get_n_args_for_combine_func (GLint func);
+
+
void
_cogl_material_get_colorubv (CoglHandle handle,
guint8 *color);
CoglHandle program);
void
-_cogl_delete_gl_texture (GLuint gl_texture);
-
-void
_cogl_material_texture_storage_change_notify (CoglHandle texture);
void
unsigned long
_cogl_material_get_age (CoglHandle handle);
+CoglMaterial *
+_cogl_material_get_authority (CoglMaterial *material,
+ unsigned long difference);
+
+typedef gboolean (*CoglMaterialChildCallback) (CoglMaterial *child,
+ void *user_data);
+
+void
+_cogl_material_foreach_child (CoglMaterial *material,
+ CoglMaterialChildCallback callback,
+ void *user_data);
+
+unsigned long
+_cogl_material_layer_compare_differences (CoglMaterialLayer *layer0,
+ CoglMaterialLayer *layer1);
+
+CoglMaterialLayer *
+_cogl_material_layer_get_authority (CoglMaterialLayer *layer,
+ unsigned long difference);
+
+CoglHandle
+_cogl_material_layer_get_texture (CoglMaterialLayer *layer);
+
+typedef gboolean (*CoglMaterialLayerCallback) (CoglMaterialLayer *layer,
+ void *user_data);
+
+void
+_cogl_material_foreach_layer (CoglMaterial *material,
+ CoglMaterialLayerCallback callback,
+ void *user_data);
+
+int
+_cogl_material_layer_get_unit_index (CoglMaterialLayer *layer);
+
#endif /* __COGL_MATERIAL_PRIVATE_H */
#define COGL_MATERIAL(X) ((CoglMaterial *)(X))
#define COGL_MATERIAL_LAYER(X) ((CoglMaterialLayer *)(X))
-typedef struct _CoglMaterialBackendARBfpPrivate
-{
- CoglMaterial *authority_cache;
- unsigned long authority_cache_age;
-
- GString *source;
- GLuint gl_program;
- gboolean *sampled;
- int next_constant_id;
-} CoglMaterialBackendARBfpPrivate;
-
typedef gboolean (*CoglMaterialStateComparitor) (CoglMaterial *authority0,
CoglMaterial *authority1);
static void handle_automatic_blend_enable (CoglMaterial *material,
CoglMaterialState changes);
-#if defined (HAVE_COGL_GL)
-
-static const CoglMaterialBackend _cogl_material_glsl_backend;
-static const CoglMaterialBackend _cogl_material_arbfp_backend;
-static const CoglMaterialBackend _cogl_material_fixed_backend;
-static const CoglMaterialBackend *backends[] =
-{
- /* The fragment processing backends in order of precedence... */
- &_cogl_material_glsl_backend,
- &_cogl_material_arbfp_backend,
- &_cogl_material_fixed_backend
-};
-/* NB: material->backend is currently a 3bit unsigned int bitfield */
-#define COGL_MATERIAL_BACKEND_GLSL 0
-#define COGL_MATERIAL_BACKEND_GLSL_MASK (1L<<0)
-#define COGL_MATERIAL_BACKEND_ARBFP 1
-#define COGL_MATERIAL_BACKEND_ARBFP_MASK (1L<<1)
-#define COGL_MATERIAL_BACKEND_FIXED 2
-#define COGL_MATERIAL_BACKEND_FIXED_MASK (1L<<2)
-
-#elif defined (HAVE_COGL_GLES2)
-
-static const CoglMaterialBackend _cogl_material_glsl_backend;
-static const CoglMaterialBackend _cogl_material_fixed_backend;
-static const CoglMaterialBackend *backends[] =
-{
- /* The fragment processing backends in order of precedence... */
- &_cogl_material_glsl_backend,
- &_cogl_material_fixed_backend
-};
-#define COGL_MATERIAL_BACKEND_GLSL 0
-#define COGL_MATERIAL_BACKEND_FIXED 1
-
-#else /* HAVE_COGL_GLES */
-
-static const CoglMaterialBackend _cogl_material_fixed_backend;
-static const CoglMaterialBackend *backends[] =
-{
- /* The fragment processing backends in order of precedence... */
- &_cogl_material_fixed_backend
-};
-
-#define COGL_MATERIAL_BACKEND_FIXED 0
+static const CoglMaterialBackend *backends[COGL_MATERIAL_N_BACKENDS];
+#ifdef COGL_MATERIAL_BACKEND_GLSL
+#include "cogl-material-glsl-private.h"
+#endif
+#ifdef COGL_MATERIAL_BACKEND_ARBFP
+#include "cogl-material-arbfp-private.h"
+#endif
+#ifdef COGL_MATERIAL_BACKEND_FIXED
+#include "cogl-material-fixed-private.h"
#endif
-
-#define COGL_MATERIAL_BACKEND_DEFAULT 0
-#define COGL_MATERIAL_BACKEND_UNDEFINED 3
COGL_HANDLE_DEFINE (Material, material);
COGL_HANDLE_DEFINE (MaterialLayer, material_layer);
g_array_free (ctx->texture_units, TRUE);
}
-static void
-set_active_texture_unit (int unit_index)
+void
+_cogl_set_active_texture_unit (int unit_index)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
* in case the driver doesn't have a sparse data structure for
* texture units.
*/
- set_active_texture_unit (1);
+ _cogl_set_active_texture_unit (1);
unit = _cogl_get_texture_unit (1);
/* NB: If we have previously bound a foreign texture to this texture
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
+ /* Take this opportunity to setup the fragment processing backends... */
+#ifdef COGL_MATERIAL_BACKEND_GLSL
+ backends[COGL_MATERIAL_BACKEND_GLSL] = &_cogl_material_glsl_backend;
+#endif
+#ifdef COGL_MATERIAL_BACKEND_ARBFP
+ backends[COGL_MATERIAL_BACKEND_ARBFP] = &_cogl_material_arbfp_backend;
+#endif
+#ifdef COGL_MATERIAL_BACKEND_FIXED
+ backends[COGL_MATERIAL_BACKEND_FIXED] = &_cogl_material_fixed_backend;
+#endif
+
material->is_weak = FALSE;
material->journal_ref_count = 0;
material->parent = NULL;
return material->real_blend_enable;
}
-static CoglMaterial *
+CoglMaterial *
_cogl_material_get_authority (CoglMaterial *material,
unsigned long difference)
{
return authority;
}
-static CoglMaterialLayer *
+CoglMaterialLayer *
_cogl_material_layer_get_authority (CoglMaterialLayer *layer,
unsigned long difference)
{
return authority;
}
-static int
+int
_cogl_material_layer_get_unit_index (CoglMaterialLayer *layer)
{
CoglMaterialLayer *authority =
g_warn_if_reached ();
}
-typedef gboolean (*CoglMaterialLayerCallback) (CoglMaterialLayer *layer,
- void *user_data);
-
/* TODO: add public cogl_material_foreach_layer but instead of passing
* a CoglMaterialLayer pointer to the callback we should pass a
* layer_index instead. */
-static void
+void
_cogl_material_foreach_layer (CoglHandle handle,
CoglMaterialLayerCallback callback,
void *user_data)
}
}
-typedef gboolean (*CoglMaterialChildCallback) (CoglMaterial *child,
- void *user_data);
-
-static void
+void
_cogl_material_foreach_child (CoglMaterial *material,
CoglMaterialChildCallback callback,
void *user_data)
}
}
-static unsigned int
-get_n_args_for_combine_func (GLint func)
+unsigned int
+_cogl_get_n_args_for_combine_func (GLint func)
{
switch (func)
{
int i;
GLint func = src->big_state->texture_combine_rgb_func;
big_state->texture_combine_rgb_func = func;
- n_args = get_n_args_for_combine_func (func);
+ n_args = _cogl_get_n_args_for_combine_func (func);
for (i = 0; i < n_args; i++)
{
big_state->texture_combine_rgb_src[i] =
func = src->big_state->texture_combine_alpha_func;
big_state->texture_combine_alpha_func = func;
- n_args = get_n_args_for_combine_func (func);
+ n_args = _cogl_get_n_args_for_combine_func (func);
for (i = 0; i < n_args; i++)
{
big_state->texture_combine_alpha_src[i] =
return layer;
}
-static CoglHandle
+CoglHandle
_cogl_material_layer_get_texture (CoglMaterialLayer *layer)
{
CoglMaterialLayer *authority =
* type of some kind then we could have a unified
* compare_differences() function.
*/
-static unsigned long
+unsigned long
_cogl_material_layer_compare_differences (CoglMaterialLayer *layer0,
CoglMaterialLayer *layer1)
{
return FALSE;
n_args =
- get_n_args_for_combine_func (big_state0->texture_combine_rgb_func);
+ _cogl_get_n_args_for_combine_func (big_state0->texture_combine_rgb_func);
for (i = 0; i < n_args; i++)
{
if ((big_state0->texture_combine_rgb_src[i] !=
}
n_args =
- get_n_args_for_combine_func (big_state0->texture_combine_alpha_func);
+ _cogl_get_n_args_for_combine_func (big_state0->texture_combine_alpha_func);
for (i = 0; i < n_args; i++)
{
if ((big_state0->texture_combine_alpha_src[i] !=
if (unit->enabled)
{
- set_active_texture_unit (unit_index);
+ _cogl_set_active_texture_unit (unit_index);
GE (glDisable (unit->current_gl_target));
unit->enabled = FALSE;
}
#endif
}
-static void
-use_program (CoglHandle program_handle, CoglMaterialProgramType type)
+void
+_cogl_use_program (CoglHandle program_handle, CoglMaterialProgramType type)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
#if defined (COGL_MATERIAL_BACKEND_GLSL) || \
defined (COGL_MATERIAL_BACKEND_ARBFP)
-static int
-get_max_texture_image_units (void)
+int
+_cogl_get_max_texture_image_units (void)
{
_COGL_GET_CONTEXT (ctx, 0);
}
#endif
-#ifdef COGL_MATERIAL_BACKEND_GLSL
-
-static int
-_cogl_material_backend_glsl_get_max_texture_units (void)
-{
- return get_max_texture_image_units ();
-}
-
-static gboolean
-_cogl_material_backend_glsl_start (CoglMaterial *material,
- int n_layers,
- unsigned long materials_difference)
-{
- _COGL_GET_CONTEXT (ctx, FALSE);
-
- if (!cogl_features_available (COGL_FEATURE_SHADERS_GLSL))
- return FALSE;
-
- /* FIXME: This will likely conflict with the GLES 2 backends use of
- * glUseProgram.
- */
- if (materials_difference & COGL_MATERIAL_STATE_USER_SHADER)
- {
- CoglMaterial *authority =
- _cogl_material_get_authority (material,
- COGL_MATERIAL_STATE_USER_SHADER);
- CoglHandle program = authority->big_state->user_program;
-
- if (program == COGL_INVALID_HANDLE)
- return FALSE; /* XXX: change me when we support code generation here */
-
- use_program (program, COGL_MATERIAL_PROGRAM_TYPE_GLSL);
- return TRUE;
- }
-
- /* TODO: also support code generation */
-
- return FALSE;
-}
-
-gboolean
-_cogl_material_backend_glsl_add_layer (CoglMaterial *material,
- CoglMaterialLayer *layer,
- unsigned long layers_difference)
-{
- return TRUE;
-}
-
-gboolean
-_cogl_material_backend_glsl_passthrough (CoglMaterial *material)
-{
- return TRUE;
-}
-
-gboolean
-_cogl_material_backend_glsl_end (CoglMaterial *material,
- unsigned long materials_difference)
-{
- return TRUE;
-}
-
-static const CoglMaterialBackend _cogl_material_glsl_backend =
-{
- _cogl_material_backend_glsl_get_max_texture_units,
- _cogl_material_backend_glsl_start,
- _cogl_material_backend_glsl_add_layer,
- _cogl_material_backend_glsl_passthrough,
- _cogl_material_backend_glsl_end,
- NULL, /* material_state_change_notify */
- NULL, /* material_set_parent_notify */
- NULL, /* layer_state_change_notify */
- NULL, /* free_priv */
-};
-
-#endif /* COGL_MATERIAL_BACKEND_GLSL */
-
-#ifdef COGL_MATERIAL_BACKEND_ARBFP
-
-static int
-_cogl_material_backend_arbfp_get_max_texture_units (void)
-{
- return get_max_texture_image_units ();
-}
-
-typedef struct
-{
- int i;
- CoglMaterialLayer **layers;
-} AddLayersToArrayState;
-
-static gboolean
-add_layer_to_array_cb (CoglMaterialLayer *layer,
- void *user_data)
-{
- AddLayersToArrayState *state = user_data;
- state->layers[state->i++] = layer;
- return TRUE;
-}
-
-static gboolean
-layers_arbfp_would_differ (CoglMaterialLayer **material0_layers,
- CoglMaterialLayer **material1_layers,
- int n_layers)
-{
- int i;
- /* The layer state that affects arbfp codegen... */
- unsigned long arbfp_codegen_modifiers =
- COGL_MATERIAL_LAYER_STATE_COMBINE |
- COGL_MATERIAL_LAYER_STATE_COMBINE_CONSTANT |
- COGL_MATERIAL_LAYER_STATE_UNIT |
- COGL_MATERIAL_LAYER_STATE_TEXTURE;
-
- for (i = 0; i < n_layers; i++)
- {
- CoglMaterialLayer *layer0 = material0_layers[i];
- CoglMaterialLayer *layer1 = material1_layers[i];
- unsigned long layer_differences;
-
- if (layer0 == layer1)
- continue;
-
- layer_differences =
- _cogl_material_layer_compare_differences (layer0, layer1);
-
- if (layer_differences & arbfp_codegen_modifiers)
- {
- /* When it comes to texture differences the only thing that
- * affects the arbfp is the target enum... */
- if (layer_differences == COGL_MATERIAL_LAYER_STATE_TEXTURE)
- {
- CoglHandle tex0 = _cogl_material_layer_get_texture (layer0);
- CoglHandle tex1 = _cogl_material_layer_get_texture (layer1);
- GLenum gl_target0;
- GLenum gl_target1;
-
- cogl_texture_get_gl_texture (tex0, NULL, &gl_target0);
- cogl_texture_get_gl_texture (tex1, NULL, &gl_target1);
- if (gl_target0 == gl_target1)
- continue;
- }
- return TRUE;
- }
- }
-
- return FALSE;
-}
-
-/* This tries to find the oldest ancestor whos state would generate
- * the same arbfp program as the current material. This is a simple
- * mechanism for reducing the number of arbfp programs we have to
- * generate.
- */
-static CoglMaterial *
-find_arbfp_authority (CoglMaterial *material)
-{
- CoglMaterial *authority0;
- CoglMaterial *authority1;
- int n_layers;
- CoglMaterialLayer **authority0_layers;
- CoglMaterialLayer **authority1_layers;
-
- /* XXX: we'll need to update this when we add fog support to the
- * arbfp codegen */
-
- /* Find the first material that modifies state that affects the
- * arbfp codegen... */
- authority0 = _cogl_material_get_authority (material,
- COGL_MATERIAL_STATE_LAYERS);
-
- /* Find the next ancestor after that, that also modifies state
- * affecting arbfp codegen... */
- if (authority0->parent)
- authority1 = _cogl_material_get_authority (authority0->parent,
- COGL_MATERIAL_STATE_LAYERS);
- else
- return authority0;
-
- n_layers = authority0->n_layers;
-
- for (;;)
- {
- AddLayersToArrayState state;
-
- if (authority0->n_layers != authority1->n_layers)
- return authority0;
-
- authority0_layers =
- g_alloca (sizeof (CoglMaterialLayer *) * n_layers);
- state.i = 0;
- state.layers = authority0_layers;
- _cogl_material_foreach_layer (authority0,
- add_layer_to_array_cb,
- &state);
-
- authority1_layers =
- g_alloca (sizeof (CoglMaterialLayer *) * n_layers);
- state.i = 0;
- state.layers = authority1_layers;
- _cogl_material_foreach_layer (authority1,
- add_layer_to_array_cb,
- &state);
-
- if (layers_arbfp_would_differ (authority0_layers, authority1_layers,
- n_layers))
- return authority0;
-
- /* Find the next ancestor after that, that also modifies state
- * affecting arbfp codegen... */
-
- if (!authority1->parent)
- break;
-
- authority0 = authority1;
- authority1 = _cogl_material_get_authority (authority1->parent,
- COGL_MATERIAL_STATE_LAYERS);
- if (authority1 == authority0)
- break;
- }
-
- return authority1;
-}
-
-static void
-invalidate_arbfp_authority_cache (CoglMaterial *material)
-{
- if (material->backend_priv_set_mask & COGL_MATERIAL_BACKEND_ARBFP_MASK)
- {
- CoglMaterialBackendARBfpPrivate *priv =
- material->backend_privs[COGL_MATERIAL_BACKEND_ARBFP];
- priv->authority_cache = NULL;
- priv->authority_cache_age = 0;
- }
-}
-
-static gboolean
-_cogl_material_backend_arbfp_start (CoglMaterial *material,
- int n_layers,
- unsigned long materials_difference)
-{
- CoglMaterial *authority;
- CoglMaterialBackendARBfpPrivate *priv;
- CoglMaterialBackendARBfpPrivate *authority_priv;
-
- _COGL_GET_CONTEXT (ctx, FALSE);
-
- if (!_cogl_features_available_private (COGL_FEATURE_PRIVATE_ARB_FP))
- return FALSE;
-
- /* TODO: support fog */
- if (ctx->fog_enabled)
- return FALSE;
-
- /* Note: we allocate ARBfp private state for both the given material
- * and the authority. (The oldest ancestor whos state will result in
- * the same program being generated) The former will simply cache a
- * pointer to the authority and the later will track the arbfp
- * program that we will generate.
- */
-
- if (!(material->backend_priv_set_mask & COGL_MATERIAL_BACKEND_ARBFP_MASK))
- {
- material->backend_privs[COGL_MATERIAL_BACKEND_ARBFP] =
- g_slice_new0 (CoglMaterialBackendARBfpPrivate);
- material->backend_priv_set_mask |= COGL_MATERIAL_BACKEND_ARBFP_MASK;
- }
- priv = material->backend_privs[COGL_MATERIAL_BACKEND_ARBFP];
-
- /* XXX: We are making assumptions that we don't yet support
- * modification of ancestors to optimize the sharing of state in the
- * material graph. When we start to support this then the arbfp
- * backend will somehow need to be notified of graph changes that
- * may invalidate authority_cache pointers.
- */
-
- if (priv->authority_cache &&
- priv->authority_cache_age != _cogl_material_get_age (material))
- invalidate_arbfp_authority_cache (material);
-
- if (!priv->authority_cache)
- {
- priv->authority_cache = find_arbfp_authority (material);
- priv->authority_cache_age = _cogl_material_get_age (material);
- }
-
- authority = priv->authority_cache;
- if (!(authority->backend_priv_set_mask & COGL_MATERIAL_BACKEND_ARBFP_MASK))
- {
- authority->backend_privs[COGL_MATERIAL_BACKEND_ARBFP] =
- g_slice_new0 (CoglMaterialBackendARBfpPrivate);
- authority->backend_priv_set_mask |= COGL_MATERIAL_BACKEND_ARBFP_MASK;
- }
- authority_priv = authority->backend_privs[COGL_MATERIAL_BACKEND_ARBFP];
-
- if (authority_priv->gl_program == 0)
- {
- /* We reuse a single grow-only GString for ARBfp code-gen */
- g_string_set_size (ctx->arbfp_source_buffer, 0);
- authority_priv->source = ctx->arbfp_source_buffer;
- g_string_append (authority_priv->source,
- "!!ARBfp1.0\n"
- "TEMP output;\n"
- "TEMP tmp0, tmp1, tmp2, tmp3, tmp4;\n"
- "PARAM half = {.5, .5, .5, .5};\n"
- "PARAM one = {1, 1, 1, 1};\n"
- "PARAM two = {2, 2, 2, 2};\n"
- "PARAM minus_one = {-1, -1, -1, -1};\n");
- authority_priv->sampled = g_new0 (gboolean, n_layers);
- }
-
- return TRUE;
-}
-
-static CoglMaterial *
-get_arbfp_authority (CoglMaterial *material)
-{
- CoglMaterialBackendARBfpPrivate *priv =
- material->backend_privs[COGL_MATERIAL_BACKEND_ARBFP];
-
- g_return_val_if_fail (priv != NULL, NULL);
-
- return priv->authority_cache;
-}
-
-/* Determines if we need to handle the RGB and A texture combining
- * separately or is the same function used for both channel masks and
- * with the same arguments...
- */
-static gboolean
-need_texture_combine_separate (CoglMaterialLayer *combine_authority)
-{
- CoglMaterialLayerBigState *big_state = combine_authority->big_state;
- int n_args;
- int i;
-
- if (big_state->texture_combine_rgb_func !=
- big_state->texture_combine_alpha_func)
- return TRUE;
-
- n_args = get_n_args_for_combine_func (big_state->texture_combine_rgb_func);
-
- for (i = 0; i < n_args; i++)
- {
- if (big_state->texture_combine_rgb_src[i] !=
- big_state->texture_combine_alpha_src[i])
- return TRUE;
-
- /*
- * We can allow some variation of the source operands without
- * needing a separation...
- *
- * "A = REPLACE (CONSTANT[A])" + either of the following...
- * "RGB = REPLACE (CONSTANT[RGB])"
- * "RGB = REPLACE (CONSTANT[A])"
- *
- * can be combined as:
- * "RGBA = REPLACE (CONSTANT)" or
- * "RGBA = REPLACE (CONSTANT[A])" or
- *
- * And "A = REPLACE (1-CONSTANT[A])" + either of the following...
- * "RGB = REPLACE (1-CONSTANT)" or
- * "RGB = REPLACE (1-CONSTANT[A])"
- *
- * can be combined as:
- * "RGBA = REPLACE (1-CONSTANT)" or
- * "RGBA = REPLACE (1-CONSTANT[A])"
- */
- switch (big_state->texture_combine_alpha_op[i])
- {
- case GL_SRC_ALPHA:
- switch (big_state->texture_combine_rgb_op[i])
- {
- case GL_SRC_COLOR:
- case GL_SRC_ALPHA:
- break;
- default:
- return FALSE;
- }
- break;
- case GL_ONE_MINUS_SRC_ALPHA:
- switch (big_state->texture_combine_rgb_op[i])
- {
- case GL_ONE_MINUS_SRC_COLOR:
- case GL_ONE_MINUS_SRC_ALPHA:
- break;
- default:
- return FALSE;
- }
- break;
- default:
- return FALSE; /* impossible */
- }
- }
-
- return FALSE;
-}
-
-static const char *
-gl_target_to_arbfp_string (GLenum gl_target)
-{
-#ifndef HAVE_COGL_GLES2
- if (gl_target == GL_TEXTURE_1D)
- return "1D";
- else
-#endif
- if (gl_target == GL_TEXTURE_2D)
- return "2D";
-#ifdef GL_ARB_texture_rectangle
- else if (gl_target == GL_TEXTURE_RECTANGLE_ARB)
- return "RECT";
-#endif
- else
- return "2D";
-}
-
-static void
-setup_texture_source (CoglMaterialBackendARBfpPrivate *priv,
- int unit_index,
- GLenum gl_target)
-{
- if (!priv->sampled[unit_index])
- {
- g_string_append_printf (priv->source,
- "TEMP texel%d;\n"
- "TEX texel%d,fragment.texcoord[%d],"
- "texture[%d],%s;\n",
- unit_index,
- unit_index,
- unit_index,
- unit_index,
- gl_target_to_arbfp_string (gl_target));
- priv->sampled[unit_index] = TRUE;
- }
-}
-
-typedef enum _CoglMaterialBackendARBfpArgType
-{
- COGL_MATERIAL_BACKEND_ARBFP_ARG_TYPE_SIMPLE,
- COGL_MATERIAL_BACKEND_ARBFP_ARG_TYPE_CONSTANT,
- COGL_MATERIAL_BACKEND_ARBFP_ARG_TYPE_TEXTURE
-} CoglMaterialBackendARBfpArgType;
-
-typedef struct _CoglMaterialBackendARBfpArg
-{
- const char *name;
-
- CoglMaterialBackendARBfpArgType type;
-
- /* for type = TEXTURE */
- int texture_unit;
- GLenum texture_target;
-
- /* for type = CONSTANT */
- int constant_id;
-
- const char *swizzle;
-
-} CoglMaterialBackendARBfpArg;
-
-static void
-append_arg (GString *source, const CoglMaterialBackendARBfpArg *arg)
-{
- switch (arg->type)
- {
- case COGL_MATERIAL_BACKEND_ARBFP_ARG_TYPE_TEXTURE:
- g_string_append_printf (source, "texel%d%s",
- arg->texture_unit, arg->swizzle);
- break;
- case COGL_MATERIAL_BACKEND_ARBFP_ARG_TYPE_CONSTANT:
- g_string_append_printf (source, "constant%d%s",
- arg->constant_id, arg->swizzle);
- break;
- case COGL_MATERIAL_BACKEND_ARBFP_ARG_TYPE_SIMPLE:
- g_string_append_printf (source, "%s%s",
- arg->name, arg->swizzle);
- break;
- }
-}
-
-/* Note: we are trying to avoid duplicating strings during codegen
- * which is why we have the slightly awkward
- * CoglMaterialBackendARBfpArg mechanism. */
-static void
-setup_arg (CoglMaterial *material,
- CoglMaterialLayer *layer,
- CoglBlendStringChannelMask mask,
- int arg_index,
- GLint src,
- GLint op,
- CoglMaterialBackendARBfpArg *arg)
-{
- CoglMaterial *arbfp_authority = get_arbfp_authority (material);
- CoglMaterialBackendARBfpPrivate *priv =
- arbfp_authority->backend_privs[COGL_MATERIAL_BACKEND_ARBFP];
- static const char *tmp_name[3] = { "tmp0", "tmp1", "tmp2" };
- GLenum gl_target;
- CoglHandle texture;
-
- switch (src)
- {
- case GL_TEXTURE:
- arg->type = COGL_MATERIAL_BACKEND_ARBFP_ARG_TYPE_TEXTURE;
- arg->name = "texel%d";
- arg->texture_unit = _cogl_material_layer_get_unit_index (layer);
- texture = _cogl_material_layer_get_texture (layer);
- cogl_texture_get_gl_texture (texture, NULL, &gl_target);
- setup_texture_source (priv, arg->texture_unit, gl_target);
- break;
- case GL_CONSTANT:
- {
- unsigned long state = COGL_MATERIAL_LAYER_STATE_COMBINE_CONSTANT;
- CoglMaterialLayer *authority =
- _cogl_material_layer_get_authority (layer, state);
- CoglMaterialLayerBigState *big_state = authority->big_state;
-
- arg->type = COGL_MATERIAL_BACKEND_ARBFP_ARG_TYPE_CONSTANT;
- arg->name = "constant%d";
- arg->constant_id = priv->next_constant_id++;
- g_string_append_printf (priv->source,
- "PARAM constant%d = "
- " {%f, %f, %f, %f};\n",
- arg->constant_id,
- big_state->texture_combine_constant[0],
- big_state->texture_combine_constant[1],
- big_state->texture_combine_constant[2],
- big_state->texture_combine_constant[3]);
- break;
- }
- case GL_PRIMARY_COLOR:
- arg->type = COGL_MATERIAL_BACKEND_ARBFP_ARG_TYPE_SIMPLE;
- arg->name = "fragment.color.primary";
- break;
- case GL_PREVIOUS:
- arg->type = COGL_MATERIAL_BACKEND_ARBFP_ARG_TYPE_SIMPLE;
- if (_cogl_material_layer_get_unit_index (layer) == 0)
- arg->name = "fragment.color.primary";
- else
- arg->name = "output";
- break;
- default: /* GL_TEXTURE0..N */
- arg->type = COGL_MATERIAL_BACKEND_ARBFP_ARG_TYPE_TEXTURE;
- arg->name = "texture[%d]";
- arg->texture_unit = src - GL_TEXTURE0;
- texture = _cogl_material_layer_get_texture (layer);
- cogl_texture_get_gl_texture (texture, NULL, &gl_target);
- setup_texture_source (priv, arg->texture_unit, gl_target);
- }
-
- arg->swizzle = "";
-
- switch (op)
- {
- case GL_SRC_COLOR:
- break;
- case GL_ONE_MINUS_SRC_COLOR:
- g_string_append_printf (priv->source,
- "SUB tmp%d, one, ",
- arg_index);
- append_arg (priv->source, arg);
- g_string_append_printf (priv->source, ";\n");
- arg->type = COGL_MATERIAL_BACKEND_ARBFP_ARG_TYPE_SIMPLE;
- arg->name = tmp_name[arg_index];
- arg->swizzle = "";
- break;
- case GL_SRC_ALPHA:
- /* avoid a swizzle if we know RGB are going to be masked
- * in the end anyway */
- if (mask != COGL_BLEND_STRING_CHANNEL_MASK_ALPHA)
- arg->swizzle = ".a";
- break;
- case GL_ONE_MINUS_SRC_ALPHA:
- g_string_append_printf (priv->source,
- "SUB tmp%d, one, ",
- arg_index);
- append_arg (priv->source, arg);
- /* avoid a swizzle if we know RGB are going to be masked
- * in the end anyway */
- if (mask != COGL_BLEND_STRING_CHANNEL_MASK_ALPHA)
- g_string_append_printf (priv->source, ".a;\n");
- else
- g_string_append_printf (priv->source, ";\n");
- arg->type = COGL_MATERIAL_BACKEND_ARBFP_ARG_TYPE_SIMPLE;
- arg->name = tmp_name[arg_index];
- break;
- default:
- g_error ("Unknown texture combine operator %d", op);
- break;
- }
-}
-
-static gboolean
-backend_arbfp_args_equal (CoglMaterialBackendARBfpArg *arg0,
- CoglMaterialBackendARBfpArg *arg1)
-{
- if (arg0->type != arg1->type)
- return FALSE;
-
- if (arg0->name != arg1->name &&
- strcmp (arg0->name, arg1->name) != 0)
- return FALSE;
-
- if (arg0->type == COGL_MATERIAL_BACKEND_ARBFP_ARG_TYPE_TEXTURE &&
- arg0->texture_unit != arg1->texture_unit)
- return FALSE;
- /* Note we don't have to check the target; a texture unit can only
- * have one target enabled at a time. */
-
- if (arg0->type == COGL_MATERIAL_BACKEND_ARBFP_ARG_TYPE_CONSTANT &&
- arg0->constant_id != arg0->constant_id)
- return FALSE;
-
- if (arg0->swizzle != arg1->swizzle &&
- strcmp (arg0->swizzle, arg1->swizzle) != 0)
- return FALSE;
-
- return TRUE;
-}
-
-static void
-append_function (CoglMaterial *material,
- CoglBlendStringChannelMask mask,
- GLint function,
- CoglMaterialBackendARBfpArg *args,
- int n_args)
-{
- CoglMaterial *arbfp_authority = get_arbfp_authority (material);
- CoglMaterialBackendARBfpPrivate *priv =
- arbfp_authority->backend_privs[COGL_MATERIAL_BACKEND_ARBFP];
- const char *mask_name;
-
- switch (mask)
- {
- case COGL_BLEND_STRING_CHANNEL_MASK_RGB:
- mask_name = ".rgb";
- break;
- case COGL_BLEND_STRING_CHANNEL_MASK_ALPHA:
- mask_name = ".a";
- break;
- case COGL_BLEND_STRING_CHANNEL_MASK_RGBA:
- mask_name = "";
- break;
- default:
- g_error ("Unknown channel mask %d", mask);
- mask_name = "";
- }
-
- switch (function)
- {
- case GL_ADD:
- g_string_append_printf (priv->source, "ADD_SAT output%s, ",
- mask_name);
- break;
- case GL_MODULATE:
- /* Note: no need to saturate since we can assume operands
- * have values in the range [0,1] */
- g_string_append_printf (priv->source, "MUL output%s, ",
- mask_name);
- break;
- case GL_REPLACE:
- /* Note: no need to saturate since we can assume operand
- * has a value in the range [0,1] */
- g_string_append_printf (priv->source, "MOV output%s, ",
- mask_name);
- break;
- case GL_SUBTRACT:
- g_string_append_printf (priv->source, "SUB_SAT output%s, ",
- mask_name);
- break;
- case GL_ADD_SIGNED:
- g_string_append_printf (priv->source, "ADD tmp3%s, ",
- mask_name);
- append_arg (priv->source, &args[0]);
- g_string_append (priv->source, ", ");
- append_arg (priv->source, &args[1]);
- g_string_append (priv->source, ";\n");
- g_string_append_printf (priv->source, "SUB_SAT output%s, tmp3, half",
- mask_name);
- n_args = 0;
- break;
- case GL_DOT3_RGB:
- /* These functions are the same except that GL_DOT3_RGB never
- * updates the alpha channel.
- *
- * NB: GL_DOT3_RGBA is a bit special because it effectively forces
- * an RGBA mask and we end up ignoring any separate alpha channel
- * function.
- */
- case GL_DOT3_RGBA:
- {
- const char *tmp4 = "tmp4";
-
- /* The maths for this was taken from Mesa;
- * apparently:
- *
- * tmp3 = 2*src0 - 1
- * tmp4 = 2*src1 - 1
- * output = DP3 (tmp3, tmp4)
- *
- * is the same as:
- *
- * output = 4 * DP3 (src0 - 0.5, src1 - 0.5)
- */
-
- g_string_append (priv->source, "MAD tmp3, two, ");
- append_arg (priv->source, &args[0]);
- g_string_append (priv->source, ", minus_one;\n");
-
- if (!backend_arbfp_args_equal (&args[0], &args[1]))
- {
- g_string_append (priv->source, "MAD tmp4, two, ");
- append_arg (priv->source, &args[1]);
- g_string_append (priv->source, ", minus_one;\n");
- }
- else
- tmp4 = "tmp3";
-
- g_string_append_printf (priv->source,
- "DP3_SAT output%s, tmp3, %s",
- mask_name, tmp4);
- n_args = 0;
- }
- break;
- case GL_INTERPOLATE:
- /* Note: no need to saturate since we can assume operands
- * have values in the range [0,1] */
-
- /* NB: GL_INTERPOLATE = arg0*arg2 + arg1*(1-arg2)
- * but LRP dst, a, b, c = b*a + c*(1-a) */
- g_string_append_printf (priv->source, "LRP output%s, ",
- mask_name);
- append_arg (priv->source, &args[2]);
- g_string_append (priv->source, ", ");
- append_arg (priv->source, &args[0]);
- g_string_append (priv->source, ", ");
- append_arg (priv->source, &args[1]);
- n_args = 0;
- break;
- default:
- g_error ("Unknown texture combine function %d", function);
- g_string_append_printf (priv->source, "MUL_SAT output%s, ",
- mask_name);
- n_args = 2;
- break;
- }
-
- if (n_args > 0)
- append_arg (priv->source, &args[0]);
- if (n_args > 1)
- {
- g_string_append (priv->source, ", ");
- append_arg (priv->source, &args[1]);
- }
- g_string_append (priv->source, ";\n");
-}
-
-static void
-append_masked_combine (CoglMaterial *arbfp_authority,
- CoglMaterialLayer *layer,
- CoglBlendStringChannelMask mask,
- GLint function,
- GLint *src,
- GLint *op)
-{
- int i;
- int n_args;
- CoglMaterialBackendARBfpArg args[3];
-
- n_args = get_n_args_for_combine_func (function);
-
- for (i = 0; i < n_args; i++)
- {
- setup_arg (arbfp_authority,
- layer,
- mask,
- i,
- src[i],
- op[i],
- &args[i]);
- }
-
- append_function (arbfp_authority,
- mask,
- function,
- args,
- n_args);
-}
-
-static gboolean
-_cogl_material_backend_arbfp_add_layer (CoglMaterial *material,
- CoglMaterialLayer *layer,
- unsigned long layers_difference)
-{
- CoglMaterial *arbfp_authority = get_arbfp_authority (material);
- CoglMaterialBackendARBfpPrivate *priv =
- arbfp_authority->backend_privs[COGL_MATERIAL_BACKEND_ARBFP];
- CoglMaterialLayer *combine_authority =
- _cogl_material_layer_get_authority (layer,
- COGL_MATERIAL_LAYER_STATE_COMBINE);
- CoglMaterialLayerBigState *big_state = combine_authority->big_state;
-
- /* Notes...
- *
- * We are ignoring the issue of texture indirection limits until
- * someone complains (Ref Section 3.11.6 in the ARB_fragment_program
- * spec)
- *
- * There always five TEMPs named tmp0, tmp1 and tmp2, tmp3 and tmp4
- * available and these constants: 'one' = {1, 1, 1, 1}, 'half'
- * {.5, .5, .5, .5}, 'two' = {2, 2, 2, 2}, 'minus_one' = {-1, -1,
- * -1, -1}
- *
- * tmp0-2 are intended for dealing with some of the texture combine
- * operands (e.g. GL_ONE_MINUS_SRC_COLOR) tmp3/4 are for dealing
- * with the GL_ADD_SIGNED texture combine and the GL_DOT3_RGB[A]
- * functions.
- *
- * Each layer outputs to the TEMP called "output", and reads from
- * output if it needs to refer to GL_PREVIOUS. (we detect if we are
- * layer0 so we will read fragment.color for GL_PREVIOUS in that
- * case)
- *
- * We aim to do all the channels together if the same function is
- * used for RGB as for A.
- *
- * We aim to avoid string duplication / allocations during codegen.
- *
- * We are careful to only saturate when writing to output.
- */
-
- if (!priv->source)
- return TRUE;
-
- if (!need_texture_combine_separate (combine_authority))
- {
- append_masked_combine (material,
- layer,
- COGL_BLEND_STRING_CHANNEL_MASK_RGBA,
- big_state->texture_combine_rgb_func,
- big_state->texture_combine_rgb_src,
- big_state->texture_combine_rgb_op);
- }
- else if (big_state->texture_combine_rgb_func == GL_DOT3_RGBA)
- {
- /* GL_DOT3_RGBA Is a bit weird as a GL_COMBINE_RGB function
- * since if you use it, it overrides your ALPHA function...
- */
- append_masked_combine (material,
- layer,
- COGL_BLEND_STRING_CHANNEL_MASK_RGBA,
- big_state->texture_combine_rgb_func,
- big_state->texture_combine_rgb_src,
- big_state->texture_combine_rgb_op);
- }
- else
- {
- append_masked_combine (material,
- layer,
- COGL_BLEND_STRING_CHANNEL_MASK_RGB,
- big_state->texture_combine_rgb_func,
- big_state->texture_combine_rgb_src,
- big_state->texture_combine_rgb_op);
- append_masked_combine (material,
- layer,
- COGL_BLEND_STRING_CHANNEL_MASK_ALPHA,
- big_state->texture_combine_alpha_func,
- big_state->texture_combine_alpha_src,
- big_state->texture_combine_alpha_op);
- }
-
- return TRUE;
-}
-
-gboolean
-_cogl_material_backend_arbfp_passthrough (CoglMaterial *material)
-{
- CoglMaterial *arbfp_authority = get_arbfp_authority (material);
- CoglMaterialBackendARBfpPrivate *priv =
- arbfp_authority->backend_privs[COGL_MATERIAL_BACKEND_ARBFP];
-
- if (!priv->source)
- return TRUE;
-
- g_string_append (priv->source, "MOV output, fragment.color.primary;\n");
- return TRUE;
-}
-
-static gboolean
-_cogl_material_backend_arbfp_end (CoglMaterial *material,
- unsigned long materials_difference)
-{
- CoglMaterial *arbfp_authority = get_arbfp_authority (material);
- CoglMaterialBackendARBfpPrivate *priv =
- arbfp_authority->backend_privs[COGL_MATERIAL_BACKEND_ARBFP];
-
- _COGL_GET_CONTEXT (ctx, FALSE);
-
- if (priv->source)
- {
- GLenum gl_error;
- COGL_STATIC_COUNTER (backend_arbfp_compile_counter,
- "arbfp compile counter",
- "Increments each time a new ARBfp "
- "program is compiled",
- 0 /* no application private data */);
-
- COGL_COUNTER_INC (_cogl_uprof_context, backend_arbfp_compile_counter);
-
- g_string_append (priv->source, "MOV result.color,output;\n");
- g_string_append (priv->source, "END\n");
-
- if (G_UNLIKELY (cogl_debug_flags & COGL_DEBUG_SHOW_SOURCE))
- g_message ("material program:\n%s", priv->source->str);
-
- GE (glGenPrograms (1, &priv->gl_program));
-
- GE (glBindProgram (GL_FRAGMENT_PROGRAM_ARB, priv->gl_program));
-
- while ((gl_error = glGetError ()) != GL_NO_ERROR)
- ;
- glProgramString (GL_FRAGMENT_PROGRAM_ARB,
- GL_PROGRAM_FORMAT_ASCII_ARB,
- priv->source->len,
- priv->source->str);
- if (glGetError () != GL_NO_ERROR)
- {
- g_warning ("\n%s\n%s",
- priv->source->str,
- glGetString (GL_PROGRAM_ERROR_STRING_ARB));
- }
-
- priv->source = NULL;
-
- g_free (priv->sampled);
- priv->sampled = NULL;
- }
- else
- GE (glBindProgram (GL_FRAGMENT_PROGRAM_ARB, priv->gl_program));
-
- use_program (COGL_INVALID_HANDLE, COGL_MATERIAL_PROGRAM_TYPE_ARBFP);
-
- return TRUE;
-}
-
-static void
-_cogl_material_backend_arbfp_material_pre_change_notify (
- CoglMaterial *material,
- CoglMaterialState change,
- const CoglColor *new_color)
-{
- CoglMaterialBackendARBfpPrivate *priv =
- material->backend_privs[COGL_MATERIAL_BACKEND_ARBFP];
- static const unsigned long fragment_op_changes =
- COGL_MATERIAL_STATE_LAYERS;
- /* TODO: COGL_MATERIAL_STATE_FOG */
-
- _COGL_GET_CONTEXT (ctx, NO_RETVAL);
-
- if (material->backend_priv_set_mask & COGL_MATERIAL_BACKEND_ARBFP_MASK &&
- priv->gl_program &&
- change & fragment_op_changes)
- {
- GE (glDeletePrograms (1, &priv->gl_program));
- priv->gl_program = 0;
- }
-}
-
-static gboolean
-invalidate_arbfp_authority_cache_cb (CoglMaterial *material,
- void *user_data)
-{
- invalidate_arbfp_authority_cache (material);
- return TRUE;
-}
-
-static void
-_cogl_material_backend_arbfp_material_set_parent_notify (
- CoglMaterial *material)
-{
- /* Any arbfp authority cache associated with this material or
- * any of its descendants will now be invalid. */
- invalidate_arbfp_authority_cache (material);
-
- _cogl_material_foreach_child (material,
- invalidate_arbfp_authority_cache_cb,
- NULL);
-}
-
-static void
-_cogl_material_backend_arbfp_layer_pre_change_notify (
- CoglMaterialLayer *layer,
- CoglMaterialLayerState changes)
-{
- /* TODO: we could be saving snippets of texture combine code along
- * with each layer and then when a layer changes we would just free
- * the snippet. */
- return;
-}
-
-static void
-_cogl_material_backend_arbfp_free_priv (CoglMaterial *material)
-{
- _COGL_GET_CONTEXT (ctx, NO_RETVAL);
-
- if (material->backend_priv_set_mask & COGL_MATERIAL_BACKEND_ARBFP_MASK)
- {
- CoglMaterialBackendARBfpPrivate *priv =
- material->backend_privs[COGL_MATERIAL_BACKEND_ARBFP];
-
- glDeletePrograms (1, &priv->gl_program);
- if (priv->sampled)
- g_free (priv->sampled);
- g_slice_free (CoglMaterialBackendARBfpPrivate, priv);
- material->backend_priv_set_mask &= ~COGL_MATERIAL_BACKEND_ARBFP_MASK;
- }
-}
-
-static const CoglMaterialBackend _cogl_material_arbfp_backend =
-{
- _cogl_material_backend_arbfp_get_max_texture_units,
- _cogl_material_backend_arbfp_start,
- _cogl_material_backend_arbfp_add_layer,
- _cogl_material_backend_arbfp_passthrough,
- _cogl_material_backend_arbfp_end,
- _cogl_material_backend_arbfp_material_pre_change_notify,
- _cogl_material_backend_arbfp_material_set_parent_notify,
- _cogl_material_backend_arbfp_layer_pre_change_notify,
- _cogl_material_backend_arbfp_free_priv,
- NULL
-};
-
-#endif /* COGL_MATERIAL_BACKEND_ARBFP */
-
-static int
-_cogl_material_backend_fixed_get_max_texture_units (void)
-{
- _COGL_GET_CONTEXT (ctx, 0);
-
- /* This function is called quite often so we cache the value to
- avoid too many GL calls */
- if (ctx->max_texture_units == -1)
- {
- ctx->max_texture_units = 1;
- GE (glGetIntegerv (GL_MAX_TEXTURE_UNITS,
- &ctx->max_texture_units));
- }
-
- return ctx->max_texture_units;
-}
-
-static gboolean
-_cogl_material_backend_fixed_start (CoglMaterial *material,
- int n_layers,
- unsigned long materials_difference)
-{
- use_program (COGL_INVALID_HANDLE, COGL_MATERIAL_PROGRAM_TYPE_FIXED);
- return TRUE;
-}
-
-static gboolean
-_cogl_material_backend_fixed_add_layer (CoglMaterial *material,
- CoglMaterialLayer *layer,
- unsigned long layers_difference)
-{
- CoglTextureUnit *unit =
- _cogl_get_texture_unit (_cogl_material_layer_get_unit_index (layer));
- int unit_index = unit->index;
- int n_rgb_func_args;
- int n_alpha_func_args;
-
- _COGL_GET_CONTEXT (ctx, FALSE);
-
- /* XXX: Beware that since we are changing the active texture unit we
- * must make sure we don't call into other Cogl components that may
- * temporarily bind texture objects to query/modify parameters since
- * they will end up binding texture unit 1. See
- * _cogl_bind_gl_texture_transient for more details.
- */
- set_active_texture_unit (unit_index);
-
- if (layers_difference & COGL_MATERIAL_LAYER_STATE_COMBINE)
- {
- CoglMaterialLayer *authority =
- _cogl_material_layer_get_authority (layer,
- COGL_MATERIAL_LAYER_STATE_COMBINE);
- CoglMaterialLayerBigState *big_state = authority->big_state;
-
- GE (glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE));
-
- /* Set the combiner functions... */
- GE (glTexEnvi (GL_TEXTURE_ENV,
- GL_COMBINE_RGB,
- big_state->texture_combine_rgb_func));
- GE (glTexEnvi (GL_TEXTURE_ENV,
- GL_COMBINE_ALPHA,
- big_state->texture_combine_alpha_func));
-
- /*
- * Setup the function arguments...
- */
-
- /* For the RGB components... */
- n_rgb_func_args =
- get_n_args_for_combine_func (big_state->texture_combine_rgb_func);
-
- GE (glTexEnvi (GL_TEXTURE_ENV, GL_SRC0_RGB,
- big_state->texture_combine_rgb_src[0]));
- GE (glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_RGB,
- big_state->texture_combine_rgb_op[0]));
- if (n_rgb_func_args > 1)
- {
- GE (glTexEnvi (GL_TEXTURE_ENV, GL_SRC1_RGB,
- big_state->texture_combine_rgb_src[1]));
- GE (glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_RGB,
- big_state->texture_combine_rgb_op[1]));
- }
- if (n_rgb_func_args > 2)
- {
- GE (glTexEnvi (GL_TEXTURE_ENV, GL_SRC2_RGB,
- big_state->texture_combine_rgb_src[2]));
- GE (glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND2_RGB,
- big_state->texture_combine_rgb_op[2]));
- }
-
- /* For the Alpha component */
- n_alpha_func_args =
- get_n_args_for_combine_func (big_state->texture_combine_alpha_func);
-
- GE (glTexEnvi (GL_TEXTURE_ENV, GL_SRC0_ALPHA,
- big_state->texture_combine_alpha_src[0]));
- GE (glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA,
- big_state->texture_combine_alpha_op[0]));
- if (n_alpha_func_args > 1)
- {
- GE (glTexEnvi (GL_TEXTURE_ENV, GL_SRC1_ALPHA,
- big_state->texture_combine_alpha_src[1]));
- GE (glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_ALPHA,
- big_state->texture_combine_alpha_op[1]));
- }
- if (n_alpha_func_args > 2)
- {
- GE (glTexEnvi (GL_TEXTURE_ENV, GL_SRC2_ALPHA,
- big_state->texture_combine_alpha_src[2]));
- GE (glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND2_ALPHA,
- big_state->texture_combine_alpha_op[2]));
- }
- }
-
- if (layers_difference & COGL_MATERIAL_LAYER_STATE_COMBINE)
- {
- CoglMaterialLayer *authority =
- _cogl_material_layer_get_authority (layer,
- COGL_MATERIAL_LAYER_STATE_COMBINE);
- CoglMaterialLayerBigState *big_state = authority->big_state;
-
- GE (glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR,
- big_state->texture_combine_constant));
- }
-
- return TRUE;
-}
-
-static gboolean
-_cogl_material_backend_fixed_end (CoglMaterial *material,
- unsigned long materials_difference)
-{
- return TRUE;
-}
-
-static const CoglMaterialBackend _cogl_material_fixed_backend =
-{
- _cogl_material_backend_fixed_get_max_texture_units,
- _cogl_material_backend_fixed_start,
- _cogl_material_backend_fixed_add_layer,
- NULL, /* passthrough */
- _cogl_material_backend_fixed_end,
- NULL, /* material_change_notify */
- NULL, /* material_set_parent_notify */
- NULL, /* layer_change_notify */
- NULL /* free_priv */
-};
-
static void
_cogl_material_layer_get_texture_info (CoglMaterialLayer *layer,
CoglHandle *texture,
&gl_texture,
&gl_target);
- set_active_texture_unit (unit_index);
+ _cogl_set_active_texture_unit (unit_index);
/* NB: There are several Cogl components and some code in
* Clutter that will temporarily bind arbitrary GL textures to
unit1 = _cogl_get_texture_unit (1);
if (unit1->enabled && unit1->dirty_gl_texture)
{
- set_active_texture_unit (1);
+ _cogl_set_active_texture_unit (1);
GE (glBindTexture (unit1->current_gl_target, unit1->gl_texture));
unit1->dirty_gl_texture = FALSE;
}
projects / profile / ivi / clutter.git / commitdiff