spec=1.4.0..1.6.0
commit dc56d908edb89fce99fcb9b911c53c91ee1be8a2
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Jan 24 18:42:28 2011 +0000

    pipeline: fix for _init_multi_property_sparse_state
    
    When copying COMBINE state in
    _cogl_pipeline_layer_init_multi_property_sparse_state we would read some
    state from the destination layer (invalid data potentially), then
    redundantly set the value back on the destination. This was picked up by
    valgrind, and the code is now more careful about how it references the
    src layer vs the destination layer.

 cogl/cogl-pipeline.c |   27 ++++++++++++++-------------
 1 files changed, 14 insertions(+), 13 deletions(-)

commit 325c620f81b4d164a066f246af7f2c5af06f4608
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Jan 21 19:05:23 2011 +0000

    framebuffer: flush journal when switching framebuffers
    
    There is currently a problem with per-framebuffer journals in that it's
    possible to create a framebuffer from a texture which then gets rendered
    too but the framebuffer (and corresponding journal) can be freed before
    the texture gets used to draw with.
    
    Conceptually we want to make sure when freeing a framebuffer that - if
    it is associated with a texture - we flush the journal as the last thing
    before really freeing the framebuffer's meta data. Technically though
    this is awkward to implement since the obvious mechanism for us to be
    notified about the framebuffer's destruction (by setting some user data
    internally with a callback) notifies when the framebuffer has a
    ref-count of 0. This means we'd have to be careful what we do with the
    framebuffer to consider e.g. recursive destruction; anything that would
    set more user data on the framebuffer while it is being destroyed and
    ensuring nothing else gets notified of the framebuffer's destruction
    before the journal has been flushed.
    
    For simplicity, for now, this patch provides another solution which is
    to flush framebuffer journals whenever we switch away from a given
    framebuffer via cogl_set_framebuffer or cogl_push/pop_framebuffer. The
    disadvantage of this approach is that we can't batch all the geometry of
    a scene that involves intermediate renders to offscreen framebufers.
    Clutter is doing this more and more with applications that use the
    ClutterEffect APIs so this is a shame. Hopefully this will only be a
    stop-gap solution while we consider how to reliably support journal
    logging across framebuffer changes.

 cogl/cogl-framebuffer.c |   26 ++++++++++++++++++++++----
 1 files changed, 22 insertions(+), 4 deletions(-)

commit 2b812d3d049ce450df2f1f335ea6643c49d7ab0d
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Jan 24 17:32:06 2011 +0000

    cogl-clip-stack: Fix flushing multiple stencil rectangles
    
    When flushing a clip stack that contains more than one rectangle which
    needs to use the stencil buffer the code takes a different path so
    that it can combine the new rectangle with the existing contents of
    the stencil buffer. However it was not correctly flushing the
    modelview and projection matrices so that rectangle would be in the
    wrong place.

 cogl/cogl-clip-stack.c |   16 ++++++++--------
 1 files changed, 8 insertions(+), 8 deletions(-)

commit 2ddab50ae45cba95a0188165166fec4a6057bcfb
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Jan 24 16:36:56 2011 +0000

    cogl-debug: Add a debug option for tracing clipping
    
    This adds a COGL_DEBUG=clipping option that reports how the clip is
    being flushed. This is needed to determine whether the scissor,
    stencil clip planes or software clipping is being used.

 cogl/cogl-clip-stack.c    |   12 ++++++++++++
 cogl/cogl-debug-options.h |    5 +++++
 cogl/cogl-debug.c         |    3 ++-
 cogl/cogl-debug.h         |    1 +
 cogl/cogl-journal.c       |    2 ++
 5 files changed, 22 insertions(+), 1 deletions(-)

commit c4a94439de2700c550da742143c46ee7e72e7f62
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Jan 24 14:28:00 2011 +0000

    cogl-debug: Split the flags to support more than 32
    
    The CoglDebugFlags are now stored in an array of unsigned ints rather
    than a single variable. The flags are accessed using macros instead of
    directly peeking at the cogl_debug_flags variable. The index values
    are stored in the enum rather than the actual mask values so that the
    enum doesn't need to be more than 32 bits wide. The hope is that the
    code to determine the index into the array can be optimized out by the
    compiler so it should have exactly the same performance as the old
    code.

 cogl/cogl-atlas-texture.c          |    2 +-
 cogl/cogl-attribute.c              |    8 ++--
 cogl/cogl-blend-string.c           |   14 +++---
 cogl/cogl-context.c                |   10 ++--
 cogl/cogl-debug.c                  |   85 ++++++++++++++++++++++-------
 cogl/cogl-debug.h                  |  105 ++++++++++++++++++++++++------------
 cogl/cogl-framebuffer.c            |    4 +-
 cogl/cogl-journal.c                |   38 +++++++-------
 cogl/cogl-matrix-private.h         |    2 +-
 cogl/cogl-pipeline-fragend-arbfp.c |    6 +-
 cogl/cogl-pipeline-fragend-fixed.c |    6 +-
 cogl/cogl-pipeline-vertend-fixed.c |    2 +-
 cogl/cogl-pipeline.c               |    2 +-
 cogl/cogl-profile.c                |   10 ++--
 cogl/cogl-rectangle-map.c          |    4 +-
 cogl/cogl-shader.c                 |    4 +-
 16 files changed, 191 insertions(+), 111 deletions(-)

commit 4bb08ba00b4d572b3201a833377304b88f66e3c3
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Jan 14 11:11:44 2011 +0000

    cogl-pipeline: Flush the lighting params in common code not vertend
    
    The lighting parameters such as the diffuse and ambient colors were
    previously only flushed in the fixed vertend. This meant that if a
    vertex shader was used then they would not be set. The lighting
    parameters are uniforms which are just as useful in a fragment shader
    so it doesn't really make sense to set them in the vertend. They are
    now flushed in the common cogl-pipeline-opengl code but the code is
    #ifdef'd for GLES2 because they need to be part of the progend in that
    case.

 cogl/cogl-pipeline-opengl.c        |   25 ++++++++++++++++++++++++-
 cogl/cogl-pipeline-vertend-fixed.c |   19 -------------------
 2 files changed, 24 insertions(+), 20 deletions(-)

commit 242d9a5002be4ffd35873e84c3cd01e82b1fe114
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Jan 13 18:24:22 2011 +0000

    cogl-pipeline-progend-glsl: Generalize updating GLES2 uniforms
    
    The uniforms for the alpha test reference value and point size on
    GLES2 are updating using similar code. This generalizes the code so
    that there is a static array of predefined builtin uniforms which
    contains the uniform name, a pointer to a function to get the value
    from the pipeline, a pointer to a function to update the uniform and a
    flag representing which CoglPipelineState change affects the
    uniform. The uniforms are then updated in a loop. This should simplify
    adding more builtin uniforms.

 cogl/cogl-pipeline-progend-glsl.c |  134 +++++++++++++++++++++----------------
 1 files changed, 77 insertions(+), 57 deletions(-)

commit b2285058a4b054e2e49ea1dbb9e7299be94b5792
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Jan 12 13:47:55 2011 +0000

    cogl-shader-boilerplate: Move the uniforms to the common code
    
    The builtin uniforms are accessible from either the vertex shader or
    the fragment shader so we should define them in the common
    section. This doesn't really matter for the current list of uniforms
    because it's pretty unlikely that you'd want to access the matrices
    from the fragment shader, but for other builtins such as the lighting
    material properties it makes sense.

 cogl/cogl-shader-boilerplate.h |   31 +++++++++++++++++--------------
 1 files changed, 17 insertions(+), 14 deletions(-)

commit a9900d22e05eedfcaaa89ab7bb5bbe9a109a6265
Merge: d6a150b 34ce527
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Fri Jan 21 20:22:32 2011 +0000

    Merge branch 'xi2'
    
    * xi2: (41 commits)
      test-devices: Actually print the axis data
      device-manager/xi2: Sync the stage of source devices
      event: Clean up clutter_event_copy()
      device: unset the axes array pointer when resetting
      device-manager/xi2: Fix device hotplugging
      glx: Clean up GLX implementation
      device/x11: Store min/max keycode in the XI device class
      x11: Hide all private symbols
      docs: More documentation fixes for InputDevice
      */event: Never manipulate the event queue directly
      win32: Update DeviceManager device creation
      device: Allow enabling/disabling non-master devices
      backend/eglx: Add newly created stages to the translators
      device: Add more doc annotations
      device: Use a double for translate_axis() argument
      test-devices: Clean up and show axes data
      event: Fix up clutter_event_copy()
      device/xi2: Translate the axis data after setting devices
      device: Add more accessors for properties
      docs: Update API reference
      ...

commit d6a150bb6e608f2198f510d01152a87b62706de4
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Jan 21 18:43:35 2011 +0000

    cogl: call _cogl_texture_init for x11 tfp
    
    When we added the texture->framebuffers member a _cogl_texture_init
    funciton was added to initialize the list of framebuffers associated
    with a texture to NULL. All the backends were updated except the
    x11 tfp backend. This was causing crashes in test-pixmap.

 cogl/winsys/cogl-texture-pixmap-x11.c |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)

commit 4758ed2cf25389ca4fca1788eaca8496633470b6
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Jan 21 17:38:14 2011 +0000

    journal: start uprof flush timer after flushing fb deps
    
    This avoids us recursively starting the _cogl_journal_flush uprof timer
    by only starting it after flushing the journals of dependency
    framebuffers.

 cogl/cogl-journal.c |    6 ++++--
 1 files changed, 4 insertions(+), 2 deletions(-)

commit affce86924c843f987f6e0a763d0c7f4f8554360
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Jan 21 17:28:34 2011 +0000

    cogl: make sure to init ctx->framebuffers
    
    This makes sure to initialize ctx->framebuffers to NULL otherwise we can
    get apps crashing when they create their first framebuffer.

 cogl/cogl-context.c |    2 ++
 1 files changed, 2 insertions(+), 0 deletions(-)

commit 9b0fd925276a245d0ff11001545e2567911ce9fb
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Jan 20 19:31:53 2011 +0000

    cogl: rename CoglVertexAttribute CoglAttribute
    
    This is part of a broader cleanup of some of the experimental Cogl API.
    One of the reasons for this particular rename is to reduce the verbosity
    of using the API. Another reason is that CoglVertexArray is going to be
    renamed CoglAttributeBuffer and we want to help emphasize the
    relationship between CoglAttributes and CoglAttributeBuffers.

 cogl/Makefile.am                          |    6 +-
 cogl/cogl-attribute-private.h             |  103 +++
 cogl/cogl-attribute.c                     | 1272 +++++++++++++++++++++++++++++
 cogl/cogl-attribute.h                     |  182 ++++
 cogl/cogl-context.c                       |    2 +-
 cogl/cogl-index-array.c                   |    4 +-
 cogl/cogl-journal.c                       |  117 ++--
 cogl/cogl-path-private.h                  |    4 +-
 cogl/cogl-pipeline-progend-glsl-private.h |    2 +-
 cogl/cogl-primitive.c                     |  309 ++++----
 cogl/cogl-primitive.h                     |   26 +-
 cogl/cogl-primitives.c                    |   84 +-
 cogl/cogl-types.h                         |   22 +
 cogl/cogl-vertex-attribute-private.h      |  103 ---
 cogl/cogl-vertex-attribute.c              | 1272 -----------------------------
 cogl/cogl-vertex-attribute.h              |  205 -----
 cogl/cogl-vertex-buffer-private.h         |    4 +-
 cogl/cogl-vertex-buffer.c                 |   18 +-
 cogl/cogl-vertex-buffer.h                 |   22 -
 cogl/cogl.c                               |    4 +-
 cogl/cogl.h                               |    2 +-
 cogl/cogl2-path.c                         |   28 +-
 22 files changed, 1872 insertions(+), 1919 deletions(-)

commit 8fa3a5e1c199ca10828d212fd1818b763e0ad1a4
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Jan 20 18:51:24 2011 +0000

    docs: Adds bitmap section to cogl reference manual
    
    This adds an include for the cogl-bitmap section to cogl-docs.xml.in

 doc/reference/cogl/cogl-docs.xml.in |    1 +
 1 files changed, 1 insertions(+), 0 deletions(-)

commit 87c990a29ca7bc92cc1a163756939535dd11db13
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Jan 20 12:29:49 2011 +0000

    cogl: s/Cogl*Vertex/CoglVertex*/
    
    We have a bunch of experimental convenience functions like
    cogl_primitive_p2/p2t2 that have corresponding vertex structures but it
    seemed a bit odd to have the vertex annotation e.g. "P2T2" be an infix
    of the type like CoglP2T2Vertex instead of be a postfix like
    CoglVertexP2T2. This switches them all to follow the postfix naming
    style.

 cogl/cogl-primitive.c        |   96 +++++++++++++++++++++---------------------
 cogl/cogl-primitive.h        |   80 +++++++++++++++++-----------------
 cogl/cogl-vertex-attribute.c |   20 ++++----
 3 files changed, 98 insertions(+), 98 deletions(-)

commit 5f6cb16e2b4d32a7d4bd2ee3381157b0bebba8d2
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Jan 20 14:41:51 2011 +0000

    debug: Adds a COGL_DEBUG=disable-fast-read-pixel option
    
    COGL_DEBUG=disable-fast-read-pixel can be used to disable the
    optimization for reading a single pixel colour back by looking at the
    geometry in the journal and not involving the GPU. With this disabled we
    will always flush the journal, rendering to the framebuffer and then use
    glReadPixels to get the result.

 cogl/cogl-debug-options.h |    7 ++++-
 cogl/cogl-debug.c         |    3 +-
 cogl/cogl-debug.h         |   61 +++++++++++++++++++++++----------------------
 cogl/cogl-framebuffer.c   |    3 ++
 cogl/cogl-journal.c       |    3 ++
 5 files changed, 45 insertions(+), 32 deletions(-)

commit a8d6c3f686d5d59417bc5afe52ad2555331333e1
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Jan 12 22:12:41 2011 +0000

    cogl: Implements a software only read-pixel fast-path
    
    This adds a transparent optimization to cogl_read_pixels for when a
    single pixel is being read back and it happens that all the geometry of
    the current frame is still available in the framebuffer's associated
    journal.
    
    The intention is to indirectly optimize Clutter's render based picking
    mechanism in such a way that the 99% of cases where scenes are comprised
    of trivial quad primitives that can easily be intersected we can avoid
    the latency of kicking a GPU render and blocking for the result when we
    know we can calculate the result manually on the CPU probably faster
    than we could even kick a render.
    
    A nice property of this solution is that it maintains all the
    flexibility of the render based picking provided by Clutter and it can
    gracefully fall back to GPU rendering if actors are drawn using anything
    more complex than a quad for their geometry.
    
    It seems worth noting that there is a limitation to the extensibility of
    this approach in that it can only optimize picking a against geometry
    that passes through Cogl's journal which isn't something Clutter
    directly controls.  For now though this really doesn't matter since
    basically all apps should end up hitting this fast-path. The current
    idea to address this longer term would be a pick2 vfunc for ClutterActor
    that can support geometry and render based input regions of actors and
    move this optimization up into Clutter instead.
    
    Note: currently we don't have a primitive count threshold to consider
    that there could be scenes with enough geometry for us to compensate for
    the cost of kicking a render and determine a result more efficiently by
    utilizing the GPU. We don't currently expect this to be common though.
    
    Note: in the future it could still be interesting to revive something
    like the wip/async-pbo-picking branch to provide an asynchronous
    read-pixels based optimization for Clutter picking in cases where more
    complex input regions that necessitate rendering are in use or if we do
    add a threshold for rendering as mentioned above.

 cogl/cogl-framebuffer-private.h |   27 ++
 cogl/cogl-framebuffer.c         |  196 +++++++++++-
 cogl/cogl-journal-private.h     |   20 ++
 cogl/cogl-journal.c             |  710 +++++++++++++++++++++++++++++----------
 cogl/cogl-vertex-attribute.c    |    7 +
 cogl/cogl.c                     |   20 +-
 6 files changed, 800 insertions(+), 180 deletions(-)

commit 3e42af2a006cefbcf7ce6d9e7315e8c204a2f896
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Jan 18 16:37:01 2011 +0000

    matrix: fix transform/project_points() APIs
    
    Both cogl_matrix_transform_points and _project_points take points_in and
    points_out arguments and explicitly allow pointing to the same array
    (i.e. to transform in-place) The implementation of the various internal
    transform functions though were not handling this possability and so it
    was possible the reference partially transformed vertex values as if
    they were original input values leading to incorrect results. This patch
    ensures we take a temporary copy of the current input point when
    transforming.

 cogl/cogl-matrix.c |  136 ++++++++++++++++++++++++++--------------------------
 1 files changed, 68 insertions(+), 68 deletions(-)

commit 1f0826543e6e04ccdaedd19e8bcf602f6bfe6931
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Jan 13 14:29:46 2011 +0000

    cogl: Adds _cogl_util_point_in_polygon API
    
    This adds a utility function that can determine if a given point
    intersects an arbitrary polygon, by counting how many edges a
    "semi-infinite" horizontal ray crosses from that point. The plan is to
    use this for a software based read-pixel fast path that avoids using the
    GPU to rasterize journaled primitives and can instead intersect a point
    being read with quads in the journal to determine the correct color.

 cogl/Makefile.am                  |    2 +
 cogl/cogl-point-in-poly-private.h |   40 +++++++++++++++++++++
 cogl/cogl-point-in-poly.c         |   69 +++++++++++++++++++++++++++++++++++++
 3 files changed, 111 insertions(+), 0 deletions(-)

commit 60fd6ab708927f37d29ed58262ed812288c9e72a
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Jan 12 22:06:58 2011 +0000

    cogl: Adds _cogl_swap_buffers_notify for clutter backends
    
    This adds a stop-gap mechanism for Cogl to know when the window system
    is requested to present the current backbuffer to the frontbuffer by
    adding a _cogl_swap_buffers_notify function that backends are now
    expected to call right after issuing the equivalent request to OpenGL
    vie the platforms OpenGL binding layer. This (blindly) updates all the
    backends to call this new function.
    
    For now Cogl doesn't do anything with the notification but the intention
    is to use it as part of a planned read-pixel optimization which will
    need to reset some state at the start of each new frame.

 cogl/cogl-framebuffer-private.h |    3 +++
 cogl/cogl-framebuffer.c         |    5 +++++
 cogl/cogl.c                     |   10 ++++++++++
 cogl/cogl.h                     |    3 +++
 4 files changed, 21 insertions(+), 0 deletions(-)

commit e1563436b1609f3e87ef83a7e9d3fbb7e624780d
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Jan 12 19:30:30 2011 +0000

    clip: rename get_clip_stack + add framebuffer_get_stack
    
    Instead of having _cogl_get/set_clip stack which reference the global
    CoglContext this instead makes those into CoglClipState method functions
    named _cogl_clip_state_get/set_stack that take an explicit pointer to a
    CoglClipState.
    
    This also adds _cogl_framebuffer_get/set_clip_stack convenience
    functions that avoid having to first get the ClipState from a
    framebuffer then the stack from that - so we can maintain the
    convenience of _cogl_get_clip_stack.

 cogl/cogl-clip-state.c          |   21 +++------------------
 cogl/cogl-clip-state.h          |   21 +++------------------
 cogl/cogl-framebuffer-private.h |   26 ++++++++++++++++++++++++++
 cogl/cogl-framebuffer.c         |   17 +++++++++++++++++
 cogl/cogl-journal.c             |    5 ++++-
 5 files changed, 53 insertions(+), 37 deletions(-)

commit cf92670fbbff1fdb70231cb23e4cc891035597b9
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Jan 12 19:13:45 2011 +0000

    clip-stack: Adds _cogl_clip_stack_get_bounds API
    
    This adds an internal function to be able to query the screen space
    bounding box of the current clip entries contained in a given
    CoglClipStack.
    
    This bounding box which is cheap to determine can be useful to know the
    largest extents that might be updated while drawing with this clip
    stack.
    
    For example the plan is to use this as part of an optimized read-pixel
    path handled on the CPU which will need to track the currently valid
    extents of the last call to cogl_clear()

 cogl/cogl-clip-stack.c |   45 ++++++++++++++++++++++++++++++++-------------
 cogl/cogl-clip-stack.h |    7 +++++++
 2 files changed, 39 insertions(+), 13 deletions(-)

commit 1a5a4df3261e1674efb2b53aa738d33fdb53af6c
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Jan 6 13:25:45 2011 +0000

    journal: Support per-framebuffer journals
    
    Instead of having a single journal per context, we now have a
    CoglJournal object for each CoglFramebuffer. This means we now don't
    have to flush the journal when switching/pushing/popping between
    different framebuffers so for example a Clutter scene that involves some
    ClutterEffect actors that transiently redirect to an FBO can still be
    batched.
    
    This also allows us to track state in the journal that relates to the
    current frame of its associated framebuffer which we'll need for our
    optimization for using the CPU to handle reading a single pixel back
    from a framebuffer when we know the whole scene is currently comprised
    of simple rectangles in a journal.

 cogl/cogl-atlas-texture.c       |   22 ++++---
 cogl/cogl-clip-state.c          |    5 +-
 cogl/cogl-context.c             |    6 --
 cogl/cogl-context.h             |   12 ++--
 cogl/cogl-framebuffer-private.h |   23 +++++++
 cogl/cogl-framebuffer.c         |  111 +++++++++++++++++++++++++++----
 cogl/cogl-journal-private.h     |   19 +++++-
 cogl/cogl-journal.c             |  140 ++++++++++++++++++++++++++-------------
 cogl/cogl-pipeline-private.h    |    3 +
 cogl/cogl-pipeline.c            |    7 ++-
 cogl/cogl-primitives.c          |    9 ++-
 cogl/cogl-sub-texture.c         |    3 +-
 cogl/cogl-texture-2d-sliced.c   |    2 +-
 cogl/cogl-texture-2d.c          |    2 +-
 cogl/cogl-texture-3d.c          |    2 +-
 cogl/cogl-texture-private.h     |   15 ++++
 cogl/cogl-texture-rectangle.c   |    2 +-
 cogl/cogl-texture.c             |   58 ++++++++++++++++
 cogl/cogl-vertex-attribute.c    |    7 ++-
 cogl/cogl.c                     |   20 +++++-
 cogl/cogl2-path.c               |    8 ++-
 21 files changed, 375 insertions(+), 101 deletions(-)

commit 5f35bd7b67d0ff6c942405621891d3f40191bacb
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Jan 12 20:37:53 2011 +0000

    cogl-object: Adds an internal _cogl_object_set_user_data
    
    This adds an internal alternative to cogl_object_set_user_data that also
    passes an instance pointer to destroy notify callbacks.
    
    When setting private data on a CoglObject it's often desirable to know
    the instance being destroyed when we are being notified to free the
    private data due to the object being freed. The typical solution to this
    is to track a pointer to the instance in the private data itself so it
    can be identified but that usually requires an extra micro allocation
    for the private data that could have been avoided if only the callback
    were given an instance pointer.
    
    The new internal _cogl_object_set_user_data passes the instance pointer
    as a second argument which means it is ABI compatible for us to layer
    the public version on top of this internal function.

 cogl/cogl-object-private.h |   21 ++++++++++++++++++++-
 cogl/cogl-object.c         |   24 +++++++++++++++++-------
 2 files changed, 37 insertions(+), 8 deletions(-)

commit a4e50b5ea58e9316e7cac1eff9db24ce94b3d4da
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Jan 5 15:30:04 2011 +0000

    framebuffer: Move clear code to cogl-framebuffer.c
    
    This moves the implementation of cogl_clear into cogl-framebuffer.c as
    two new internal functions _cogl_framebuffer_clear and
    _cogl_framebuffer_clear4f. It's not clear if this is what the API will
    look like as we make more of the CoglFramebuffer API public due to the
    limitations of using flags to identify buffers when framebuffers may
    contain any number of ancillary buffers but conceptually it makes some
    sense to tie the operation of clearing a color buffer to a framebuffer.
    
    The short term intention is to enable tracking the current clear color
    as a property of the framebuffer as part of an optimization for reading
    back single pixels when the geometry is simple enough that we can
    compute the result quickly on the CPU. (If the point doesn't intersect
    any geometry we'll need to return the last clear color.)

 cogl/cogl-framebuffer-private.h |   20 ++++++++
 cogl/cogl-framebuffer.c         |  103 +++++++++++++++++++++++++++++++++++++++
 cogl/cogl.c                     |   66 ++-----------------------
 cogl/cogl2-path.c               |    4 +-
 4 files changed, 129 insertions(+), 64 deletions(-)

commit 34ce527dca3bb552a547c2c1949e40402f8bd634
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Jan 17 12:21:33 2011 +0000

    cogl-program: Don't use separate definitions on GLES 1.1
    
    Previously most of the code for cogl-program and cogl-shader was
    ifdef'd out for GLES 1.1 and alternate stub definitions were
    defined. This patch removes those and instead puts #ifdef's directly
    in the functions that need it. This should make it a little bit easier
    to maintain.
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2516

 cogl/cogl-program.c |  105 ++++++--------------------------------------------
 cogl/cogl-shader.c  |   91 +++++++++++++++-----------------------------
 2 files changed, 44 insertions(+), 152 deletions(-)

commit ed29d405b2a1272ed35de934cda69896cf191b3f
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Jan 17 12:20:06 2011 +0000

    cogl-pipeline-opengl: #ifdef out set_glsl_program for GLES 1.1
    
    glUseProgram is not available under GLES 1.1 so it was breaking the
    build.
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2516

 cogl/cogl-pipeline-opengl.c |    9 +++++++++
 1 files changed, 9 insertions(+), 0 deletions(-)

commit d33f66303f0e4bb1f44a34f3aa7b5b8887b05665
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Jan 17 12:06:13 2011 +0000

    cogl-pipeline: Fix the enum names for the constant combine source
    
    When determining whether to hash the combine constant Cogl checks the
    arguments to the combine funcs to determine whether the combine
    constant is used. However is was using the GLenums GL_CONSTANT_COLOR
    and GL_CONSTANT_ALPHA but these are not valid values for the
    CoglPipelineCombineSource enum so presumably the constant would never
    get hashed. This patch makes it use Cogl's enum of
    COGL_PIPELINE_COMBINE_SOURCE_CONSTANT instead.
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2516

 cogl/cogl-pipeline.c |   12 ++++++------
 1 files changed, 6 insertions(+), 6 deletions(-)

commit 4f08e3cf6e719c05e8e93016ae8e25568457ceb4
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Jan 13 15:54:50 2011 +0000

    cogl-buffer: Support mapping buffers for write on GLES
    
    GLES has an extension called GL_OES_mapbuffer to support mapping
    buffer objects but only for writing. Cogl now has two new feature
    flags to advertise whether mapping for reading and writing is
    supported. Under OpenGL, these features are always set if the VBO
    extension is advertised and under GLES only the write flag is set if
    the GL_OES_mapbuffer extension is advertised.

 cogl/cogl-buffer.c                             |   44 +++++++++++-------------
 cogl/cogl-types.h                              |    8 ++++-
 cogl/driver/gl/cogl-feature-functions-gl.h     |    4 ++-
 cogl/driver/gles/cogl-feature-functions-gles.h |   12 ++++++
 4 files changed, 42 insertions(+), 26 deletions(-)

commit 36b996672c58227750014504eca8826407a0b019
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Jan 13 15:36:08 2011 +0000

    cogl: Enable the VBOs feature for GLES2
    
    The GLES2 wrapper code has been removed so there are no longer any
    problems with enabling VBOs.

 cogl/driver/gles/cogl-gles.c |    5 -----
 1 files changed, 0 insertions(+), 5 deletions(-)

commit a8216aff2f3daa56225aec56ff27317af6d0eba8
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Jan 13 15:35:30 2011 +0000

    cogl: Fallback to set_data when mapping a buffer to fill it
    
    In the journal code and when generating the stroke path the vertices
    are generated on the fly and stored in a CoglBuffer using
    cogl_buffer_map. However cogl_buffer_map is allowed to fail but it
    wasn't checking for a NULL return value. In particular on GLES it will
    always fail because glMapBuffer is only provided by an extension. This
    adds a new pair of internal functions called
    _cogl_buffer_{un,}map_for_fill_or_fallback which wrap
    cogl_buffer_map. If the map fails then it will instead return a
    pointer into a GByteArray attached to the context. When the buffer is
    unmapped the array is copied into the buffer using
    cogl_buffer_set_data.

 cogl/cogl-buffer-private.h |   19 +++++++++++++--
 cogl/cogl-buffer.c         |   51 ++++++++++++++++++++++++++++++++++++++++++++
 cogl/cogl-context.c        |    5 ++++
 cogl/cogl-context.h        |    6 +++++
 cogl/cogl-journal.c        |    5 +--
 cogl/cogl2-path.c          |    7 ++---
 6 files changed, 83 insertions(+), 10 deletions(-)

commit ac81f3b936b7efb287d4c81973f5fd84166f52d5
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Jan 13 14:12:10 2011 +0000

    cogl-context: Don't enable point sprites on GLES2
    
    On GLES2 there's no builtin mechanism to replace texture coordinates
    with point sprite coordinates so calling glEnable(GL_POINT_SPRITE)
    isn't valid. Instead the point sprite coords are implemented by using
    a special builtin varying variable in GLSL.

 cogl/cogl-context.c |    5 ++++-
 1 files changed, 4 insertions(+), 1 deletions(-)

commit 03dbf67ca4eb35fdc78d2a2d100c415c3e489fb8
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Jan 11 16:02:06 2011 +0000

    pipeline: differentiate texture target and data state
    
    There are several places where we need to compare the texture state of a
    pipeline and sometimes we need to take into consideration if the
    underlying texture has changed but other times we may only care to know
    if the texture target has changed.
    
    For example the fragends typically generate programs that they want to
    share with all pipelines with equivalent fragment processing state, and
    in this case when comparing pipelines we only care about the texture
    targets since changes to the underlying texture won't affect the
    programs generated.
    
    Prior to this we had tried to handle this by passing around some special
    flags to various functions that evaluate pipeline state to say when we
    do/don't care about the texture data, but this wasn't working in all
    cases and was more awkward to manage than the new approach.
    
    Now we simply have two state bits:
    COGL_PIPELINE_LAYER_STATE_TEXTURE_TARGET and
    COGL_PIPELINE_LAYER_STATE_TEXTURE_DATA and CoglPipelineLayer has an
    additional target member. Since all the appropriate code takes masks of
    these state bits to determine what to evaluate we don't need any extra
    magic flags.

 cogl/cogl-pipeline-fragend-arbfp.c |    9 +-
 cogl/cogl-pipeline-fragend-fixed.c |   25 ++--
 cogl/cogl-pipeline-fragend-glsl.c  |    3 +-
 cogl/cogl-pipeline-opengl.c        |    9 +-
 cogl/cogl-pipeline-private.h       |   28 ++---
 cogl/cogl-pipeline-progend-glsl.c  |    3 +-
 cogl/cogl-pipeline-vertend-glsl.c  |    3 +-
 cogl/cogl-pipeline.c               |  273 +++++++++++++++++++++++++-----------
 8 files changed, 223 insertions(+), 130 deletions(-)

commit a6628ca1130929feca77be9bf9774072af5b0b6b
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Jan 12 17:11:48 2011 +0000

    pipeline: optimize state init if changing property
    
    When notifying that a pipeline property is going to change, then at
    times a pipeline will take over being the authority of the corresponding
    state group. Some state groups can contain multiple properties and so to
    maintain the integrity of all of the properties we have to initialize
    all the property values in the new authority. For state groups with only
    one property we don't have to initialize anything during the
    pre_change_notify() because we can assume the value will be initialized
    as part of the change being notified.
    
    This patch optimizes how we handle this initialization of state groups
    in a couple of ways; firstly we no longer do anything to initialize
    state-groups with only one property, secondly we no longer use
    _cogl_pipeline_copy_differences - (we have a new
    _cogl_pipeline_init_multi_property_sparse_state() func) so we can avoid
    lots calls to handle_automatic_blend_enable() which is sometimes seen
    high in sysprof profiles.

 cogl/cogl-pipeline-private.h |  161 +++++++++++++++++----------
 cogl/cogl-pipeline.c         |  255 +++++++++++++++++++++++++++---------------
 2 files changed, 266 insertions(+), 150 deletions(-)

commit 6e14b72284e10ca14bc61c577a3fa57bb63d1a4f
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Jan 12 16:56:52 2011 +0000

    cogl-atlas-texture: Don't disable atlas if can't read texture data
    
    Previously atlasing would be disabled if the GL driver does not
    support reading back texture data. This meant that atlasing would not
    happen on GLES. However we also require that the driver support FBOs
    and the texture data is only read back as a fallback if the FBO
    fails. Therefore the atlas should be ok on GLES 2 which has FBO
    support in core.

 cogl/cogl-atlas-texture.c |    8 +++-----
 1 files changed, 3 insertions(+), 5 deletions(-)

commit a74050554a485c5d3513ed8e639ee3c4c3be2438
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Jan 11 14:10:11 2011 +0000

    pipeline: don't skip flush if skip_gl_color flag differs
    
    We try and bail out of flushing pipeline state asap if we can see the
    pipeline has already been flushed and hasn't changed but we weren't
    checking to see if the skip_gl_color flag is the same as when it was
    last flush too and so we'd sometimes bail out without updating the
    glColor correctly.

 cogl/cogl-pipeline-opengl.c |    3 ++-
 1 files changed, 2 insertions(+), 1 deletions(-)

commit 3b3cfe182468fe3fcee92d8f6ba1821199fd673a
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Jan 10 20:13:41 2011 +0000

    cogl-vertex-attribute: Optionally avoid applying the legacy state
    
    When an item is added to the journal the current pipeline immediately
    gets the legacy state applied to it and the modified pipeline is
    logged instead of the original. However the actual drawing from the
    journal is done using the vertex attribute API which was also applying
    the legacy state. This meant that the legacy state used would be a
    combination of the state set when the journal entry was added as well
    as the state set when the journal is flushed. To fix this there is now
    an extra CoglDrawFlag to avoid applying the legacy state when setting
    up the GL state for the vertex attributes. The journal uses this flag
    when flushing.

 cogl/cogl-journal.c                  |    3 ++-
 cogl/cogl-vertex-attribute-private.h |    6 +++++-
 cogl/cogl-vertex-attribute.c         |    6 ++++--
 3 files changed, 11 insertions(+), 4 deletions(-)

commit bbce77fceaf2db65809035545418b5394491cf9c
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Dec 14 14:44:45 2010 +0000

    cogl-journal: Avoid enabling blending if possible
    
    The vertex attribute API assumes that if there is a color array
    enabled then we can't determine if the colors are opaque so we have to
    enable blending. The journal always uses a color array to avoid
    switching color state between rectangles. Since the journal switched
    to using vertex attributes this means we effectively always enable
    blending from the journal. To fix this there is now a new flag for
    _cogl_draw_vertex_attributes to specify that the color array is known
    to only contain opaque colors which causes the draw function not to
    copy the pipeline. If the pipeline has blending disabled then the
    journal passes this flag.
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2481

 cogl/cogl-journal.c                  |    9 ++++++---
 cogl/cogl-vertex-attribute-private.h |    9 ++++++++-
 cogl/cogl-vertex-attribute.c         |   10 ++++++----
 3 files changed, 20 insertions(+), 8 deletions(-)

commit a847289850fc5378343775d731d3ac992ddf4437
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Dec 14 14:24:17 2010 +0000

    cogl-vertex-attribute: Add flags to _cogl_draw_vertex_attributes_array
    
    There is an internal version of cogl_draw_vertex_attributes_array
    which previously just bypassed the framebuffer flushing, journal
    flushing and pipeline validation so that it could be used to draw the
    journal. This patch generalises the function so that it takes a set of
    flags to specify which parts to flush. The public version of the
    function now just calls the internal version with the flags set to
    0. The '_real' version of the function has now been merged into the
    internal version of the function because it was only called in one
    place. This simplifies the code somewhat. The common code which
    flushed the various state has been moved to a separate function. The
    indexed versions of the functions have had a similar treatment.
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2481

 cogl/cogl-journal.c                  |   17 +++-
 cogl/cogl-primitives.c               |    6 +-
 cogl/cogl-vertex-attribute-private.h |   13 ++-
 cogl/cogl-vertex-attribute.c         |  167 +++++++++++++---------------------
 cogl/cogl2-path.c                    |   14 ++-
 5 files changed, 100 insertions(+), 117 deletions(-)

commit 4a7dbc0e4ed39d056c6137f711a5cc6d4ba738fb
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Dec 17 16:30:23 2010 +0000

    cogl: Don't assume that CoglBitmaps are allocated to height*rowstride
    
    Cogl no longer has any code that assumes the buffer in a CoglBitmap is
    allocated to the full size of height*rowstride. We should comment that
    this is the case so that we remember to keep it that way. This is
    important for cogl_texture_new_from_data because the application may
    have created the data from a sub-region of a larger image and in that
    case it's not safe to read the full rowstride of the last row when the
    sub region contains the last row of the larger image.
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2491

 cogl/cogl-bitmap-pixbuf.c  |   60 ++++++-------------------------------------
 cogl/cogl-bitmap-private.h |    8 ++++++
 2 files changed, 17 insertions(+), 51 deletions(-)

commit 0f43e01cbcac72d3e8de07b2c2472ad2410f13a9
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Dec 17 16:09:26 2010 +0000

    cogl-texture-driver-gles: Don't copy the bitmap if alignment matches
    
    When uploading data for GLES we need to deal with cases where the
    rowstride is too large to be described only by GL_UNPACK_ALIGNMENT
    because there is no GL_UNPACK_ROW_LENGTH. Previously for the
    sub-region uploading code it would always copy the bitmap and for the
    code to upload the whole image it would copy the bitmap unless the
    rowstride == bpp*width. Neither paths took into account that we don't
    need to copy if the rowstride is just an alignment of bpp*width. This
    moves the bitmap copying code to a separate function that is used by
    both upload methods. It only copies the bitmap if the rowstride is not
    just an alignment of bpp*width.
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2491

 cogl/driver/gles/cogl-texture-driver-gles.c |  103 ++++++++++++++------------
 1 files changed, 55 insertions(+), 48 deletions(-)

commit 14e94647bf09d9841cfa0ac650aa37ffc1e3862c
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Dec 17 16:06:10 2010 +0000

    cogl-util: Add an internal wrapper for the ffs function
    
    The ffs function is defined in C99 so if we want to use it in Cogl we
    need to provide a fallback for MSVC. This adds a configure check for
    the function and then a fallback using a while loop if it is not
    available.
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2491

 cogl/cogl-util.c |   21 +++++++++++++++++++++
 cogl/cogl-util.h |    8 ++++++++
 2 files changed, 29 insertions(+), 0 deletions(-)

commit 0b2dc74dbce582c5ac7d8cababfbadbbf4234dbe
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Dec 17 14:52:25 2010 +0000

    cogl-texture: Don't use the source rowstride if we have to copy bitmap
    
    If we have to copy the bitmap to do the premultiplication then we were
    previously using the rowstride of the source image as the rowstride
    for the new image. This is wasteful if the source image is a subregion
    of a larger image which would make it use a large rowstride. If we
    have to copy the data anyway we might as well compact it to the
    smallest rowstride. This also prevents the copy from reading past the
    end of the last row of pixels.
    
    An internal function called _cogl_bitmap_copy has been added to do the
    copy. It creates a new bitmap with the smallest possible rowstride
    rounded up the nearest multiple of 4 bytes. There may be other places
    in Cogl that are currently assuming we can read height*rowstride of
    the source buffer so they may want to take advantage of this function
    too.
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2491

 cogl/cogl-bitmap-private.h |    4 ++++
 cogl/cogl-bitmap.c         |   29 +++++++++++++++++++++++++++++
 cogl/cogl-texture.c        |   22 +---------------------
 3 files changed, 34 insertions(+), 21 deletions(-)

commit 7ae61c3763ab0c26e9c191f447a37d800207dafd
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Dec 22 01:45:09 2010 +0000

    cogl-vertex-attribute: Fix the name of the cogl_normal_in attribute
    
    The builtin vertex attribute for the normals was incorrectly checked
    for as 'cogl_normal' however it is defined as cogl_normal_in in the
    shader boilerplate and for the name generated by CoglVertexBuffer.
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2499

 cogl/cogl-vertex-attribute.c |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)

commit aa4f63338c3fe5dab521d32671cde1bbd11188c5
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Wed Dec 22 09:42:41 2010 +0000

    docs: Fixes for the Cogl API reference

 cogl/cogl-bitmap.h                   |    4 +-
 cogl/cogl-buffer.h                   |    8 +++---
 cogl/cogl-index-array.h              |    2 +-
 cogl/cogl-material-compat.h          |   11 +++++----
 cogl/cogl-object.h                   |   19 ++++++++-------
 cogl/cogl-path.h                     |    8 +++---
 cogl/cogl-pipeline.h                 |    2 +-
 cogl/cogl-types.h                    |    4 +-
 cogl/cogl-vertex-array.h             |    2 +-
 cogl/cogl-vertex-buffer.h            |    2 +-
 doc/reference/cogl/cogl-sections.txt |   39 ++++++++++++++++++++++++++++++---
 11 files changed, 67 insertions(+), 34 deletions(-)

commit ba4e3905d32c7bdeca889d87036ed64ce4f7f4eb
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Tue Dec 21 12:03:38 2010 +0000

    build: Ignore private headers when building the Cogl reference
    
    Otherwise gtk-doc will try to look up private symbols.

 doc/reference/cogl/Makefile.am |   22 +++++++++++++++++-----
 1 files changed, 17 insertions(+), 5 deletions(-)

commit 885942aec08a85a19ed3bb372d44e8d77c407b33
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Dec 14 13:02:47 2010 +0000

    cogl-pipeline-fragend-arbfp: Generate ARBfp if user vertex shader
    
    The ARBfp fragend was bypassing generating a shader if the pipeline
    contains a user program. However it shouldn't do this if the pipeline
    only contains a vertex shader. This was breaking
    test-cogl-just-vertex-shader.

 cogl/cogl-pipeline-fragend-arbfp.c |   17 +++++++++++++----
 1 files changed, 13 insertions(+), 4 deletions(-)

commit 9aea72fab5a0b030c320dbc2efd905764b9af3ce
Author: Neil Roberts <neil@linux.intel.com>
Date:   Sat Nov 27 13:15:02 2010 +0000

    Allow multiple CoglAtlases for textures
    
    Previously Cogl would only ever use one atlas for textures and if it
    reached the maximum texture size then all other new textures would get
    their own GL texture. This patch makes it so that we create as many
    atlases as needed. This should avoid breaking up some batches and it
    will be particularly good if we switch to always using multi-texturing
    with a default shader that selects between multiple atlases using a
    vertex attribute.
    
    Whenever a new atlas is created it is stored in a GSList on the
    context. A weak weference is taken on the atlas using
    cogl_object_set_user_data so that it can be removed from the list when
    the atlas is destroyed. The atlas textures themselves take a reference
    to the atlas and this is the only thing that keeps the atlas
    alive. This means that once the atlas becomes empty it will
    automatically be destroyed.
    
    All of the COGL_NOTEs pertaining to atlases are now prefixed with the
    atlas pointer to make it clearer which atlas is changing.

 cogl/cogl-atlas-texture-private.h |   10 ++--
 cogl/cogl-atlas-texture.c         |  105 +++++++++++++++++++++++++-----------
 cogl/cogl-atlas.c                 |   19 ++++---
 cogl/cogl-atlas.h                 |    3 -
 cogl/cogl-context.c               |    5 +-
 cogl/cogl-context.h               |    2 +-
 pango/cogl-pango-glyph-cache.c    |    1 +
 7 files changed, 93 insertions(+), 52 deletions(-)

commit 0f0f763570b904591bdae10888a971a887e01f22
Author: Neil Roberts <neil@linux.intel.com>
Date:   Sat Nov 27 13:06:38 2010 +0000

    cogl-atlas: Convert to be a CoglObject subclass
    
    To implement multiple atlases it will be useful to have ref-counting
    on the CoglAtlas so it makes sense to convert it to be a CoglObject.

 cogl/cogl-atlas.c              |   10 ++++++++--
 cogl/cogl-atlas.h              |    8 +++++---
 cogl/cogl-context.c            |    2 +-
 pango/cogl-pango-glyph-cache.c |    4 ++--
 4 files changed, 16 insertions(+), 8 deletions(-)

commit 03d33a6f4ddde77371e320122884911e8577316c
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Dec 7 13:44:45 2010 +0000

    cogl-shader-boilerplate: Add the 3D texture extension on GLES2
    
    To use the 3D texture extension on GLES2 it has to be enabled with the
    following line in GLSL:
    
    #extension GL_OES_texture_3D : enable

 cogl/cogl-shader.c |   14 ++++++++++++--
 1 files changed, 12 insertions(+), 2 deletions(-)

commit 38971e4977e7d57fd543d598b08f902160b2093c
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Dec 7 10:38:51 2010 +0000

    cogl2-path: Don't flush the enable flags
    
    All of the drawing needed in _cogl_add_path_to_stencil_buffer is done
    with the vertex attribute API so there should be no need to flush the
    enable flags to enable the vertex array. This was causing problems on
    GLES2 where the vertex array isn't available.

 cogl/cogl2-path.c |    5 -----
 1 files changed, 0 insertions(+), 5 deletions(-)

commit dc1f1949d0f639a3ef60ebd69feeee935eced1bf
Author: Neil Roberts <neil@linux.intel.com>
Date:   Sun Dec 5 18:02:05 2010 +0000

    Remove the GLES2 wrapper
    
    The GLES2 wrapper is no longer needed because the shader generation is
    done within the GLSL fragend and vertend and any functions that are
    different for GLES2 are now guarded by #ifdefs.

 cogl/Makefile.am                               |   20 -
 cogl/cogl-atlas.c                              |    6 +-
 cogl/cogl-buffer.c                             |    4 -
 cogl/cogl-clip-stack.c                         |   13 +-
 cogl/cogl-context.c                            |    6 +-
 cogl/cogl-framebuffer.c                        |    6 +-
 cogl/cogl-pipeline-fragend-arbfp.c             |    4 -
 cogl/cogl-pipeline-fragend-glsl.c              |    4 -
 cogl/cogl-pipeline-opengl.c                    |   16 +-
 cogl/cogl-pipeline-progend-glsl.c              |   34 +-
 cogl/cogl-pipeline-vertend-glsl.c              |   24 +
 cogl/cogl-pixel-array.c                        |    4 -
 cogl/cogl-texture-2d.c                         |    2 +
 cogl/cogl-texture-3d.c                         |    2 +
 cogl/cogl-vertex-attribute.c                   |    1 -
 cogl/cogl.c                                    |   16 +-
 cogl/driver/gles/cogl-context-driver-gles.c    |    6 -
 cogl/driver/gles/cogl-context-driver-gles.h    |    4 -
 cogl/driver/gles/cogl-fixed-vertex-shader.glsl |   73 --
 cogl/driver/gles/cogl-gles.c                   |    4 +
 cogl/driver/gles/cogl-gles2-wrapper.c          |  993 ------------------------
 cogl/driver/gles/cogl-gles2-wrapper.h          |  388 ---------
 cogl/driver/gles/cogl-texture-driver-gles.c    |    6 +-
 23 files changed, 81 insertions(+), 1555 deletions(-)

commit 2b32a9eb2a2a87f8bf7d885fe3a2163fd97b9624
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Dec 6 21:29:56 2010 +0000

    cogl-pipeline: Use enums for the layer combine values
    
    Once the GLES2 wrapper is removed then we won't have the GLenums
    needed for setting up the layer combine state. This adds Cogl enums
    instead which have the same values as the corresponding GLenums. The
    enums are:
    
    CoglPipelineCombineFunc
    CoglPipelineCombineSource
     and
    CoglPipelineCombineOp

 cogl/cogl-pipeline-fragend-arbfp.c |   41 +++++++-------
 cogl/cogl-pipeline-fragend-glsl.c  |   48 +++++++++-------
 cogl/cogl-pipeline-private.h       |   46 +++++++++++++--
 cogl/cogl-pipeline.c               |  107 +++++++++++++++++++++---------------
 4 files changed, 148 insertions(+), 94 deletions(-)

commit a05c701e6b354f699b0886eb16b3863ed735d3c5
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Dec 6 12:31:51 2010 +0000

    cogl: upload matrices with uniforms on GLES2
    
    Once the GLES2 wrapper is removed we won't be able to upload the
    matrices with the fixed function API any more. The fixed function API
    gives a global state for setting the matrix but if a custom shader
    uniform is used for the matrices then the state is per
    program. _cogl_matrix_stack_flush_to_gl is called in a few places and
    it is assumed the current pipeline doesn't need to be flushed before
    it is called. To allow these semantics to continue to work, on GLES2
    the matrix flush now just stores a reference to the matrix stack in
    the CoglContext. A pre_paint virtual is added to the progend which is
    called whenever a pipeline is flushed, even if the same pipeline was
    flushed already. This gives the GLSL progend a chance to upload the
    matrices to the uniforms. The combined modelview/projection matrix is
    only calculated if it is used. The generated programs end up never
    using the modelview or projection matrix so it usually only has to
    upload the combined matrix. When a matrix stack is flushed a reference
    is taked to it by the pipeline progend and the age is stored so that
    if the same state is used with the same program again then we don't
    need to reupload the uniform.

 cogl/cogl-context.c                   |   12 ++
 cogl/cogl-context.h                   |   10 ++
 cogl/cogl-matrix-stack.c              |  127 +++++++++++++----
 cogl/cogl-matrix-stack.h              |   10 ++
 cogl/cogl-pipeline-opengl.c           |    7 +
 cogl/cogl-pipeline-private.h          |    4 +
 cogl/cogl-pipeline-progend-glsl.c     |  250 ++++++++++++++++++++++++++++++++-
 cogl/cogl-pipeline-vertend-glsl.c     |    4 +
 cogl/driver/gles/cogl-gles2-wrapper.c |    2 +
 9 files changed, 396 insertions(+), 30 deletions(-)

commit 35b07f6b8394c0ca371183f9bd2709812c884754
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Dec 10 17:42:39 2010 +0000

    cogl-matrix-stack: Add _cogl_matrix_stack_has_identity_flag
    
    This adds an internal function to quickly determine whether the top of
    the matrix stack is known to be the identity matrix.

 cogl/cogl-matrix-stack.c |    6 ++++++
 cogl/cogl-matrix-stack.h |    7 +++++++
 2 files changed, 13 insertions(+), 0 deletions(-)

commit c11f72fd6d226037a20aba14caae3bd4d3b30858
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Dec 10 16:06:16 2010 +0000

    cogl-matrix-stack: Convert to be a CoglObject
    
    We will want to use ref-counting on the CoglMatrixStack so it might as
    well be a CoglObject.

 cogl/cogl-framebuffer.c     |    4 ++--
 cogl/cogl-matrix-stack.c    |   13 ++++++++++---
 cogl/cogl-matrix-stack.h    |    3 ---
 cogl/cogl-pipeline-opengl.c |    2 +-
 4 files changed, 13 insertions(+), 9 deletions(-)

commit d678125dd480e6587e6d116fe5e517b9db05db09
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Dec 10 11:34:02 2010 +0000

    matrix-stack: Make header style consistent
    
    Cogl doesn't follow the Clutter/GTK+ columnized function prototype style
    so this updates cogl-matrix-stack.h to match the other Cogl headers.

 cogl/cogl-matrix-stack.c |    2 +-
 cogl/cogl-matrix-stack.h |  126 +++++++++++++++++++++++++++-------------------
 2 files changed, 76 insertions(+), 52 deletions(-)

commit 104961de6a2c5acc9ed735f623abd5242e19f313
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Dec 10 11:13:09 2010 +0000

    matrix-stack: Adds a stack age counter
    
    Sometimes it would be useful if we could efficiently track when a matrix
    stack has been modified. For example on GLES2 we have to upload the
    modelview as a uniform to our glsl programs but because the modelview
    state is part of the framebuffer state it becomes a bit more tricky to
    know when to re-sync the value of the uniform with the framebuffer
    state. This adds an "age" counter to CoglMatrixStack which is
    incremented for any operation that effectively modifies the top of the
    stack so now we can save the age of the stack inside the pipeline
    whenever we update modelview uniform and later compare that with the
    stack to determine if it has changed.

 cogl/cogl-matrix-stack.c |   18 ++++++++++++++++++
 cogl/cogl-matrix-stack.h |    2 ++
 2 files changed, 20 insertions(+), 0 deletions(-)

commit 566831de665aa164320232ba3744e9464306b5e9
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Dec 6 12:31:16 2010 +0000

    cogl-pipeline: Add internal API to get the layer matrix
    
    This returns the layer matrix given a pipeline and a layer index. The
    API is kept as internal because it directly returns a pointer into the
    layer private data to avoid a copy into an out-param. We might also
    want to add a public function which does the copy.

 cogl/cogl-pipeline-private.h |    4 ++++
 cogl/cogl-pipeline.c         |   19 +++++++++++++++++++
 2 files changed, 23 insertions(+), 0 deletions(-)

commit e38e9e03555ed8b3af3fb1fbc52767196cd3e481
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Dec 3 17:46:16 2010 +0000

    cogl-vertex-attribute: Use glVertexAttribPointer on GLES2
    
    When the GLES2 wrapper is removed we can't use the fixed function API
    such as glColorPointer to set the builtin attributes. Instead the GLSL
    progend now maintains a cache of attribute locations that are queried
    with glGetAttribLocation. The code that previously maintained a cache
    of the enabled texture coord arrays has been modified to also cache
    the enabled vertex attributes under GLES2. The vertex attribute API is
    now the only place that is using this cache so it has been moved into
    cogl-vertex-attribute.c

 cogl/cogl-bitmask.c                       |   16 +-
 cogl/cogl-bitmask.h                       |   10 +-
 cogl/cogl-context.c                       |    8 +-
 cogl/cogl-context.h                       |    8 +-
 cogl/cogl-internal.h                      |    6 -
 cogl/cogl-pipeline-opengl.c               |   30 +++-
 cogl/cogl-pipeline-progend-glsl-private.h |   18 ++
 cogl/cogl-pipeline-progend-glsl.c         |  139 +++++++++++++
 cogl/cogl-vertex-attribute-private.h      |    3 +
 cogl/cogl-vertex-attribute.c              |  311 ++++++++++++++++++++++-------
 cogl/cogl.c                               |   36 +---
 11 files changed, 451 insertions(+), 134 deletions(-)

commit 12b3d21aaac6f3091c7b23a34afdb67050a7a3ab
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Dec 3 11:31:09 2010 +0000

    cogl-path: Stroke using the vertex attribute API
    
    Previously when stroking a path it was flushing a pipeline and then
    directly calling glDrawArrays to draw the line strip from the path
    nodes array. This patch changes it to build a CoglVertexArray and a
    series of attributes to paint with instead. The vertex array and
    attributes are attached to the CoglPath so it can be reused later. The
    old vertex array for filling has been renamed to fill_vbo.

 cogl/cogl-path-private.h |   12 ++-
 cogl/cogl2-path.c        |  201 +++++++++++++++++++++++++++++++---------------
 2 files changed, 143 insertions(+), 70 deletions(-)

commit 79732c664160e9a6a2c809cc20bbf4086bc79e0b
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Dec 2 22:19:44 2010 +0000

    cogl: Move COGL_DEBUG=show-source into cogl-shader.c
    
    The code to display the source when the show-source debug option is
    given has been moved to _cogl_shader_set_source_with_boilerplate so
    that it will show both user shaders and generated shaders. It also
    shows the code with the full boilerplate. To make it the same for
    ARBfp, cogl_shader_compile_real now also dumps user ARBfp shaders.

 cogl/cogl-pipeline-fragend-glsl.c |    5 -----
 cogl/cogl-pipeline-vertend-glsl.c |    5 -----
 cogl/cogl-shader.c                |   23 +++++++++++++++++++++++
 3 files changed, 23 insertions(+), 10 deletions(-)

commit fa13f6c1078dd3f67b18048afbe4ef271b4804e4
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Dec 2 20:48:45 2010 +0000

    cogl: Add a vertend to generate GLSL
    
    The GLSL vertend is mostly only useful for GLES2. The fixed function
    vertend is kept at higher priority than the GLSL vertend so it is
    unlikely to be used in any other circumstances.

 cogl/Makefile.am                          |    2 +
 cogl/cogl-context.c                       |    3 +-
 cogl/cogl-context.h                       |    3 +-
 cogl/cogl-pipeline-fragend-arbfp.c        |    3 +-
 cogl/cogl-pipeline-fragend-fixed.c        |   10 +-
 cogl/cogl-pipeline-fragend-glsl.c         |   13 +-
 cogl/cogl-pipeline-opengl.c               |  130 +++++++---
 cogl/cogl-pipeline-private.h              |   30 ++-
 cogl/cogl-pipeline-progend-glsl.c         |   83 ++++--
 cogl/cogl-pipeline-vertend-fixed.c        |   28 ++
 cogl/cogl-pipeline-vertend-glsl-private.h |   39 +++
 cogl/cogl-pipeline-vertend-glsl.c         |  396 +++++++++++++++++++++++++++++
 cogl/cogl-pipeline.c                      |    7 +
 cogl/driver/gles/cogl-gles2-wrapper.c     |   19 +-
 14 files changed, 679 insertions(+), 87 deletions(-)

commit e98bd86e0a2f03d87e7987d4f520f804738a201e
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Dec 7 12:33:39 2010 +0000

    cogl-shader-boilerplate: Don't put the color attrib in location 0
    
    Due to Mesa bug 28585 calling glVertexAttrib with attrib location 0
    doesn't appear to work. This patch just reorders the vertex and color
    attributes in the shader in the hope that Mesa will assign the color
    attribute to a different location.

 cogl/cogl-shader-boilerplate.h |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)

commit 4232de637abdb05ef3c6bb5fec5fbaed63670eb1
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Dec 2 22:08:51 2010 +0000

    cogl-shader-boilerplate: Add more builtins for GLES2
    
    Some builtin attributes such as the matrix uniforms and some varyings
    were missing from the boilerplate for GLES2. This also moves the
    texture matrix and texture coord attribute declarations to
    cogl-shader.c so that they can be dynamically defined depending on the
    number of texture coord arrays enabled.

 cogl/cogl-shader-boilerplate.h |   23 ++++++++++++++++++++---
 cogl/cogl-shader.c             |   30 ++++++++++++++++++++++++------
 2 files changed, 44 insertions(+), 9 deletions(-)

commit 0c732c27ae01c50ae1ddaf2cf429cab2685f790a
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Dec 2 18:05:22 2010 +0000

    cogl-pipeline: Rename the fragment_{source,header}_buffer to codegen
    
    We want to reuse the same buffers for vertends so calling them
    fragment_* doesn't make sense.

 cogl/cogl-context.c                |    4 ++--
 cogl/cogl-context.h                |    4 ++--
 cogl/cogl-pipeline-fragend-arbfp.c |    4 ++--
 cogl/cogl-pipeline-fragend-glsl.c  |    8 ++++----
 cogl/cogl-pipeline-progend-glsl.c  |   12 ++++++------
 5 files changed, 16 insertions(+), 16 deletions(-)

commit 3cf9159769e76ed5cc44c8b689cd549d1c7616f1
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Nov 29 18:32:21 2010 +0000

    cogl: Add a fixed function vertend
    
    The vertends are intended to flush state that would be represented in
    a vertex program. Code to handle the layer matrix, lighting and
    point size has now been moved from the common cogl-pipeline-opengl
    backend to the fixed vertend.

 cogl/Makefile.am                           |    2 +
 cogl/cogl-pipeline-opengl.c                |  109 ++++++++++++++++++++-------
 cogl/cogl-pipeline-private.h               |   34 ++++++++-
 cogl/cogl-pipeline-vertend-fixed-private.h |   36 +++++++++
 cogl/cogl-pipeline-vertend-fixed.c         |  114 ++++++++++++++++++++++++++++
 cogl/cogl-pipeline.c                       |   80 ++++++++++++++++++-
 6 files changed, 342 insertions(+), 33 deletions(-)

commit 9b1ab9f0ec79fb3bb9f35ea86646c4640a37a639
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Dec 2 14:00:46 2010 +0000

    cogl: Add a GLSL 'progend'
    
    'progend' is short for 'program backend'. The progend is intended to
    operate on combined state from a fragment backend and a vertex
    backend. The progend has an 'end' function which is run whenever the
    pipeline is flushed and the two pipeline change notification
    functions. All of the progends are run whenever the pipeline is
    flushed instead of selecting a single one because it is possible that
    multiple progends may be in use for example if the vertends and
    fragends are different. The GLSL progend will take the shaders
    generated by the fragend and vertend and link them into a single
    program. The fragend code has been changed to only generate the shader
    and not the program. The idea is that pipelines can share fragment
    shader objects even if their vertex state is different. The authority
    for the progend needs to be the combined authority on the vertend and
    fragend state.

 cogl/Makefile.am                          |    2 +
 cogl/cogl-pipeline-fragend-glsl-private.h |    3 +
 cogl/cogl-pipeline-fragend-glsl.c         |  725 ++++++++---------------------
 cogl/cogl-pipeline-opengl.c               |    5 +
 cogl/cogl-pipeline-private.h              |   29 ++
 cogl/cogl-pipeline-progend-glsl-private.h |   36 ++
 cogl/cogl-pipeline-progend-glsl.c         |  542 +++++++++++++++++++++
 cogl/cogl-pipeline.c                      |   39 ++-
 8 files changed, 839 insertions(+), 542 deletions(-)

commit 91132871ad9b2347edc790cb4f7fe95bbc599c43
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Dec 2 13:54:15 2010 +0000

    cogl-program: Add private functions to check if have each shader type
    
    This adds two internal functions:
    
    gboolean
    _cogl_program_has_fragment_shader (CoglHandle handle);
    
    gboolean
    _cogl_program_has_vertex_shader (CoglHandle handle);
    
    They just check whether any of the contained shaders are of that type.

 cogl/cogl-program-private.h |    6 ++++++
 cogl/cogl-program.c         |   29 +++++++++++++++++++++++++++++
 2 files changed, 35 insertions(+), 0 deletions(-)

commit 7562a176858881b9a95120b1c4a1cf1b19c25441
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Dec 1 17:06:18 2010 +0000

    cogl-pipeline: Make find codegen authority more general
    
    The pipeline function _cogl_pipeline_find_codegen_authority has been
    renamed to _cogl_pipeline_find_equivalent_parent and it now takes a
    set of flags for the pipeline and layer state that affects the
    authority. This is needed so that we can reuse the same code in the
    vertend and progends.

 cogl/cogl-pipeline-fragend-arbfp.c |   47 ++++---------
 cogl/cogl-pipeline-fragend-glsl.c  |    9 ++-
 cogl/cogl-pipeline-private.h       |   39 +++++++++--
 cogl/cogl-pipeline.c               |  137 ++++++++++++++++--------------------
 4 files changed, 116 insertions(+), 116 deletions(-)

commit 6b7139b0080b5b11e5562ebcc6442a5a0e8b850e
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Nov 30 12:48:27 2010 +0000

    cogl-pipeline: Move texture enabling/disabling to fixed fragend
    
    Previously enabling and disabling textures was done whatever the
    backend in cogl-pipeline-opengl. However enabling and disabling
    texture targets only has any meaning if no fragment shaders are being
    used so this patch moves the code to cogl-pipeline-fragend-fixed.
    
    The GLES2 wrapper has also been changed to ignore enabledness when
    deciding whether to update texture coordinate attribute pointers.

 cogl/cogl-pipeline-fragend-arbfp.c    |    7 --
 cogl/cogl-pipeline-fragend-fixed.c    |  107 ++++++++++++++++++++++++++++++++-
 cogl/cogl-pipeline-fragend-glsl.c     |    7 --
 cogl/cogl-pipeline-opengl-private.h   |   16 ++---
 cogl/cogl-pipeline-opengl.c           |   95 +++++------------------------
 cogl/cogl-pipeline-private.h          |    2 -
 cogl/driver/gles/cogl-gles2-wrapper.c |   67 +++++++++-----------
 7 files changed, 157 insertions(+), 144 deletions(-)

commit 0098dc7acccff51f2b50ac0ff4aba69be005a687
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Nov 29 16:56:41 2010 +0000

    Rename CoglPipelineBackend to CoglPipelineFragend
    
    The current Cogl pipeline backends are entirely concerned with the
    fragment processing state. We also want to eventually have separate
    backends to generate shaders for the vertex processing state so we
    need to rename the fragment backends. 'Fragend' is a somewhat weird
    name but we wanted to avoid ending up with illegible symbols like
    CoglPipelineFragmentBackendGlslPrivate.

 cogl/Makefile.am                           |   12 +-
 cogl/cogl-context.c                        |    6 +-
 cogl/cogl-pipeline-arbfp-private.h         |   42 -
 cogl/cogl-pipeline-arbfp.c                 | 1133 -------------------------
 cogl/cogl-pipeline-fixed-private.h         |   36 -
 cogl/cogl-pipeline-fixed.c                 |  260 ------
 cogl/cogl-pipeline-fragend-arbfp-private.h |   43 +
 cogl/cogl-pipeline-fragend-arbfp.c         | 1133 +++++++++++++++++++++++++
 cogl/cogl-pipeline-fragend-fixed-private.h |   36 +
 cogl/cogl-pipeline-fragend-fixed.c         |  260 ++++++
 cogl/cogl-pipeline-fragend-glsl-private.h  |   36 +
 cogl/cogl-pipeline-fragend-glsl.c          | 1263 ++++++++++++++++++++++++++++
 cogl/cogl-pipeline-glsl-private.h          |   36 -
 cogl/cogl-pipeline-glsl.c                  | 1263 ----------------------------
 cogl/cogl-pipeline-opengl.c                |   66 +-
 cogl/cogl-pipeline-private.h               |   48 +-
 cogl/cogl-pipeline.c                       |  100 ++--
 17 files changed, 2887 insertions(+), 2886 deletions(-)

commit 6ce210062debddf6dd1099bf0150dd6e1e4e1c2a
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Dec 2 15:37:53 2010 +0000

    cogl-pipeline-opengl: Remove the includes for the various backends
    
    Nothing in cogl-pipeline-opengl needs to know about the actual backend
    implementations, instead it just accesses then through the vtables.

 cogl/cogl-pipeline-opengl.c |   10 ----------
 1 files changed, 0 insertions(+), 10 deletions(-)

commit 42c991fa24c1644ddf357a549bd76db89180bcfd
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Thu Dec 9 15:52:04 2010 +0000

    docs: Add 1.6 index to the API references

 doc/reference/cogl/cogl-docs.xml.in |    5 +++++
 1 files changed, 5 insertions(+), 0 deletions(-)

commit 83bfa4558403aa9486b476e22d8d22c537a4d30a
Merge: 87f979c d2326d4
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Thu Dec 9 11:58:10 2010 +0000

    Merge remote branch 'elliot/cookbook-animations-looping-new-api'
    
    * elliot/cookbook-animations-looping-new-api:
      cookbook: Use new API to reverse timeline

commit 87f979cfd869c0a911362644aadba7b829b3c267
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Dec 8 18:57:42 2010 +0000

    pipeline: don't dereference NULL program state
    
    This avoid dereferencing a NULL arbfp program state in
    _cogl_pipeline_backend_arbfp_layer_pre_change_notify for
    _STATE_COMBINE_CONSTANT changes.

 cogl/cogl-pipeline-arbfp.c |   12 ++++++++----
 1 files changed, 8 insertions(+), 4 deletions(-)

commit 82f6800442a3d9416bd129337375929dab5006af
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Dec 8 16:29:37 2010 +0000

    arbfp: Copy pipelines used as cache keys
    
    We are currently using a pipeline as a key into our arbfp program cache
    but because we weren't making a copy of the pipelines used as keys there
    were times when doing a lookup in the cache would end up trying to
    compare a lookup key with an entry key that would point to invalid
    memory.
    
    Note: the current approach isn't ideal from the pov that that key
    pipeline may reference some arbitrarily large user textures will now be
    kept alive indefinitely. The plan to improve on this is that we will
    have a mechanism to create a special "key pipeline" which will derive
    from the default Cogl pipeline (to avoid affecting the lifetime of
    other pipelines) and only copy state from the original pipeline that
    affects the arbfp program and will reference small dummy textures
    instead of potentially large user textures.

 cogl/cogl-pipeline-arbfp.c |   34 +++++++++++++++++++++++++++++++++-
 1 files changed, 33 insertions(+), 1 deletions(-)

commit ba95ee66a32414fbe389ae6071d2140b9779251a
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Dec 8 16:27:57 2010 +0000

    arbfp: initialize arbfp_program_state->next_constant_id
    
    When allocating a new ArbfpProgramState struct when starting code
    generation we weren't initializing arbfp_program_state->next_constant_id
    to 0.

 cogl/cogl-pipeline-arbfp.c |    1 +
 1 files changed, 1 insertions(+), 0 deletions(-)

commit ea8c9f3b2786a1d479d578239d1251acd5f53c58
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Dec 8 16:23:10 2010 +0000

    pipeline: Clarify stages for finding an arbfp program
    
    In the arbfp backend there is a seqential approach to finding a suitable
    arbfp program to use for a given pipeline; first we see if there's
    already a program associated with the pipeline, 2nd we try and find a
    program associated with the "arbfp-authority" 3rd we try and lookup a
    program in a cache and finally we resort to starting code-generation for
    a new program. This patch slightly reworks the code of these steps to
    hopefully make them a bit clearer.

 cogl/cogl-pipeline-arbfp.c |  104 ++++++++++++++++++++++++++------------------
 1 files changed, 61 insertions(+), 43 deletions(-)

commit 62a12a16a2a494bed152d768f0dae89a4dad37de
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Dec 6 21:14:33 2010 +0000

    cogl-pipeline: Fix the layer_has_alpha_cb
    
    _cogl_pipeline_needs_blending_enabled tries to determine whether each
    layer is using the default combine state. However it was using
    argument 0 for both checks so the if-statement would never be true.

 cogl/cogl-pipeline.c |    4 ++--
 1 files changed, 2 insertions(+), 2 deletions(-)

commit 3984f79c283a462a4bd4a67553a4f4554074a0b6
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Dec 8 11:38:56 2010 +0000

    pipeline: remove unused HashState member
    
    There was an unused pipeline_differences member as part of the HashState
    struct which this patch remove to avoid confusion.

 cogl/cogl-pipeline.c |    1 -
 1 files changed, 0 insertions(+), 1 deletions(-)

commit 778700288e3c0a89cfe1c284af7557698717b750
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Dec 8 11:35:16 2010 +0000

    pipeline: initialize HashState flags member
    
    There are a set of "EvalFlags" that get passed to _cogl_pipeline_hash
    that can tweak the semantics of what state is evaluated for hashing but
    these flags weren't getting passed via the HashState state structure
    so it would be undefined if you would get the correct semantics.

 cogl/cogl-pipeline.c |    1 +
 1 files changed, 1 insertions(+), 0 deletions(-)

commit e7535c6b6a95478641671793ab3aa7e022b16d18
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Dec 8 11:30:00 2010 +0000

    pipeline: don't use near/far symbols
    
    According to 9cc90333473e3 the windows headers #define near as nothing,
    and presumable the same is true for 'far' too. Apparently this define is
    to improve compatibility with code written for Windows 3.1, so it's good
    that people will be able to incorporate such code into their Clutter
    applications.

 cogl/cogl-pipeline.c |    8 ++++----
 1 files changed, 4 insertions(+), 4 deletions(-)

commit 19562fc97205664db5c48a9123dc24b575807df3
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Dec 7 16:44:36 2010 +0000

    context: only declare arbfp cache for GL
    
    We were trying to declare and initializing an arbfp program cache for
    GLES but since the prototypes for the _hash and _equal functions were
    only available for GL this broke the GLES builds. By #ifdefing the code
    to conditionally declare/initialize for GL only this should hopefully
    fix GLES builds.

 cogl/cogl-context.c |    4 ++++
 cogl/cogl-context.h |    2 ++
 2 files changed, 6 insertions(+), 0 deletions(-)

commit 6112ebd723fd5840d56a0a531587345f2a4ef4e7
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Dec 7 16:36:44 2010 +0000

    pipeline: remove spurious use of True instead of TRUE
    
    The constant 'True' is defined by Xlib which isn't used for all clutter
    builds so this replaces occurrences of True with TRUE which is defined
    by glib. This should hopefully fix the win32 builds.

 cogl/cogl-pipeline.c |    4 ++--
 1 files changed, 2 insertions(+), 2 deletions(-)

commit 0087910574e448b534186d98764652e8c222af9d
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Dec 3 12:01:18 2010 +0000

    arbfp: Adds an ARBfp program cache
    
    This adds a cache (A GHashTable) of ARBfp programs and before ever
    starting to code-generate a new program we will always first try and
    find an existing program in the cache. This uses _cogl_pipeline_hash and
    _cogl_pipeline_equal to hash and compare the keys for the cache.
    
    There is a new COGL_DEBUG=disable-program-caches option that can disable
    the cache for debugging purposes.

 cogl/cogl-context.c                |    6 ++
 cogl/cogl-context.h                |    2 +
 cogl/cogl-debug-options.h          |    5 ++
 cogl/cogl-debug.c                  |    8 ++-
 cogl/cogl-debug.h                  |    3 +-
 cogl/cogl-pipeline-arbfp-private.h |    6 ++
 cogl/cogl-pipeline-arbfp.c         |  111 +++++++++++++++++++++++++++++------
 7 files changed, 118 insertions(+), 23 deletions(-)

commit 046434e222cff3717a0a2c46cdfb6b399621511a
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Nov 4 13:57:36 2010 +0000

    pipeline: Implements _cogl_pipeline_hash function
    
    This allows us to get a hash for a set of state groups for a given
    pipeline. This can be used for example to get a hash of the fragment
    processing state of a pipeline so we can implement a cache for compiled
    arbfp/glsl programs.

 cogl/cogl-color-private.h    |    5 +
 cogl/cogl-context.c          |    2 +
 cogl/cogl-pipeline-private.h |   18 ++-
 cogl/cogl-pipeline.c         |  520 ++++++++++++++++++++++++++++++++++++++++++
 cogl/cogl-util.c             |    9 +
 cogl/cogl-util.h             |   27 +++
 6 files changed, 580 insertions(+), 1 deletions(-)

commit 2c9cd76baa76aa6ad4b6612bece7585ba9ed95b2
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Dec 3 11:36:49 2010 +0000

    pipeline: generalize _cogl_pipeline_equal
    
    _cogl_pipeline_equal now accepts a mask of pipeline differences and layer
    differences to constrain what state will be compared. In addition a set
    of flags are passed that can tweak the comparison semantics for some
    state groups. For example when comparing layer textures we sometimes
    only need to compare the texture target and can ignore the data itself.
    
    In updating the code this patch also changes it so all required pipeline
    authorities are resolved in one step up-front instead of resolving the
    authority for each state group in turn and repeatedly having to traverse
    the pipeline's ancestry. This adds two new functions
    _cogl_pipeline_resolve_authorities and
    _cogl_pipeline_layer_resolve_authorities to handle resolving a set of
    authorities.

 cogl/cogl-journal.c          |    9 +-
 cogl/cogl-pipeline-private.h |  155 ++++++++++++++++-------
 cogl/cogl-pipeline.c         |  287 ++++++++++++++++++++++++++++-------------
 3 files changed, 312 insertions(+), 139 deletions(-)

commit 8e899985c676d7b5cd37533082082a35bfac64e2
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Dec 1 16:53:08 2010 +0000

    pipeline: remove layer->backend_priv[] array
    
    This removes the unused array of per-packend priv data pointers
    associated with every CoglPipelineLayer. This reduces the size of all
    layer allocations and avoids having to zero an array for each
    _cogl_pipeline_layer_copy.

 cogl/cogl-pipeline-arbfp.c   |    1 -
 cogl/cogl-pipeline-glsl.c    |    3 +--
 cogl/cogl-pipeline-private.h |    9 ---------
 cogl/cogl-pipeline.c         |   24 ------------------------
 4 files changed, 1 insertions(+), 36 deletions(-)

commit ae3a9eec7ca876d8bbfc7758671937a1c085ef81
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Dec 1 16:37:25 2010 +0000

    cogl-object: remove un-used cogl_object_get_type
    
    A non-static function named cogl_object_get_type was inadvertently added
    during the addition of the CoglObject base type, but there is no public
    prototype in the headers and it's only referenced inside cogl-object.c
    to implement cogl_handle_get_type() for compatibility. This removes the
    function since we don't want to commit to CoglObject always simply being
    a boxed type. In the future we may want to register hierarchical
    GTypeInstance based types.

 cogl/cogl-object.c |    8 +-------
 1 files changed, 1 insertions(+), 7 deletions(-)

commit fd10e3a545f071e3006694cd1c0baa8dd2bd0914
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Nov 29 21:42:06 2010 +0000

    matrix gtype: registers a boxed type for CoglMatrix
    
    To allow us to have gobject properties that accept a CoglMatrix value we
    need to register a GType. This adds a cogl_gtype_matrix_get_type function
    that will register a static boxed type called "CoglMatrix".
    
    This adds a new section to the reference manual for GType integration
    functions.

 cogl/Makefile.am                     |    1 +
 cogl/cogl-gtype-private.h            |   48 ++++++++++++++++++++++++++++++++++
 cogl/cogl-matrix.c                   |    7 +++++
 cogl/cogl-matrix.h                   |   16 +++++++++++
 cogl/cogl.h                          |    6 ++++
 doc/reference/cogl/cogl-docs.xml.in  |    1 +
 doc/reference/cogl/cogl-sections.txt |    6 ++++
 7 files changed, 85 insertions(+), 0 deletions(-)

commit 3ac023163fc64b0bddfa891430b5a2e1ca9e0fd1
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Nov 29 18:47:10 2010 +0000

    matrix: Adds matrix_copy and _free functions
    
    As a pre-requisite for being able to register a boxed GType for
    CoglMatrix (enabling us to define gobject properties that accept a
    CoglMatrix) this adds cogl_matrix_copy and _free functions.

 cogl/cogl-matrix.c |   15 +++++++++++++++
 cogl/cogl-matrix.h |   27 +++++++++++++++++++++++++++
 2 files changed, 42 insertions(+), 0 deletions(-)

commit 98dd3f723c19b1d9f5a249d6bd08db58c76eabba
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Dec 3 16:59:52 2010 +0000

    pipeline simple optimization for _needs_blending_enabled
    
    In _cogl_pipeline_needs_blending_enabled after first checking whether
    the property most recently changed requires blending we would then
    resort to checking all other properties too in case some other state
    also requires blending. We now avoid checking all other properties in
    the case that blending was previously disabled and checking the property
    recently changed doesn't require blending.
    
    Note: the plan is to improve this further by explicitly keeping track
    of the properties that currently cause blending to be enabled so that we
    never have to resort to checking all other properties we can constrain
    the checks to those masked properties.

 cogl/cogl-pipeline.c |   17 +++++++++++++----
 1 files changed, 13 insertions(+), 4 deletions(-)

commit 6b08583f2f08d4737d3a436f440cdf52c2d70108
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Dec 3 16:56:54 2010 +0000

    pipeline: inline _get_parent and _get_authority
    
    This moves _cogl_pipeline_get_parent and _cogl_pipeline_get_authority
    into cogl-pipeline-private.h so they can be inlined since they have been
    seen to get quite high in profiles. Given that they both contain such
    small amounts of code the function call overhead is significant.

 cogl/cogl-pipeline-private.h |   17 +++++++++++++++++
 cogl/cogl-pipeline.c         |   17 -----------------
 2 files changed, 17 insertions(+), 17 deletions(-)

commit e292d28c5657e300d4128f15968930832dfefa0a
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Nov 10 14:02:31 2010 +0000

    Add a COGL_DEBUG option to disable software clipping
    
    This adds a debug option called disable-software-clipping which causes
    the journal to always log the clip stack state rather than trying to
    manually clip rectangles.

 cogl/cogl-debug-options.h |    5 +++++
 cogl/cogl-debug.c         |    3 ++-
 cogl/cogl-debug.h         |    3 ++-
 cogl/cogl-journal.c       |   23 +++++++++++++----------
 4 files changed, 22 insertions(+), 12 deletions(-)

commit 1d88e6c8acdbbad6c9285ab92ea435eb7d3c0840
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Nov 9 19:18:37 2010 +0000

    cogl-journal: Attempt to clip manually to avoid breaking up batches
    
    Before flushing the journal there is now a separate iteration that
    will try to determine if the matrix of the clip stack and the matrix
    of the rectangle in each entry are on the same plane. If they are it
    can completely avoid the clip stack and instead manually modify the
    vertex and texture coordinates to implement the clip. The has the
    advantage that it won't break up batching if a single clipped
    rectangle is used in a scene.
    
    The software clip is only used if there is no user program and no
    texture matrices. There is a threshold to the size of the batch where
    it is assumed that it is worth the cost to break up a batch and
    program the GPU to do the clipping. Currently this is set to 8
    although this figure is plucked out of thin air.
    
    To check whether the two matrices are on the same plane it tries to
    determine if one of the matrices is just a simple translation of the
    other. In the process of this it also works out what the translation
    would be. These values can be used to translate the clip rectangle
    into the coordinate space of the rectangle to be logged. Then we can
    do the clip directly in the rectangle's coordinate space.

 cogl/cogl-context.c         |    3 +
 cogl/cogl-context.h         |    1 +
 cogl/cogl-journal-private.h |    2 +
 cogl/cogl-journal.c         |  363 ++++++++++++++++++++++++++++++++++++++++++-
 4 files changed, 363 insertions(+), 6 deletions(-)

commit 7294e5552c943fa9851af8fa41f6f3fa68029830
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Nov 9 19:09:25 2010 +0000

    cogl-clip-stack: Move the struct definitions to the header
    
    It will be useful to be able to directly examine the contents of the
    clip stack within the journal code.

 cogl/cogl-clip-stack.c |  112 -----------------------------------------------
 cogl/cogl-clip-stack.h |  114 ++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 114 insertions(+), 112 deletions(-)

commit 07e49d5257abd3ad58a238b02ade18b8ae0d5475
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Nov 9 12:01:04 2010 +0000

    cogl-clip-stack: Don't convert rect clips to window clips
    
    Previously in cogl-clip-state.c when it detected that the current
    modelview matrix is screen-aligned it would convert the clip entry to
    a window clip. Instead of doing this cogl-clip-stack.c now contains
    the detection and keeps the entry as a rectangle clip but marks that
    it is entirely described by its scissor rect. When flusing the clip
    stack it doesn't do anything extra for entries that have this mark
    (because the clip will already been setup by the scissor). This is
    needed so that we can still track the original rectangle coordinates
    and modelview matrix to help detect when it would be faster to modify
    the rectangle when adding it to the journal rather than having to
    break up the batch to set the clip state.

 cogl/cogl-clip-stack.c |  109 ++++++++++++++++++++++++++++++++++++-----------
 cogl/cogl-clip-state.c |   55 ------------------------
 2 files changed, 83 insertions(+), 81 deletions(-)

commit b14c2f799c880ab1012d72007e61074de5ee3e6c
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Nov 25 21:08:45 2010 +0000

    cogl-journal: Defer expanding the vertices until uploading
    
    When logging a quad we now only store the 2 vertices representing the
    top left and bottom right of the quad. The color is only stored once
    per entry. Once we come to upload the data we expand the 2 vertices
    into four and copy the color to each vertex. We do this by mapping the
    buffer and directly expanding into it. We have to copy the data before
    we can render it anyway so it doesn't make much sense to expand the
    vertices before uploading and this way should save some space in the
    size of the journal. It also makes it slightly easier if we later want
    to do pre-processing on the journal entries before uploading such as
    doing software clipping.
    
    The modelview matrix is now always copied to the journal entry whereas
    before it would only be copied if we aren't doing software
    transform. The journal entry struct always has the space for the
    modelview matrix so hopefully it's only a small cost to copy the
    matrix.
    
    The transform for the four entries is now done using
    cogl_matrix_transform_points which may be slightly faster than
    transforming them each individually with a call to
    cogl_matrix_transfom.

 cogl/cogl-context.h |    1 +
 cogl/cogl-journal.c |  273 ++++++++++++++++++++++++++++++++-------------------
 2 files changed, 173 insertions(+), 101 deletions(-)

commit f8449582c8dc974bd9adb33fd3dc00d2d1217c95
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Dec 2 21:08:30 2010 +0000

    Revert "cogl: Remove the generated array size for cogl_tex_coord_in"
    
    This reverts commit 4cfe90bde275dbb952645397aa2ba2d6f6e2f3ba.
    
    GLSL 1.00 on GLES doesn't support unsized arrays so the whole idea
    can't work.
    
    Conflicts:
    
    	clutter/cogl/cogl/cogl-pipeline-glsl.c

 cogl/cogl-context.c                 |    2 +-
 cogl/cogl-pipeline-arbfp.c          |    3 +-
 cogl/cogl-pipeline-fixed.c          |    3 +-
 cogl/cogl-pipeline-glsl.c           |   52 +++++++-
 cogl/cogl-pipeline-opengl-private.h |    3 +-
 cogl/cogl-pipeline-opengl.c         |    6 +-
 cogl/cogl-pipeline-private.h        |    3 +-
 cogl/cogl-shader-boilerplate.h      |    1 -
 cogl/cogl-shader-private.h          |    6 +
 cogl/cogl-shader.c                  |  229 ++++++++++++++++++++++++++---------
 cogl/cogl-vertex-attribute.c        |    4 +-
 cogl/cogl.c                         |    9 ++-
 cogl/cogl2-path.c                   |    4 +-
 13 files changed, 250 insertions(+), 75 deletions(-)

commit f54cc7abd43b8f6919daf36f096f4f89520a6046
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Dec 2 16:30:55 2010 +0000

    cogl-pipeline-glsl: Fix reusing shaders for shared ancestors
    
    The check for whether we can reuse a program we've already generated
    was only being done if the pipeline already had a
    glsl_program_state. When there is no glsl_program_state it then looks
    for the nearest ancestor it can share the program with. It then
    wasn't checking whether that ancestor already had a GL program so it
    would start generating the source again. It wouldn't however compile
    that source again because _cogl_pipeline_backend_glsl_end does check
    whether there is already a program. This patch moves the check until
    after it has found the glsl_program_state, whether or not it was found
    from an ancestor or as its own state.

 cogl/cogl-pipeline-glsl.c |   32 +++++++++++++++-----------------
 1 files changed, 15 insertions(+), 17 deletions(-)

commit 6607306a2de23245ed7d36cdefc2dfc7883e61f2
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Dec 2 12:27:29 2010 +0000

    cogl: Remove the generated array size for cogl_tex_coord_in
    
    Under GLES2 we were defining the cogl_tex_coord_in varying as an array
    with a size determined by the number of texture coordinate arrays
    enabled whenever the program is used. This meant that we may have to
    regenerate the shader with a different size if the shader is used with
    more texture coord arrays later. However in OpenGL the equivalent
    builtin varying gl_TexCoord is simply defined as:
    
    varying vec4 gl_TexCoord[]; /* <-- no size */
    
    GLSL is documented that if you declare an array with no size then you
    can only access it with a constant index and the size of the array
    will be determined by the highest index used. If you want to access it
    with a non-constant expression you need to redeclare the array
    yourself with a size.
    
    We can replicate the same behaviour in our Cogl shaders by instead
    declaring the cogl_tex_coord_in with no size. That way we don't have
    to pass around the number of tex coord attributes enabled when we
    flush a material. It also means that CoglShader can go back to
    directly uploading the source string to GL when cogl_shader_source is
    called so that we don't have to keep a copy of it around.
    
    If the user wants to access cogl_tex_coord_in with a non-constant
    index then they can simply redeclare the array themself. Hopefully
    developers will expect to have to do this if they are accustomed to
    the gl_TexCoord array.

 cogl/cogl-context.c                 |    2 +-
 cogl/cogl-pipeline-arbfp.c          |    3 +-
 cogl/cogl-pipeline-fixed.c          |    3 +-
 cogl/cogl-pipeline-glsl.c           |   46 +-------
 cogl/cogl-pipeline-opengl-private.h |    3 +-
 cogl/cogl-pipeline-opengl.c         |    6 +-
 cogl/cogl-pipeline-private.h        |    3 +-
 cogl/cogl-shader-boilerplate.h      |    1 +
 cogl/cogl-shader-private.h          |    6 -
 cogl/cogl-shader.c                  |  229 +++++++++--------------------------
 cogl/cogl-vertex-attribute.c        |    4 +-
 cogl/cogl.c                         |    9 +--
 cogl/cogl2-path.c                   |    4 +-
 13 files changed, 73 insertions(+), 246 deletions(-)

commit d2326d497ad24a5a75ad8ad350b82aa66f967bb7
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Dec 1 15:48:37 2010 +0000

    cogl-pipeline: Fix comparing layer states for finding codgen authority
    
    When compiling for GLES2, the codegen is affected by state other than
    the layers. That means when we find an authority for the codegen state
    we can't directly look at authority->n_layers to determine the number
    of layers because it isn't necessarily the layer state authority. This
    patch changes it to use cogl_pipeline_get_n_layers instead. Once we
    have two authorities that differ in codegen state we then compare all
    of the layers to decide if they would affect codegen. However it was
    ignoring the fact that the authorities might also differ by the other
    codegen state. This path also adds an extra check for whether
    _cogl_pipeline_compare_differences contains any codegen bits other
    than COGL_PIPELINE_STATE_LAYERS.

 cogl/cogl-pipeline.c |   11 +++++++++--
 1 files changed, 9 insertions(+), 2 deletions(-)

commit cf50b4f614f08a5d4afc4dd39295ffd7787a10d6
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Dec 1 14:39:28 2010 +0000

    cogl-pipeline: Fix the codgen authority for texture target changes
    
    When determining if a layer would require a different shader to be
    generated it needs to check a certain set of state changes and it
    needs to check whether the texture target is different. However it was
    checking whether texture texture was different only if the other state
    was also different which doesn't make any sense. It also only checked
    the texture difference if that was the only state change which meant
    that effectively the code was impossible to reach. Now it does the
    texture target check indepent of the other state changes.

 cogl/cogl-pipeline.c |   29 ++++++++++++++---------------
 1 files changed, 14 insertions(+), 15 deletions(-)

commit c492db38e03e2b73d6a131b83d9b3f32e1ad7d47
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Nov 30 22:28:38 2010 +0000

    cogl-pipeline-fixed: Use the correct state flag for combine constant
    
    The fixed pipeline backend wasn't correctly flushing the combine
    constant because it was using the wrong flag to determine if the
    combine constant has changed since the last flushed material.

 cogl/cogl-pipeline-fixed.c |    6 +++---
 1 files changed, 3 insertions(+), 3 deletions(-)

commit 7ea97b3eb7dedb5bf23525076a8b680881c2ecd9
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Nov 30 22:17:17 2010 +0000

    cogl-pipeline-opengl: Fix enabling previously disabled units
    
    When enabling a unit that was disabled from a previous flush pipeline
    it was forgetting to rebind the right texture unit so it wouldn't
    work. This was causing the redhand to disappear when using the fixed
    function backend in test-cogl-multitexture if anything else is added
    to the scene.

 cogl/cogl-pipeline-opengl.c |    1 +
 1 files changed, 1 insertions(+), 0 deletions(-)

commit 7d840de18f6bc44287e93112870ed02b614f421b
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Nov 30 22:15:40 2010 +0000

    cogl-pipeline: Add more ignored state changes for program generation
    
    For shader generation backends we don't need to worry about changes to
    the texture object and changing the user matrix. The missing user
    matrix flag was causing test-cogl-multitexture to regenerate the
    shader every frame.

 cogl/cogl-pipeline-arbfp.c |    5 ++++-
 cogl/cogl-pipeline-glsl.c  |    5 ++++-
 2 files changed, 8 insertions(+), 2 deletions(-)

commit e905087e70db1470c6114334e93680a11f469ebe
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Tue Nov 30 16:36:56 2010 +0000

    cogl: Revert "build: Remove unused variable"
    
    Having ctx here produces a warning on GLES. However it's needed for Big
    GL as we have at the top of the file:
    
     #ifdef HAVE_COGL_GL
     #define glClientActiveTexture ctx->drv.pf_glClientActiveTexture
     #endif
    
    This reverts commit 27a3a2056a245aca64b8e3a7d82b7976c13e897a.

 cogl/cogl.c |    2 ++
 1 files changed, 2 insertions(+), 0 deletions(-)

commit 8f6bf57dfbb5f35e1cd81d90bf45e6d93667bab4
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Tue Nov 30 16:03:26 2010 +0000

    cogl: Fix unused variable warning with GLES2
    
    This shader variable is only used with big GL.

 cogl/cogl-shader.c |    2 ++
 1 files changed, 2 insertions(+), 0 deletions(-)

commit 5eb800656d94327367191f15ccf9f39dde3da497
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Fri Nov 19 14:51:39 2010 -0500

    build: Remove unused variable
    
    and be 100% warning free again.

 cogl/cogl.c |    2 --
 1 files changed, 0 insertions(+), 2 deletions(-)

commit 3cad93b8a201695339bd412e2f73d3ef52c9a3b2
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Nov 29 10:55:49 2010 +0000

    cogl-shader.c: Don't add the common boilerplate twice
    
    In 6246c2bd6 I moved the code to add the boilerplate to a shader to a
    separate function and also made it so that the common boilerplate is
    added as a separate string to glShaderSource. However I didn't notice
    that the #define for the vertex and fragment shaders already includes
    the common part so it was being added twice. Mesa seems to accept this
    but it was causing problems on the IMG driver because COGL_VERSION was
    defined twice.

 cogl/cogl-shader.c |    8 ++------
 1 files changed, 2 insertions(+), 6 deletions(-)

commit 84dc0ad2eb5a6c1efd02945f435b72f6bf00ed1d
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Nov 29 10:51:40 2010 +0000

    cogl-pipeline-glsl: Use char* instead of GLchar*
    
    It appears that some GLES2 headers don't define GLchar and it works
    just as well to use a regular char.

 cogl/cogl-pipeline-glsl.c |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)

commit 44678af8abd7745d10ebbde327781e354717efda
Merge: 2f95704 38929d5
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Nov 29 11:56:36 2010 +0000

    Merge remote branch 'elliot/cookbook-animations-scaling'
    
    * elliot/cookbook-animations-scaling:
      cookbook: Add recipe for animated scaling of an actor
      cookbook: Add example of scaling a texture
      cookbook: Added "animated scaling" recipe skeleton
      cookbook: Added animated scaling example

commit 2f95704d0a0778ddb1c23cbb17d658335c0a35e1
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Nov 26 15:23:15 2010 +0000

    cogl_pipeline_equal: Fix the comparison for layer texture equality
    
    Before commit 49898d43 CoglPipeline would compare whether a pipeline
    layer's texture is equal by fetching the underlying GL handle. I
    changed that so that it would only compare the CoglHandles because
    that commit removes the GL handle texture overrides and sliced
    textures instead log the underlying primitive texture. However I
    forgot that the primitives don't always use
    _cogl_texture_foreach_sub_texture_in_region when the quad fits within
    the single texture so it won't use a texture override. This meant that
    atlas textures and sub textures get logged with the atlas handle so
    the comparison still needs to be done using the GL handles. It might
    be nice to add a CoglTexture virtual to get the underlying primitive
    texture instead to avoid having the pipeline poke around with GL
    handles.

 cogl/cogl-pipeline.c |    9 ++++++++-
 1 files changed, 8 insertions(+), 1 deletions(-)

commit a57e6e7214f217bc9368b702b1ee9610855d303d
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Nov 25 20:12:36 2010 +0000

    primitives: avoid leaking polygon override materials
    
    If we have to make override changes to the user's source material to
    handle cogl_polygon then we need to make sure we unref the override
    material at the end.

 cogl/cogl-primitives.c |    3 +++
 1 files changed, 3 insertions(+), 0 deletions(-)

commit c64e0103afdf5d4f79137638657cfdacbddd34a8
Author: Alexandre Quessy <alexandre@quessy.net>
Date:   Thu Nov 25 13:13:51 2010 -0500

    Fixed "the the" repetitions in some doc strings
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2450

 cogl/cogl-fixed.c         |    2 +-
 cogl/cogl-vertex-buffer.c |    2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

commit cf647e327f96fdc956143f51e50289001a5b043a
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Nov 25 13:19:59 2010 +0000

    pipeline: Simplify layer change notifications to backend
    
    Previously we used the layers->backend_priv[] members to determine when
    to notify backends about layer changes, but it entirely up to the
    backends if they want to associate private state with layers, even
    though they may still be interested in layer change notifications (they
    may associate layer related state with the owner pipeline).
    
    We now make the observation that in
    _cogl_pipeline_backend_layer_change_notify we should be able to assume
    there can only be one backend currently associated with the layer
    because we wouldn't allow changes to a layer with multiple dependants.
    This means we can determine the backend to notify by looking at the
    owner pipeline instead.

 cogl/cogl-pipeline.c |   22 ++++++++++------------
 1 files changed, 10 insertions(+), 12 deletions(-)

commit 7474d320f6e1ea9bcfbaebfc3ba23de767386c20
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Nov 24 18:37:47 2010 +0000

    cogl-context: Get rid of the features_cached member
    
    The features_cached member of CoglContext is intended to mark when
    we've calculated the features so that we know if they are ready in
    cogl_get_features. However we always intialize the features while
    creating the context so features_cached will never be FALSE so it's
    not useful. We also had the odd behaviour that the COGL_DEBUG feature
    overrides were only applied in the first call to
    cogl_get_features. However there are other functions that use the
    feature flags such as cogl_features_available that don't use this
    function so in some cases the feature flags will be interpreted before
    the overrides are applied. This patch makes it always initialize the
    features and apply the overrides immediately while creating the
    context. This fixes a problem with COGL_DEBUG=disable-arbfp where the
    first material flushed is done before any call to cogl_get_features so
    it may still use ARBfp.

 cogl/cogl-context.c          |   24 +++++++++++++++++++++++-
 cogl/cogl-context.h          |    1 -
 cogl/cogl.c                  |   24 ------------------------
 cogl/driver/gl/cogl-gl.c     |    1 -
 cogl/driver/gles/cogl-gles.c |    1 -
 5 files changed, 23 insertions(+), 28 deletions(-)

commit bbf912b61d298ca3b1a3aff399c79c9ad493cb6a
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Nov 24 17:42:34 2010 +0000

    Lower the priority of the GLSL pipeline backend
    
    Now that the GLSL backend can generate code it can effectively handle
    any pipeline unless there is an ARBfp program. However with current
    open source GL drivers the ARBfp compiler is more stable so it makes
    sense to prefer ARBfp when possible. The GLSL backend is also lower
    than the fixed function backend on the assumption that any driver that
    supports GLSL will also support ARBfp so it's quicker to try the fixed
    function backend next.

 cogl/cogl-pipeline-private.h |   12 ++++++------
 1 files changed, 6 insertions(+), 6 deletions(-)

commit 4d0b167be4cab8ff6a89c0a4a66d37cd3ebeecad
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Nov 24 17:29:00 2010 +0000

    Add a COGL_DEBUG option to disable the fixed function pipeline backend
    
    This adds COGL_DEBUG=disable-fixed to disable the fixed function
    pipeline backend. This is needed to test the GLSL shader generation
    because otherwise the fixed function backend would always override it.

 cogl/cogl-debug-options.h  |    5 +++++
 cogl/cogl-debug.c          |    1 +
 cogl/cogl-debug.h          |   15 ++++++++-------
 cogl/cogl-pipeline-fixed.c |    3 +++
 4 files changed, 17 insertions(+), 7 deletions(-)

commit 54ac6b16bf4f51c21201483dd59af76ff2f7c851
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Nov 24 17:33:07 2010 +0000

    Don't use the fixed function backend if there is a user program
    
    The fixed function pipeline backend can't handle a user program so it
    should bail out if one is given.

 cogl/cogl-pipeline-fixed.c |    6 ++++++
 1 files changed, 6 insertions(+), 0 deletions(-)

commit 8083167be98b92cc65a786b5b37e35c840bbbcf8
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Nov 24 17:37:55 2010 +0000

    Add a warning message when no usable Cogl pipeline backend is found
    
    If none of the pipeline backends can handle the state then it now
    displays a warning so the developer has a chance to work out what's
    going on.

 cogl/cogl-pipeline-opengl.c |    3 +++
 1 files changed, 3 insertions(+), 0 deletions(-)

commit cda5ea771bd2f85d7c171c2ad6484e43e35a8bb3
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Nov 24 15:30:56 2010 +0000

    cogl-pipeline-glsl: Don't use gl_PointCoord on OpenGL
    
    We don't want to use gl_PointCoord to implement point sprites on big
    GL because in that case we already use glTexEnv(GL_COORD_REPLACE) to
    replace the texture coords with the point sprite coords. Although GL
    also supports the gl_PointCoord variable, it requires GLSL 1.2 which
    would mean we would have to declare the GLSL version and check for
    it. We continue to use gl_PointCoord for GLES2 because it has no
    glTexEnv function.

 cogl/cogl-pipeline-glsl.c |    9 ++++++++-
 1 files changed, 8 insertions(+), 1 deletions(-)

commit c50cb72748f708b8e4cf80a38c833403ef07f981
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Nov 23 14:47:17 2010 +0000

    Remove the fragment shader generation from the GLES2 wrapper
    
    The GLES2 wrapper no longer needs to generate any fragment shader
    state because the GLSL pipeline backend will always give the wrapper a
    custom fragment shader. This simplifies a lot of the state comparison
    done by the wrapper. The fog generation is also removed even though
    it's actually part of the vertex shader because only the fixed
    function pipeline backend actually calls the fog functions so it would
    be disabled when using any of the other backends anyway. We can fix
    this when the two shader backends also start generating vertex
    shaders.

 cogl/Makefile.am                                 |    5 +-
 cogl/cogl-pipeline-opengl.c                      |    8 +
 cogl/driver/gles/cogl-fixed-fragment-shader.glsl |   64 --
 cogl/driver/gles/cogl-gles2-wrapper.c            |  737 +---------------------
 cogl/driver/gles/cogl-gles2-wrapper.h            |   69 +--
 5 files changed, 22 insertions(+), 861 deletions(-)

commit 9089d95b3fa78a712cc56fee76e37bfd9f16c04f
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Nov 23 14:51:49 2010 +0000

    Disable the fixed function backend for GLES2
    
    GLES2 doesn't really support fixed function so if we disable it we can
    remove the fixed function wrappers from the GLES2 Cogl backend.

 cogl/cogl-pipeline-fixed.c   |   11 -----------
 cogl/cogl-pipeline-private.h |    4 +---
 cogl/cogl-pipeline.c         |    2 ++
 3 files changed, 3 insertions(+), 14 deletions(-)

commit a86a1df3725522dfd5133181c7063f9712cbefbe
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Nov 22 18:33:49 2010 +0000

    cogl-pipeline-glsl: Generate the alpha test snippet under GLES2
    
    GLES2 has no glAlphaFunc function so we need to simulate the behaviour
    in the fragment shader. The alpha test function is simulated with an
    if-statement and a discard statement. The reference value is stored as
    a uniform.

 cogl/cogl-pipeline-glsl.c |  144 +++++++++++++++++++++++++++++++++++++++++++-
 1 files changed, 140 insertions(+), 4 deletions(-)

commit 0a314a752d640afeaa373cf19892a4eeae0c1d25
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Nov 22 18:32:43 2010 +0000

    cogl-pipeline: Add getters for the alpha test state
    
    This adds two public functions:
    
     cogl_pipeline_get_alpha_test_function
       and
     cogl_pipeline_get_alpha_test_reference.

 cogl/cogl-pipeline.c |   25 +++++++++++++++++++++++++
 cogl/cogl-pipeline.h |   22 ++++++++++++++++++++++
 2 files changed, 47 insertions(+), 0 deletions(-)

commit 60000690e1b24174d6ced3addce16d87be9bec40
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Nov 22 18:29:50 2010 +0000

    cogl: Separate out state flags for the alpha test func and ref
    
    Previously the flag to mark the differences for the alpha test
    function and reference value were conflated into one. However this is
    awkward when generating shader code to simulate the alpha testing for
    GLES 2 because in that case changing the function would need a
    different program but changing the reference value just requires
    updating a uniform. This patch makes the function and reference have
    their own state flags.

 cogl/cogl-pipeline-opengl.c  |    3 +-
 cogl/cogl-pipeline-private.h |   25 +++++----
 cogl/cogl-pipeline.c         |  110 ++++++++++++++++++++++++++++++++---------
 3 files changed, 102 insertions(+), 36 deletions(-)

commit 38ad560b19c67c05e9815d4662cc4bfe2a23ddbe
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Nov 22 16:44:11 2010 +0000

    Remove the disabling of layer constants for GLES2
    
    The GLSL shader generation supports layer combine constants so there's
    no need to disable it for GLES2. It looks like there was also code for
    it in the GLES2 wrapper so I'm not sure why it was disabled in the
    first place.

 cogl/cogl-blend-string.c |   10 ----------
 1 files changed, 0 insertions(+), 10 deletions(-)

commit 7da3610e82bda0340b017551a1a8c54097a47186
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Nov 19 10:44:27 2010 +0000

    Generate GLSL in the CoglPipeline GLSL backend
    
    The GLSL pipeline backend can now generate code to represent the
    pipeline state in a similar way to the ARBfp backend. Most of the code
    for this is taken from the GLES 2 wrapper.

 cogl/cogl-context.c       |    1 +
 cogl/cogl-context.h       |    1 +
 cogl/cogl-pipeline-glsl.c |  772 ++++++++++++++++++++++++++++++++++++++++-----
 3 files changed, 702 insertions(+), 72 deletions(-)

commit 46e59dc50fdab6cc9d272e29ab28563fd7cfa1db
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Nov 22 12:15:35 2010 +0000

    Move the cogl shader boilerplate setting code to a separate function
    
    _cogl_shader_compile_real had some code to create a set of strings to
    combine the boilerplate code with a shader before calling
    glShaderSource. This has now been moved to its own internal function
    so that it could be used from the GLSL pipeline backend as well.

 cogl/cogl-shader-private.h |    8 ++++
 cogl/cogl-shader.c         |   96 ++++++++++++++++++++++++++++++++++----------
 2 files changed, 82 insertions(+), 22 deletions(-)

commit 0b280188735dfcc1360fe6f16e647fc641ccdcc4
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Nov 19 15:42:26 2010 +0000

    Move need_texture_combine_separate to cogl-pipeline
    
    need_texture_combine_separate is moved to cogl-pipeline.c and renamed
    to _cogl_pipeline_need_texture_combine_separate. The function is
    needed by both the ARBfp and GLSL codegen backends so it makes sense to
    share it.

 cogl/cogl-pipeline-arbfp.c   |   75 +-----------------------------------------
 cogl/cogl-pipeline-private.h |    4 ++
 cogl/cogl-pipeline.c         |   74 +++++++++++++++++++++++++++++++++++++++++
 3 files changed, 79 insertions(+), 74 deletions(-)

commit fac7338fdd2a9008f6f3fd1ab18273f95172b499
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Nov 19 10:43:52 2010 +0000

    Move find_arbfp_authority to cogl-pipeline.c
    
    The code for finding the arbfp authority for a pipeline should be the
    same as finding the GLSL authority. So that the code can be shared the
    function has been moved to cogl-pipeline.c and renamed to
    _cogl_pipeline_find_codegen_authority.

 cogl/cogl-pipeline-arbfp.c   |  145 +-----------------------------------------
 cogl/cogl-pipeline-private.h |    4 +
 cogl/cogl-pipeline.c         |  142 +++++++++++++++++++++++++++++++++++++++++
 3 files changed, 147 insertions(+), 144 deletions(-)

commit 7379a5fc04605661d895f2fac85cf7311b2bedbd
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Nov 1 17:25:26 2010 +0000

    cogl: Rename arbfp_source_buffer to fragment_source_buffer
    
    Only one of the material backends can be generating code at the same
    time so it seems to make sense to share the same source buffer between
    arbfp and glsl. The new name is fragment_source_buffer in case we
    later want to create a new buffer for the vertex shader. That probably
    couldn't share the same buffer because it will likely need to be
    generated at the same time.

 cogl/cogl-context.c        |    2 +-
 cogl/cogl-context.h        |    2 +-
 cogl/cogl-pipeline-arbfp.c |    6 +++---
 3 files changed, 5 insertions(+), 5 deletions(-)

commit 3be05abf6046c54b549bb4059ae0ea9d68fb2688
Author: Evan Nemerson <evan@coeus-group.com>
Date:   Fri Nov 19 23:27:46 2010 -0800

    cogl: Include exported pacakges information in GIR
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2438

 cogl/Makefile.am |    1 +
 1 files changed, 1 insertions(+), 0 deletions(-)

commit cda29a80112bfc070df9916366cc9cd541db550c
Author: Owen W. Taylor <otaylor@fishsoup.net>
Date:   Fri Nov 12 11:02:13 2010 -0500

    Use FBOs and use cogl_read_pixels() to efficiently read partial textures
    
    * cogl_texture_get_data() is converted to use
       _cogl_texture_foreach_sub_texture_in_region() to iterate
      through the underlying textures.
    
     * When we need to read only a portion of the underlying
       texture, we set up a FBO and use _cogl_read_pixels()
       to read the portion we need. This is enormously more
       efficient for reading a small portion of a large atlas
       texture.
    
     * The CoglAtlasTexture, CoglSubTexture, and CoglTexture2dSliced
       implementation of get_texture() are removed.
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2414

 cogl/cogl-atlas-texture.c     |   17 +----
 cogl/cogl-sub-texture.c       |   70 +---------------
 cogl/cogl-texture-2d-sliced.c |  149 +-------------------------------
 cogl/cogl-texture.c           |  191 +++++++++++++++++++++++++++++++++++++++--
 4 files changed, 186 insertions(+), 241 deletions(-)

commit 47ccbf472e3e76946c4f7add9114d8a6141de54f
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Nov 17 17:57:17 2010 +0000

    cogl-framebuffer: Try to track format of the framebuffer
    
    Previously in cogl_read_pixels we assume the format of the framebuffer
    is always premultiplied because that is the most likely format with
    the default Cogl blend mode. However when the framebuffer is bound to
    a texture we should be able to make a better guess at the format
    because we know the texture keeps track of the premult status. This
    patch adds an internal format member to CoglFramebuffer. For onscreen
    framebuffers we still assume it is RGBA_8888_PRE but for offscreen to
    textures we copy the texture format. cogl_read_pixels uses this to
    determine whether the data returned by glReadPixels will be
    premultiplied.
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2414

 cogl/cogl-framebuffer-private.h |    3 +++
 cogl/cogl-framebuffer.c         |   15 +++++++++++++++
 cogl/cogl.c                     |   22 ++++++++++------------
 3 files changed, 28 insertions(+), 12 deletions(-)

commit 8fd47276b7958f1f494e98da1dcce2b5802d1e05
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Nov 17 17:45:27 2010 +0000

    cogl_read_pixels: Fix the format used in GLES2
    
    When converting the data in cogl_read_pixels it was using bmp_format
    instead of the format passed in to the function. bmp_format is the
    same as the passed in format except that it always has the premult bit
    set. Therefore the conversion would not handle premultiply correctly.
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2414

 cogl/cogl.c |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)

commit e41e5efac087baf14e2dcd500840ccb27a9a037f
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Nov 17 15:38:20 2010 +0000

    Add an internal _cogl_read_pixels_with_rowstride
    
    This is the same as _cogl_read_pixels except that it takes a rowstride
    parameter for the destination buffer. Under OpenGL setting the
    rowstride this will end up calling GL_ROW_LENGTH so that the buffer
    region can be directly written to. Under GLES GL_ROW_LENGTH is not
    supported so it will use an intermediate buffer as it does if the
    format is not GL_RGBA.
    
    cogl_read_pixels now just calls the full version of the function with
    the rowstride set to width*bpp.
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2414

 cogl/cogl-private.h |   10 ++++++++++
 cogl/cogl.c         |   39 ++++++++++++++++++++++++++++-----------
 2 files changed, 38 insertions(+), 11 deletions(-)

commit 05d8cc1223cfaf3623a4ab34615881f1fbfbe254
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Nov 11 15:28:44 2010 +0000

    Add an internal _cogl_offscreen_new_to_texture_full function
    
    This function is the same as cogl_offscreen_new_to_texture but it
    takes a level parameter and a set of flags so that FBOs can be used to
    render to higher mipmap levels and to disable the depth and stencil
    buffers. cogl_offscreen_new_to_texture now just calls the new function
    with the level set to zero. This function could be useful in a few
    places in Cogl where we want to use FBOs as an implementation detail
    such as when copying between textures.
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2414

 cogl/cogl-framebuffer-private.h |   24 +++++++++
 cogl/cogl-framebuffer.c         |  100 +++++++++++++++++++++++++++++---------
 2 files changed, 100 insertions(+), 24 deletions(-)

commit 38929d55c9558c0f2021347106add7c5c072e995
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Nov 23 14:07:16 2010 +0000

    cogl-texture-driver-gles: Fix image height for uploading 3D textures
    
    When uploading a 3D texture with an awkward rowstride, on GLES Cogl
    will copy the images to an intermediate buffer to pass to GL. However
    it was using the wrong height when copying the data so it would end up
    overflowing the buffer and crashing.

 cogl/driver/gles/cogl-texture-driver-gles.c |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)

commit 8e8f5d5748c634a54d5410b4419f88c1abf20d64
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Tue Nov 23 13:05:47 2010 +0000

    pipeline: Use WrapModeInternal in the Layer struct
    
    Since we're using CoglPipelineWrapModeInternal in the internal API
    anyway, and the compiler complains loudly when comparing two enumeration
    types without casting, the PipelineLayer struct should store the
    wrap modes using the internal enumeration.

 cogl/cogl-pipeline-private.h |   44 +++++++++++++++++++++---------------------
 1 files changed, 22 insertions(+), 22 deletions(-)

commit 0ec9e406ea5157d3ffbe7a7ae1ed228a351fda06
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Nov 22 15:51:15 2010 +0000

    clip-stack: combine modelview-projection in set_clip_planes
    
    When using clip planes and we we have to project some vertices into
    screen coordinates we used to transform those by the modelview and then
    the projection matrix separately. Now we combine the modelview and
    projection matrix and then use that to transform the vertices in one
    step instead.

 cogl/cogl-clip-stack.c |   24 ++++++++++++------------
 1 files changed, 12 insertions(+), 12 deletions(-)

commit 649aaffbe975f9404fa4627b75b034a2d713a988
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Nov 22 12:44:36 2010 +0000

    journal: remove possability of fallback layers
    
    When logging quads in the journal it used to be possible to specify a
    mask of fallback layers (layers where a default white texture should be
    used in-place of the corresponding texture in the current source
    pipeline). Since we now handle fallbacks for cogl_rectangle* primitives
    when validating the pipeline up-front before logging in the journal we
    no longer need the ability for the journal to apply fallbacks too.

 cogl/cogl-journal-private.h |    1 -
 cogl/cogl-journal.c         |    6 ------
 cogl/cogl-primitives.c      |    2 --
 3 files changed, 0 insertions(+), 9 deletions(-)

commit e9e824fd86961d94ecdf34a09cfbe74f3d1c5966
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Nov 12 13:35:24 2010 +0000

    matrix: Adds experimental cogl_matrix_{transform,project}_points
    
    This add two new function that allows us to transform or project an
    array of points instead of only transforming one point at a time. Recent
    benchmarking has shown cogl_matrix_transform_point to be a bottleneck
    sometimes, so this should allow us to reduce the overhead when
    transforming lots of vertices at the same time, and also reduce the cost
    of 3 component, non-projective transforms.
    
    For now they are marked as experimental (you have to define
    COGL_ENABLE_EXPERIMENTAL_API) because there is some concern that it
    introduces some inconsistent naming. cogl_matrix_transform_point would
    have to be renamed cogl_matrix_project_point to be consistent, but that
    would be an API break.

 cogl/cogl-matrix.c                   |  346 ++++++++++++++++++++++++++++++++++
 cogl/cogl-matrix.h                   |  123 ++++++++++++
 doc/reference/cogl/cogl-sections.txt |    2 +-
 3 files changed, 470 insertions(+), 1 deletions(-)

commit 56f36cf9c2cb06317462992229159b632e94b6d5
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Nov 11 16:28:45 2010 +0000

    primitives: validate with _cogl_pipeline_foreach_layer
    
    Switch _cogl_rectangles_with_multitexture_coords to using
    _cogl_pipeline_foreach_layer to iterate the layers of a pipeline when
    validating instead of iterating the pipelines internal list, which is
    risky since any modifications to pipelines (even to an override pipeline
    derived from the original), could potentially corrupt the list as it is
    being iterated.

 cogl/cogl-pipeline-private.h |    3 +-
 cogl/cogl-pipeline.c         |    6 +-
 cogl/cogl-primitives.c       |  324 ++++++++++++++++++++++-------------------
 3 files changed, 180 insertions(+), 153 deletions(-)

commit 1a3f946cc66b37f6043488a9b7b68df58b994d63
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Nov 11 15:08:38 2010 +0000

    cogl: remove WrapModeOverrides from FlushOptions
    
    This removes the possibility to specify wrap mode overrides within a
    CoglPipelineFlushOptions struct since the right way to handle these
    overrides is by copying the user's material and making the changes to
    that copy before flushing. All primitives code has already switched away
    from using these wrap mode overrides so this patch just removes unused
    code and types. It also remove the wrap_mode_overrides argument for
    _cogl_journal_log_quad.

 cogl/cogl-journal-private.h  |    2 -
 cogl/cogl-journal.c          |    7 -----
 cogl/cogl-pipeline-private.h |   32 +-----------------------
 cogl/cogl-pipeline.c         |   55 ------------------------------------------
 cogl/cogl-primitives.c       |    2 -
 5 files changed, 1 insertions(+), 97 deletions(-)

commit ebdf1127320ab11a0ac7c1e6f2236fb633b61112
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Sat Nov 20 10:46:57 2010 +0000

    build: Add missing cogl-shader-boilerplate.h

 cogl/Makefile.am |    1 +
 1 files changed, 1 insertions(+), 0 deletions(-)

commit 13561e2e2da4bf049963361cc457a11db5d95abf
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Fri Nov 19 18:29:43 2010 +0000

    build: Add a missing file

 cogl/Makefile.am |    1 +
 1 files changed, 1 insertions(+), 0 deletions(-)

commit 05f5ae1a9700edefe964095ce08ef9bcfbcb3865
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Fri Nov 19 18:15:29 2010 +0000

    build: Don't reference non-existing files

 cogl/Makefile.am |    1 -
 1 files changed, 0 insertions(+), 1 deletions(-)

commit 4e56eec36620907a8ccba7ae41965ccacd7252bb
Author: Owen W. Taylor <otaylor@fishsoup.net>
Date:   Mon Nov 15 01:32:42 2010 -0500

    Free state at the end of a journal flush
    
    At the end of flushing the journal, we need to free the vertex
    attributes and vertex array.
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2423

 cogl/cogl-journal.c |    8 +++++++-
 1 files changed, 7 insertions(+), 1 deletions(-)

commit fae591b168b72b1a1f8ca9f0452bd0318ced36d5
Author: Owen W. Taylor <otaylor@fishsoup.net>
Date:   Sun Nov 14 22:59:24 2010 -0500

    Actually free buffer objects
    
    With the refactoring to centralize code into CoglBuffer,
    _cogl_buffer_fini() was never actually implemented, so all GL
    vertex and index buffer objects were leaked.
    
    The duplicate call to glDeleteBuffers() in CoglPixelArray is
    removed (it wasn't paying attention to whether the buffer had been
    allocated as a PBO or not.)
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2423

 cogl/cogl-buffer.c      |    7 +++++++
 cogl/cogl-pixel-array.c |    2 --
 2 files changed, 7 insertions(+), 2 deletions(-)

commit 460e4b90d3ef10c04a32bdb1bd4556f9464d8d1e
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Nov 16 13:06:08 2010 +0000

    debug: Adds a COGL_DEBUG=wireframe option
    
    This adds a COGL_DEBUG=wireframe option to visualize the underlying
    geometry of the primitives being drawn via Cogl. This works for triangle
    list, triangle fan, triangle strip and quad (internal only) primitives.
    It also works for indexed vertex arrays.

 cogl/cogl-debug-options.h    |    5 +
 cogl/cogl-debug.c            |    3 +-
 cogl/cogl-debug.h            |    3 +-
 cogl/cogl-vertex-attribute.c |  243 ++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 252 insertions(+), 2 deletions(-)

commit 20a1f876286e3f5cff7bae7dabd9c37629d61336
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Nov 16 08:52:49 2010 +0000

    vertex-buffer: don't unref NULL object
    
    In cogl_vertex_buffer_indices_get_for_quads() we sometimes have to
    extend the length of an existing array, but when we came to unref the
    previous array we didn't first check that it wasn't simply NULL.

 cogl/cogl-vertex-buffer.c |    3 ++-
 1 files changed, 2 insertions(+), 1 deletions(-)

commit 982f1b4bd064dea10ed510d4d09ee17fd2800b9d
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Nov 16 08:49:55 2010 +0000

    vertex-array: Adds data arg for _vertex_array_new()
    
    This adds an optional data argument for cogl_vertex_array_new() since it
    seems that mostly every case where we use this API we follow up with a
    cogl_buffer_set_data() matching the size of the new array. This
    simplifies all those cases and whenever we want to delay uploading of
    data then NULL can simply be passed.

 cogl/cogl-journal.c       |    2 +-
 cogl/cogl-primitive.c     |   40 ++++++++--------------------------------
 cogl/cogl-primitives.c    |    6 ++----
 cogl/cogl-vertex-array.c  |   11 +++++++++--
 cogl/cogl-vertex-array.h  |    9 +++++++--
 cogl/cogl-vertex-buffer.c |    3 ++-
 cogl/cogl2-path.c         |   12 ++++--------
 7 files changed, 33 insertions(+), 50 deletions(-)

commit 60daaff724a99b3e6686ef43fba54ecd429e8f31
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Nov 16 08:41:29 2010 +0000

    indices: Makes cogl_indices_get_array public
    
    This makes the previously internal only _cogl_indices_get_array API
    public as cogl_indices_get_array (Though marked as experimental)

 cogl/cogl-indices-private.h  |    3 ---
 cogl/cogl-indices.c          |    2 +-
 cogl/cogl-indices.h          |    3 +++
 cogl/cogl-vertex-attribute.c |    2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

commit fbc01d659c81c86bb13e376ed0749d61a4418c21
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Nov 16 08:38:59 2010 +0000

    build: cogl-clip-state.h depends on cogl-clip-stack.h
    
    This adds a #include "cogl-clip-stack.h" to cogl-clip-state.h which
    depends on the CoglClipStack typedef.

 cogl/cogl-clip-state.h |    2 ++
 1 files changed, 2 insertions(+), 0 deletions(-)

commit 26f68b6f0eb0def3ccee999a64b77471a5d2a5a0
Merge: dedceb2 8c3bfaf
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Nov 15 15:41:46 2010 +0000

    Merge remote branch 'elliot/cookbook-opacity-values-fix'
    
    * elliot/cookbook-opacity-values-fix:
      cookbook: Fix opacity examples in recipe
      cookbook: Fix incorrect value for opacity

commit dedceb2647a2156cf079eb202d99d7eb55b4c2bc
Merge: 7e9a209 8c3bfaf
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Nov 15 15:37:42 2010 +0000

    Merge remote branch 'elliot/cookbook-animations-looping'
    
    * elliot/cookbook-animations-looping:
      cookbook: Recipe for "looping animations"
      cookbook: Clarify how signals are emitted during looped animation
      cookbook: First draft for looping animations recipe
      cookbook: Recipe skeleton for "looping animations"
      cookbook: Looping animation examples

commit 7e9a20960cf52b8e6d5f9c08f432d8cc11e435fc
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Nov 15 15:26:07 2010 +0000

    Merge remote branch 'elliot/c90-fix'

commit 8c3bfaf8d9447f077c82884fe142ff3c4fc7346b
Merge: 081eb2d 353ea52
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Thu Nov 11 17:53:42 2010 +0000

    Merge branch 'wip/static-colors'
    
    * wip/static-colors:
      Move tests to static colors where possible
      color: Add named, global colors

commit 081eb2d75d83322f89ccf32049dffdeb4ce2abb1
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Nov 11 16:24:54 2010 +0000

    cogl-texture: Remove the gl_handle from CoglTextureSliceCallback
    
    There's no longer any need to use the GL handle in the callback for
    _cogl_texture_foreach_sub_texture_in_region because it can now work in
    terms of primitive cogl textures so it has now been removed. This
    would be helpful if we ever want to make the foreach function public
    so that apps could implement their own primitives using sliced
    textures.

 cogl/cogl-primitives.c        |    2 --
 cogl/cogl-sub-texture.c       |    4 +---
 cogl/cogl-texture-2d-sliced.c |    4 ----
 cogl/cogl-texture-2d.c        |    2 --
 cogl/cogl-texture-3d.c        |    2 --
 cogl/cogl-texture-private.h   |    2 --
 cogl/cogl-texture-rectangle.c |    2 --
 7 files changed, 1 insertions(+), 17 deletions(-)

commit 22c61c53157840011936b1f5cee3756b19504f45
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Nov 11 16:18:25 2010 +0000

    cogl-pipeline: Use layer overrides as CoglHandles instead of GLuint
    
    Since d5634e37 the sliced texture backend now works in terms of
    CoglTexture2Ds so there's no need to have special casing for
    overriding the texture of a pipeline layer with a GL handle. Instead
    we can just use cogl_pipeline_set_layer_texture with the
    CoglHandle. The special _cogl_pipeline_set_layer_gl_texture_slice
    function has now been removed and parts of the code for comparing
    materials have been simplified.

 cogl/cogl-journal-private.h  |    2 +-
 cogl/cogl-journal.c          |    2 +-
 cogl/cogl-pipeline-opengl.c  |   35 ++++----------
 cogl/cogl-pipeline-private.h |    7 +--
 cogl/cogl-pipeline.c         |  105 +++++-------------------------------------
 cogl/cogl-primitives.c       |   15 +++++-
 6 files changed, 38 insertions(+), 128 deletions(-)

commit 9302d146d16c843603fe06cac142f21f7569893b
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Nov 11 15:42:12 2010 +0000

    CoglTexture2DSliced: Pass slice tex to callback in foreach_sub_texture
    
    The cogl_texture_foreach_sub_texture_in_region virtual for the sliced
    texture backend was previously passing the CoglHandle of the sliced
    texture to the callback. Since d5634e37 the slice texture backend now
    works in terms of 2D textures so it's possible to pass the underlying
    slice texture as a handle too. This makes all of the foreach callbacks
    consistent in that they pass a CoglHandle of the primitive texture
    type that matches the GL handle.

 cogl/cogl-texture-2d-sliced.c |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)

commit cce8645aba8d076e250e4efe93e8689585aa12f5
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Nov 4 00:27:47 2010 +0000

    path 2.0: update path API for experimental 2.0 API
    
    When COGL_ENABLE_EXPERIMENTAL_2_0_API is defined cogl.h will now include
    cogl2-path.h which changes cogl_path_new() so it can directly return a
    CoglPath pointer; it no longer exposes a prototype for
    cogl_{get,set}_path and all the remaining cogl_path_ functions now take
    an explicit path as their first argument.
    
    The idea is that we want to encourage developers to retain path objects
    for as long as possible so they can take advantage of us uploading the
    path geometry to the GPU. Currently although it is possible to start a
    new path and query the current path, it is not convenient.
    
    The other thing is that we want to get Cogl to the point where nothing
    depends on a global, current context variable. This will allow us to one
    day define a sensible threading model if/when that is ever desired.

 cogl/Makefile.am                |   15 +-
 cogl/cogl-clip-state.c          |    8 +-
 cogl/cogl-context.c             |    4 +-
 cogl/cogl-context.h             |    2 +-
 cogl/cogl-path-private.h        |   14 +-
 cogl/cogl-path.c                | 1363 ++----------------------------------
 cogl/cogl-path.h                |    2 +
 cogl/cogl.h                     |    6 +
 cogl/cogl2-path.c               | 1466 +++++++++++++++++++++++++++++++++++++++
 cogl/cogl2-path.h               |  506 ++++++++++++++
 pango/cogl-pango-display-list.c |    7 +-
 11 files changed, 2085 insertions(+), 1308 deletions(-)

commit 1b75ad9c80e250a56e3c049bfd3bd166641a5cbb
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Nov 3 20:26:20 2010 +0000

    cogl: Adds COGL_ENABLE_EXPERIMENTAL_2_0_API define
    
    For now this new define is simply an alias for
    COGL_ENABLE_EXPERIMENTAL_API but the intention is that we will also use
    it to start experimenting with changes that need to break the existing
    Cogl API in incompatible ways.

 cogl/cogl.h |    4 ++++
 1 files changed, 4 insertions(+), 0 deletions(-)

commit 353ea5299b40df57e1b20dccba68a065fa1a47d3
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Jul 23 17:46:41 2010 +0100

    cogl-shader: Prepend boilerplate for portable shaders
    
    We now prepend a set of defines to any given GLSL shader so that we can
    define builtin uniforms/attributes within the "cogl" namespace that we
    can use to provide compatibility across a range of the earlier versions
    of GLSL.
    
    This updates test-cogl-shader-glsl.c and test-shader.c so they no longer
    needs to special case GLES vs GL when splicing together its shaders as
    well as the blur, colorize and desaturate effects.
    
    To get a feel for the new, portable uniform/attribute names here are the
    defines for OpenGL vertex shaders:
    
     #define cogl_position_in gl_Vertex
     #define cogl_color_in gl_Color
     #define cogl_tex_coord_in  gl_MultiTexCoord0
     #define cogl_tex_coord0_in gl_MultiTexCoord0
     #define cogl_tex_coord1_in gl_MultiTexCoord1
     #define cogl_tex_coord2_in gl_MultiTexCoord2
     #define cogl_tex_coord3_in gl_MultiTexCoord3
     #define cogl_tex_coord4_in gl_MultiTexCoord4
     #define cogl_tex_coord5_in gl_MultiTexCoord5
     #define cogl_tex_coord6_in gl_MultiTexCoord6
     #define cogl_tex_coord7_in gl_MultiTexCoord7
     #define cogl_normal_in gl_Normal
    
     #define cogl_position_out gl_Position
     #define cogl_point_size_out gl_PointSize
     #define cogl_color_out gl_FrontColor
     #define cogl_tex_coord_out gl_TexCoord
    
     #define cogl_modelview_matrix gl_ModelViewMatrix
     #define cogl_modelview_projection_matrix gl_ModelViewProjectionMatrix
     #define cogl_projection_matrix gl_ProjectionMatrix
     #define cogl_texture_matrix gl_TextureMatrix
    
    And for fragment shaders we have:
    
     #define cogl_color_in gl_Color
     #define cogl_tex_coord_in gl_TexCoord
    
     #define cogl_color_out gl_FragColor
     #define cogl_depth_out gl_FragDepth
    
     #define cogl_front_facing gl_FrontFacing

 cogl/cogl-context.c                              |    2 +-
 cogl/cogl-path.c                                 |    4 +-
 cogl/cogl-pipeline-arbfp.c                       |    3 +-
 cogl/cogl-pipeline-fixed.c                       |    3 +-
 cogl/cogl-pipeline-glsl.c                        |   44 +++++-
 cogl/cogl-pipeline-opengl-private.h              |    3 +-
 cogl/cogl-pipeline-opengl.c                      |    6 +-
 cogl/cogl-pipeline-private.h                     |    3 +-
 cogl/cogl-shader-boilerplate.h                   |  107 +++++++++++
 cogl/cogl-shader-private.h                       |    5 +
 cogl/cogl-shader.c                               |  206 +++++++++++++++++-----
 cogl/cogl-vertex-attribute.c                     |    4 +-
 cogl/cogl-vertex-buffer.c                        |   86 +++++++++-
 cogl/cogl.c                                      |   16 ++-
 cogl/driver/gles/cogl-fixed-fragment-shader.glsl |   24 ++--
 cogl/driver/gles/cogl-fixed-vertex-shader.glsl   |   40 +++--
 cogl/driver/gles/cogl-gles2-wrapper.c            |   62 ++++---
 17 files changed, 494 insertions(+), 124 deletions(-)

commit 7a4c7b41c213de3eca8895084d59a16b567722c9
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Nov 8 16:01:19 2010 +0000

    gtk-doc: Fixes for the API references

 cogl/cogl-vertex-attribute.h |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)

commit d2ddd9c945a9c6456c4fe2704c8fee7b08a32185
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Sat Nov 6 18:12:41 2010 +0000

    Remove a compiler warning

 cogl/cogl-vertex-attribute.c |    3 ++-
 1 files changed, 2 insertions(+), 1 deletions(-)

commit ff8130101aa4696b9c0403bc5067b6ef48de4cc8
Author: Maxim Ermilov <zaspire@rambler.ru>
Date:   Fri Nov 5 20:20:14 2010 +0300

    CoglContext: correct initialization order
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2401

 cogl/cogl-context.c |    4 ++--
 1 files changed, 2 insertions(+), 2 deletions(-)

commit 3bd20acfb4209f595f847394bd48365aec6d9b5e
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Nov 5 14:38:19 2010 +0000

    cogl-texture-2d-sliced: Fix the foreach callback for waste textures
    
    When converting the virtual coordinates of the underlying texture for
    a slice to virtual coordinates for the whole texture it was using the
    size and offset of the intersection as the size of the child
    texture. This would be incorrect if the texture contains waste or the
    texture coordinates are not the default. Instead the sliced foreach
    function now passes the CoglSpan to the callback instead of the
    intersection.
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2398

 cogl/cogl-texture-2d-sliced.c |   56 +++++++++++++++++++----------------------
 1 files changed, 26 insertions(+), 30 deletions(-)

commit 3203c2382f53275314f9f706f652817cc515c25d
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Nov 5 14:55:46 2010 +0000

    Replace the disable-npots tool with a COGL_DEBUG option
    
    Previously in the tests/tools directory we build a disable-npots
    library which was used as an LD_PRELOAD to trick Cogl in to thinking
    there is no NPOT texture extension. This is a little awkward to use so
    it seems much simpler to just define a COGL_DEBUG option to disable
    npot textures.

 cogl/cogl-debug-options.h |    6 ++++++
 cogl/cogl-debug.c         |    3 ++-
 cogl/cogl-debug.h         |    3 ++-
 cogl/cogl.c               |    6 ++++++
 4 files changed, 16 insertions(+), 2 deletions(-)

commit 117ef6baff7c644534d2c1ab81ef77b937ab4ec7
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Nov 1 22:07:11 2010 +0000

    matrix-stack: use GArray instead of GSList for stack
    
    In some micro-benchmarks testing journal throughput the list
    manipulation jumps pretty high in the profile. This replaces the GSList
    usage with a GArray instead which is effectively a grow only allocation
    that means we avoid ongoing allocations while manipulating the stack
    mid-scene.

 cogl/cogl-matrix-stack.c |   55 ++++++++++++++-------------------------------
 1 files changed, 17 insertions(+), 38 deletions(-)

commit b41bf9e67fd09a71600f333947c4b50ae6eeed1e
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Nov 1 20:33:20 2010 +0000

    pipeline: Avoid costly checking of lighting properties
    
    During _cogl_pipeline_needs_blending_enabled we were always checking the
    current lighting properties (ambient,diffuse,specular,emission) which
    had a notable impact during micro-benchmarks that exercise journal
    throughput of simple colored rectangles. This #if 0's the offending code
    considering that Cogl doesn't actually support lighting currently and
    when it actually does then we will be able to optimize this by avoiding
    the checks when lighting is disabled.

 cogl/cogl-pipeline.c |   42 ++++++++++++++++++++++++------------------
 1 files changed, 24 insertions(+), 18 deletions(-)

commit e5eff5fc89fb0a789b1130135d3c699b4c78c370
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Nov 1 20:27:32 2010 +0000

    cogl: add separate material for blended source_colors
    
    When using cogl_set_source_color4ub there is a notable difference
    between colors that require blending and those that dont. When trying to
    modify the color of pipeline referenced by the journal we don't force a
    flush of the journal unless the color change will also change the
    blending state. By using two separate pipeline objects for handing
    opaque or transparent colors we can avoid ever flushing the journal when
    repeatedly using cogl_set_source_color and jumping between opaque and
    transparent colors.

 cogl/cogl-context.c |   13 ++++++++-----
 cogl/cogl-context.h |    5 +++--
 cogl/cogl.c         |   19 ++++++++++++++-----
 3 files changed, 25 insertions(+), 12 deletions(-)

commit 4bd64b6ba69ed71ef0855cffe09ae1922708e5c1
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Nov 1 18:55:48 2010 +0000

    texture_quad_multiple_primitives: rework wrap mode overrides
    
    This reworks _cogl_texture_quad_multiple_primitives so instead of using
    the CoglPipelineWrapModeOverrides mechanism to force the clamp to edge
    repeat mode we now derive an override pipeline using cogl_pipeline_copy
    instead. This avoids a relatively large, unconditional, memset.

 cogl/cogl-primitives.c |   84 +++++++++++++++++++++++++++++++----------------
 1 files changed, 55 insertions(+), 29 deletions(-)

commit 636310a81ebb29be934ceea3933ebae1c6a7c52d
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Nov 1 18:33:17 2010 +0000

    _multitexture_quad_single_primitive: avoid wrap overrides
    
    This avoids using the wrap mode overrides mechanism to implement
    _cogl_multitexture_quad_single_primitive which requires memsetting a
    fairly large array. This updates it to use cogl_pipeline_foreach_layer()
    and we now derive an override_material to handle changes to the wrap
    modes instead of using the CoglPipelineWrapModeOverrides.

 cogl/cogl-primitives.c |  265 +++++++++++++++++++++++++++---------------------
 1 files changed, 151 insertions(+), 114 deletions(-)

commit a25aad954e4a7bef577fea0cd9b88439b536f096
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Nov 3 16:02:27 2010 +0000

    cogl-path: Don't bother filling the path if less than 3 nodes
    
    Previously there was a check to avoid filling the path if there are
    zero nodes. However the tesselator also won't generate any triangles
    if there are less than 3 nodes so we might as well bail out in that
    case too. If we don't emit any triangles then we would end up trying
    to create an empty VBO. Although I don't think this should necessarily
    be a problem, this seems to cause Mesa to segfault in version 7.8.1
    when calling glBufferSubData (although not in
    master). test-cogl-primitives tries to fill a path with only two
    points so it's convenient to be able to avoid the crash in this case.

 cogl/cogl-path.c |    4 ++--
 1 files changed, 2 insertions(+), 2 deletions(-)

commit 3c8c1951151f16bedc7e298e2f0a8af536643617
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Nov 2 17:35:17 2010 +0000

    cogl-journal: Log the clip state in the journal
    
    When adding a new entry to the journal a reference is now taken on the
    current clip stack. Modifying the current clip state no longer causes
    a journal flush. The journal flushing code now has an extra stage to
    compare the clip state of each entry. The comparison can simply be
    done by comparing the pointers. Although different clip states will
    still end up with multiple draw calls this at leasts allows a scene
    comprising of multiple different clips to be upload with one vbo. It
    also lays the groundwork to do certain tricks when drawing clipped
    rectangles such as modifying the geometry instead of setting a clip
    state.

 cogl/cogl-clip-state.c      |   24 ----------
 cogl/cogl-journal-private.h |    2 +
 cogl/cogl-journal.c         |  106 +++++++++++++++++++++++++++++++++----------
 3 files changed, 83 insertions(+), 49 deletions(-)

commit 6cf01ff0f49f085e7fc90e0263246ec070bb0e0c
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Nov 2 17:34:51 2010 +0000

    cogl-framebuffer: Add a flag to skip flushing the clip state
    
    This adds a flag to avoid flushing the clip state when flushing the
    framebuffer state. This will be used by the journal to manage its own
    clip state flushing.

 cogl/cogl-framebuffer-private.h |    3 +++
 cogl/cogl-framebuffer.c         |    3 ++-
 2 files changed, 5 insertions(+), 1 deletions(-)

commit caa991d7a1b9b3ee34a04b54db6adcf99ed0d72d
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Nov 2 17:15:06 2010 +0000

    cogl: Don't flush the journal when flushing clip state
    
    Flushing the clip state no longer does anything that would cause the
    journal to flush. The clip state is only flushed when flushing the
    framebuffer state and in all cases this ends up flushing the journal
    in one way or another anyway. Avoiding flushing the journal will make
    it easier to log the clip state in the journal.
    
    Previously when trying to set up a rectangle clip that can't be
    scissored or when using a path clip the code would use cogl_rectangle
    as part of the process to fill the stencil buffer. This is now changed
    to use a new internal _cogl_rectangle_immediate function which
    directly uses the vertex array API to draw a triangle strip without
    affecting the journal. This should be just as efficient as the
    previous journalled code because these places would end up flushing
    the journal immediately before and after submitting the single
    rectangle anyway and flushing the journal always creates a new vbo so
    it would effectively do the same thing.
    
    Similarly there is also a new internal _cogl_clear function that does
    not flush the journal.

 cogl/Makefile.am               |    2 +
 cogl/cogl-clip-stack.c         |   47 +++++++++++--------------
 cogl/cogl-clip-state.c         |    5 +++
 cogl/cogl-path.c               |   76 ++++++++++++++++++++--------------------
 cogl/cogl-primitives-private.h |   43 ++++++++++++++++++++++
 cogl/cogl-primitives.c         |   40 +++++++++++++++++++++
 cogl/cogl-private.h            |   34 ++++++++++++++++++
 cogl/cogl.c                    |   30 ++++++++++-----
 8 files changed, 203 insertions(+), 74 deletions(-)

commit db86a5a4867b4a31a9f18a3486cdbd3ff1758502
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Nov 3 15:48:56 2010 +0000

    cogl-path: Use the vertex array API instead of CoglVertexBuffer
    
    The new vertex array is now implemented in terms of the
    CoglVertexBuffer anyway so it should be slightly faster to use a
    vertex array directly.

 cogl/cogl-path-private.h |   26 ++++++++-------
 cogl/cogl-path.c         |   81 ++++++++++++++++++++++++++--------------------
 2 files changed, 60 insertions(+), 47 deletions(-)

commit 0c8eb904c0657ee730c9569afad7467736d68dcc
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Nov 2 14:28:12 2010 +0000

    cogl: Move the clip stack dirtiness to the context rather than the FB
    
    Previously we tracked whether the clip stack needs flushing as part of
    the CoglClipState which is part of the CoglFramebuffer state. This is
    a bit odd because most of the clipping state (such as the clip planes
    and the scissor) are part of the GL context's state rather than the
    framebuffer. We were marking the clip state on the framebuffer dirty
    every time we change the framebuffer anyway so it seems to make more
    sense to have the dirtiness be part of the global context.
    
    Instead of a just a single boolean to record whether the state needs
    flushing, the CoglContext now holds a reference to the clip stack that
    was flushed. That way we can flush arbitrary stack states and if it
    happens to be the same as the state already flushed then Cogl will do
    nothing. This will be useful if we log the clip stack in the journal
    because then we will need to flush unrelated clip stack states for
    each batch.

 cogl/cogl-clip-stack.c  |   44 ++++++++++++++++++++++++++++++++++++++------
 cogl/cogl-clip-stack.h  |    6 ++++--
 cogl/cogl-clip-state.c  |   40 +++-------------------------------------
 cogl/cogl-clip-state.h  |    6 ------
 cogl/cogl-context.c     |    5 +++++
 cogl/cogl-context.h     |   22 ++++++++++++++++++++++
 cogl/cogl-framebuffer.c |    2 +-
 cogl/cogl-path.c        |   10 +++-------
 8 files changed, 76 insertions(+), 59 deletions(-)

commit f15b47cc03b2f8f2388b785706d61e2f2c05707a
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Nov 1 19:52:45 2010 +0000

    cogl-clip-stack: Don't allocate a separate struct for CoglClipStack
    
    Instead of having a separate CoglHandle for CoglClipStack the code is
    now expected to directly hold a pointer to the top entry on the
    stack. The empty stack is then the NULL pointer. This saves an
    allocation when we want to copy the stack because we can just take a
    reference on a stack entry. The idea is that this will make it
    possible to store the clip stack in the journal without any extra
    allocations.
    
    The _cogl_get_clip_stack and set functions now take a CoglClipStack
    pointer instead of a handle so it would no longer make sense to make
    them public. However I think the only reason we would have wanted that
    in the first place would be to save the clip state between switching
    FBOs and that is no longer necessary.

 cogl/cogl-clip-stack.c |  193 ++++++++++++++++++-----------------------------
 cogl/cogl-clip-stack.h |   38 ++++------
 cogl/cogl-clip-state.c |   55 +++++---------
 cogl/cogl-clip-state.h |   20 ++---
 4 files changed, 116 insertions(+), 190 deletions(-)

commit af5ddb0b132c4088285f6ebbcb3e9b17cca0d6b7
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Nov 3 13:34:21 2010 +0000

    cogl: Don't flush the framebuffer state for the internal draw
    
    CoglVertexAttribute has an internal draw function that is used by the
    CoglJournal to avoid the call to cogl_journal_flush which would
    otherwise end up recursively flushing the journal forever. The
    enable_gl_state function called by this was previously also calling
    _cogl_flush_framebuffer_state. However the journal code tries to
    handle this function specially by calling it with a flag to disable
    flushing the modelview matrix. This is useful because the journal
    handles flushing the modelview itself. Without this patch the journal
    state ends up getting flushed twice. This isn't a particularly big
    problem currently because the matrix stack has caching to recognise
    when it would push the same state twice and bails out. However if we
    later want to use the framebuffer flush flags to override a particular
    state of the framebuffer (such as the clip state) then we need to make
    sure the flush isn't called twice.

 cogl/cogl-vertex-attribute.c |   29 +++++++++++++++++++----------
 1 files changed, 19 insertions(+), 10 deletions(-)

commit 6027aa04a4bd1943ffd98db1f258e948198a0926
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Nov 4 16:01:23 2010 +0000

    cogl-buffer: Use void* instead of guint8* for map and set_data
    
    Unless the CoglBuffer is being used for texture data then it's
    relatively unlikely that the data will contain an array of bytes. For
    example if it's used as a vertex array then it's more likely to be
    floats or some vertex struct. In that case it's much more convenient
    if set_data and map use void* pointers so that we can avoid a cast.

 cogl/cogl-buffer-private.h |    8 ++++----
 cogl/cogl-buffer.c         |   12 ++++++------
 cogl/cogl-buffer.h         |    4 ++--
 cogl/cogl-journal.c        |    2 +-
 cogl/cogl-primitive.c      |   16 ++++++++--------
 cogl/cogl-primitives.c     |    2 +-
 6 files changed, 22 insertions(+), 22 deletions(-)

commit 2155bd754653c1ccfad8b411f96c31b507f03deb
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Nov 4 17:21:56 2010 +0000

    cogl-primitive: Fix the texture attribute offsets
    
    The offsets for the texture coordinate attributes in the convenience
    constructors were all wrong.

 cogl/cogl-primitive.c |    8 ++++----
 1 files changed, 4 insertions(+), 4 deletions(-)

commit 7aa39f18a4e0fa7f089498676578fc2e90c137dc
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Nov 4 16:54:20 2010 +0000

    cogl-primitive: Fix a typo in new_with_attributes_array
    
    A typo in the g_return_val_if_fail was causing it to segfault.

 cogl/cogl-primitive.c |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)

commit ec080f2db09dca52cdac7a2a915f59c18ba47605
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Nov 4 16:42:11 2010 +0000

    cogl-primitive: Add the missing cogl_primitive_new_p2 function
    
    There was a struct defined for CoglP2Vertex but there was no
    constructor function to use it.

 cogl/cogl-primitive.c |   27 +++++++++++++++++++++++++++
 cogl/cogl-primitive.h |   44 ++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 71 insertions(+), 0 deletions(-)

commit 5dc1b2fb8fe79c67fda72951ccce8f42a9e707fb
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Nov 4 16:13:01 2010 +0000

    cogl-primitive: Fix the ref-counting for the convenience constuctors
    
    The convenience constructors for the builtin vertex structs were
    creating the primitive and then immediately destroying it and
    returning the pointer. I think the intention was to unref the
    attributes instead. This adds an internal wrapper around the
    new_with_attributes_array constructor which unrefs the attributes
    instead of the primitive. The convenience constructors now use that.

 cogl/cogl-primitive.c |   89 ++++++++++++++++++++++++++++++-------------------
 1 files changed, 55 insertions(+), 34 deletions(-)

commit 18e302c5cd40e1fff9a742495b7e3ed135e80c38
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Nov 4 13:23:23 2010 +0000

    primitive: fix prototypes and start adding docs
    
    This fixes the prototypes for the cogl_primitive_new_xyz functions and
    also adds documentation with examples for each one.

 cogl/cogl-primitive.h |  329 +++++++++++++++++++++++++++++++++++++++++++++----
 1 files changed, 307 insertions(+), 22 deletions(-)

commit 2a7e7fb6d38a7679a19dcc44004e78898aa9cc01
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Nov 4 14:56:44 2010 +0000

    cogl-gles2-wrapper: Fix a reference to the old name for CoglPipeline
    
    The GLES2 wrapper was referring to COGL_MATERIAL_PROGRAM_TYPE_GLSL but
    this has since been renamed to COGL_PIPELINE_PROGRAM_TYPE_GLSL so the
    GLES2 backend wouldn't compile.

 cogl/driver/gles/cogl-gles2-wrapper.c |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)

commit 61bb91a2e76d105d7bbbede3b339f01ac72463a5
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Oct 29 15:49:25 2010 +0100

    gles2: disable vbos until while we rework backend
    
    The gles2 wrapper functions don't understand about the CoglBuffer API so
    they don't support attributes stored in a CoglVertexArray. Instead of
    teaching the backend about buffers we are going to wait until we have
    overhauled the GLES 2 backend. We are currently making progress
    consolidating the GLES 2 backend with a new GLSL backend for
    CoglMaterial. This will hugely simplify the GLES 2 support and share
    code with the OpenGL backend. In the end it's hoped that this problem
    will simply go away so it doesn't make much sense to solve it with the
    current design.

 cogl/driver/gles/cogl-gles.c |    5 +++++
 1 files changed, 5 insertions(+), 0 deletions(-)

commit f80cb197a9113da847375c3f60334a1282a639bc
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Oct 27 18:54:57 2010 +0100

    cogl: rename CoglMaterial -> CoglPipeline
    
    This applies an API naming change that's been deliberated over for a
    while now which is to rename CoglMaterial to CoglPipeline.
    
    For now the new pipeline API is marked as experimental and public
    headers continue to talk about materials not pipelines. The CoglMaterial
    API is now maintained in terms of the cogl_pipeline API internally.
    Currently this API is targeting Cogl 2.0 so we will have time to
    integrate it properly with other upcoming Cogl 2.0 work.
    
    The basic reasons for the rename are:
    - That the term "material" implies to many people that they are
      constrained to fragment processing; perhaps as some kind of high-level
      texture abstraction.
        - In Clutter they get exposed by ClutterTexture actors which may be
          re-inforcing this misconception.
    - When comparing how other frameworks use the term material, a material
      sometimes describes a multi-pass fragment processing technique which
      isn't the case in Cogl.
    - In code, "CoglPipeline" will hopefully be a much more self documenting
      summary of what these objects represent; a full GPU pipeline
      configuration including, for example, vertex processing, fragment
      processing and blending.
    - When considering the API documentation story, at some point we need a
      document introducing developers to how the "GPU pipeline" works so it
      should become intuitive that CoglPipeline maps back to that
      description of the GPU pipeline.
    - This is consistent in terminology and concept to OpenGL 4's new
      pipeline object which is a container for program objects.
    
    Note: The cogl-material.[ch] files have been renamed to
    cogl-material-compat.[ch] because otherwise git doesn't seem to treat
    the change as a moving the old cogl-material.c->cogl-pipeline.c and so
    we loose all our git-blame history.

 cogl/Makefile.am                            |   24 +-
 cogl/cogl-atlas-texture.c                   |   14 +-
 cogl/cogl-atlas.c                           |    2 +-
 cogl/cogl-buffer-private.h                  |    2 +-
 cogl/cogl-clip-stack.c                      |    6 +-
 cogl/cogl-context.c                         |   48 +-
 cogl/cogl-context.h                         |   28 +-
 cogl/cogl-framebuffer.c                     |    2 +-
 cogl/cogl-journal-private.h                 |    8 +-
 cogl/cogl-journal.c                         |  128 +-
 cogl/cogl-material-arbfp-private.h          |   36 -
 cogl/cogl-material-arbfp.c                  | 1218 ------
 cogl/cogl-material-compat.c                 |  495 +++
 cogl/cogl-material-compat.h                 | 1396 +++++++
 cogl/cogl-material-fixed-private.h          |   36 -
 cogl/cogl-material-fixed.c                  |  261 --
 cogl/cogl-material-glsl-private.h           |   36 -
 cogl/cogl-material-glsl.c                   |  452 ---
 cogl/cogl-material-opengl-private.h         |  155 -
 cogl/cogl-material-opengl.c                 | 1212 ------
 cogl/cogl-material-private.h                |  957 -----
 cogl/cogl-material.c                        | 5743 ---------------------------
 cogl/cogl-material.h                        | 1440 -------
 cogl/cogl-path.c                            |   42 +-
 cogl/cogl-pipeline-arbfp-private.h          |   36 +
 cogl/cogl-pipeline-arbfp.c                  | 1218 ++++++
 cogl/cogl-pipeline-fixed-private.h          |   36 +
 cogl/cogl-pipeline-fixed.c                  |  261 ++
 cogl/cogl-pipeline-glsl-private.h           |   36 +
 cogl/cogl-pipeline-glsl.c                   |  452 +++
 cogl/cogl-pipeline-opengl-private.h         |  156 +
 cogl/cogl-pipeline-opengl.c                 | 1212 ++++++
 cogl/cogl-pipeline-private.h                |  993 +++++
 cogl/cogl-pipeline.c                        | 5725 ++++++++++++++++++++++++++
 cogl/cogl-pipeline.h                        | 1234 ++++++
 cogl/cogl-primitives.c                      |  212 +-
 cogl/cogl-texture-2d-private.h              |    2 +-
 cogl/cogl-texture-2d-sliced-private.h       |    2 +-
 cogl/cogl-texture-2d-sliced.c               |    2 +-
 cogl/cogl-texture-2d.c                      |    2 +-
 cogl/cogl-texture-3d-private.h              |    4 +-
 cogl/cogl-texture-3d.c                      |    4 +-
 cogl/cogl-texture-private.h                 |    4 +-
 cogl/cogl-texture-rectangle-private.h       |    2 +-
 cogl/cogl-texture-rectangle.c               |    2 +-
 cogl/cogl-texture.c                         |   26 +-
 cogl/cogl-types.h                           |   52 +-
 cogl/cogl-util.c                            |    2 +-
 cogl/cogl-vertex-attribute.c                |   76 +-
 cogl/cogl-vertex-buffer.c                   |   92 +-
 cogl/cogl.c                                 |   68 +-
 cogl/cogl.h                                 |    9 +-
 cogl/driver/gl/cogl-texture-driver-gl.c     |    4 +-
 cogl/driver/gles/cogl-texture-driver-gles.c |    4 +-
 cogl/winsys/cogl-texture-pixmap-x11.c       |    6 +-
 55 files changed, 13713 insertions(+), 11962 deletions(-)

commit 47ceb34ba914efde2621c05ff9776ed74e7f33ad
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Oct 27 12:43:36 2010 +0100

    pango: Use CoglMaterial type for materials
    
    Instead of using the CoglHandle type for material variables this updates
    the pango code to use CoglMaterial * instead. CoglHandle is the old
    typename which is being phased out of the API.

 pango/cogl-pango-display-list.c |    6 +++---
 pango/cogl-pango-display-list.h |    4 ++--
 pango/cogl-pango-render.c       |    4 ++--
 3 files changed, 7 insertions(+), 7 deletions(-)

commit e673de0b55c0757306539fee1c91117fd170c677
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Oct 27 12:36:24 2010 +0100

    pango: push/pop source instead of trashing users source
    
    The pango-display-list code was calling cogl_set_source in numerous
    places and it didn't appear to be saving the users source to restore
    later. This could result in the user inadvertantly drawing a primitive
    with one of these internally managed materials instead of one that they
    chose. To rectify this the code now uses cogl_{push,pop}_source to save
    and restore the users source.

 pango/cogl-pango-display-list.c |   76 +++++++++++++++++++++++----------------
 1 files changed, 45 insertions(+), 31 deletions(-)

commit 44644d0a9e793aa9d1d60090e00d847a6fc9bd0e
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Oct 18 17:17:22 2010 +0100

    primitives: implements cogl_polygon on vertex_attributes
    
    This updates the implementation of cogl_polygon so it sits on the new
    CoglVertexArray and CoglVertexAttribute apis. This lets us minimize the
    number of different drawing paths we have to maintain in Cogl.
    
    Since the sliced texture support for cogl_polygon has been broken for a
    long time now and no one has complained this patch also greatly
    simplifies the code by not doing any special material validation so
    cogl_polygon will be restricted in the same way as
    cogl_draw_vertex_attributes. (i.e. sliced textures not supported).

 cogl/cogl-context.c    |    5 +
 cogl/cogl-context.h    |    3 +-
 cogl/cogl-primitives.c |  579 +++++++++++++----------------------------------
 3 files changed, 167 insertions(+), 420 deletions(-)

commit 37657a5dd84539152fff4e4788f20700c157b1a9
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Oct 26 19:22:57 2010 +0100

    journal: port to the vertex_attributes API
    
    Instead of using raw OpenGL in the journal we now use the vertex
    attributes API instead. This is part of an ongoing effort to reduce the
    number of drawing paths we maintain in Cogl.

 cogl/cogl-context.c |    4 +
 cogl/cogl-context.h |    1 +
 cogl/cogl-journal.c |  262 +++++++++++++++++++++++++++------------------------
 3 files changed, 145 insertions(+), 122 deletions(-)

commit afb8a64bc431ba9e6c6392a49faa311e4d5817da
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Oct 26 18:56:57 2010 +0100

    vertex-buffer: use cogl_get_rectangle_indices
    
    The functionality of cogl_vertex_buffer_indices_get_for_quads is now
    provided by cogl_get_rectangle_indices so this reworks the former to now
    work in terms of the latter so we don't have duplicated logic.

 cogl/cogl-context.c       |    9 ----
 cogl/cogl-context.h       |    6 ---
 cogl/cogl-vertex-buffer.c |  101 ++++++++++++++++-----------------------------
 3 files changed, 36 insertions(+), 80 deletions(-)

commit c6761aa93b50fef7c22267c6065fe197e9173a94
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Oct 12 12:55:23 2010 +0100

    vertex-buffer: port to CoglVertexAttributes + CoglPrimitive
    
    As part of an ongoing effort to reduce the number of draw paths we have
    in Cogl this re-works CoglVertexBuffer to use the CoglVertexAttribute
    and CoglPrimitive APIs instead of using raw GL.

 cogl/cogl-vertex-buffer-private.h |   42 +-
 cogl/cogl-vertex-buffer.c         | 1140 ++++++++++++-------------------------
 2 files changed, 371 insertions(+), 811 deletions(-)

commit b03f905094fdbb62bfc9d5089173ab79a161a505
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Oct 26 18:57:33 2010 +0100

    primitive: adds immutable ref/unref mechanism
    
    This adds a way to mark that a primitive is in use so that modifications
    will generate a warning. The plan is to use this mechanism when batching
    primitives in the journal to warn users that mid-scene modifications of
    primitives is not allowed.

 cogl/cogl-primitive-private.h |    8 ++++
 cogl/cogl-primitive.c         |   77 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 85 insertions(+), 0 deletions(-)

commit a03a5814e7b8af7d6cefcaf1cbc2b9dd13252a6b
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Oct 12 15:48:31 2010 +0100

    primitive: Adds convenience constructors
    
    This adds convenience primitive constructors named like:
      cogl_primitive_new_p3 or
      cogl_primitive_new_p3c4 or
      cogl_primitive_new_p3t2c4
    where the letters correspond to the interleved vertex attributes layouts
    such as CoglP3Vertex which is a struct with 3 float x,y,z members for
    the [p]osition, or CoglP3T2C4Vertex which is a struct with 3 float x,y,z
    members for the [p]osition, 2 float s,t members for the [t]exture
    coordinates and 4 unsigned byte r,g,b,a members for the [c]olor.
    
    The hope is that people will find these convenient enough to replace
    cogl_polygon.

 cogl/cogl-primitive.c |  246 +++++++++++++++++++++++++++++++++++++++++++++++++
 cogl/cogl-primitive.h |   66 ++++++++++---
 2 files changed, 296 insertions(+), 16 deletions(-)

commit 9498d505dd94657e1af72147515c9fb746519115
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Oct 12 12:54:07 2010 +0100

    cogl: Adds experimental CoglPrimitive API
    
    A CoglPrimitive is a retainable object for drawing a single primitive,
    such as a triangle strip, fan or list.
    
    CoglPrimitives build on CoglVertexAttributes and CoglIndices which
    themselves build on CoglVertexArrays and CoglIndexArrays respectively.
    
    A CoglPrimitive encapsulates enough information such that it can be
    retained in a queue (e.g. the Cogl Journal, or renderlists in the
    future) and drawn at some later time.

 cogl/Makefile.am              |    3 +
 cogl/cogl-primitive-private.h |   46 ++++++
 cogl/cogl-primitive.c         |  223 +++++++++++++++++++++++++++++
 cogl/cogl-primitive.h         |  311 +++++++++++++++++++++++++++++++++++++++++
 cogl/cogl.h                   |    1 +
 5 files changed, 584 insertions(+), 0 deletions(-)

commit 070d90937be07d66449ba35c3b67a0aee42b4d59
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Oct 12 12:53:10 2010 +0100

    cogl: Adds experimental CoglVertexAttribute API
    
    A CoglVertexAttribute defines a single attribute contained in a
    CoglVertexArray. I.e. a CoglVertexArray is simply a buffer of N bytes
    intended for containing a collection of attributes (position, color,
    normals etc) and a CoglVertexAttribute defines one such attribute by
    specifying its start offset in the array, its type, the number of
    components and the stride etc.

 cogl/Makefile.am                     |    3 +
 cogl/cogl-vertex-attribute-private.h |   80 +++
 cogl/cogl-vertex-attribute.c         |  882 ++++++++++++++++++++++++++++++++++
 cogl/cogl-vertex-attribute.h         |  205 ++++++++
 cogl/cogl.h                          |    1 +
 5 files changed, 1171 insertions(+), 0 deletions(-)

commit 6e620e94b69dea9ee2fb3c859de0a9a517129e22
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Oct 12 12:48:58 2010 +0100

    cogl: Adds experimental CoglIndices API
    
    CoglIndices define a range of indices inside a CoglIndexArray. I.e. a
    CoglIndexArray is simply a buffer of N bytes and you can then
    instantiate multiple CoglIndices collections that define a sub-region of
    a CoglIndexArray by specifying a start offset and an index data type.

 cogl/Makefile.am            |    3 +
 cogl/cogl-context.c         |   18 +++
 cogl/cogl-context.h         |   10 ++
 cogl/cogl-indices-private.h |   57 ++++++++++
 cogl/cogl-indices.c         |  253 +++++++++++++++++++++++++++++++++++++++++++
 cogl/cogl-indices.h         |   74 +++++++++++++
 cogl/cogl.h                 |    1 +
 7 files changed, 416 insertions(+), 0 deletions(-)

commit 296d14e94625b95304092d0b66d1d37871f58b71
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Oct 12 12:34:27 2010 +0100

    cogl: Adds experimental CoglVertexArray type
    
    This adds a new CoglVertexArray object which is a subclass of CoglBuffer
    used to hold vertex attributes. A later commit will add a
    CoglVertexAttribute API which will be used to describe the attributes
    inside a CoglVertexArray.

 cogl/Makefile.am                 |    3 +
 cogl/cogl-vertex-array-private.h |   39 +++++++++++++++++++
 cogl/cogl-vertex-array.c         |   70 ++++++++++++++++++++++++++++++++++
 cogl/cogl-vertex-array.h         |   77 ++++++++++++++++++++++++++++++++++++++
 cogl/cogl.h                      |    1 +
 5 files changed, 190 insertions(+), 0 deletions(-)

commit 4d990a93a8ee0dfcbb16d91d944f7c096f55b9f8
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Oct 12 12:36:22 2010 +0100

    cogl: Adds experimental CoglIndexArray type
    
    A CoglIndexArray is a subclass of CoglBuffer and will be used to hold
    vertex indices. A later commit will add a CoglIndices API which will
    allow describing a range of indices inside a CoglIndexArray.

 cogl/Makefile.am                |    3 +
 cogl/cogl-index-array-private.h |   39 ++++++++++++
 cogl/cogl-index-array.c         |  131 +++++++++++++++++++++++++++++++++++++++
 cogl/cogl-index-array.h         |   79 +++++++++++++++++++++++
 cogl/cogl.h                     |    1 +
 5 files changed, 253 insertions(+), 0 deletions(-)

commit 7901e30aacda2dad8d4aae791721ad0ad79eac2d
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Oct 26 19:08:51 2010 +0100

    buffer: adds immutable ref/unref mechanism
    
    This adds an internal mechanism to mark that a buffer is in-use so that
    a warning can be generated if the user attempts to modify the buffer.
    
    The plans is for the journal to use this mechanism so that we can warn
    users about mid-scene modifications of buffers.

 cogl/cogl-buffer-private.h |    8 ++++++++
 cogl/cogl-buffer.c         |   42 ++++++++++++++++++++++++++++++++++++++++--
 2 files changed, 48 insertions(+), 2 deletions(-)

commit 7cc6dedea495f9b84bd974209b770f2cfe389f52
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Oct 12 13:14:17 2010 +0100

    buffer: make _bind() return base pointer
    
    We now make _cogl_buffer_bind return a base pointer for the bound buffer
    which can be used with OpenGL. The pointer will be NULL for GPU based
    buffers or may point to an malloc'd buffer. Since OpenGL expects an
    offset instead of a pointer when dealing with buffer objects this means
    we can handle fallback malloc buffers and GPU buffers in a consistent
    way.

 cogl/cogl-bitmap.c         |   28 ++++++++--------------------
 cogl/cogl-buffer-private.h |    2 +-
 cogl/cogl-buffer.c         |   17 ++++++++++-------
 3 files changed, 19 insertions(+), 28 deletions(-)

commit 406d0c4a289a1388f9fc1aeb0b6938309b625218
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Oct 26 19:02:04 2010 +0100

    material: Bail out faster if re-flushing unchanged material
    
    This allows _cogl_material_flush_gl_state to bail out faster if
    repeatedly asked to flush the same material and we can see the material
    hasn't changed.
    
    Since we can rely on the material age incrementing when any material
    property changes or any associated layer property changes then we can
    track the age of the material after flushing so it can be compared with
    the age of the material if it is subsequently re-flushed. If the age is
    the same we only have to re-assert the texture object state.

 cogl/cogl-context.h         |    1 +
 cogl/cogl-material-opengl.c |   16 ++++++++++++++--
 2 files changed, 15 insertions(+), 2 deletions(-)

commit 8f15f63212389aac582db2f99696a9c7d6d2714d
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Oct 26 17:43:16 2010 +0100

    material-node: track if node owns reference on parent
    
    MaterialNodes are used for the sparse graph of material state and layer
    state. In the case of materials there is the idea of weak materials that
    don't take a reference on their parent and in that case we need to be
    careful not to unref our parent during
    _cogl_material_node_unparent_real. This adds a has_parent_reference
    member to the CoglMaterialNode struct so we now know when to skip the
    unref.

 cogl/cogl-material-private.h |    4 ++++
 cogl/cogl-material.c         |    4 +++-
 2 files changed, 7 insertions(+), 1 deletions(-)

commit 7927aed5d60e494c9072087bf5451617d49d6b49
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Oct 26 17:38:58 2010 +0100

    cogl-object: correctly free user_data_array in _unref
    
    If there is private data associated with a CoglObject then there may be
    a user_data_array that needs to be freed. The code was mistakenly
    freeing the array inside the loop that was actually iterating over the
    user data array notifying the objects destruction instead of waiting
    until all the data entries had been destroyed.

 cogl/cogl-object.c |    3 +--
 1 files changed, 1 insertions(+), 2 deletions(-)

commit 63206a208b30c036b785cdf58c312088bafd62cd
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Oct 15 18:00:29 2010 +0100

    Merge cogl-program-{gl,gles}.c into one cogl-program.c
    
    This merges the two implementations of CoglProgram for the GLES2 and
    GL backends into one. The implementation is more like the GLES2
    version which would track the uniform values and delay sending them to
    GL. CoglProgram is now effectively just a GList of CoglShaders along
    with an array of stored uniform values. CoglProgram never actually
    creates a GL program, instead this is left up to the GLSL material
    backend. This is necessary on GLES2 where we may need to relink the
    user's program with different generated shaders depending on the other
    emulated fixed function state. It will also be necessary in the future
    GLSL backends for regular OpenGL. The GLSL and ARBfp material backends
    are now the ones that create and link the GL program from the list of
    shaders. The linked program is attached to the private material state
    so that it can be reused if the CoglProgram is used again with the
    same material. This does mean the program will get relinked if the
    shader is used with multiple materials. This will be particularly bad
    if the legacy cogl_program_use function is used because that
    effectively always makes one-shot materials. This problem will
    hopefully be alleviated if we make a hash table with a cache of
    generated programs. The cogl program would then need to become part of
    the hash lookup.
    
    Each CoglProgram now has an age counter which is incremented every
    time a shader is added. This is used by the material backends to
    detect when we need to create a new GL program for the user program.
    
    The internal _cogl_use_program function now takes a GL program handle
    rather than a CoglProgram. It no longer needs any special differences
    for GLES2. The GLES2 wrapper function now also uses this function to
    bind its generated shaders.
    
    The ARBfp shaders no longer store a copy of the program source but
    instead just directly create a program object when cogl_shader_source
    is called. This avoids having to reupload the source if the same
    shader is used in multiple materials.
    
    There are currently a few gross hacks to get the GLES2 backend to work
    with this. The problem is that the GLSL material backend is now
    generating a complete GL program but the GLES2 wrapper still needs to
    add its fixed function emulation shaders if the program doesn't
    provide either a vertex or fragment shader. There is a new function in
    the GLES2 wrapper called _cogl_gles2_use_program which replaces the
    previous cogl_program_use implementation. It extracts the GL shaders
    from the GL program object and creates a new GL program containing all
    of the shaders plus its fixed function emulation. This new program is
    returned to the GLSL material backend so that it can still flush the
    custom uniforms using it. The user_program is attached to the GLES2
    settings struct as before but its stored using a GL program handle
    rather than a CoglProgram pointer. This hack will go away once the
    GLSL material backend replaces the GLES2 wrapper by generating the
    code itself.
    
    Under Mesa this currently generates some GL errors when glClear is
    called in test-cogl-shader-glsl. I think this is due to a bug in Mesa
    however. When the user program on the material is changed the GLSL
    backend gets notified and deletes the GL program that it linked from
    the user shaders. The program will still be bound in GL
    however. Leaving a deleted shader bound exposes a bug in Mesa's
    glClear implementation. More details are here:
    
    https://bugs.freedesktop.org/show_bug.cgi?id=31194

 cogl/Makefile.am                           |    6 +-
 cogl/cogl-internal.h                       |    4 +-
 cogl/cogl-material-arbfp.c                 |   36 +-
 cogl/cogl-material-fixed.c                 |   17 +-
 cogl/cogl-material-glsl.c                  |  355 ++++++++++++++-
 cogl/cogl-material-opengl.c                |  158 +++-----
 cogl/cogl-material-private.h               |    2 +-
 cogl/cogl-program-private.h                |   78 ++++
 cogl/cogl-program.c                        |  683 ++++++++++++++++++++++++++++
 cogl/cogl-shader-private.h                 |    1 -
 cogl/cogl-shader.c                         |   56 ++-
 cogl/driver/gl/cogl-feature-functions-gl.h |   11 +
 cogl/driver/gl/cogl-program-gl.c           |  488 --------------------
 cogl/driver/gl/cogl-program-gl.h           |   46 --
 cogl/driver/gles/cogl-gles2-wrapper.c      |  194 +++------
 cogl/driver/gles/cogl-gles2-wrapper.h      |    9 +-
 cogl/driver/gles/cogl-program-gles.c       |  437 ------------------
 cogl/driver/gles/cogl-program-gles.h       |   52 ---
 18 files changed, 1308 insertions(+), 1325 deletions(-)

commit 7ab928a4e015fb0df5507c5482b83e113be43396
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Oct 27 15:07:03 2010 +0100

    cogl: Use separate materials for set_source_color and texture
    
    Previously cogl_set_source_color and cogl_set_source_texture modified
    a single global material. If an application then mixes using
    cogl_set_source_color and texture then the material will constantly
    need a new ARBfp program because the numbers of layers alternates
    between 0 and 1. This patch just adds a second global material that is
    only used for cogl_set_source_texture. I think it would still end up
    flushing the journal if cogl_set_source_texture is used with multiple
    different textures but at least it should avoid a recompile unless the
    texture target also changes. It might be nice to somehow attach a
    material to the CoglTexture for use with cogl_set_source_texture but
    it would be difficult to implement this without creating a circular
    reference.

 cogl/cogl-context.c |    3 +++
 cogl/cogl-context.h |    3 ++-
 cogl/cogl.c         |   11 ++---------
 3 files changed, 7 insertions(+), 10 deletions(-)

commit 812dd1d83ded5936dd0bc1985856efd8746e8e47
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Oct 12 12:53:44 2010 +0100

    Move IndicesType and VerticesMode typedefs to cogl-types.h
    
    This moves the CoglIndicesType and CoglVerticesMode typedefs from
    cogl-vertex-buffer.h to cogl-types.h so they can be shared with the
    anticipated cogl vertex attribute API.

 cogl/cogl-types.h         |   48 +++++++++++++++++++++++++++++++++++++++++++++
 cogl/cogl-vertex-buffer.h |   47 --------------------------------------------
 2 files changed, 48 insertions(+), 47 deletions(-)

commit 6fe6dd18ac06eee4c8129cdea618fe7036a8cbc2
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Oct 26 16:05:00 2010 +0100

    buffer: BufferBindTarget + BufferUsageHint enum renaming
    
    This renames the BufferBindTarget + BufferUsageHint enums to match the
    anticipated new APIs for "index arrays" and "vertex arrays" as opposed
    to using the terms "vertices" or "indices".

 cogl/cogl-buffer-private.h |    5 +++--
 cogl/cogl-buffer.c         |    2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

commit 525504f9bf82eac89a0950c134544aa7ef034d64
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Oct 18 18:50:02 2010 +0100

    buffer: warn if (offset + size) > buffer->size
    
    previously we would silently bail out if the given offset + data size
    would overflow the buffer size. Now we use g_return_val_if_fail so we
    get a warning if we hit this case.

 cogl/cogl-buffer.c |    7 ++-----
 1 files changed, 2 insertions(+), 5 deletions(-)

commit aafcee31b20d8afe6b91fa84a30de855b07f2020
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Oct 12 13:25:05 2010 +0100

    pixel-array: Remove some benign variables
    
    There were some completely unused static global variables declared in
    cogl-pixel-array.c which this patch removes.

 cogl/cogl-pixel-array.c |    7 -------
 1 files changed, 0 insertions(+), 7 deletions(-)

commit 46b614a7c3c5b1b30d1f29a3c7b5c6e082e11c2c
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Oct 12 13:23:44 2010 +0100

    pixel-array: Remove flags member and flag macros
    
    There are no flags associated with pixel-arrays so we don't need the
    flags member or flag macros.

 cogl/cogl-pixel-array-private.h |   18 ------------------
 cogl/cogl-pixel-array.c         |    2 --
 2 files changed, 0 insertions(+), 20 deletions(-)

commit e18bfd92e4985fb69692916741334dc2209ef85b
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Oct 26 16:06:46 2010 +0100

    buffer: Add a store_created bit field member
    
    This adds a store_created bit field to CoglBuffer so we know if the
    underlying buffer has been allocated yet. Previously the code was trying
    to do something really wrong by accidentally using the
    COGL_PIXEL_ARRAY_FLAG_IS_SET macro (note "PIXEL_ARRAY") and what is more
    odd was the declaration of a CoglPixelArray *pixel_array in
    cogl-buffer.c which the buffer was being cast too before calling using
    the macro. Probably this was the fall-out of some previous code
    re-factoring.

 cogl/cogl-buffer-private.h |    2 ++
 cogl/cogl-buffer.c         |   25 +++++++++++--------------
 2 files changed, 13 insertions(+), 14 deletions(-)

commit 071253c48be87926a942d6e1d5d0f6289220f9b5
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Oct 12 11:46:29 2010 +0100

    buffer: remove flag macros
    
    All the macros get used for are to |= (a new flag bit), &= ~(a flag bit)
    or use the & operator to test if a flag bit is set. I haven't found the
    code more readable with these macros, but several times now I've felt
    the need to double check if these macros do anything else behind the
    hood or I've forgotten what flags are available so I've had to go to the
    macro definition to see what the full enum names are for the flags (the
    macros use symbol concatenation) so I can search for the definition of
    all the flags. It turns out they are defined next to the macro so you
    don't have to search far, but without the macro that wouldn't have been
    necessary.
    
    The more common use of the _IS_SET macro is actually more concise
    expanded and imho since it doesn't hide anything in a separate header
    file the code is more readable without the macro.

 cogl/cogl-bitmap.c         |    4 ++--
 cogl/cogl-buffer-private.h |    9 ---------
 cogl/cogl-buffer.c         |   20 ++++++++++----------
 3 files changed, 12 insertions(+), 21 deletions(-)

commit 1bed79d19a3e6add697955f9dfb5c21bfaf04c84
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Oct 12 12:35:47 2010 +0100

    material: Adds _cogl_material_get_layer_texture
    
    This is a counter part for _cogl_material_layer_get_texture which takes
    a layer index instead of a direct CoglMaterialLayer pointer. The aim is
    to phase out code that directly iterates the internal layer pointers of
    a material since the layer pointers can change if any property of any
    layer is changed making direct layer pointers very fragile.

 cogl/cogl-material-private.h |    4 ++++
 cogl/cogl-material.c         |    9 +++++++++
 2 files changed, 13 insertions(+), 0 deletions(-)

commit a74c26d8d14fd6f703f4887569b70c5dfd2aff5f
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Oct 18 19:00:50 2010 +0100

    material: add internal layer filter getters
    
    This adds internal _cogl_material_get_layer_filters and
    _cogl_material_get_layer_{min,mag}_filter functions which can be used to
    query the filters associated with a layer using a layer_index, as
    opposed to a layer pointer. Accessing layer pointers is considered
    deprecated so we need to provide layer_index based replacements.

 cogl/cogl-material-private.h |   14 +++++++++++++
 cogl/cogl-material.c         |   45 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 59 insertions(+), 0 deletions(-)

commit 0330a7a2e68531773107d14a81626aa1d7d77a51
Author: Robert Bragg <robert@linux.intel.com>
Date:   Sun Aug 1 23:05:28 2010 +0100

    material: Adds missing get_layer_wrap_mode_xyz prototypes
    
    This adds missing getter function prototypes for
    cogl_material_get_layer_wrap_mode_{s,t,p}

 cogl/cogl-material.h |   52 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 52 insertions(+), 0 deletions(-)

commit 876bf6cb287000de5d982199324453c7c18bbdaa
Author: Robert Bragg <robert@linux.intel.com>
Date:   Sun Aug 1 16:07:38 2010 +0100

    vertex-buffer: remove the unstrided CBO type
    
    When we come to submitting the users given attributes we sort them into
    different types of buffers. Previously we had three types; strided,
    unstrided and multi-pack. Really though unstrided was just a limited
    form of multi-pack buffer and didn't imply any hind of special
    optimization so this patch consolidates some code by reducing to just
    two types; strided and multi-pack.

 cogl/cogl-vertex-buffer-private.h |    5 ++---
 cogl/cogl-vertex-buffer.c         |   33 ++++++---------------------------
 2 files changed, 8 insertions(+), 30 deletions(-)

commit b64c1c97817fb51c61f17a21beeae7fabde70c69
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Jul 28 13:59:34 2010 +0100

    material: Adds _cogl_material_pre_paint_for_layer
    
    This is a counter part for _cogl_material_layer_pre_paint which takes a
    layer index instead of a direct CoglMaterialLayer pointer. The aim is to
    phase out code that directly iterates the internal layer pointers of a
    material since the layer pointers can change if any property of any
    layer is changed making direct layer pointers very fragile.

 cogl/cogl-material-private.h |    9 +++++++++
 cogl/cogl-material.c         |    8 ++++++++
 2 files changed, 17 insertions(+), 0 deletions(-)

commit 1b9a247174d7d23a1de36738437046734ef9568d
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Oct 25 13:25:21 2010 +0100

    cogl: Adds {push,pop,get}_source functions
    
    This exposes the idea of a stack of source materials instead of just
    having a single current material. This allows the writing of orthogonal
    code that can change the current source material and restore it to its
    previous state. It also allows the implementation of new composite
    primitives that may want to validate the current source material and
    possibly make override changes in a derived material.

 cogl/cogl-clip-stack.c               |    7 +--
 cogl/cogl-context.c                  |    6 +-
 cogl/cogl-context.h                  |    2 +-
 cogl/cogl-material-private.h         |    3 +
 cogl/cogl-path.c                     |   41 ++++++-------
 cogl/cogl-primitives.c               |   99 ++++++++++++++----------------
 cogl/cogl-texture.c                  |    7 +--
 cogl/cogl-vertex-buffer.c            |   38 +++++++-----
 cogl/cogl.c                          |  109 +++++++++++++++++++++++++++++++---
 cogl/cogl.h                          |   58 +++++++++++++++---
 doc/reference/cogl/cogl-sections.txt |    3 +
 11 files changed, 252 insertions(+), 121 deletions(-)

commit 4ccd915064754e1f7718e44d5603f6ef50f017ba
Merge: 8986877 c6977cd
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Oct 25 23:44:53 2010 +0100

    Merge branch 'private-cleanup'
    
    * private-cleanup:
      Add copyright notices
      Clean up clutter-private.h/6
      Clean up clutter-private.h/5
      Clean up clutter-private.h/4
      Clean up clutter-private.h/3
      Clean up clutter-private.h/2
      Clean up clutter-private.h/1

commit 8986877c3ec0d362c7b694f6eb13bdbc92a8214d
Merge: c381f0c 66680d2
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Oct 25 17:09:46 2010 +0100

    Merge branch 'wip/path-constraint'
    
    * wip/path-constraint:
      docs: Add PathConstraint
      tests: Add a PathConstraint interactive test
      Add ClutterPathConstraint
      actor-box: Add setters for origin and size

commit c381f0cb8b0edcc6927438626730904397e113f3
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Oct 25 13:15:01 2010 +0100

    cogl-context-winsys: Avoid zero-length arrays
    
    When compiling for non-glx platforms the winsys feature data array
    ends up empty. Empty arrays cause problems for MSVC so this patch adds
    a stub entry so that the array always has at least one entry.
    
    Based on a patch by Ole André Vadla Ravnås

 cogl/winsys/cogl-context-winsys.c |    8 +++++++-
 1 files changed, 7 insertions(+), 1 deletions(-)

commit 371e6bd47ccea22a0f309c04765c2d2f1cb9b429
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Oct 25 13:08:52 2010 +0100

    Avoid mixing declarations and code
    
    Mixing declarations and code causes problems for MSVC as it is a C99
    feature so we should try to avoid it.

 cogl/cogl-material-opengl.c |    9 ++++++++-
 cogl/cogl-material.c        |    4 +++-
 2 files changed, 11 insertions(+), 2 deletions(-)

commit 66680d22f82449f991a4f5e8e2589bc276d6caa9
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Oct 4 14:34:24 2010 +0100

    cogl-texture-2d-sliced: Use the other backends for the slices
    
    Instead of directly manipulating GL textures itself,
    CoglTexture2DSliced now works in terms of CoglHandles. It creates the
    texture slices using cogl_texture_new_with_size which should always
    end up creating a CoglTexture2D because the size should fit. This
    allows us to avoid replicating some code such as the first pixel
    mipmap tracking and it better enforces the separation that each
    texture backend is the only place that contains code dealing with each
    texture target.

 cogl/cogl-texture-2d-sliced-private.h |   20 +-
 cogl/cogl-texture-2d-sliced.c         | 1103 ++++++++++++++-------------------
 2 files changed, 462 insertions(+), 661 deletions(-)

commit b540dcb75a45c2f39c59752e5d582d6299da38d5
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Oct 4 15:27:38 2010 +0100

    Support foreign textures in the texture-2d and rectangle backends
    
    This adds two new internal functions to create a foreign texture for
    the texture 2d and rectangle backends. cogl_texture_new_from_foreign
    will now use one of these backends directly if there is no waste
    instead of always using the sliced texture backend.

 cogl/cogl-texture-2d-private.h        |    7 ++
 cogl/cogl-texture-2d.c                |  135 +++++++++++++++++++++++++++++++--
 cogl/cogl-texture-rectangle-private.h |    7 ++
 cogl/cogl-texture-rectangle.c         |  118 +++++++++++++++++++++++++++--
 cogl/cogl-texture.c                   |   42 ++++++++--
 5 files changed, 287 insertions(+), 22 deletions(-)

commit c6977cdb13fd0c2743863edddf9e2e18b7725203
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Thu Oct 14 16:32:13 2010 +0100

    build: Fix EGL/CEX100 build with GLES2
    
    Some headers files have been renamed or removed and the gles(2) did not
    compile anymore, fix that.

 cogl/driver/gles/cogl-gles.c          |    2 +-
 cogl/driver/gles/cogl-gles2-wrapper.c |    2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

commit 963a0662b430c00da0e9ee94e41652f326902f92
Author: Kristian Høgsberg <krh@bitplanet.net>
Date:   Tue Sep 28 10:17:46 2010 -0400

    Add wayland backend
    
    This adds a clutter backend for running under the wayland window system.
    Initial cogl framebuffer integration by Robert Bragg.

 cogl/Makefile.am       |    4 ++++
 cogl/winsys/cogl-egl.c |   10 +++++++---
 2 files changed, 11 insertions(+), 3 deletions(-)

commit a80a65ce8f0d77522a70e4cb00a8531a8902c831
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Oct 5 17:17:53 2010 +0100

    cogl-texture-2d-sliced: Use the smallest possible waste
    
    When picking a size for the last slice in a texture, Cogl would always
    pick the biggest power of two size that doesn't create too much
    waste and is less than or equal to the previous slice size. However
    this can end up creating a texture that is bigger than needed if there
    is a smaller power of two.
    
    For example, if the maximum waste is 127 (the current default) and we
    try to create a texture that is 257 pixels wide it will decide that
    the next power of two (512) is too much waste (255) so it will create
    the first slice at 256 pixels wide. Then we only have 1 pixel left to
    allocate but Cogl would pick the next smaller size that has a small
    enough waste which is 128. But of course 1 is already a power of two
    so that's redundantly oversized by 127.
    
    This patch fixes it so that whenever it finds a size that would be big
    enough, instead of using exactly that it picks the next power of two
    up from the size we need to fill.
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2355

 cogl/cogl-texture-2d-sliced.c |    4 ++++
 1 files changed, 4 insertions(+), 0 deletions(-)

commit 01e72335a030735d97889528f29694179106f8c5
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Tue Oct 5 08:03:19 2010 +0100

    cogl: Use Cogl (not COGL) consistently
    
    If I remember correctly, Robert wants to name Cogl, Cogl (not COGL) so
    start by having a consistent naming in the code.

 cogl/cogl-debug.c |    8 ++++----
 1 files changed, 4 insertions(+), 4 deletions(-)

commit c878acf6cf4c0e4532d57538f9f5892616f9b610
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Oct 4 14:12:21 2010 +0100

    cogl-x11: Trap glXDestroyPixmap()
    
    There are ordering issues in the pixmap destruction with current and
    past X11 server, Mesa and dri2. Under some circumstances, an X pixmap
    might be destroyed with the GLX pixmap still referencing it, and thus
    the X server will decide to destroy the GLX pixmap as well; then, when
    Cogl tries to destroy the GLX pixmap, it gets BadDrawable errors.
    
    Clutter 1.2 used to trap + sync all calls to glXDestroyPixmap(), but
    then we assumed that the ordering issue had been solved. So, we're back
    to square 1.
    
    I left a Big Fat Comment™ right above the glXDestroyPixmap() call
    referencing the bug and the reasoning behind the trap, so that we don't
    go and remove it in the future without checking that the issue has been
    in fact solved.
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2324

 cogl/winsys/cogl-texture-pixmap-x11.c |   22 ++++++++++++++++++++++
 1 files changed, 22 insertions(+), 0 deletions(-)

commit d9e18215015b37da6845d4bfdc6abbf29aa5ec3f
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Oct 4 08:57:29 2010 +0100

    build: Unconditionally add GLES2 shaders to EXTRA_DIST

 cogl/Makefile.am |    3 +--
 1 files changed, 1 insertions(+), 2 deletions(-)

commit ac9e59721a52a01b110152ce05759603da0be07c
Merge: f85d152 51b0905
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Thu Sep 30 12:24:32 2010 +0100

    Merge remote branch 'elliot/events-buttons'
    
    * elliot/events-buttons:
      cookbook: Add recipe about handling button events
      cookbook: Example of using button press and release events
      cookbook: Example of ClutterClickAction
      cookbook: Example of simple handling of button events

commit f85d1520a01fe433fde857462a1d431db6a5d956
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Sep 24 01:01:33 2010 +0100

    material: tweak dot file debug code
    
    When using the debug function _cogl_debug_dump_materials_dot_file to
    write a dot file representing the sparse graph of material state we now
    only show a link between materials and layers when the material directly
    owns that layer reference (i.e. just those referenced in
    material->layer_differences) This makes it possible to see when
    ancestors of a material are being deferred too for layer state.
    
    For example when looking at the graph if you see that a material has an
    n_layers of 3 but there is only a link to 2 layers, then you know you
    need to look at it's ancestors to find the last layer.

 cogl/cogl-material.c |    6 +++++-
 1 files changed, 5 insertions(+), 1 deletions(-)

commit 51b090541a0879e1f117deb0a4d6f66efae16fd1
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Sep 29 15:40:22 2010 +0100

    cogl-texture-2d-sliced: Don't create the slice textures twice
    
    Both of the cogl_texture_2d_sliced_new functions called the
    slices_create function which creates the underlying GL
    textures. However this was also called by init_base so the textures
    would end up being created twice. This would make it leak the GL
    textures and the arrays which point to them.

 cogl/cogl-texture-2d-sliced.c |   18 ------------------
 1 files changed, 0 insertions(+), 18 deletions(-)

commit c4638fa1df9b8c9ad58f96dab84c7087893018fa
Merge: d011502 eb179d4
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Wed Sep 29 15:55:58 2010 +0100

    Merge branch 'wip/non-recursive'
    
    * wip/non-recursive:
      build: Start moving to a non-recursive layout

commit d011502603bcb442ed51f641d6bd14c978582afd
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Sep 7 23:35:26 2010 +0100

    cogl: removes unused _cogl_setup_viewport
    
    Clutter has now taken responsibility for managing its viewport,
    projection matrix and view transform as part of ClutterStage so
    _cogl_setup_viewport is no longer used by anything, and since it's quite
    an obscure API anyway it's we've taken the opportunity to remove the
    function.

 cogl/cogl.c |   74 -----------------------------------------------------------
 cogl/cogl.h |   26 --------------------
 2 files changed, 0 insertions(+), 100 deletions(-)

commit eb179d4b679f0dc9d25e2a8e0f13a99f678b1bf9
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Sep 13 11:30:30 2010 +0100

    build: Start moving to a non-recursive layout
    
            *** WARNING: THIS COMMIT CHANGES THE BUILD ***
    
    Do not recurse into the backend directories to build private, internal
    libraries.
    
    We only recurse from clutter/ into the cogl sub-directory; from there,
    we don't recurse any further. All the backend-specific code in Cogl and
    Clutter is compiled conditionally depending on the macros defined by the
    configure script.
    
    We still recurse from the top-level directory into doc, clutter and
    tests, because gtk-doc and tests do not deal nicely with non-recursive
    layouts.
    
    This change makes Clutter compile slightly faster, and cleans up the
    build system, especially when dealing with introspection data.
    
    Ideally, we also want to make Cogl part of the top-level build, so that
    we can finally drop the sed trick to change the shared library from the
    GIR before compiling it.
    
    Currently disabled:
    
      ‣ OSX backend
      ‣ Fruity backend
    
    Currently enabled but untested:
    
      ‣ EGL backend
      ‣ Windows backend

 cogl/Makefile.am                               |  136 +++++--
 cogl/cogl-context.h                            |   10 +-
 cogl/cogl-material-arbfp.c                     |    9 +-
 cogl/cogl-material-fixed.c                     |    9 +-
 cogl/cogl-material-glsl.c                      |    8 +-
 cogl/cogl-material-opengl.c                    |    9 +-
 cogl/driver/gl/Makefile.am                     |   34 --
 cogl/driver/gl/cogl-context-driver-gl.c        |   39 ++
 cogl/driver/gl/cogl-context-driver-gl.h        |   53 +++
 cogl/driver/gl/cogl-context-driver.c           |   39 --
 cogl/driver/gl/cogl-context-driver.h           |   53 ---
 cogl/driver/gl/cogl-feature-functions-gl.h     |  410 +++++++++++++++++++
 cogl/driver/gl/cogl-feature-functions.h        |  410 -------------------
 cogl/driver/gl/cogl-gl.c                       |  237 +++++++++++
 cogl/driver/gl/cogl-program-gl.c               |  488 ++++++++++++++++++++++
 cogl/driver/gl/cogl-program-gl.h               |   46 ++
 cogl/driver/gl/cogl-program.c                  |  488 ----------------------
 cogl/driver/gl/cogl-program.h                  |   46 --
 cogl/driver/gl/cogl-texture-driver-gl.c        |  522 ++++++++++++++++++++++++
 cogl/driver/gl/cogl-texture-driver.c           |  522 ------------------------
 cogl/driver/gl/cogl.c                          |  237 -----------
 cogl/driver/gles/Makefile.am                   |   57 ---
 cogl/driver/gles/cogl-context-driver-gles.c    |   46 ++
 cogl/driver/gles/cogl-context-driver-gles.h    |   56 +++
 cogl/driver/gles/cogl-context-driver.c         |   46 --
 cogl/driver/gles/cogl-context-driver.h         |   56 ---
 cogl/driver/gles/cogl-feature-functions-gles.h |  111 +++++
 cogl/driver/gles/cogl-feature-functions.h      |  111 -----
 cogl/driver/gles/cogl-gles.c                   |  117 ++++++
 cogl/driver/gles/cogl-gles2-wrapper.c          |    1 -
 cogl/driver/gles/cogl-gles2-wrapper.h          |    2 +-
 cogl/driver/gles/cogl-program-gles.c           |  437 ++++++++++++++++++++
 cogl/driver/gles/cogl-program-gles.h           |   52 +++
 cogl/driver/gles/cogl-program.c                |  437 --------------------
 cogl/driver/gles/cogl-program.h                |   52 ---
 cogl/driver/gles/cogl-texture-driver-gles.c    |  504 +++++++++++++++++++++++
 cogl/driver/gles/cogl-texture-driver.c         |  504 -----------------------
 cogl/driver/gles/cogl.c                        |  117 ------
 cogl/driver/gles/stringify.sh                  |   94 -----
 39 files changed, 3248 insertions(+), 3357 deletions(-)
