Re-design the matrix stack using a graph of ops

This re-designs the matrix stack so we now keep track of each separate
operation such as rotating, scaling, translating and multiplying as
immutable, ref-counted nodes in a graph.

Being a "graph" here means that different transformations composed of
a sequence of linked operation nodes may share nodes.

The first node in a matrix-stack is always a LOAD_IDENTITY operation.

As an example consider if an application where to draw three rectangles
A, B and C something like this:

cogl_framebuffer_scale (fb, 2, 2, 2);
cogl_framebuffer_push_matrix(fb);

  cogl_framebuffer_translate (fb, 10, 0, 0);

  cogl_framebuffer_push_matrix(fb);

    cogl_framebuffer_rotate (fb, 45, 0, 0, 1);
    cogl_framebuffer_draw_rectangle (...); /* A */

  cogl_framebuffer_pop_matrix(fb);

  cogl_framebuffer_draw_rectangle (...); /* B */

cogl_framebuffer_pop_matrix(fb);

cogl_framebuffer_push_matrix(fb);
  cogl_framebuffer_set_modelview_matrix (fb, &mv);
  cogl_framebuffer_draw_rectangle (...); /* C */
cogl_framebuffer_pop_matrix(fb);

That would result in a graph of nodes like this:

LOAD_IDENTITY
      |
    SCALE
    /     \
SAVE       LOAD
  |           |
TRANSLATE    RECTANGLE(C)
  |     \
SAVE    RECTANGLE(B)
  |
ROTATE
  |
RECTANGLE(A)

Each push adds a SAVE operation which serves as a marker to rewind too
when a corresponding pop is issued and also each SAVE node may also
store a cached matrix representing the composition of all its ancestor
nodes. This means if we repeatedly need to resolve a real CoglMatrix
for a given node then we don't need to repeat the composition.

Some advantages of this design are:
- A single pointer to any node in the graph can now represent a
  complete, immutable transformation that can be logged for example
  into a journal. Previously we were storing a full CoglMatrix in
  each journal entry which is 16 floats for the matrix itself as well
  as space for flags and another 16 floats for possibly storing a
  cache of the inverse. This means that we significantly reduce
  the size of the journal when drawing lots of primitives and we also
  avoid copying over 128 bytes per entry.
- It becomes much cheaper to check for equality. In cases where some
  (unlikely) false negatives are allowed simply comparing the pointers
  of two matrix stack graph entries is enough. Previously we would use
  memcmp() to compare matrices.
- It becomes easier to do comparisons of transformations. By looking
  for the common ancestry between nodes we can determine the operations
  that differentiate the transforms and use those to gain a high level
  understanding of the differences. For example we use this in the
  journal to be able to efficiently determine when two rectangle
  transforms only differ by some translation so that we can perform
  software clipping.

Reviewed-by: Neil Roberts <neil@linux.intel.com>

1 files changed, 22 insertions, 15 deletions

diff --git a/cogl/cogl-clip-stack.h b/cogl/cogl-clip-stack.h
index 04d8c307..48ab800e 100644
--- a/cogl/cogl-clip-stack.h
+++ b/cogl/cogl-clip-stack.h
@@ -28,6 +28,7 @@
 #include "cogl-matrix.h"
 #include "cogl-primitive.h"
 #include "cogl-framebuffer.h"
+#include "cogl-matrix-stack.h"
 
 /* The clip stack works like a GSList where only a pointer to the top
    of the stack is stored. The empty clip stack is represented simply
@@ -112,13 +113,13 @@ struct _CoglClipStack
 
 struct _CoglClipStackRect
 {
-  CoglClipStack     _parent_data;
+  CoglClipStack _parent_data;
 
   /* The rectangle for this clip */
-  float                  x0;
-  float                  y0;
-  float                  x1;
-  float                  y1;
+  float x0;
+  float y0;
+  float x1;
+  float y1;
 
   /* If this is true then the clip for this rectangle is entirely
      described by the scissor bounds. This implies that the rectangle
@@ -128,15 +129,15 @@ struct _CoglClipStackRect
      modelview matrix is that same as when a rectangle is added to the
      journal. In that case we can use the original clip coordinates
      and modify the rectangle instead. */
-  CoglBool               can_be_scissor;
+  CoglBool can_be_scissor;
 
   /* The matrix that was current when the clip was set */
-  CoglMatrix             matrix;
+  CoglMatrixEntry *matrix_entry;
 };
 
 struct _CoglClipStackWindowRect
 {
-  CoglClipStack     _parent_data;
+  CoglClipStack _parent_data;
 
   /* The window rect clip doesn't need any specific data because it
      just adds to the scissor clip */
@@ -144,12 +145,12 @@ struct _CoglClipStackWindowRect
 
 struct _CoglClipStackPath
 {
-  CoglClipStack     _parent_data;
+  CoglClipStack _parent_data;
 
   /* The matrix that was current when the clip was set */
-  CoglMatrix             matrix;
+  CoglMatrixEntry *matrix_entry;
 
-  CoglPath              *path;
+  CoglPath *path;
 };
 
 struct _CoglClipStackPrimitive
@@ -157,7 +158,7 @@ struct _CoglClipStackPrimitive
   CoglClipStack _parent_data;
 
   /* The matrix that was current when the clip was set */
-  CoglMatrix matrix;
+  CoglMatrixEntry *matrix_entry;
 
   CoglPrimitive *primitive;
 
@@ -180,12 +181,16 @@ _cogl_clip_stack_push_rectangle (CoglClipStack *stack,
                                  float y_1,
                                  float x_2,
                                  float y_2,
-                                 const CoglMatrix *modelview_matrix);
+                                 CoglMatrixEntry *modelview_entry,
+                                 CoglMatrixEntry *projection_entry,
+                                 const float *viewport);
 
 CoglClipStack *
 _cogl_clip_stack_push_from_path (CoglClipStack *stack,
                                  CoglPath *path,
-                                 const CoglMatrix *modelview_matrix);
+                                 CoglMatrixEntry *modelview_entry,
+                                 CoglMatrixEntry *projection_entry,
+                                 const float *viewport);
 
 CoglClipStack *
 _cogl_clip_stack_push_primitive (CoglClipStack *stack,
@@ -194,7 +199,9 @@ _cogl_clip_stack_push_primitive (CoglClipStack *stack,
                                  float bounds_y1,
                                  float bounds_x2,
                                  float bounds_y2,
-                                 const CoglMatrix *modelview_matrix);
+                                 CoglMatrixEntry *modelview_entry,
+                                 CoglMatrixEntry *projection_entry,
+                                 const float *viewport);
 
 CoglClipStack *
 _cogl_clip_stack_pop (CoglClipStack *stack);