CoglMaterial: Implements sparse materials design

This is a complete overhaul of the data structures used to manage
CoglMaterial state.

We have these requirements that were aiming to meet:
(Note: the references to "renderlists" correspond to the effort to
support scenegraph level shuffling of Clutter actor primitives so we can
minimize GPU state changes)

Sparse State:
We wanted a design that allows sparse descriptions of state so it scales
well as we make CoglMaterial responsible for more and more state. It
needs to scale well in terms of memory usage and the cost of operations
we need to apply to materials such as comparing, copying and flushing
their state. I.e. we would rather have these things scale by the number
of real changes a material represents not by how much overall state
CoglMaterial becomes responsible for.

Cheap Copies:
As we add support for renderlists in Clutter we will need to be able to
get an immutable handle for a given material's current state so that we
can retain a record of a primitive with its associated material without
worrying that changes to the original material will invalidate that
record.

No more flush override options:
We want to get rid of the flush overrides mechanism we currently use to
deal with texture fallbacks, wrap mode changes and to handle the use of
highlevel CoglTextures that need to be resolved into lowlevel textures
before flushing the material state.

The flush options structure has been expanding in size and the structure
is logged with every journal entry so it is not an approach that scales
well at all. It also makes flushing material state that much more
complex.

Weak Materials:
Again for renderlists we need a way to create materials derived from
other materials but without the strict requirement that modifications to
the original material wont affect the derived ("weak") material. The
only requirement is that its possible to later check if the original
material has been changed.

A summary of the new design:

A CoglMaterial now basically represents a diff against its parent.
Each material has a single parent and a mask of state that it changes.

Each group of state (such as the blending state) has an "authority"
which is found by walking up from a given material through its ancestors
checking the difference mask until a match for that group is found.

There is only one root node to the graph of all materials, which is the
default material first created when Cogl is being initialized.

All the groups of state are divided into two types, such that
infrequently changed state belongs in a separate "BigState" structure
that is only allocated and attached to a material when necessary.

CoglMaterialLayers are another sparse structure. Like CoglMaterials they
represent a diff against their parent and all the layers are part of
another graph with the "default_layer_0" layer being the root node that
Cogl creates during initialization.

Copying a material is now basically just a case of slice allocating a
CoglMaterial, setting the parent to be the source being copied and
zeroing the mask of changes.

Flush overrides should now be handled by simply relying on the cheapness
of copying a material and making changes to it. (This will be done in a
follow on commit)

Weak material support will be added in a follow on commit.

1 files changed, 14 insertions, 7 deletions

diff --git a/cogl/cogl-context.h b/cogl/cogl-context.h
index 148bbaab..530184f0 100644
--- a/cogl/cogl-context.h
+++ b/cogl/cogl-context.h
@@ -49,10 +49,12 @@ typedef struct
   gboolean                features_cached;
 
   CoglHandle        default_material;
+  CoglHandle        default_layer_0;
+  CoglHandle        default_layer_n;
+  CoglHandle        dummy_layer_dependant;
 
   /* Enable cache */
   unsigned long     enable_flags;
-  guint8            color_alpha;
   gboolean          fog_enabled;
 
   gboolean          enable_backface_culling;
@@ -91,11 +93,12 @@ typedef struct
 
   /* Some simple caching, to minimize state changes... */
   CoglHandle	    current_material;
-  unsigned long     current_material_flags;
-  gboolean          current_material_fallback_layers;
-  gboolean          current_material_disable_layers;
-  GLuint            current_material_layer0_override;
+  unsigned long     current_material_changes_since_flush;
   gboolean          current_material_skip_gl_color;
+
+  GArray           *material0_nodes;
+  GArray           *material1_nodes;
+
   /* Bitmask of texture coordinates arrays that are enabled */
   CoglBitmask       texcoord_arrays_enabled;
   /* These are temporary bitmasks that are used when disabling
@@ -104,6 +107,8 @@ typedef struct
   CoglBitmask       texcoord_arrays_to_disable;
   CoglBitmask       temp_bitmask;
 
+  gboolean          gl_blend_enable_cache;
+
   /* PBOs */
   /* This can be used to check if a pbo is bound */
   CoglBuffer       *current_pbo;
@@ -143,9 +148,11 @@ typedef struct
   GLint             max_texture_image_units;
   GLint             max_activateable_texture_units;
 
-  CoglHandle        current_program;
+  /* Fragment processing programs */
+  CoglHandle              current_program;
+
   CoglMaterialProgramType current_use_program_type;
-  GLuint            current_gl_program;
+  GLuint                  current_gl_program;
 
   CoglContextDriver drv;
 } CoglContext;