Only things missing here from upstream are translations and .gitignore changes

diff --git a/cogl/Makefile.am b/cogl/Makefile.am

index 33214ab..80d3b09 100644

--- a/cogl/Makefile.am

+++ b/cogl/Makefile.am

@@ -349,6 +349,8 @@ cogl_sources_c = \

 	$(srcdir)/cogl-pipeline-snippet.c		\

 	$(srcdir)/cogl-pipeline-cache.h			\

 	$(srcdir)/cogl-pipeline-cache.c			\

+	$(srcdir)/cogl-pipeline-hash-table.h		\

+	$(srcdir)/cogl-pipeline-hash-table.c		\

 	$(srcdir)/cogl-material-compat.c		\

 	$(srcdir)/cogl-program.c			\

 	$(srcdir)/cogl-program-private.h		\

@@ -552,7 +554,7 @@ include $(top_srcdir)/build/autotools/Makefile.am.enums

 lib_LTLIBRARIES += libcogl.la

-libcogl_la_LIBADD = -lm $(COGL_DEP_LIBS) $(COGL_EXTRA_LDFLAGS)

+libcogl_la_LIBADD = $(LIBM) $(COGL_DEP_LIBS) $(COGL_EXTRA_LDFLAGS)

 if !USE_GLIB

 libcogl_la_LIBADD += $(top_builddir)/deps/glib/libglib.la

 libcogl_la_LIBADD += $(top_builddir)/deps/gmodule/libgmodule.la

diff --git a/cogl/cogl-bitmap-pixbuf.c b/cogl/cogl-bitmap-pixbuf.c

index a02b253..ad34234 100644

--- a/cogl/cogl-bitmap-pixbuf.c

+++ b/cogl/cogl-bitmap-pixbuf.c

@@ -125,11 +125,24 @@ _cogl_bitmap_from_file (CoglContext *ctx,

   /* allocate buffer big enough to hold pixel data */

   bmp = _cogl_bitmap_new_with_malloc_buffer (ctx,

                                              width, height,

-                                             COGL_PIXEL_FORMAT_ARGB_8888);

+                                             COGL_PIXEL_FORMAT_ARGB_8888,

+                                             error);

+  if (bmp == NULL)

+    {

+      CFRelease (image);

+      return NULL;

+    }

   rowstride = cogl_bitmap_get_rowstride (bmp);

   out_data = _cogl_bitmap_map (bmp,

                                COGL_BUFFER_ACCESS_WRITE,

-                               COGL_BUFFER_MAP_HINT_DISCARD);

+                               COGL_BUFFER_MAP_HINT_DISCARD,

+                               error);

+  if (out_data == NULL)

+    {

+      cogl_object_unref (bmp);

+      CFRelease (image);

+      return NULL;

+    }

   /* render to buffer */

   color_space = CGColorSpaceCreateWithName (kCGColorSpaceGenericRGB);

diff --git a/cogl/cogl-matrix.h b/cogl/cogl-matrix.h

index 90f3ea9..a136ea0 100644

--- a/cogl/cogl-matrix.h

+++ b/cogl/cogl-matrix.h

@@ -27,6 +27,8 @@

 #ifndef __COGL_MATRIX_H

 #define __COGL_MATRIX_H

+#include <cogl/cogl-defines.h>

+

 #ifdef COGL_HAS_GTYPE_SUPPORT

 #include <glib-object.h>

 #endif /* COGL_HAS_GTYPE_SUPPORT */

diff --git a/cogl/cogl-pipeline-cache.c b/cogl/cogl-pipeline-cache.c

index fab3614..df4c433 100644

--- a/cogl/cogl-pipeline-cache.c

+++ b/cogl/cogl-pipeline-cache.c

@@ -3,7 +3,7 @@

  *

  * An object oriented GL/GLES Abstraction/Utility Layer

  *

- * Copyright (C) 2011 Intel Corporation.

+ * Copyright (C) 2011, 2013 Intel Corporation.

  *

  * This library is free software; you can redistribute it and/or

  * modify it under the terms of the GNU Lesser General Public

@@ -32,133 +32,47 @@

 #include "cogl-context-private.h"

 #include "cogl-pipeline-private.h"

 #include "cogl-pipeline-cache.h"

+#include "cogl-pipeline-hash-table.h"

 struct _CoglPipelineCache

 {

-  GHashTable *fragment_hash;

-  GHashTable *vertex_hash;

-  GHashTable *combined_hash;

+  CoglPipelineHashTable fragment_hash;

+  CoglPipelineHashTable vertex_hash;

+  CoglPipelineHashTable combined_hash;

 };

-static unsigned int

-pipeline_fragment_hash (const void *data)

-{

-  unsigned int fragment_state;

-  unsigned int layer_fragment_state;

-

-  _COGL_GET_CONTEXT (ctx, 0);

-

-  fragment_state =

-    _cogl_pipeline_get_state_for_fragment_codegen (ctx);

-  layer_fragment_state =

-    _cogl_pipeline_get_layer_state_for_fragment_codegen (ctx);

-

-  return _cogl_pipeline_hash ((CoglPipeline *)data,

-                              fragment_state, layer_fragment_state,

-                              0);

-}

-

-static CoglBool

-pipeline_fragment_equal (const void *a, const void *b)

+CoglPipelineCache *

+_cogl_pipeline_cache_new (void)

 {

+  CoglPipelineCache *cache = g_new (CoglPipelineCache, 1);

+  unsigned long vertex_state;

+  unsigned long layer_vertex_state;

   unsigned int fragment_state;

   unsigned int layer_fragment_state;

   _COGL_GET_CONTEXT (ctx, 0);

+  vertex_state =

+    COGL_PIPELINE_STATE_AFFECTS_VERTEX_CODEGEN;

+  layer_vertex_state =

+    COGL_PIPELINE_LAYER_STATE_AFFECTS_VERTEX_CODEGEN;

   fragment_state =

     _cogl_pipeline_get_state_for_fragment_codegen (ctx);

   layer_fragment_state =

     _cogl_pipeline_get_layer_state_for_fragment_codegen (ctx);

-  return _cogl_pipeline_equal ((CoglPipeline *)a, (CoglPipeline *)b,

-                               fragment_state, layer_fragment_state,

-                               0);

-}

-

-static unsigned int

-pipeline_vertex_hash (const void *data)

-{

-  unsigned long vertex_state =

-    COGL_PIPELINE_STATE_AFFECTS_VERTEX_CODEGEN;

-  unsigned long layer_vertex_state =

-    COGL_PIPELINE_LAYER_STATE_AFFECTS_VERTEX_CODEGEN;

-

-  return _cogl_pipeline_hash ((CoglPipeline *)data,

-                              vertex_state, layer_vertex_state,

-                              0);

-}

-

-static CoglBool

-pipeline_vertex_equal (const void *a, const void *b)

-{

-  unsigned long vertex_state =

-    COGL_PIPELINE_STATE_AFFECTS_VERTEX_CODEGEN;

-  unsigned long layer_vertex_state =

-    COGL_PIPELINE_LAYER_STATE_AFFECTS_VERTEX_CODEGEN;

-

-  return _cogl_pipeline_equal ((CoglPipeline *)a, (CoglPipeline *)b,

-                               vertex_state, layer_vertex_state,

-                               0);

-}

-

-static unsigned int

-pipeline_combined_hash (const void *data)

-{

-  unsigned int combined_state;

-  unsigned int layer_combined_state;

-

-  _COGL_GET_CONTEXT (ctx, 0);

-

-  combined_state =

-    _cogl_pipeline_get_state_for_fragment_codegen (ctx) |

-    COGL_PIPELINE_STATE_AFFECTS_VERTEX_CODEGEN;

-  layer_combined_state =

-    _cogl_pipeline_get_layer_state_for_fragment_codegen (ctx) |

-    COGL_PIPELINE_LAYER_STATE_AFFECTS_VERTEX_CODEGEN;

-

-  return _cogl_pipeline_hash ((CoglPipeline *)data,

-                              combined_state, layer_combined_state,

-                              0);

-}

-

-static CoglBool

-pipeline_combined_equal (const void *a, const void *b)

-{

-  unsigned int combined_state;

-  unsigned int layer_combined_state;

-

-  _COGL_GET_CONTEXT (ctx, 0);

-

-  combined_state =

-    _cogl_pipeline_get_state_for_fragment_codegen (ctx) |

-    COGL_PIPELINE_STATE_AFFECTS_VERTEX_CODEGEN;

-  layer_combined_state =

-    _cogl_pipeline_get_layer_state_for_fragment_codegen (ctx) |

-    COGL_PIPELINE_LAYER_STATE_AFFECTS_VERTEX_CODEGEN;

-

-  return _cogl_pipeline_equal ((CoglPipeline *)a, (CoglPipeline *)b,

-                               combined_state, layer_combined_state,

-                               0);

-}

-

-CoglPipelineCache *

-_cogl_pipeline_cache_new (void)

-{

-  CoglPipelineCache *cache = g_new (CoglPipelineCache, 1);

-

-  cache->fragment_hash = g_hash_table_new_full (pipeline_fragment_hash,

-                                                pipeline_fragment_equal,

-                                                cogl_object_unref,

-                                                cogl_object_unref);

-  cache->vertex_hash = g_hash_table_new_full (pipeline_vertex_hash,

-                                              pipeline_vertex_equal,

-                                              cogl_object_unref,

-                                              cogl_object_unref);

-  cache->combined_hash = g_hash_table_new_full (pipeline_combined_hash,

-                                                pipeline_combined_equal,

-                                                cogl_object_unref,

-                                                cogl_object_unref);

+  _cogl_pipeline_hash_table_init (&cache->vertex_hash,

+                                  vertex_state,

+                                  layer_vertex_state,

+                                  "vertex shaders");

+  _cogl_pipeline_hash_table_init (&cache->fragment_hash,

+                                  fragment_state,

+                                  layer_fragment_state,

+                                  "fragment shaders");

+  _cogl_pipeline_hash_table_init (&cache->combined_hash,

+                                  vertex_state | fragment_state,

+                                  layer_vertex_state | layer_fragment_state,

+                                  "programs");

   return cache;

 }

@@ -166,9 +80,9 @@ _cogl_pipeline_cache_new (void)

 void

 _cogl_pipeline_cache_free (CoglPipelineCache *cache)

 {

-  g_hash_table_destroy (cache->fragment_hash);

-  g_hash_table_destroy (cache->vertex_hash);

-  g_hash_table_destroy (cache->combined_hash);

+  _cogl_pipeline_hash_table_destroy (&cache->fragment_hash);

+  _cogl_pipeline_hash_table_destroy (&cache->vertex_hash);

+  _cogl_pipeline_hash_table_destroy (&cache->combined_hash);

   g_free (cache);

 }

@@ -176,107 +90,22 @@ CoglPipeline *

 _cogl_pipeline_cache_get_fragment_template (CoglPipelineCache *cache,

                                             CoglPipeline *key_pipeline)

 {

-  CoglPipeline *template =

-    g_hash_table_lookup (cache->fragment_hash, key_pipeline);

-

-  if (template == NULL)

-    {

-      /* XXX: I wish there was a way to insert into a GHashTable with

-       * a pre-calculated hash value since there is a cost to

-       * calculating the hash of a CoglPipeline and in this case we

-       * know we have already called _cogl_pipeline_hash during the

-       * lookup so we could pass the value through to here to avoid

-       * hashing it again.

-       */

-

-      /* XXX: Any keys referenced by the hash table need to remain

-       * valid all the while that there are corresponding values,

-       * so for now we simply make a copy of the current authority

-       * pipeline.

-       *

-       * FIXME: A problem with this is that our key into the cache may

-       * hold references to some arbitrary user textures which will

-       * now be kept alive indefinitly which is a shame. A better

-       * solution will be to derive a special "key pipeline" from the

-       * authority which derives from the base Cogl pipeline (to avoid

-       * affecting the lifetime of any other pipelines) and only takes

-       * a copy of the state that relates to the fragment shader and

-       * references small dummy textures instead of potentially large

-       * user textures. */

-      template = cogl_pipeline_copy (key_pipeline);

-

-      g_hash_table_insert (cache->fragment_hash,

-                           template,

-                           cogl_object_ref (template));

-

-      if (G_UNLIKELY (g_hash_table_size (cache->fragment_hash) > 50))

-        {

-          static CoglBool seen = FALSE;

-          if (!seen)

-            g_warning ("Over 50 separate fragment shaders have been "

-                       "generated which is very unusual, so something "

-                       "is probably wrong!\n");

-          seen = TRUE;

-        }

-    }

-

-  return template;

+  return _cogl_pipeline_hash_table_get (&cache->fragment_hash,

+                                        key_pipeline);

 }

 CoglPipeline *

 _cogl_pipeline_cache_get_vertex_template (CoglPipelineCache *cache,

                                           CoglPipeline *key_pipeline)

 {

-  CoglPipeline *template =

-    g_hash_table_lookup (cache->vertex_hash, key_pipeline);

-

-  if (template == NULL)

-    {

-      template = cogl_pipeline_copy (key_pipeline);

-

-      g_hash_table_insert (cache->vertex_hash,

-                           template,

-                           cogl_object_ref (template));

-

-      if (G_UNLIKELY (g_hash_table_size (cache->vertex_hash) > 50))

-        {

-          static CoglBool seen = FALSE;

-          if (!seen)

-            g_warning ("Over 50 separate vertex shaders have been "

-                       "generated which is very unusual, so something "

-                       "is probably wrong!\n");

-          seen = TRUE;

-        }

-    }

-

-  return template;

+  return _cogl_pipeline_hash_table_get (&cache->vertex_hash,

+                                        key_pipeline);

 }

 CoglPipeline *

 _cogl_pipeline_cache_get_combined_template (CoglPipelineCache *cache,

                                             CoglPipeline *key_pipeline)

 {

-  CoglPipeline *template =

-    g_hash_table_lookup (cache->combined_hash, key_pipeline);

-

-  if (template == NULL)

-    {

-      template = cogl_pipeline_copy (key_pipeline);

-

-      g_hash_table_insert (cache->combined_hash,

-                           template,

-                           cogl_object_ref (template));

-

-      if (G_UNLIKELY (g_hash_table_size (cache->combined_hash) > 50))

-        {

-          static CoglBool seen = FALSE;

-          if (!seen)

-            g_warning ("Over 50 separate programs have been "

-                       "generated which is very unusual, so something "

-                       "is probably wrong!\n");

-          seen = TRUE;

-        }

-    }

-

-  return template;

+  return _cogl_pipeline_hash_table_get (&cache->combined_hash,

+                                        key_pipeline);

 }

diff --git a/cogl/cogl-pipeline-hash-table.c b/cogl/cogl-pipeline-hash-table.c

new file mode 100644

index 0000000..8921efc

--- /dev/null

+++ b/cogl/cogl-pipeline-hash-table.c

@@ -0,0 +1,153 @@

+/*

+ * Cogl

+ *

+ * An object oriented GL/GLES Abstraction/Utility Layer

+ *

+ * Copyright (C) 2013 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:

+ *   Neil Roberts <neil@linux.intel.com>

+ *   Robert Bragg <robert@linux.intel.com>

+ */

+

+#ifdef HAVE_CONFIG_H

+#include "config.h"

+#endif

+

+#include "cogl-context-private.h"

+#include "cogl-pipeline-private.h"

+#include "cogl-pipeline-hash-table.h"

+

+typedef struct

+{

+  /* The template pipeline */

+  CoglPipeline *pipeline;

+

+  /* Calculating the hash is a little bit expensive for pipelines so

+   * we don't want to do it repeatedly for entries that are already in

+   * the hash table. Instead we cache the value here and calculate it

+   * outside of the GHashTable. */

+  unsigned int hash_value;

+

+  /* GHashTable annoyingly doesn't let us pass a user data pointer to

+   * the hash and equal functions so to work around it we have to

+   * store the pointer in every hash table entry. We will use this

+   * entry as both the key and the value */

+  CoglPipelineHashTable *hash;

+} CoglPipelineHashTableEntry;

+

+static void

+value_destroy_cb (void *value)

+{

+  CoglPipelineHashTableEntry *entry = value;

+

+  cogl_object_unref (entry->pipeline);

+

+  g_slice_free (CoglPipelineHashTableEntry, entry);

+}

+

+static unsigned int

+entry_hash (const void *data)

+{

+  const CoglPipelineHashTableEntry *entry = data;

+

+  return entry->hash_value;

+}

+

+static CoglBool

+entry_equal (const void *a,

+             const void *b)

+{

+  const CoglPipelineHashTableEntry *entry_a = a;

+  const CoglPipelineHashTableEntry *entry_b = b;

+  const CoglPipelineHashTable *hash = entry_a->hash;

+

+  return _cogl_pipeline_equal (entry_a->pipeline,

+                               entry_b->pipeline,

+                               hash->main_state,

+                               hash->layer_state,

+                               0);

+}

+

+void

+_cogl_pipeline_hash_table_init (CoglPipelineHashTable *hash,

+                                unsigned int main_state,

+                                unsigned int layer_state,

+                                const char *debug_string)

+{

+  hash->n_unique_pipelines = 0;

+  hash->debug_string = debug_string;

+  hash->main_state = main_state;

+  hash->layer_state = layer_state;

+  hash->table = g_hash_table_new_full (entry_hash,

+                                       entry_equal,

+                                       NULL, /* key destroy */

+                                       value_destroy_cb);

+}

+

+void

+_cogl_pipeline_hash_table_destroy (CoglPipelineHashTable *hash)

+{

+  g_hash_table_destroy (hash->table);

+}

+

+CoglPipeline *

+_cogl_pipeline_hash_table_get (CoglPipelineHashTable *hash,

+                               CoglPipeline *key_pipeline)

+{

+  CoglPipelineHashTableEntry dummy_entry;

+  CoglPipelineHashTableEntry *entry;

+  unsigned int copy_state;

+

+  dummy_entry.pipeline = key_pipeline;

+  dummy_entry.hash = hash;

+  dummy_entry.hash_value = _cogl_pipeline_hash (key_pipeline,

+                                                hash->main_state,

+                                                hash->layer_state,

+                                                0);

+  entry = g_hash_table_lookup (hash->table, &dummy_entry);

+

+  if (entry)

+    return entry->pipeline;

+

+  if (hash->n_unique_pipelines == 50)

+    g_warning ("Over 50 separate %s have been generated which is very "

+               "unusual, so something is probably wrong!\n",

+               hash->debug_string);

+

+  entry = g_slice_new (CoglPipelineHashTableEntry);

+  entry->hash = hash;

+  entry->hash_value = dummy_entry.hash_value;

+

+  copy_state = hash->main_state;

+  if (hash->layer_state)

+    copy_state |= COGL_PIPELINE_STATE_LAYERS;

+

+  /* Create a new pipeline that is a child of the root pipeline

+   * instead of a normal copy so that the template pipeline won't hold

+   * a reference to the original pipeline */

+  entry->pipeline = _cogl_pipeline_deep_copy (key_pipeline,

+                                              copy_state,

+                                              hash->layer_state);

+

+  g_hash_table_insert (hash->table, entry, entry);

+

+  hash->n_unique_pipelines++;

+

+  return entry->pipeline;

+}

diff --git a/cogl/cogl-pipeline-hash-table.h b/cogl/cogl-pipeline-hash-table.h

new file mode 100644

index 0000000..1b0a0d9

--- /dev/null

+++ b/cogl/cogl-pipeline-hash-table.h

@@ -0,0 +1,69 @@

+/*

+ * Cogl

+ *

+ * An object oriented GL/GLES Abstraction/Utility Layer

+ *

+ * Copyright (C) 2013 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/>.

+ *

+ *

+ */

+

+#ifndef __COGL_PIPELINE_HASH_H__

+#define __COGL_PIPELINE_HASH_H__

+

+#include "cogl-pipeline.h"

+

+typedef struct

+{

+  /* Total number of pipelines that were ever added to the hash. This

+   * is not decremented when a pipeline is removed. It is only used to

+   * generate a warning if an unusually high number of pipelines are

+   * generated */

+  int n_unique_pipelines;

+

+  /* String that will be used to describe the usage of this hash table

+   * in the debug warning when too many pipelines are generated. This

+   * must be a static string because it won't be copied or freed */

+  const char *debug_string;

+

+  unsigned int main_state;

+  unsigned int layer_state;

+

+  GHashTable *table;

+} CoglPipelineHashTable;

+

+void

+_cogl_pipeline_hash_table_init (CoglPipelineHashTable *hash,

+                                unsigned int main_state,

+                                unsigned int layer_state,

+                                const char *debug_string);

+

+void

+_cogl_pipeline_hash_table_destroy (CoglPipelineHashTable *hash);

+

+/*

+ * Gets a pipeline from the hash that has the same state as

+ * @key_pipeline according to the limited state bits passed to

+ * _cogl_pipeline_hash_table_init(). If there is no matching pipelines

+ * already then a copy of key_pipeline is stored in the hash so that

+ * it will be used next time the function is called with a similar

+ * pipeline. In that case the copy itself will be returned

+ */

+CoglPipeline *

+_cogl_pipeline_hash_table_get (CoglPipelineHashTable *hash,

+                               CoglPipeline *key_pipeline);

+

+#endif /* __COGL_PIPELINE_HASH_H__ */

diff --git a/cogl/cogl-pipeline-layer-private.h b/cogl/cogl-pipeline-layer-private.h

index 125b967..7577559 100644

--- a/cogl/cogl-pipeline-layer-private.h

+++ b/cogl/cogl-pipeline-layer-private.h

@@ -358,6 +358,11 @@ _cogl_pipeline_layer_get_wrap_mode_t (CoglPipelineLayer *layer);

 CoglPipelineWrapMode

 _cogl_pipeline_layer_get_wrap_mode_p (CoglPipelineLayer *layer);

+void

+_cogl_pipeline_layer_copy_differences (CoglPipelineLayer *dest,

+                                       CoglPipelineLayer *src,

+                                       unsigned long differences);

+

 unsigned long

 _cogl_pipeline_layer_compare_differences (CoglPipelineLayer *layer0,

                                           CoglPipelineLayer *layer1);

diff --git a/cogl/cogl-pipeline-layer.c b/cogl/cogl-pipeline-layer.c

index d9590c8..9bc26ef 100644

--- a/cogl/cogl-pipeline-layer.c

+++ b/cogl/cogl-pipeline-layer.c

@@ -42,6 +42,8 @@

 #include "cogl-context-private.h"

 #include "cogl-texture-private.h"

+#include <string.h>

+

 static void

 _cogl_pipeline_layer_free (CoglPipelineLayer *layer);

@@ -146,6 +148,107 @@ _cogl_get_n_args_for_combine_func (CoglPipelineCombineFunc func)

   return 0;

 }

+void

+_cogl_pipeline_layer_copy_differences (CoglPipelineLayer *dest,

+                                       CoglPipelineLayer *src,

+                                       unsigned long differences)

+{

+  CoglPipelineLayerBigState *big_dest, *big_src;

+

+  if ((differences & COGL_PIPELINE_LAYER_STATE_NEEDS_BIG_STATE) &&

+      !dest->has_big_state)

+    {

+      dest->big_state = g_slice_new (CoglPipelineLayerBigState);

+      dest->has_big_state = TRUE;

+    }

+

+  big_dest = dest->big_state;

+  big_src = src->big_state;

+

+  dest->differences |= differences;

+

+  while (differences)

+    {

+      int index = _cogl_util_ffs (differences) - 1;

+

+      differences &= ~(1 << index);

+

+      /* This convoluted switch statement is just here so that we'll

+       * get a warning if a new state is added without handling it

+       * here */

+      switch (index)

+        {

+        case COGL_PIPELINE_LAYER_STATE_COUNT:

+        case COGL_PIPELINE_LAYER_STATE_UNIT_INDEX:

+          g_warn_if_reached ();

+          break;

+

+        case COGL_PIPELINE_LAYER_STATE_TEXTURE_TYPE_INDEX:

+          dest->texture_type = src->texture_type;

+          break;

+

+        case COGL_PIPELINE_LAYER_STATE_TEXTURE_DATA_INDEX:

+          dest->texture = src->texture;

+          if (dest->texture)

+            cogl_object_ref (dest->texture);

+          break;

+

+        case COGL_PIPELINE_LAYER_STATE_SAMPLER_INDEX:

+          dest->sampler_cache_entry = src->sampler_cache_entry;

+          break;

+

+        case COGL_PIPELINE_LAYER_STATE_COMBINE_INDEX:

+          {

+            CoglPipelineCombineFunc func;

+            int n_args, i;

+

+            func = big_src->texture_combine_rgb_func;

+            big_dest->texture_combine_rgb_func = func;

+            n_args = _cogl_get_n_args_for_combine_func (func);

+            for (i = 0; i < n_args; i++)

+              {

+                big_dest->texture_combine_rgb_src[i] =

+                  big_src->texture_combine_rgb_src[i];

+                big_dest->texture_combine_rgb_op[i] =

+                  big_src->texture_combine_rgb_op[i];

+              }

+

+            func = big_src->texture_combine_alpha_func;

+            big_dest->texture_combine_alpha_func = func;

+            n_args = _cogl_get_n_args_for_combine_func (func);

+            for (i = 0; i < n_args; i++)

+              {

+                big_dest->texture_combine_alpha_src[i] =

+                  big_src->texture_combine_alpha_src[i];

+                big_dest->texture_combine_alpha_op[i] =

+                  big_src->texture_combine_alpha_op[i];

+              }

+          }

+          break;

+

+        case COGL_PIPELINE_LAYER_STATE_COMBINE_CONSTANT_INDEX:

+          memcpy (big_dest->texture_combine_constant,

+                  big_src->texture_combine_constant,

+                  sizeof (big_dest->texture_combine_constant));

+          break;

+

+        case COGL_PIPELINE_LAYER_STATE_POINT_SPRITE_COORDS_INDEX:

+          big_dest->point_sprite_coords = big_src->point_sprite_coords;