spec=1.2.0..1.4.0
commit 14dbe81deb8c9d583c8c56e4ede45a46880c2a76
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Sep 23 22:18:42 2010 +0100

    material: Don't prune ancestry if it owns some layers
    
    Each time a material property changes we look to see if any of its
    ancestry has become redundant and if so we prune that redundant
    ancestry.
    
    There was a problem with the logic that handles this though because we
    weren't considering that a material which is a layer state authority may
    still defer to ancestors to define the state of individual layers.
    
    For example a material that derives from a parent with 5 layers can
    become a STATE_LAYERS authority by simply changing it's ->n_layers count
    to 4 and in that case it can still defer to its ancestors to define the
    state of those 4 layers.
    
    This patch checks first if a material is a layer state authority and if
    so only tries to prune its ancestry if it also *owns* all the individual
    layers it depends on. (I.e. if g_list_length
    (material->layer_differences) != material->n_layers then it's not safe
    to try pruning its ancestry!)
    
    http://bugzilla-attachments.gnome.org/attachment.cgi?id=170907

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

commit 256f83973c836bf68ae54a4ed4a8967f4fede5ca
Author: Jammy Zhou <jammy.zhou@linaro.org>
Date:   Tue Sep 21 11:37:52 2010 +0800

    cogl-framebuffer.c: GL_DEPTH_STENCIL not supported in gles
    
    There is GL_INVALID_ENUM error for GL_DEPTH_STENCIL when call
    glRenderbufferStorage() with OpenGL ES backend. So enable this
    only for OpenGL backend.
    
    Signed-off-by: Robert Bragg <robert@linux.intel.com>

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

commit 8150292879625eacc3d36273eeaa56fadbb3a43d
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Sep 23 15:45:27 2010 +0100

    docs: Put deprecated Cogl symbols into new section
    
    This adds a "Cogl deprecated API" chapter to the Cogl reference manual
    so we can group all the documentation for deprecated symbols together
    instead of having them clutter up the documentation of symbols we would
    rather developers used.

 doc/reference/cogl/cogl-docs.xml.in  |   28 ++++++++++
 doc/reference/cogl/cogl-sections.txt |   99 +++++++++++++++++++++++-----------
 2 files changed, 96 insertions(+), 31 deletions(-)

commit d9d0b7881172dbe16d4c0703cdb2e9ae9f94a16d
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Aug 25 22:31:30 2010 +0100

    docs: update the overview paragraph for Cogl
    
    Instead of describing OpenGL as "a low level OpenGL abstraction
    library" it is now summarised as "modern 3D graphics API".

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

commit fb05fe795808fac47c0ba35a8c1fe0706f359d7e
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Aug 25 20:36:20 2010 +0100

    docs: cogl-texture-3d wasn't listed as experimental
    
    The CoglTexture3D API is only available when defining
    COGL_ENABLE_EXPERIMENTAL_API so it should be listed in the experimental
    section of the API reference.

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

commit e5e892fe47ee727df10330d32d9bd4569068e70a
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Aug 25 20:33:27 2010 +0100

    docs: Use "Cogl" not "COGL" in Cogl API reference
    
    Cogl isn't an acronym so we should use "Cogl" instead of "COGL" in
    our documentation.

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

commit 6f0f964e12f61e1afd34330988a7decee20e2e17
Merge: ab78575 c8f8352
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Sep 20 14:33:26 2010 +0100

    Merge branch 'cookbook-layouts-bind-constraint'
    
    * cookbook-layouts-bind-constraint:
      cookbook: Add recipe about sync'ing actor sizes
      cookbook: Example using allocation-changed to sync actor size
      cookbook: Simple example to demonstrate bind constraint
      cookbook: Example of using a bind constraint for an overlay

commit ab78575823dbac0c1f9783425f7f08ada7aa5292
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Sep 20 13:15:44 2010 +0100

    docs: API reference fixes

 cogl/cogl-path.h                      |    2 ++
 cogl/winsys/cogl-texture-pixmap-x11.h |   18 +++++++++++-------
 2 files changed, 13 insertions(+), 7 deletions(-)

commit 0b2985ad66f7a5a3f7db2b7fc7f3b554ee1037a4
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Sep 17 17:18:09 2010 +0100

    cogl-object-private.h: Include cogl-debug.h
    
    If COGL_OBJECT_DEBUG is defined then cogl-object-private.h will call
    COGL_NOTE in the ref and unref macros. For this to work the debug
    header needs to also be included or COGL_NOTE won't necessarily be
    defined.

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

commit c8f83525ce204e7006ea2d8fa1e9d6530ea5077d
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Wed Sep 15 15:56:42 2010 +0100

    build: Add cogl-debug-options.h

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

commit 583d5cc79f2a00ac6e9ac93253f9cfdb528830a2
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Sep 15 14:39:05 2010 +0100

    cogl: Make cogl_util_next_p2 internal and fix the documentation
    
    cogl_util_next_p2 is declared in cogl-util.h which is a private header
    so it shouldn't be possible for an application to use it. It's
    probably not a function we'd like to export from Cogl so it seems
    better to keep it private. This patch renames it to _cogl_util_next_p2
    so that it won't be exported from the shared library.
    
    The documentation for the function is also slightly wrong because it
    stated that the function returned the next power greater than
    'a'. However the code would actually return 'a' if it's already a
    power of two. I think the actual behaviour is more useful so this
    patch changes the documentation rather than the code.

 cogl/cogl-texture-2d-sliced.c |    4 ++--
 cogl/cogl-util.c              |   11 ++++++-----
 cogl/cogl-util.h              |    2 +-
 3 files changed, 9 insertions(+), 8 deletions(-)

commit a433bd8e9e732016e03ced0bc7ab57ee44c54620
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Sep 15 14:07:30 2010 +0100

    cogl-vertex-buffer: Don't always set COGL_MATERIAL_FLUSH_FALLBACK_MASK
    
    Previously CoglVertexBuffer would always set the flush options flags
    to at least contain COGL_MATERIAL_FLUSH_FALLBACK_MASK. The code then
    later checks whether any flags are set before deciding whether to copy
    the material to implement the overrides. This means that it would
    always end up copying the material even if there are no fallback
    layers. This patch changes it so that it only sets
    COGL_MATERIAL_FLUSH_FALLBACK_MASK if fallback_layers != 0.

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

commit 91b46890f776171afcfa6187b3dcfbe13d353214
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Sep 14 20:25:23 2010 +0100

    material-arbfp: fix updating params if sharing progs
    
    If a single arbfp program is being shared between multiple CoglMaterials
    then we need to make sure we update all program.local params when
    switching between materials. Previously we had a dirty flag to track
    when combine_constant params were changed but didn't take in to account
    that different materials sharing the same program may have different
    combine constants.

 cogl/cogl-material-arbfp.c |   12 +++++++++++-
 1 files changed, 11 insertions(+), 1 deletions(-)

commit cad5624a2a236242ad4b038346ad36b2f2af8e4b
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Sep 14 18:50:50 2010 +0100

    material-arbfp: Another pass at simplifying the code
    
    Previously the backend private state was used to either link to an
    authority material or provide authoritative program state. The mechanism
    seemed overly complex and felt very fragile. I made a recent comment
    which added a lot of documentation to make it easier to understand but
    still it didn't feel very elegant.
    
    This patch takes a slightly different approach; we now have a
    ref-counted ArbfpProgramState object which encapsulates a single ARBfp
    program and the backend private state now just has a single member which
    is a pointer to one of these arbfp_program_state objects. We no longer
    need to cache pointers to our arbfp-authority and so we can get rid of
    a lot of awkward code that ensured these pointers were
    updated/invalidated at the right times. The program state objects are
    not tightly bound to a material so it will also allow us to later
    implement a cache mechanism that lets us share state outside a materials
    ancestry. This may help to optimize code not following the
    recommendations of deriving materials from templates, avoiding one-shot
    materials and not repeatedly modifying materials because even if a
    material's ancestry doesn't naturally lead us to shareable state we can
    fallback to searching for shareable state using central hash tables.

 cogl/cogl-material-arbfp.c |  600 +++++++++++++++++++-------------------------
 1 files changed, 256 insertions(+), 344 deletions(-)

commit 16c64054b941b1508d0f904ff61582e01912a06b
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Jul 5 21:33:26 2010 +0100

    material: Adds experimental cogl_material_foreach_layer API
    
    This adds a way to iterate the layer indices of the given material since
    cogl_material_get_layers has been deprecated. The user provides a
    callback to be called once for each layer.
    
    Because modification of layers in the callback may potentially
    invalidate any number of the internal CoglMaterialLayer structures and
    invalidate the material's layer cache this should be more robust than
    cogl_material_get_layers() which used to return a const GList *
    pointing directly to internal state.

 cogl/cogl-material-arbfp.c   |   12 ++--
 cogl/cogl-material-opengl.c  |   18 ++++----
 cogl/cogl-material-private.h |   10 ++--
 cogl/cogl-material.c         |  108 +++++++++++++++++++++++++++++------------
 cogl/cogl-material.h         |   33 +++++++++++++
 5 files changed, 129 insertions(+), 52 deletions(-)

commit 7eff623b96a3bec083b9355d4e66217ec0fc9de7
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Sep 14 12:13:30 2010 +0100

    material: don't declare backend vtables in headers
    
    This fixes the material backends to declare their constant vtable in the
    c file with a corresponding extern declaration in the header. This
    should fix complaints about duplicate symbols seen on OSX.

 cogl/cogl-material-arbfp-private.h |    2 +-
 cogl/cogl-material-arbfp.c         |    2 ++
 cogl/cogl-material-fixed-private.h |    2 +-
 cogl/cogl-material-fixed.c         |    2 ++
 cogl/cogl-material-glsl-private.h  |    2 +-
 cogl/cogl-material-glsl.c          |    2 ++
 6 files changed, 9 insertions(+), 3 deletions(-)

commit 56a382a50724f47b1a2cd9bcd7fbad4b8ae69623
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Sep 14 00:33:46 2010 +0100

    material-arbfp: don't recompile for constant changes
    
    Instead of lazily incorporating combine constants as arbfp PARAM
    constants in the source directly we now use program.local parameters
    instead so we can avoid repeating codegen if a material's combine
    constant is updated. This should be a big win for applications animating
    a constant used for example in an animated interpolation, such as
    gnome-shell.
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2280

 cogl/cogl-material-arbfp.c |   68 +++++++++++++++++++++++++++++---------------
 1 files changed, 45 insertions(+), 23 deletions(-)

commit 17538cf5e622fd8dd134883d3aa344770e0720ff
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Sep 14 00:27:57 2010 +0100

    material-arbfp: don't redo codegen for texture changes
    
    This makes it so we don't consider LAYER_STATE_TEXTURE changes to affect
    the arbfp code. This should avoid a lot of unneeded passes of
    code generation for applications modifying the texture for a layer.

 cogl/cogl-material-arbfp.c |   12 +++++++++---
 1 files changed, 9 insertions(+), 3 deletions(-)

commit 0717eb9f6b0acae8a7914f71ceeb1b5789d831f6
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Sep 14 00:18:02 2010 +0100

    material: make layer/material_pre_changes mutually exclusive
    
    This makes it so we only notify backends of either a single material
    change or a single layer change. Previously all material STATE_LAYERS
    changes would be followed by a more detailed layer change.
    
    For backends that perform code generation for fragment processing they
    typically need to understand the details of how layers get changed to
    determine if they need to repeat codegen. It doesn't help them to report
    a material STATE_LAYERS change for all layer changes since it's so
    broad, they really need to wait for the layer change to be notified.
    
    What does help though is to report a STATE_LAYERS change for a change in
    material->n_layers because they typically do need to repeat codegen in
    that case.

 cogl/cogl-material-arbfp.c |    7 +++++++
 cogl/cogl-material.c       |   22 +++++++++++++++++++++-
 2 files changed, 28 insertions(+), 1 deletions(-)

commit 95fbe5fb0d243029f4cfd820386a8c0d7b9889ff
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Sep 13 23:52:18 2010 +0100

    material-arbfp: fixes for how we track private state
    
    This fixes a number of issues relating to how we track the arbfp private
    state associated with CoglMaterials. At the same time it adds much more
    extensive code documentation to try and make it a bit more approachable.

 cogl/cogl-material-arbfp.c |  175 ++++++++++++++++++++++++++++++++++++--------
 1 files changed, 143 insertions(+), 32 deletions(-)

commit 0e99fa7a1e0191328b0616b5a901fb1ab14dd1fb
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Sep 13 23:05:49 2010 +0100

    material: pass material owner for layer pre changes
    
    When notifying a backend about a layer being modified we now pass the
    layers current owner for reference. NB: Although a layer can indirectly
    be referenced by multiple layers, a layer is considered immutable once
    it has dependants, so there is only ever one material associated with a
    layer being modified. Passing the material pointer to the backends
    layer_pre_change callback can be useful for backends that associate
    their private state with materials and may need to update that state in
    response to layer changes.

 cogl/cogl-material-arbfp.c   |   11 ++++++++++-
 cogl/cogl-material-private.h |    3 ++-
 cogl/cogl-material.c         |    7 ++++---
 3 files changed, 16 insertions(+), 5 deletions(-)

commit 8f63ca6ffc95a8b4e3f5190114301d06fecea857
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Sep 13 22:56:44 2010 +0100

    arbfp: rename get_arbfp_authority clarifying semantics
    
    This renames the get_arbfp_authority function to
    get_arbfp_authority_no_check to clarify that the function doesn't
    validate that the authority cache is still valid by looking at the age
    of the referenced material. The function should only be used when we
    *know* the cache has already been checked.

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

commit 3a2a10d2e8edddb2324e60fa5fefac5a1c2fa07e
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Sep 13 21:26:31 2010 +0100

    material: track if material change is layer change
    
    We now pass a boolean to _cogl_material_pre_change_notify to know when
    a material change is as a result of a layer change. We plan to use this
    information to avoid notifying the backends about material changes if
    they are as a result of layer changes. This will simplify the handling
    of state changes in the backends because they can assume that layer and
    material changes are mutually exclusive.

 cogl/cogl-material.c |   52 +++++++++++++++++++++++++++----------------------
 1 files changed, 29 insertions(+), 23 deletions(-)

commit bc187dc31e18c008103b20deaf7283d07c1711bb
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Sep 13 21:21:09 2010 +0100

    material: Adds _get_layer_combine_constant API
    
    This adds an internal _cogl_material_get_layer_combine_constant function
    so we can query the current layer combine constant back. We should
    probably make this a public property getter, but for now we just need
    this so we can read the constant in the arbfp backend.

 cogl/cogl-material-private.h |    5 +++++
 cogl/cogl-material.c         |   26 ++++++++++++++++++++++++++
 2 files changed, 31 insertions(+), 0 deletions(-)

commit c9ac838fad48040c3d37e3bcebeedb608109f5fd
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Sep 13 21:17:30 2010 +0100

    material: track unit state with arbfp private state
    
    We are going to start tracking more per-texture unit state with arbfp
    private state so this adds an internal UnitState type and we allocate an
    array of these when setting up a new private state structure. The first
    thing that has been moved into this is the sampled boolean to know when
    a particular texture unit gets sampled from in the generated arbfp code.

 cogl/cogl-material-arbfp.c |   36 +++++++++++++++++++++++++++---------
 1 files changed, 27 insertions(+), 9 deletions(-)

commit 71f62ca5000064d22944ff2d8f4398489dc75842
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Wed Sep 15 11:56:59 2010 +0100

    Enumeration value should be on the same line
    
    The glib-mkenums script is not clever enough to deal with
    
      FLAGS_VALUE = FLAGS_A |
                    FLAGS_B
    
    And since this breaks the enumeration GType and the introspection data,
    we cannot really wait for it to be fixed.
    
    See: https://bugzilla.gnome.org/show_bug.cgi?id=629741
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2238

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

commit 33a64408121d1030d7dfdd5515f9d786ff858dae
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Sep 1 15:15:20 2010 +0100

    cogl-framebuffer: fix leak when popping framebuffer
    
    We were using g_slist_remove_link instead of g_slist_delete_link
    resulting in a memory leak. Thanks to Simon Lanzmich for
    reporting this bug.

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

commit eabce897dc05e227e7039cc4ce6bc4938f58852b
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Aug 16 21:11:42 2010 +0100

    Initialize the cogl uprof state in cogl_create_context
    
    This avoids the use of of gcc constructor and destructor attributes to
    initialize the cogl uprof context and optionally print a cogl uprof
    report at app exit. We now initialize the uprof context in
    cogl_context_create instead.

 cogl/cogl-context.c |   17 +++++++++++++++++
 cogl/cogl-profile.c |   30 ++++++++++++++++--------------
 cogl/cogl-profile.h |    3 +++
 3 files changed, 36 insertions(+), 14 deletions(-)

commit d1ac02594f7985bdb7f4b215a59f54c51f2624bc
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Jul 26 15:21:18 2010 +0100

    journal: provide more detailed uprof instrumentation
    
    This adds more timing around key stages of the journal flushing process.

 cogl/cogl-journal.c  |   39 +++++++++++++++++++++++++++++++++++++++
 cogl/cogl-material.c |   40 ++++++++++++++++++++++++++++------------
 2 files changed, 67 insertions(+), 12 deletions(-)

commit 9d4ad1584d32a61ec6879601bc320fd79e2efb1e
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Jun 21 15:36:46 2010 +0100

    profile: Update to uprof-0.3 dep for --enable-profile
    
    When building with --enable-profile we now depend on the uprof-0.3
    developer release which brings a few improvements:
    
    » It lets us "fix" how we initialize uprof so that instead of using a shared
    object constructor/destructor (which was a hack used when first adding
    uprof support to Clutter) we can now initialize as part of clutter's
    normal initialization code. As a side note though, I found that the way
    Clutter initializes has some quite serious problems whenever it
    involves GOptionGroups. It is not able to guarantee the initialization
    of dependencies like uprof and Cogl. For this reason we still use the
    contructor/destructor approach to initialize uprof in Cogl.
    
    » uprof-0.3 provides a better API for adding custom columns when reporting
    timer and counter statistics which lets us remove quite a lot of manual
    report generation code in clutter-profile.c.
    
    » uprof-0.3 provides a shared context for tracking mainloop timer
    statistics. This means any mainloop based library following the same
    "Mainloop" timer naming convention can use the shared context and no
    matter who ends up owning the final mainloop the statistics will always
    be in the same place. This allows profiling of Clutter with an
    external mainloop such as with the Mutter compositor.
    
    » uprof-0.3 can export statistics over dbus and comes with an ncurses
    based ui to vizualize timer and counter stats live.
    
    The latest version of uprof can be cloned from:
    git://github.com/rib/UProf.git

 cogl/cogl-debug-options.h |  145 +++++++++++++++++++++++++++++++++++++++++++++
 cogl/cogl-debug.c         |   37 ++---------
 cogl/cogl-debug.h         |   18 +++---
 cogl/cogl-profile.c       |   48 +++++++++++++++
 cogl/cogl-profile.h       |    4 +
 cogl/cogl-texture-3d.c    |    1 +
 6 files changed, 215 insertions(+), 38 deletions(-)

commit 4628d28172b2ec1cb6ef160d11f05863bcd5bd50
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Sep 6 17:18:11 2010 +0100

    cogl-framebuffer: Clear the renderbuffer list on failure
    
    When try_creating_fbo fails it deletes any intermediate render buffers
    that were created. However it doesn't clear the list so I think if it
    failed a second time it would try to delete the render buffers
    again. This could potentially cause problems if a subsequent fbo is
    created because the destructor for the original might delete the
    renderbuffers of the new fbo.

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

commit e333a3645ce5ae5eacf395fea03ab300c89d9fae
Merge: 6a48065 bc4be1c
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Sep 13 15:51:18 2010 +0100

    Merge remote branch 'elliot/cookbook-animations-reuse'
    
    * elliot/cookbook-animations-reuse:
      cookbook: Added a recipe for reusing a complex animation
      cookbook: Added id for section in "rotating an actor" recipe
      cookbook: Simplified and clarified example code
      cookbook: Cleaned up the "animations reuse" example
      cookbook: Refactored reusable animation example
      cookbook: Added example for animation reuse recipe

commit 6a48065761c7448d71a05973610ce3a3d31fa166
Author: Murray Cumming <murrayc@murrayc.com>
Date:   Mon Sep 13 16:16:25 2010 +0200

    Remove trailin enum commas, avoiding C++ warnings.
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2314

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

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

    build: Add tesselator to the include paths

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

commit a8560037917550fdce83f2ae3b6f15c03812266c
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Sep 13 02:01:21 2010 +0100

    build: Remove gir files from dist
    
    The introspection data is going to be generated, so it should never be
    in the dist.

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

commit 8f049b360ad78f84688d76fd3ae04922ae5c4df3
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Sun Sep 12 19:25:47 2010 +0100

    build: Do not build a noinst library for the tesselator
    
    Let's try to keep Cogl's build as non-recursive as possible, in the hope
    that one day we'll be able to make it fully non-recursive along with the
    rest of Clutter.

 cogl/Makefile.am            |   59 ++++++++++++++++++++++++++++++++++++------
 cogl/tesselator/Makefile.am |   41 -----------------------------
 2 files changed, 50 insertions(+), 50 deletions(-)

commit ecbdbb666bd8c161d4ac0e576ed3f875fa99409f
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Sep 9 12:15:59 2010 +0100

    cogl-vertex-buffer: Flush the framebuffer state first
    
    Flushing the framebuffer state can cause some drawing to occur if the
    framebuffer has a clip stack which needs the stencil buffer. This was
    causing the array pointers set up by enable_state_for_drawing_buffer
    to get mangled so it would crash when it hits glDrawArrays. This patch
    moves the framebuffer state flush to before it sets up the array
    pointers.
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2297

 cogl/cogl-vertex-buffer.c |   13 ++++++++-----
 1 files changed, 8 insertions(+), 5 deletions(-)

commit 58827bb54c02f4f913ac131ceeab72d6a1bb0415
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Sep 6 18:07:07 2010 +0100

    material: Check before unreferencing a texture
    
    When disposing a material layer of type 'texture' we should check that
    the texture handle is still valid before calling cogl_handle_unref().
    This avoids an assertion failure when disposing a ClutterTexture.

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

commit 6b5934a18e76d6f33002586500bfb08a8ef78431
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Sep 6 16:11:46 2010 +0100

    Add some more introspection annotations

 cogl/cogl-material.h  |    2 +-
 cogl/cogl-offscreen.h |   11 ++++++-----
 cogl/cogl-types.h     |    2 +-
 3 files changed, 8 insertions(+), 7 deletions(-)

commit fd0cd2e55cbf9eabf7dea23d2bac0a388369b5ca
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Fri Sep 3 17:15:22 2010 +0100

    docs: Fix up the Cogl API reference build

 doc/reference/cogl/Makefile.am      |   41 ++++++++++++++++++++--------------
 doc/reference/cogl/cogl-docs.xml.in |    2 +-
 2 files changed, 25 insertions(+), 18 deletions(-)

commit ec3068f2268a26dc537bfc040dbd7f60438ab565
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Fri Sep 3 16:56:12 2010 +0100

    cogl-shader: Add deprecation guards for cogl_program_uniform_*

 cogl/cogl-shader.h |   14 +++++++++-----
 1 files changed, 9 insertions(+), 5 deletions(-)

commit 73a94a7a79292c5d900832f9b4068c20995278c7
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Fri Sep 3 16:55:12 2010 +0100

    Replace cogl_color_set_from_* with cogl_color_init_from_*
    
    The former is not yet "officially" deprecated by the latter, but it's
    confusing to have them both in the code base.

 cogl/cogl-material.c            |    4 ++--
 cogl/cogl.c                     |    6 +++---
 pango/cogl-pango-display-list.c |   10 +++++-----
 pango/cogl-pango-render.c       |   10 +++++-----
 4 files changed, 15 insertions(+), 15 deletions(-)

commit e950d2feec2d9c3830ffa8b0465b32739c9c6ce4
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Fri Sep 3 16:52:06 2010 +0100

    docs: Add annotation glossary to the Cogl API reference
    
    It's the only way to let gtk-doc know that we're using annotations in
    the comments.

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

commit b12f688415d5f8854abfc676db604585825034d3
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Fri Sep 3 16:10:44 2010 +0100

    docs: Fixes for gtk-doc

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

commit 08eb738c9387f524c50a84004618f6dfb01c4487
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Fri Sep 3 11:09:57 2010 +0100

    build: Use Makefile.introspection
    
    Whenever possible, instead of writing our own rules for generating GIR
    files and typelibs.

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

commit d4d899fa278efff9e7d4730527d12703f9d39dc5
Author: Colin Walters <walters@verbum.org>
Date:   Thu Sep 2 11:45:42 2010 -0400

    introspection: Build fixes
    
    This patch merges in substantial work from
    Emmanuele Bassi <ebassi@linux.intel.com>
    
    * Use new introspection --include-uninstalled API since we don't want
      to try to find the clutter-1.0.pc file before it's installed.
    * Use --pkg-export for Clutter-1.0.gir, since we want the .gir file to
      contain the associated pkg-config file.
    * Drop the use of --pkg for dependencies; those come from the associated
      .gir files.  (Actually, --pkg is almost never needed)
    * Add --quiet
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2292

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

commit 7e158c6bc5dc611417a9db4e005fcd80b0deeb45
Author: Damien Lespiau <damien.lespiau@gmail.com>
Date:   Thu Aug 12 09:25:17 2010 -0400

    cex100: Add a Clutter EGL backend for CE3100/CE4100 SoCs
    
    Intel CE3100 and CE4100 SoCs are designed for TVs. They have separate
    framebuffers that are blended together by a piece of hardware to make
    the final output. The library that allows you to initialize and
    configure those planes is called GDL. A EGL GDL winsys can then be
    use with those planes as NativeWindowType to select which plane to use.
    
    This patch adds a new ClutterBackendCex100 backend that can be
    selected at compile time with the new --with-flavour=cex100 option.

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

commit 7367188ab5f6c7f3824443f83646985444df2d00
Author: Damien Lespiau <damien.lespiau@gmail.com>
Date:   Thu Aug 12 09:05:01 2010 -0400

    egl: Fix compilation for EGL native
    
    Some minor fixes here and there: missing include, wrongly placed #endif,
    unused variable warning fixes, missing #ifdef.
    
    Make ClutterStageEGL a subclass of either ClutterStageX11 or GObject
    depending if you compile with X11 support (EGLX) or not (native).

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

commit a77e14c96935663cc065fdf4b4a82c6078e2d8d4
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Sat Aug 28 21:21:08 2010 +0100

    docs: Pass -DCOGL_ENABLE_EXPERIMENTAL_API when scanning

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

commit bed08767493672552e6d1a47e6866a26994edc78
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Fri Aug 20 15:24:42 2010 +0100

    Merge remote branch 'elliot/cookbook-textures-crossfade'
    
    * elliot/cookbook-textures-crossfade:
      cookbook: Use GdkPixbuf instead of getting data from a texture
      cookbook: Added a recipe for cross-fading between two images
      cookbook: Modified COGL example for consistency
      cookbook: Added video of two texture cross-fade
      cookbook: Removed unused constant
      cookbook: Renamed front/back to top/bottom in cross-fade example
      cookbook: Don't need to set keep-aspect-ratio for simple example
      cookbook: Modified ordering of statements in cross-fade example
      cookbook: Added a longer slideshow example
      cookbook: Made code examples more consistent
      cookbook: Added example code for texture cross-fading
      Post-release version bump to 1.3.13
      Release Clutter 1.3.12 (developers snapshot)
    
    Conflicts:
    	doc/cookbook/examples/Makefile.am

commit 90f633dd8d9d5b1e357e513b8e53affd0c0d993b
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Aug 9 16:01:17 2010 +0100

    material: Implements weak materials
    
    Weak materials are ones that don't take a reference on their parent and
    they are associated with a callback that notifies when the material is
    destroyed, because its parent was freed or modified.
    
    More details can be found at:
    http://wiki.clutter-project.org/wiki/CoglDesign/CoglMaterial
    
    For now the concept is internal only but the plan is to make this public
    at some point once we have tested the design internally.

 cogl/cogl-material-private.h |  142 +++++++++++++++++++++++++++++++
 cogl/cogl-material.c         |  191 ++++++++++++++++++++++++++++++++++--------
 2 files changed, 297 insertions(+), 36 deletions(-)

commit 65c2caea65ed79b41c8f8965d6bf6c47252742a4
Merge: 63fd426 8b8dd92
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Thu Aug 12 18:29:08 2010 +0100

    Merge remote branch 'elliot/cookbook-events-mouse-scroll'
    
    * elliot/cookbook-events-mouse-scroll:
      cookbook: Cleaning up grammar and wording in mouse scroll recipe
      cookbook: Added more explanation about setting y coord on scrollable
      cookbook: Mentioned the animation in the sample code
      cookbook: Included video of the scroll example running
      cookbook: Made stage slightly smaller for scroll event example
      cookbook: Added video showing scrollable actor
      cookbook: Added walk through of code example for mouse scroll
      cookbook: Fixed link to example in mouse scroll recipe
      cookbook: Simplified full scroll example
      cookbook: Improved wording and formatting in mouse scroll intro.
      cookbook: Handle all possible mouse scroll directions
      cookbook: Build mouse scroll example with cookbook
      cookbook: Cleaned up redundant comments in code example
      cookbook: Added xmlns for XInclude to events docbook file
      cookbook: Added basic mouse scroll recipe

commit 63fd426b4b4751810895b5343e8aaa36f92e2a98
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Aug 12 10:43:22 2010 +0100

    cogl-shader: get_info_log should always use strdup
    
    In the case where there is no error log for arbfp we were returning a
    "" string literal. The other paths were using g_strdup to return a
    string that could be freed with g_free. This makes the arbfp path return
    g_strdup ("") instead.

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

commit a0247f294ddcc02ba589f7ea9afe6d1f4f7b0c1a
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Aug 12 10:40:39 2010 +0100

    cogl-shader: correctly #ifdef guard an if else block
    
    There are quite a few if {} else {} blocks for dealing with arbfp else
    glsl and the first block is guarded with #ifdef HAVE_COGL_GL. In this
    case though the #endif was before the else so it wouldn't compile for
    gles.

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

commit 13e72608682b2632b0cb0c523d001a2c643064f6
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Aug 12 10:37:55 2010 +0100

    material-glsl: #include "cogl-shader-private.h"
    
    We need to include cogl-shader-private.h to have the
    COGL_SHADER_TYPE_GLSL define. When building for opengl this wasn't
    noticed probably because some other header indirectly includes this
    file. It was a problem when building for gles2 though.

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

commit 8d80a88e148419c0b2be9a7cdea6c6638d3f921e
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Aug 11 19:18:14 2010 +0100

    cogl-program: Adds use_uniform_xyz methods
    
    Instead of exposing an API that provides an OpenGL state machine style
    where you first have to bind the program to the context using
    cogl_program_use() followed by updating uniforms using
    cogl_program_uniform_xyz we now have uniform setter methods that take an
    explicit CoglHandle for the program.
    
    This deprecates cogl_program_use and all the cogl_program_uniform
    variants and provides the following replacements:
        cogl_program_set_uniform_1i
        cogl_program_set_uniform_1f
        cogl_program_set_uniform_int
        cogl_program_set_uniform_float
        cogl_program_set_uniform_matrix

 cogl/cogl-shader.h                   |  119 +++++++++++++++++++++++++-
 cogl/driver/gl/cogl-program.c        |  157 ++++++++++++++++++++++------------
 cogl/driver/gles/cogl-program.c      |  127 ++++++++++++++++++++-------
 doc/reference/cogl/cogl-sections.txt |    5 +
 4 files changed, 316 insertions(+), 92 deletions(-)

commit 64b5308d7fe2d80ae4d6ae4e04b7150ae76dec7e
Author: Damien Lespiau <damien.lespiau@gmail.com>
Date:   Thu Aug 12 10:36:04 2010 -0400

    introspection: Use the --quiet flag conditionally
    
    --quiet has been added to g-ir-scanner in the 0.9.1 cycle. We really
    want to be able to compile clutter with 0.6.14 to be able to reuse
    gir files that are distributed in current distributions.
    
    Use the INTROSPECTION_SCANNER_ARGS (previously unused) variable to
    convey --quiet when necessary.
    
    Fixes: http://bugzilla.clutter-project.org/show_bug.cgi?id=2265

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

commit 717cb2c47f6ad511c0b374975e66d5cb171d558c
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Aug 12 09:59:58 2010 +0100

    cogl-atlas: Verify that the chosen initial size is supported
    
    CoglAtlas chooses a fairly large default initial size of either
    512x512 or 1024x1024 depending on the texture format. There is a
    chance that this size will not be supported on some platforms which
    would be catastrophic for the glyph cache because it would mean that
    it would always fail to put any glyphs in the cache so text wouldn't
    work. To fix this the atlas code now checks whether the chosen initial
    size is supported by the texture driver and if not it will get halved
    until it is supported.

 cogl/cogl-atlas.c |   56 ++++++++++++++++++++++++++++++++++++----------------
 1 files changed, 39 insertions(+), 17 deletions(-)

commit b4240cba29e63652bc9d43138e554672e1b50e5a
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Aug 12 09:08:30 2010 +0100

    cogl-atlas: Use _cogl_texture_driver_size_supported
    
    Previously when creating a new rectangle map it would try increasingly
    larger texture sizes until GL_MAX_TEXTURE_SIZE is reached. This is bad
    because it queries state which should really be owned by the texture
    driver. Also GL_MAX_TEXTURE_SIZE is often a conservative estimate so
    larger texture sizes can be used if the proxy texture is queried
    instead.

 cogl/cogl-atlas.c |   25 +++++++++++++++----------
 1 files changed, 15 insertions(+), 10 deletions(-)

commit 1e72ba49326f3388077a8a6a5fd02aa5b9f1f4eb
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Aug 11 15:08:00 2010 +0100

    cogl-rectangle-map: Record largest gap rather than the remaining space
    
    Previously each node in the rectangle map tree would store the total
    remaining space in all of its children to use as an optimization when
    adding nodes. With this it could skip an entire branch of the tree if
    it knew there could never be enough space for the new node in the
    branch. This modifies that slightly to instead store the largest
    single gap. This allows it to skip a branch earlier because often
    there would be a lot of small gaps which would add up to enough a
    space for the new rectangle, but the space can't be used unless it is
    in a single node.
    
    The rectangle map still needs to keep track of the total remaining
    space for the whole map for the debugging output so this has been
    added back in to the CoglRectangleMap struct. There is a separate
    debugging function to verify this value.

 cogl/cogl-rectangle-map.c |   94 ++++++++++++++++++++++++++++++++------------
 1 files changed, 68 insertions(+), 26 deletions(-)

commit 0aaea4a93aac5eab6be13c277c17b414de092a68
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Aug 6 18:42:43 2010 +0100

    cogl-atlas: Try the next size when there would be less than 6% waste
    
    Previously when the atlas needs to be migrated it would start by
    trying with the same size as the existing atlas if there is enough
    space for the new texture. However even if the atlas is completely
    sorted there will always be some amount of waste so when the atlas
    needs to grow it would usually end up redundantly trying the same size
    when it is very unlikely to fit. This patch changes it so that there
    must be at least 6% waste available after the new texture is added
    otherwise it will start with the next atlas size.

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

commit c6b6f619a92da88b42547bafb283b5a087e05d0c
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Aug 6 18:42:01 2010 +0100

    cogl-atlas: Add some more debugging notes
    
    This adds some debugging notes which report when the atlas is trying
    various sizes.

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

commit 74b64848125f2a027f044b7387eb9c1b451d4708
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Aug 6 17:40:52 2010 +0100

    cogl-rectangle-map: Use a GArray for the stack
    
    When iterating over the rectangle map a stack is used to implement a
    recursive algorithm. Previously this was slice allocating a linked
    list. Now it uses a GArray which is retained with the rectangle map to
    avoid frequent allocations which is a little bit faster.

 cogl/cogl-rectangle-map.c |  120 +++++++++++++++++++++++++--------------------
 1 files changed, 67 insertions(+), 53 deletions(-)

commit 9a62c069aa4d748c94ea9d364738dad26466671b
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Aug 6 16:13:20 2010 +0100

    cogl-rectangle-map: Store the remaining space per node
    
    Previously the remaining space was managed as part of the
    CoglRectangleMap struct. Now it is stored per node so that at any
    point in the hierarchy we can quickly determine how much space is
    remaining in all of the node's children. That way when adding a
    rectangle we can miss out entire branches more quickly if we know that
    there is no way the new rectangle would fit in that branch.
    
    This also adds a function to recursively verify the cached state in
    the nodes such as the remaining space and the number of
    rectangles. This function is only called when the dump-atlas-image
    debug flag is set because it is potentially quite slow.

 cogl/cogl-rectangle-map.c |  108 ++++++++++++++++++++++++++++++++++++++++-----
 1 files changed, 96 insertions(+), 12 deletions(-)

commit 92b712f6e478a20d4ef7b853c4d162574dedcf83
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Aug 6 11:44:39 2010 +0100

    cogl-atlas: Increase the default minimum texture size
    
    When initially creating a texture it would start with a minimum size
    of 256x256. This increases the size so that it would try to match 1MB
    of memory.

 cogl/cogl-atlas.c |   18 +++++++++++++++---
 1 files changed, 15 insertions(+), 3 deletions(-)

commit 8123330061319d75291dd55df28e0c7c6a01bedc
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Aug 4 18:05:21 2010 +0100

    cogl-pango: Use a CoglAtlas to maintain the glyph cache
    
    The glyph cache is now stored in a CoglAtlas structure instead of the
    custom atlasing code. This has the advantage that it can share code
    with the main texture atlas and that it supports reorganizing the
    atlas when it becomes full. Unlike the texture atlas, the glyph cache
    can use multiple atlases which would be neccessary if the maximum
    texture size is reached and we need to create a second
    texture. Whenever a display list is created it now has to register a
    callback with the glyph cache so that the display list can be
    recreated whenever any of the atlases are reorganized. This is needed
    because the display list directly stores texture coordinates within
    the atlas texture and they would become invalid when the texture is
    moved.
    
    The ensure_glyphs_for_layout now works in two steps. First it reserves
    space in the atlas for all of the glyphs. The atlas is created with
    the DISABLE_MIGRATION flag so that it won't actually copy any textures
    if any rearranging is needed. Whenever the position is updated for a
    glyph then it is marked as dirty. After space for all of the glyphs
    has been reserved it will iterate over all dirty glyphs and redraw
    them using Cairo. The rendered glyph is then stored in the texture
    with a sub texture update.
    
    The glyphs need to all be set at the right location before starting to
    create the display list because the display list stores the texture
    coordinates of the glyph. If any of the glyphs were moved around then
    the parts of the display list that was created already would become
    invalid. To make this work, ensure_glyphs_for_layout is now always
    called before rendering a layout or a layout line.

 pango/cogl-pango-glyph-cache.c |  371 ++++++++++++++++++----------------------
 pango/cogl-pango-glyph-cache.h |   46 ++++--
 pango/cogl-pango-render.c      |  226 ++++++++++++++++---------
 3 files changed, 343 insertions(+), 300 deletions(-)

commit bbac3243567e89f2468182731fb32480650e56b7
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Aug 5 13:24:02 2010 +0100

    cogl-atlas: Support multiple formats and clearing the texture
    
    _cogl_atlas_new now has two extra parameters to specify the format of
    the textures it creates as well as a set of flags to modify the
    behavious of the atlas. One of the flags causes the new textures to be
    cleared and the other causes migration to avoid actually copying the
    textures. This is needed to use CoglAtlas from the pango glyph cache
    because it needs to use COGL_PIXEL_A_8 and to clear the textures as it
    does not fill in the gaps between glyphs. It needs to avoid copying
    the textures so that it can work on GL implementations without FBO
    support.

 cogl/cogl-atlas-texture.c |    4 +-
 cogl/cogl-atlas.c         |   96 +++++++++++++++++++++++++++++++++-----------
 cogl/cogl-atlas.h         |   12 +++++-
 3 files changed, 86 insertions(+), 26 deletions(-)

commit b2f2e6926448473508c829bb270ac43d66005d5d
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Aug 2 16:29:10 2010 +0100

    cogl-atlas-texture: Split out the atlas data structure
    
    Instead of storing a pointer to the CoglRectangleMap and a handle to
    the atlas texture in the context, there is a now a separate data
    structure called a CoglAtlas to manage these two. The context just
    contains a pointer to this. The code to reorganise the atlas has been
    moved from cogl-atlas-texture.c to cogl-atlas.c

 cogl/Makefile.am                  |    2 +
 cogl/cogl-atlas-texture-private.h |    4 +
 cogl/cogl-atlas-texture.c         |  585 +++++-------------------------------
 cogl/cogl-atlas.c                 |  596 +++++++++++++++++++++++++++++++++++++
 cogl/cogl-atlas.h                 |   86 ++++++
 cogl/cogl-context.c               |   10 +-
 cogl/cogl-context.h               |    5 +-
 7 files changed, 774 insertions(+), 514 deletions(-)

commit cb114f43ab42087537a7036ef7bd411668eb8065
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Aug 4 17:59:06 2010 +0100

    cogl: Add an internal utility to maintain a list of callback functions
    
    This adds an internal CoglCallbackList type which is just a GSList of
    of function pointers along with a data pointer to form a
    closure. There are functions to add and remove items and to invoke the
    list of functions. This could be used in a number of places in Cogl.

 cogl/Makefile.am          |    2 +
 cogl/cogl-callback-list.c |  107 +++++++++++++++++++++++++++++++++++++++++++++
 cogl/cogl-callback-list.h |   58 ++++++++++++++++++++++++
 3 files changed, 167 insertions(+), 0 deletions(-)

commit bc200105821a7e2d50a9f9bc34edfe354fc5ebfe
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Aug 2 15:24:03 2010 +0100

    cogl-atlas: Rename to CoglRectangleMap
    
    This simply renames CoglAtlas to CoglRectangleMap without making any
    functional changes. The old 'CoglAtlas' is just a data structure for
    managing unused areas of a rectangle and it doesn't neccessarily have
    to be used for an atlas so it wasn't a very good name.

 cogl/Makefile.am                  |    4 +-
 cogl/cogl-atlas-texture-private.h |   12 +-
 cogl/cogl-atlas-texture.c         |  169 ++++++-----
 cogl/cogl-atlas.c                 |  598 ------------------------------------
 cogl/cogl-atlas.h                 |   78 -----
 cogl/cogl-context.c               |    7 +-
 cogl/cogl-context.h               |    4 +-
 cogl/cogl-rectangle-map.c         |  612 +++++++++++++++++++++++++++++++++++++
 cogl/cogl-rectangle-map.h         |   78 +++++
 9 files changed, 792 insertions(+), 770 deletions(-)

commit bb17fd70e25f9f1b42ce3ca17592c9670d441236
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Aug 12 09:11:28 2010 +0100

    cogl-material: Compare whether textures are equal by their GL handle
    
    Textures within a layer were compared for equality by comparing their
    texture handle. However this means that sub textures and atlas
    textures which may be internally using the same GL handle would not be
    batched together. Instead it now tries to determine the underlying GL
    handle using either the slice override or _cogl_texture_get_gl_texture
    and then compares those.

 cogl/cogl-material.c |   35 ++++++++++++++++++++++++++---------
 1 files changed, 26 insertions(+), 9 deletions(-)

commit b7807d99957e568422743a6b7355c9bf52afc950
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed May 5 16:45:21 2010 +0100

    cogl-atlas-texture: Accept formats with different component orders
    
    When filtering on allowed formats for atlas textures, it now masks out
    the BGR and AFIRST bits in addition to the premult bit. That way it
    will accept RGB and RGBA formats in any component order.
    
    In theory it could also accept luminance and alpha-only textures but I
    haven't added this because presumably if the application has requested
    these formats then it has some reason not to use a full RGB or RGBA
    texture and we should respect that.

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

commit 4be7310fb168b128f6fe796f44349525730ac558
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Thu Aug 12 09:03:58 2010 +0100

    build: Make the introspection generation quiet (again)

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

commit 8b8dd92be367263bb57b2e9891d1f30e95223d73
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Wed Aug 11 11:32:44 2010 +0100

    Merge branch 'wip/table-layout'
    
    * wip/table-layout:
      Add ClutterTableLayout, a layout showing children in rows and columns
      box-layout: Use allocate_align_fill()
      bin-layout: Migrate to allocate_align_fill()
      actor: Add allocate_align_fill()
      test-flow-layout: Use BindConstraints

commit d8e521af0a98d55a2505598995ba2eabf3495f16
Author: Owen W. Taylor <otaylor@fishsoup.net>
Date:   Mon Aug 9 15:06:35 2010 -0400

    Always bind a new texture to unit 1 when necessary
    
    The special handling for texture unit 1 caught the case where unit
    1 was changed for transient purposes, but didn't properly handle
    the case where the actual non-transient texture was different between
    two materials with no transient binding in between.
    
    If the actual texture has changed when flushing, mark unit 1 as dirty
    and needing a rebind.
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2261

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

commit 242afd96ebd11b430f6c95118883b484f6f73ca8
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Aug 9 19:38:23 2010 +0100

    Silence a compiler warning

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

commit 786e292671753421daf103a8140eb06532ebeb8d
Merge: 65196a4 abea3d7
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Aug 9 17:44:42 2010 +0100

    Merge remote branch 'elliot/cookbook-layouts-introduction'
    
    * elliot/cookbook-layouts-introduction:
      cookbook: Added layout introduction and "stacking actors" recipe
      cookbook: Added layouts.xml to the list of XML files
      cookbook: Added layouts section and introduction

commit 65196a4a9b58ae417588c5721b7ece3c92342999
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Aug 4 17:53:51 2010 +0100

    cogl: Allow setting ARBfp source on a CoglShader
    
    This makes CoglProgram/Shader automatically detect when the user has
    given an ARBfp program by checking for "!!ARBfp1.0" at the beginning of
    the user's source.
    
    ARBfp local parameters can be set with cogl_program_uniform_float
    assuming you pass a @size of 4 (all ARBfp program.local parameters
    are vectors of 4 floats).
    
    This doesn't expose ARBfp environment parameters or double precision
    local parameters.

 cogl/cogl-material-arbfp.c      |   72 +++++++++++---
 cogl/cogl-material-glsl.c       |   24 ++---
 cogl/cogl-shader-private.h      |   13 +++
 cogl/cogl-shader.c              |  116 ++++++++++++++++++----
 cogl/cogl.c                     |    6 +-
 cogl/driver/gl/cogl-program.c   |  204 +++++++++++++++++++++++++++++++++------
 cogl/driver/gl/cogl-program.h   |   11 ++-
 cogl/driver/gles/cogl-program.c |    7 ++
 8 files changed, 371 insertions(+), 82 deletions(-)

commit 11045c724c9344f2f3146054c9ed533d0d6e29ff
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Aug 5 10:59:03 2010 +0100

    cogl: Adds a COGL_FEATURE_SHADERS_ARBFP feature flag
    
    This adds a public feature flag for ARBfp so developers can determine if
    the cogl API supports ARBfp or not.

 cogl/cogl-internal.h                    |    2 +-
 cogl/cogl-material-arbfp.c              |    2 +-
 cogl/cogl-types.h                       |    4 +++-
 cogl/cogl.c                             |    2 +-
 cogl/driver/gl/cogl-feature-functions.h |    4 ++--
 5 files changed, 8 insertions(+), 6 deletions(-)

commit b025a4a020a39a86070da362d02977e107514295
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Aug 5 10:46:54 2010 +0100

    material: Add cogl_material_{get,set}_user_program
    
    Previously we had an internal only _cogl_material_set_user_program to
    redirect legacy usage of cogl_program_use() through CoglMaterial. This
    instead makes the API public because until we implement our planned
    "snippet" framework we need a stop-gap solution for using shaders in
    Cogl.
    
    The plan is to also support ARBfp with the cogl_program/shader API so
    this API will also allow clutter-gst to stop using direct OpenGL calls
    that conflict with Cogl's state tracking.

 cogl/cogl-material-private.h |    4 --
 cogl/cogl-material.c         |   24 +++++++++++++--
 cogl/cogl-material.h         |   64 ++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 84 insertions(+), 8 deletions(-)

commit 937fc0dbec965a4aed55d310da9590fb0dde6b7e
Author: Robert Bragg <robert@linux.intel.com>
Date:   Sun Aug 8 13:54:07 2010 +0100

    material: chain up in layer_pre_change_notify
    
    A change to a layer is also going to be a change to its owning material
    so we have to chain up in _cogl_material_layer_pre_change_notify and
    call _cogl_material_pre_change_notify. Previously we were only
    considering if the owning material was referenced in the journal but
    that ignores that it might also have dependants. We no longer need to
    flush the journal directly in layer_pre_change_notify.

 cogl/cogl-material.c |   16 ++++++++++++----
 1 files changed, 12 insertions(+), 4 deletions(-)

commit b493b3025783c3141bc989c5a89723da889eac04
Author: Robert Bragg <robert@linux.intel.com>
Date:   Sun Aug 8 14:26:45 2010 +0100

    material: unlink old layer from owner when replacing
    
    In _cogl_material_layer_pre_change_notify when we see that a layer has
    dependants and it can't be modified directly then we allocate a new
    layer. In this case we also have to link the new layer to its required
    owner. If the immutable layer we copied had the same owner though we
    weren't unlinking that old layer.

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

commit 021265e634d4b6ee5fa279693e02d3976ef43feb
Author: Robert Bragg <robert@linux.intel.com>
Date:   Sun Aug 8 13:41:15 2010 +0100

    material: fix initialization of sparse properties
    
    In _cogl_material_pre_change_notify we need to identify if it's a sparse
    property being changed and if so initialize the state group if the given
    material isn't currently the authority for it.
    
    Previously we were unconditionally calling
    _cogl_material_initialize_state which would e.g. NULL the layer
    differences list of a material each time a layer change was notified.
    
    It would also call _cogl_material_initialize_state for non-sparse
    properties which should always be valid at this point so the function
    has been renamed to _cogl_material_initialize_sparse_state to make this
    clearer with a corresponding g_return_if_fail check.

 cogl/cogl-material.c |   25 ++++++++++++++-----------
 1 files changed, 14 insertions(+), 11 deletions(-)

commit 02ce77dc08705eb6aa1260fdfb234e7af670672a
Author: Robert Bragg <robert@linux.intel.com>
Date:   Sun Aug 8 13:09:27 2010 +0100

    material: fix copying of material layer differences
    
    This fixes how we copy layer differences in
    _cogl_material_copy_layer_differences.
    
    We were making a redundant g_list_copy of the src differences and then
    iterating the src list calling _cogl_material_add_layer_difference for
    each entry which would double the list length, but the initial copy
    directly referenced the original layers which wasn't correct.
    
    Also we were initializing dest->n_layers before copying the layer
    differences but the act of copying the differences will re-initialize
    n_layers to 0 when adding the first layer_difference since it will
    trigger a layer_pre_change_notify and since the dest material isn't yet
    a STATE_LAYERS authority the state group is initialized before allowing
    the change.

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

commit a75a7fadabf40eb08f2c0a051e723732f7eb84c2
Author: Robert Bragg <robert@linux.intel.com>
Date:   Sun Aug 8 13:05:40 2010 +0100

    material: don't dereference layer->texture directly
    
    In _cogl_material_texture_storage_change_notify we were potentially
    dereferencing layer->texture without checking first that it is the
    authority of texture state. We now use
    _cogl_material_layer_get_texture() instead.

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

commit 8caaf5a8b233f138f354028fdd6f8fd4e1014cf9
Author: Robert Bragg <robert@linux.intel.com>
Date:   Sun Aug 8 14:09:26 2010 +0100

    material: Improve the dot file debugging code
    
    This improve the dot file output available when calling
    _cogl_debug_dump_materials_dot_file. The material graph now directly
    points into the layer graph and the layers now show the texture unit
    index.

 cogl/cogl-material.c |   30 ++++++++++++++++--------------
 1 files changed, 16 insertions(+), 14 deletions(-)

commit abea3d7ead5b2d91a82d6ac9504ee28986f6c8bb
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Aug 6 16:41:41 2010 +0100

    cogl-material: Unref the texture when reverting authority
    
    When the texture is set on a layer so that it is back to the parent's
    texture it would clear the texture change flag but it wouldn't unref
    the texture. The free function for a material layer does not unref the
    texture if the change flag is cleared so the texture would end up
    leaking. This happens for ClutterTexture because it disposes the
    texture by setting layer 0 of the material to COGL_INVALID_HANDLE
    which ends up the same as the default material.

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

commit eda852e78cb4037322bb9c4190f9a702bf74883e
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Aug 6 14:12:22 2010 +0100

    material: only deference layer->texture for authority
    
    In _cogl_material_layer_pre_paint we were mistakenly dereferencing the
    layer->texture member for the passed layer instead of dereferencing the
    texture state authority which was causing crashes in some cases.

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

commit 3aca1462150be07a78f3e581a34cffb6462e1aa8
Merge: 99ae7b1 a2c2797
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Tue Aug 3 15:44:46 2010 +0100

    Merge remote branch 'elliot/cookbook-animations-rotating'
    
    * elliot/cookbook-animations-rotating:
      cookbook: Added recipe for animated rotation of an actor
      cookbook: Add explanation about including code samples
      cookbook: Make filename used in video example consistent
      cookbook: Add example code for animated rotation

commit 99ae7b15f5dc462ef2f31f9fd5207e868bcbd65e
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Jul 23 10:12:39 2010 +0100

    cogl-program: gles2: bind programs lazily as for GL
    
    This makes the gles2 cogl_program_use consistent with the GL version by
    not binding the program immediately and instead leaving it to
    cogl-material.c to bind the program when actually drawing something.

 cogl/cogl-material-glsl.c           |    3 ---
 cogl/cogl-material-opengl-private.h |    2 +-
 cogl/cogl-material-opengl.c         |   34 ++++++++++++++++++++--------------
 cogl/driver/gl/cogl-program.c       |   10 +++++-----
 cogl/driver/gles/cogl-program.c     |    3 ---
 5 files changed, 26 insertions(+), 26 deletions(-)

commit 650df3f2eb3bb187bb7313ab9d5071a00a6ce4a4
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Jun 8 23:06:50 2010 +0100

    gles2: Have CoglProgram track uniforms per program
    
    Previously custom uniforms were tracked in _CoglGles2Wrapper but as part
    of a process to consolidate the gl/gles2 shader code it seems to make
    sense for this state to be tracked in the CoglProgram object instead.
    
    http://bugzilla.o-hand.com/show_bug.cgi?id=2179

 cogl/driver/gles/cogl-gles2-wrapper.c |   41 +++++++++++++++++----------------
 cogl/driver/gles/cogl-gles2-wrapper.h |   11 ++++-----
 cogl/driver/gles/cogl-program.c       |   38 ++++++++++++++++++++----------
 cogl/driver/gles/cogl-program.h       |   11 ++++++++-
 4 files changed, 61 insertions(+), 40 deletions(-)

commit 7705469d2ba6388740001e61363b02c0b226ffd9
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Aug 2 21:40:55 2010 +0100

    cogl-shader: unifies the driver/{gl,gles} shader files
    
    The per driver implementations of cogl-shader.c had become almost
    identical we now have a single cogl/cogl-shader.c instead.

 cogl/Makefile.am                       |    2 +
 cogl/cogl-shader-private.h             |   40 ++++++
 cogl/cogl-shader.c                     |  235 ++++++++++++++++++++++++++++++++
 cogl/driver/gl/Makefile.am             |    2 -
 cogl/driver/gl/cogl-shader-private.h   |   40 ------
 cogl/driver/gl/cogl-shader.c           |  169 -----------------------
 cogl/driver/gles/Makefile.am           |    2 -
 cogl/driver/gles/cogl-shader-private.h |   40 ------
 cogl/driver/gles/cogl-shader.c         |  214 -----------------------------
 9 files changed, 277 insertions(+), 467 deletions(-)

commit 6e176f94faf6a2dd38ea29eafbef0b28e3598edc
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Jul 23 17:44:53 2010 +0100

    cogl-shader: Store the CoglShaderType in CoglShader
    
    Instead of having to query GL and translate the GL enum into a
    CoglShaderType each time cogl_shader_get_type is called we now keep
    track of the type in CoglShader.

 cogl/driver/gl/cogl-shader-private.h |    1 +
 cogl/driver/gl/cogl-shader.c         |   14 ++------------
 cogl/driver/gles/cogl-shader.c       |   13 +------------
 3 files changed, 4 insertions(+), 24 deletions(-)

commit 8640f527cb36ace0af291d42871c5463e3f99502
Author: Robert Bragg <robert@linux.intel.com>
Date:   Sun Jul 25 21:36:41 2010 +0100

    cogl: don't include cogl-debug.h in cogl.h or install
    
    cogl-debug.h is an internal header so it shouldn't have been included by
    cogl.h and the header shouldn't be installed either.

 cogl/Makefile.am                      |    2 +-
 cogl/cogl-atlas-texture.c             |    1 +
 cogl/cogl-bitmap.c                    |    1 +
 cogl/cogl-framebuffer.c               |    1 +
 cogl/cogl-journal.c                   |    1 +
 cogl/cogl-material-arbfp.c            |    1 +
 cogl/cogl-material-opengl.c           |    1 +
 cogl/cogl-material.c                  |    1 +
 cogl/cogl-matrix.c                    |    1 +
 cogl/cogl-primitives.c                |    1 +
 cogl/cogl-texture-2d-sliced.c         |    1 +
 cogl/cogl.h                           |    1 -
 cogl/winsys/cogl-texture-pixmap-x11.c |    1 +
 pango/cogl-pango-render.c             |    1 +
 14 files changed, 13 insertions(+), 2 deletions(-)

commit a2c2797105082e4abe9dbda0cc93670b7c72ce37
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Jul 14 19:39:24 2010 +0100

    gles/cogl-shader.c: Store the shader type in CoglShader
    
    Nothing was storing the shader type when a shader was created so it
    would get confused about whether it was a custom vertex or fragment
    shader.
    
    Also the 'type' member of CoglShader was a GLenum but the only place
    that read it was treating it as if it was CoglShaderType. This changes
    it be CoglShaderType.

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

commit 023510636c74decc278074318f8732edf7b879fa
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Jul 22 16:58:23 2010 +0100

    Plug the leaking CoglProgram and CoglShader
    
    _cogl_program_free and _cogl_shader_free never freed the struct their
    structs so it would end up leaking a little bit.

 cogl/driver/gl/cogl-program.c   |    2 ++
 cogl/driver/gl/cogl-shader.c    |    2 ++
 cogl/driver/gles/cogl-program.c |    2 ++
 cogl/driver/gles/cogl-shader.c  |    2 ++
 4 files changed, 8 insertions(+), 0 deletions(-)

commit 2ccee98b31d3bd5cdebb9347cec44bad7cd3dd3d
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Jul 22 19:58:47 2010 +0100

    cogl-bitmap-pixbuf: Avoid copying the buffer in more circumstances
    
    When loading an RGB image GdkPixbuf will pad the rowstride so that the
    beginning of each row is aligned to 4 bytes. This was causing us to
    fallback to the code that copies the buffer. It is probably safe to
    avoid copying the buffer if we can detect that the rowstride is simply
    an alignment of the packed rowstride.
    
    This also changes the copying fallback code so that it uses the
    aligned rowstride. However it is now extremely unlikely that the
    fallback code would ever be used.

 cogl/cogl-bitmap-pixbuf.c |   33 ++++++++++++++++++++++++---------
 1 files changed, 24 insertions(+), 9 deletions(-)

commit fecb40a0433e6c069a27f6120506c105e747e2f7
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Jul 22 19:15:44 2010 +0100

    cogl-bitmap-pixbuf: Fix the rowstride used when copying a GdkPixbuf
    
    In commit b780413e5ae4b the GdkPixbuf loading code was changed so that
    if it needs to copy the pixbuf then it would tightly pack it. However
    it was still using the rowstride from the pixbuf so the image would
    end up skewed. This fixes it to use the real rowstride.
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2235

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

commit 0ab6dc9db129bc0b2d084dd1ce0e6093d01bce6a
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Jul 20 17:34:04 2010 +0100

    cogl-material: Don't map the shininess value to [0,1]
    
    In OpenGL the 'shininess' lighting parameter is floating point value
    limited to the range 0.0→128.0. This number is used to affect the size
    of the specular highlight. Cogl materials used to only accept a number
    between 0.0 and 1.0 which then gets multiplied by 128.0 before sending
    to GL. I think the assumption was that this is just a weird GL quirk
    so we don't expose it. However the value is used as an exponent to
    raise the attenuation to a power so there is no conceptual limit to
    the value.
    
    This removes the mapping and changes some of the documentation.
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2222

 cogl/cogl-material-opengl.c |    6 ++----
 cogl/cogl-material.c        |    4 +++-
 cogl/cogl-material.h        |    9 +++++----
 3 files changed, 10 insertions(+), 9 deletions(-)

commit 89286f6a474eafc1d22c99fc7bcaec5bc79cf3ba
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Jul 21 23:22:07 2010 +0100

    cogl-material: Always reset the GLSL program to zero when flushing
    
    When flushing a fixed-function or arbfp material it would always call
    disable_glsl to try to get rid of the previous GLSL shader. This is
    needed even if current_use_program_type is not GLSL because if an
    application calls cogl_program_uniform then Cogl will have to bind the
    program to set the uniform. If this happens then it won't update
    current_use_program_type presumably because the enabled state of arbfp
    is still valid.
    
    The problem was that disable_glsl would only select program zero when
    the current_use_program_type is set to GLSL which wouldn't be the case
    if cogl_program_uniform was called. This patch changes it to just
    directly call _cogl_gl_use_program_wrapper(0) instead of having a
    separate disable_glsl function. The current program is cached in the
    cogl context anyway so it shouldn't cause any extra unnecessary GL
    calls.
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2232

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

commit 5b6298db102327bc10c3deecaafe465150e505e1
Author: Neil Roberts <neil@linux.intel.com>
Date:   Sat Jul 17 14:08:28 2010 +0100

    cogl-material: Consider the shader when deciding if materials equate
    
    _cogl_material_equal was ignoring the user shader state so rectangles
    with different shaders would get batched together.
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2220

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

commit b2247b10fd4c53572c04fe539802dfac2b1145f6
Author: Neil Roberts <neil@linux.intel.com>
Date:   Sat Jul 17 12:40:19 2010 +0100

    cogl-material-arbfp: Use separate buffers when calling g_ascii_dtostr
    
    g_ascii_dtostr was being used in four separate arguments to
    g_string_append_printf but all invocations of it were using the same
    buffer. This would end up with all of the arguments having the same
    value which would depend on whichever order the compiler evaluates
    them in. This patches changes it to use a multi-dimensional array and
    a loop to fill in the separate buffers.
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2219

 cogl/cogl-material-arbfp.c |   19 ++++++++++---------
 1 files changed, 10 insertions(+), 9 deletions(-)

commit 62fa7b4e028db5364d033ec0b6b497df7bc67457
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Fri Jul 16 23:37:59 2010 +0100

    material-arbfp: Use locale-independent double to string conversion
    
    The ARBfp programs are created with a printf() wrapper, which usually
    fails in non-en locales as soon as you start throwing things like
    floating point values in the mix.
    
    We should use the g_ascii_dtostr() function which places a double into a
    string buffer in a locale-independent way.
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2219

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

commit 094ad196071f964a8b59fb12416a610e73e67338
Merge: a3a7a7e 4eca571
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Fri Jul 16 17:23:36 2010 +0100

    Merge remote branch 'elliot/cookbook-actor-opacity'
    
    Conflicts:
    	doc/cookbook/Makefile.am

commit a3a7a7ebcb89c25cd268a91e1055a99318a959ba
Merge: ae8fe82 7d269c6
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Fri Jul 16 17:13:12 2010 +0100

    Merge remote branch 'elliot/cookbook-include-videos'
    
    * elliot/cookbook-include-videos:
      cookbook: Tweak so that videos sit inside a paragraph for better spacing
      docs: Note the P_() macro in the HACKING file
      cookbook: Added support for inline video
    
    Conflicts:
    	doc/cookbook/Makefile.am

commit ae8fe829b62b01d942e8cbb066f181714151da78
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Fri Jul 16 17:12:37 2010 +0100

    Merge remote branch 'elliot/cookbook-animation-fading'
    
    * elliot/cookbook-animation-fading:
      cookbook: Minor modification to wording to improve clarity
      cookbook: Added recipe for fading actors in/out

commit 4eca571a32a0669650de99eee4362c13600c7d4c
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Jul 15 13:05:55 2010 +0100

    Add an internal _cogl_bitmap_new_from_buffer
    
    This function creates a CoglBitmap which internally references a
    CoglBuffer. The map and unmap functions will divert to mapping the
    buffer. There are also now bind and unbind functions which should be
    used instead of map and unmap whenever the data doesn't need to be
    read from the CPU but will instead be passed to GL for packing or
    unpacking. For bitmaps created from buffers this just binds the
    bitmap.
    
    cogl_texture_new_from_buffer now just uses this function to wrap the
    buffer in a bitmap rather than trying to bind the buffer
    immediately. This means that the buffer will be bound only at the
    point right before the texture data is uploaded.
    
    This approach means that using a pixel array will take the fastest
    upload route if possible, but can still fallback to copying the data
    by mapping the buffer if some conversion is needed. Previously it
    would just crash in this case because the texture functions were all
    passed a NULL pointer.
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2112

 cogl/cogl-bitmap-private.h             |   25 ++++++
 cogl/cogl-bitmap.c                     |  139 ++++++++++++++++++++++++++++++--
 cogl/cogl-texture.c                    |   37 ++-------
 cogl/driver/gl/cogl-texture-driver.c   |  114 ++++++++++++--------------
 cogl/driver/gles/cogl-texture-driver.c |   81 +++++++++---------
 5 files changed, 261 insertions(+), 135 deletions(-)

commit e5dc645753e958c6b9d59b0c8cf58da1924c22e7
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Jul 15 13:02:23 2010 +0100

    Add a Cogl debug flag for BITMAP
    
    CoglBitmap will soon want to report notes as it gets more complicated
    so this adds a debug flag for it.

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

commit c5205c50d246e033265b77d2b746a72c1137e7e1
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Jul 15 11:32:08 2010 +0100

    Try to avoid copying the GdkPixbuf when it is tightly packed
    
    The docs for GdkPixbuf say that the last row of the image won't
    necessarily be allocated to the size of the full rowstride. The rest
    of Cogl and possibly GL assumes that we can copy the bitmap with
    memcpy(height*rowstride) so we previously would copy the pixbuf data
    to ensure this. However if the rowstride is the same as bpp*width then
    there is no way for the last row to be under-allocated so in this case
    we can just directly upload from the gdk pixbuf. Now that CoglBitmap
    can be created with a destroy function we can make it keep a reference
    to the pixbuf and unref it during its destroy callback. GdkPixbuf
    seems to always pack the image with no padding between rows even if it
    is RGB so this should end up always avoiding the memcpy.
    
    The fallback code for when we do have to copy the pixbuf is now
    simplified so that it copies all of the rows in a single loop. We only
    copy the useful region of each row so this should be safe. The
    rowstride of the CoglBitmap is now always allocated to bpp*width
    regardless of the rowstride of the pixbuf.

 cogl/cogl-bitmap-pixbuf.c |   41 ++++++++++++++++++++++++-----------------
 1 files changed, 24 insertions(+), 17 deletions(-)

commit ccc3068ffdeb2c5b44ef54a6a2d06b7c3a08b694
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Jul 7 18:44:16 2010 +0100

    cogl-bitmap: Encapsulate the CoglBitmap even internally
    
    The CoglBitmap struct is now only defined within cogl-bitmap.c so that
    all of its members can now only be accessed with accessor
    functions. To get to the data pointer for the bitmap image you must
    first call _cogl_bitmap_map and later call _cogl_bitmap_unmap. The map
    function takes the same arguments as cogl_pixel_array_map so that
    eventually we can make a bitmap optionally internally divert to a
    pixel array.
    
    There is a _cogl_bitmap_new_from_data function which constructs a new
    bitmap object and takes ownership of the data pointer. The function
    gets passed a destroy callback which gets called when the bitmap is
    freed. This is similar to how gdk_pixbuf_new_from_data
    works. Alternatively NULL can be passed for the destroy function which
    means that the caller will manage the life of the pointer (but must
    guarantee that it stays alive at least until the bitmap is
    freed). This mechanism is used instead of the old approach of creating
    a CoglBitmap struct on the stack and manually filling in the
    members. It could also later be used to create a CoglBitmap that owns
    a GdkPixbuf ref so that we don't necessarily have to copy the
    GdkPixbuf data when converting to a bitmap.
    
    There is also _cogl_bitmap_new_shared. This creates a bitmap using a
    reference to another CoglBitmap for the data. This is a bit of a hack
    but it is needed by the atlas texture backend which wants to divert
    the set_region virtual to another texture but it needs to override the
    format of the bitmap to ignore the premult flag.

 cogl/cogl-atlas-texture-private.h      |    2 +-
 cogl/cogl-atlas-texture.c              |  187 +++++-----
 cogl/cogl-bitmap-fallback.c            |  144 +++++---
 cogl/cogl-bitmap-pixbuf.c              |   82 ++---
 cogl/cogl-bitmap-private.h             |  109 +++++--
 cogl/cogl-bitmap.c                     |  228 ++++++++++--
 cogl/cogl-texture-2d-private.h         |    2 +-
 cogl/cogl-texture-2d-sliced-private.h  |    2 +-
 cogl/cogl-texture-2d-sliced.c          |  607 ++++++++++++++++++--------------
 cogl/cogl-texture-2d.c                 |   70 +++--
 cogl/cogl-texture-3d-private.h         |    2 +-
 cogl/cogl-texture-3d.c                 |  109 +++---
 cogl/cogl-texture-private.h            |    4 +-
 cogl/cogl-texture-rectangle-private.h  |    2 +-
 cogl/cogl-texture-rectangle.c          |   43 ++--
 cogl/cogl-texture.c                    |  355 +++++++++++--------
 cogl/cogl.c                            |   77 +++--
 cogl/driver/gl/cogl-texture-driver.c   |  116 ++++---
 cogl/driver/gles/cogl-texture-driver.c |  200 ++++++-----
 19 files changed, 1421 insertions(+), 920 deletions(-)

commit 41cd2ae2c84f2e217cebb632d303a16fbb7a9fb5
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Jul 14 13:21:54 2010 +0100

    cogl-texture-2d-sliced: Store the internal format not image format
    
    The 'format' member of CoglTexture2DSliced is returned by
    cogl_texture_get_format. All of the other backends return the internal
    format of the GL texture in this case. However the sliced backend was
    returning the format of the image data used to create the texture. It
    doesn't make any sense to retain this information because it doesn't
    necessarily indicate the format of the actual texture. This patch
    changes it to store the internal format instead.

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

commit 7d269c631532bcdfa556016b4d18249391f53cef
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Jul 14 17:49:16 2010 +0100

    gles/cogl-texture-driver.c: Fix the include for cogl-material-private
    
    In ddb9016be4 the GL texture driver backend was changed to include
    cogl-material-opengl-private.h instead of cogl-material-private.h.
    However the gles texture backend was missed from this so it was giving
    a compiler warning about using an undeclared function.

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

commit 00e3d77be3adee84cb934d912d075d31d35b04b7
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Jul 14 17:45:15 2010 +0100

    cogl-texture-3d: Use glTexSubImage3D through an indirect pointer
    
    glTexSubImage3D was being called directly in cogl-texture-3d.c but the
    function is only available since GL version 1.2 so on Windows it won't
    be possible to directly link to it. Also under GLES it is only
    available conditionally in an extension.

 cogl/cogl-texture-3d.c                  |    1 +
 cogl/driver/gl/cogl-feature-functions.h |    7 +++++++
 2 files changed, 8 insertions(+), 0 deletions(-)

commit a104b37068b4603fd548a86336d38c674bb6ce11
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Jul 14 16:35:33 2010 +0100

    cogl-texture-3d: Fix the cogl-material-private header include
    
    In ddb9016be4 the texture backends were changed to include
    cogl-material-opengl-private.h instead of cogl-material-private.h.
    However the 3D texture backend was missed from this so it was giving a
    compiler warning about using an undeclared function.

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

commit 8b8f5efbe523a1cf1b461df214562b7c4522b674
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Jul 14 16:34:36 2010 +0100

    cogl-texture-3d: Don't include cogl-texture-2d-private.h
    
    I think this was included by a cut-and-paste error as it isn't needed
    anywhere in the source.

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

commit 96b0e6c3047aa6361da173fe5221434920b3c8fa
Author: Robert Bragg <robert@linux.intel.com>
Date:   Sat Jul 10 03:40:47 2010 +0100

    material: splits out all the state flushing code
    
    This moves the code supporting _cogl_material_flush_gl_state into
    cogl-material-opengl.c as part of an effort to reduce the size of
    cogl-material.c to keep it manageable.

 cogl/cogl-journal.c                 |    1 +
 cogl/cogl-material-opengl-private.h |    7 +
 cogl/cogl-material-opengl.c         | 1014 +++++++++++++++++++++++++++++++++
 cogl/cogl-material-private.h        |   26 +-
 cogl/cogl-material.c                | 1061 ++---------------------------------
 cogl/cogl-path.c                    |    1 +
 cogl/cogl-primitives.c              |    1 +
 cogl/cogl-vertex-buffer.c           |    1 +
 cogl/cogl.c                         |    1 +
 cogl/driver/gl/cogl-program.c       |    1 +
 10 files changed, 1088 insertions(+), 1026 deletions(-)

commit 5442e429ba85718c85bdb9ca8ea529d5d2013098
Author: Robert Bragg <robert@linux.intel.com>
Date:   Sat Jul 10 02:53:38 2010 +0100

    material: split the texture unit management out
    
    In general cogl-material.c has become far to large to manage in one
    source file. As one of the ways to try and break it down this patch
    starts to move some of lower level texture unit state management out
    into cogl-material-opengl.c. The naming is such because the plan is to
    follow up and migrate the very GL specific state flushing code into the
    same file.

 cogl/Makefile.am                      |    2 +
 cogl/cogl-atlas-texture.c             |    1 +
 cogl/cogl-context.c                   |    1 +
 cogl/cogl-material-fixed.c            |    1 +
 cogl/cogl-material-opengl-private.h   |  148 +++++++++++++++++++++
 cogl/cogl-material-opengl.c           |  230 +++++++++++++++++++++++++++++++++
 cogl/cogl-material-private.h          |  110 ----------------
 cogl/cogl-material.c                  |  197 +---------------------------
 cogl/cogl-texture-2d-sliced.c         |    2 +-
 cogl/cogl-texture-2d.c                |    2 +-
 cogl/cogl-texture-rectangle.c         |    1 +
 cogl/driver/gl/cogl-texture-driver.c  |    2 +-
 cogl/winsys/cogl-texture-pixmap-x11.c |    1 +
 13 files changed, 391 insertions(+), 307 deletions(-)

commit be9564b3db8bf28fdd4f3f2d681add340917841e
Author: Robert Bragg <robert@linux.intel.com>
Date:   Sat Jul 10 01:36:22 2010 +0100

    material: copy_differences: handle copying fog state
    
    When the support for redirecting the legacy fog state through cogl
    material was added in 9b9e764dc, the code to handle copying the fog
    state in _cogl_material_copy_differences was missed.

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

commit ae88bff3294f574ba65761b5c3d08734367078fa
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Jul 13 18:41:01 2010 +0100

    Add a GL_GENERATE_MIPMAP fallback to the texture 2d and 3d backends
    
    The CoglTexture2DSliced backend has a fallback for when the
    framebuffer extension is missing so it's not possible to use
    glGenerateMipmap. This involves keeping a copy of the upper-left pixel
    of the tex image so that we can temporarily enable GL_GENERATE_MIPMAP
    on the texture object and do a sub texture update by reuploading the
    contents of the first pixel. This patch copies that mechanism to the
    2D and 3D backends. The CoglTexturePixel structure which was
    previously internal to the sliced backend has been moved to
    cogl-texture-private.h so that it can be shared.

 cogl/cogl-texture-2d-private.h        |    2 +
 cogl/cogl-texture-2d-sliced-private.h |   13 --------
 cogl/cogl-texture-2d.c                |   48 ++++++++++++++++++++++++-------
 cogl/cogl-texture-3d-private.h        |    2 +
 cogl/cogl-texture-3d.c                |   50 +++++++++++++++++++++------------
 cogl/cogl-texture-private.h           |   16 ++++++++++
 6 files changed, 89 insertions(+), 42 deletions(-)

commit 9e8d3d17b0994f2d5f8572319beb4e9ab9840d48
Merge: 671abec 23a1729
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Tue Jul 13 16:12:14 2010 +0100

    Merge branch 'wip/xkb-support'
    
    * wip/xkb-support:
      x11: Use XKB to translate keycodes into key symbols
      x11: Use XKB to track the Locks state
      x11: Use XKB detectable auto-repeat
      x11: Add a Keymap ancillary object
      x11: Store the group inside the event platform data
      events: Add platform-data to allocated Events
      build: Check for the XKB extension

commit 671abec8b792ae96c62253c99482d0f49b1aab8b
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Jul 2 13:33:06 2010 +0100

    Make the material functions for setting the p wrap mode public
    
    Now that we have 3D texture support it makes sense to expose the wrap
    mode for the p coordinate.

 cogl/cogl-material-private.h         |   10 ---------
 cogl/cogl-material.c                 |   15 +++++--------
 cogl/cogl-material.h                 |   38 ++++++++++++++++++++++++++++++---
 cogl/cogl-vertex-buffer.c            |    2 +-
 doc/reference/cogl/cogl-sections.txt |    2 +
 5 files changed, 43 insertions(+), 24 deletions(-)

commit ec718d4ca47923edfb9687b3929a824a8c7005ac
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Jul 12 17:01:32 2010 +0100

    Rename the third texure coordinate from 'r' to 'p'
    
    Using 'r' to name the third component is problematic because that is
    commonly used to represent the red component of a vector representing
    a color. Under GLSL this is awkward because the texture swizzling for
    a vector uses a single letter for each component and the names for
    colors, textures and positions are synonymous. GLSL works around this
    by naming the components of the texture s, t, p and q. Cogl already
    effectively already exposes this naming because it exposes GLSL so it
    makes sense to use that naming consistently. Another alternative could
    be u, v and w. This is what Blender and Direct3D use. However the w
    component conflicts with the w component of a position vertex.

 cogl/cogl-atlas-texture.c             |    4 +-
 cogl/cogl-material-private.h          |    8 ++--
 cogl/cogl-material.c                  |   68 +++++++++++++++++++-------------
 cogl/cogl-sub-texture.c               |    4 +-
 cogl/cogl-texture-2d-sliced.c         |    2 +-
 cogl/cogl-texture-2d.c                |    2 +-
 cogl/cogl-texture-3d-private.h        |    2 +-
 cogl/cogl-texture-3d.c                |   10 ++--
 cogl/cogl-texture-private.h           |    4 +-
 cogl/cogl-texture-rectangle.c         |    2 +-
 cogl/cogl-texture.c                   |    4 +-
 cogl/cogl-vertex-buffer.c             |    4 +-
 cogl/winsys/cogl-texture-pixmap-x11.c |    4 +-
 13 files changed, 65 insertions(+), 53 deletions(-)

commit 5288f6d88d94988875d69d8a850053f66319d042
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Jul 1 22:04:59 2010 +0100

    Add a Cogl texture 3D backend
    
    This adds a publicly exposed experimental API for a 3D texture
    backend. There is a feature flag which can be checked for whether 3D
    textures are supported. Although we require OpenGL 1.2 which has 3D
    textures in core, GLES only provides them through an extension so the
    feature can be used to detect that.
    
    The textures can be created with one of two new API functions :-
    
    cogl_texture_3d_new_with_size
    
     and
    
    cogl_texture_3d_new_from_data
    
    There is also internally a new_from_bitmap function. new_from_data is
    implemented in terms of this function.
    
    The two constructors are effectively the only way to upload data to a
    3D texture. It does not work to call glTexImage2D with the
    GL_TEXTURE_3D target so the virtual for cogl_texture_set_region does
    nothing. It would be possible to make cogl_texture_get_data do
    something sensible like returning all of the images as a single long
    image but this is not currently implemented and instead the virtual
    just always fails. We may want to add API specific to the 3D texture
    backend to get and set a sub region of the texture.
    
    All of those three functions can throw a GError. This will happen if
    the GPU does not support 3D textures or it does not support NPOTs and
    an NPOT size is requested. It will also fail if the FBO extension is
    not supported and the COGL_TEXTURE_NO_AUTO_MIPMAP flag is not
    given. This could be avoided by copying the code for the
    GL_GENERATE_MIPMAP TexParameter fallback, but in the interests of
    keeping the code simple this is not yet done.
    
    This adds a couple of functions to cogl-texture-driver for uploading
    3D data and querying the 3D proxy
    texture. prep_gl_for_pixels_upload_full now also takes sets the
    GL_UNPACK_IMAGE_HEIGHT parameter so that 3D textures can have padding
    between the images. Whenever 3D texture is uploading, both the height
    of the images and the height of all of the data is specified (either
    explicitly or implicilty from the CoglBitmap) so that the image height
    can be deduced by dividing by the depth.

 cogl/Makefile.am                          |    3 +
 cogl/cogl-material-arbfp.c                |    7 +
 cogl/cogl-texture-3d-private.h            |   96 +++++
 cogl/cogl-texture-3d.c                    |  657 +++++++++++++++++++++++++++++
 cogl/cogl-texture-3d.h                    |  154 +++++++
 cogl/cogl-texture-driver.h                |   26 ++
 cogl/cogl-types.h                         |    4 +-
 cogl/cogl.h                               |    1 +
 cogl/driver/gl/cogl-feature-functions.h   |   14 +
 cogl/driver/gl/cogl-texture-driver.c      |  108 ++++-
 cogl/driver/gles/cogl-feature-functions.h |   19 +
 cogl/driver/gles/cogl-gles2-wrapper.c     |   23 +-
 cogl/driver/gles/cogl-gles2-wrapper.h     |    4 +
 cogl/driver/gles/cogl-texture-driver.c    |  135 ++++++-
 doc/reference/cogl/cogl-docs.xml.in       |    1 +
 doc/reference/cogl/cogl-sections.txt      |    8 +
 16 files changed, 1233 insertions(+), 27 deletions(-)

commit 159c7ed7e55dadd203dc15762951e6769ae1b02f
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Jul 12 14:30:44 2010 +0100

    configure: Include gl2ext.h or glext.h under GLES
    
    Under big GL, glext.h is included automatically by gl.h. However under
    GLES this doesn't appear to happen so it has to be included explicitly
    to get the defines for extensions. This patch changes the
    clutter_gl_header to be called cogl_gl_headers and it can now take a
    space seperated list of multiple headers. This is then later converted
    to a list of #include lines which ends up cogl-defines.h. The gles2
    and gles1 backends now add their respective ext header to this list.

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

commit 42dcffbc3a02df2dfdcbfce79f4f0170c40ab751
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Jul 1 21:49:16 2010 +0100

    Make a public CoglBitmapError enum
    
    There are many places in the texture backend that need to do
    conversion using the CoglBitmap code. Currently none of these
    functions can throw an error but they do return a value to indicate
    failure. In future it would make sense if new texture functions could
    throw an error and in that case they would want to use a CoglBitmap
    error if the failure was due to the conversion. This moves the
    internal CoglBitmap error from the quartz backend to be public in
    cogl-bitmap.h so that it can be used in this way.

 cogl/cogl-bitmap-pixbuf.c            |   16 ----------------
 cogl/cogl-bitmap.c                   |    5 +++++
 cogl/cogl-bitmap.h                   |   32 ++++++++++++++++++++++++++++++++
 doc/reference/cogl/cogl-sections.txt |    2 ++
 4 files changed, 39 insertions(+), 16 deletions(-)

commit 396ef40d43baa41b05fd5fe8aa201ef0c11bb269
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Jul 13 12:59:24 2010 +0100

    Rename COGL_ERROR_MISSING_FEATURE to COGL_ERROR_UNSUPPORTED
    
    We can use this error in more unsupported situations than just when we
    have a Cogl feature flag for the error. For example if a non-sliced
    texture is created with dimensions that are too large then we could
    throw this error. Therefore it seems good to rename to something more
    general.

 cogl/cogl-material.c |    4 ++--
 cogl/cogl-types.h    |   21 ++++++++++++++++++---
 2 files changed, 20 insertions(+), 5 deletions(-)

commit c3489a0a22308b76c064e13926f0f18d7456292a
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Jul 1 11:07:03 2010 +0100

    Move _cogl_texture_2d_is_pot to cogl-util.h
    
    This function could be used in many places in Cogl so it makes sense
    to share it in cogl-util.h as _cogl_util_is_pot().

 cogl/cogl-texture-2d.c |   11 ++---------
 cogl/cogl-util.h       |    8 ++++++++
 2 files changed, 10 insertions(+), 9 deletions(-)

commit ccd45fc723611b43247638d16968393ecad12e58
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Jul 13 13:59:07 2010 +0100

    cogl-gles2-wrapper: Layers aren't equal if one is enabled and one is not
    
    Previously when comparing whether the settings for a layer are equal
    it would only check if one of them was enabled. If so then it would
    assume the other one was enabled and continue to compare the texture
    environment. Now it also checks whether the enabledness differs.

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

commit 23a172935d59491771e328166c4eb08e4ef8d9ca
Merge: 8dba134 044523d
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Jul 12 21:25:25 2010 +0100

    Merge remote branch 'elliot/cookbook-animation-inversion'
    
    * elliot/cookbook-animation-inversion:
      cookbook: Fixed invalid XML tag
      cookbook: Added "inverting an animation" recipe
      docs: Enabled animation section

commit 8dba1349c30460ed817efa83e37f54340512e0d3
Merge: 89df91a 044523d
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Jul 12 21:25:22 2010 +0100

    Merge remote branch 'elliot/cookbook-animation-intro'
    
    * elliot/cookbook-animation-intro:
      cookbook: Added introduction for animations section
      docs: Enabled animation section

commit 89df91a3897981e50e3eb790fe0da77fb429dcdd
Merge: 044523d bf56e79
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Jul 12 21:20:30 2010 +0100

    Merge remote branch 'elliot/cookbook-consistency'
    
    * elliot/cookbook-consistency:
      cookbook: Fixed typo
      cookbook: Fix build so CSS files get installed
      cookbook: Moved paragraph where it logically belongs
      cookbook: Added some judicious note elements
      cookbook: Added more information for contributors
      cookbook: Link out to docbook site
      cookbook: Made docbook element usage consistent
      cookbook: Additional selectors in CSS stylesheet
      cookbook: Copy the CSS file into the HTML build directory

commit 044523db26c730b43e5c408d7528505c13120f7e
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Jul 9 19:09:49 2010 +0100

    Add the deprecated ref-counting for cogl_program
    
    cogl_program has always had cogl_program_ref and cogl_program_unref
    but this was missed from 89cb325fd4 so they got removed.

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

commit 2c8bf0099572a5498fa9cc0fe8b5c034a93bfab0
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Jul 9 18:46:31 2010 +0100

    Don't define public cogl_is_* functions for internal types
    
    This adds a COGL_OBJECT_INTERNAL_DEFINE macro and friends that are the
    same as COGL_OBJECT_DEFINE except that they prefix the cogl_is_*
    function with an underscore so that it doesn't get exported in the
    shared library.

 cogl/cogl-atlas-texture.c     |    2 +-
 cogl/cogl-clip-stack.c        |    4 +-
 cogl/cogl-framebuffer.c       |    8 ++--
 cogl/cogl-material.c          |   18 ++++++----
 cogl/cogl-object-private.h    |   78 ++++++++++++++++++++++++++++++-----------
 cogl/cogl-sub-texture.c       |    4 +-
 cogl/cogl-texture-2d-sliced.c |    2 +-
 cogl/cogl-texture-2d.c        |    4 +-
 cogl/cogl-texture-private.h   |    6 +++
 cogl/cogl-texture-rectangle.c |    2 +-
 10 files changed, 87 insertions(+), 41 deletions(-)

commit 9e3705ecb3b19ffbf65eff1baab018e2dd365d5e
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Jul 9 18:24:28 2010 +0100

    Add cogl_vertex_buffer_is_indices to the public headers
    
    This function has always been defined in the shared library but it was
    missed from the public headers.

 cogl/cogl-vertex-buffer.h            |   15 +++++++++++++++
 doc/reference/cogl/cogl-sections.txt |    1 +
 2 files changed, 16 insertions(+), 0 deletions(-)

commit b25035ad2d83729247678ccd96fc4f26051820d4
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Jul 9 17:59:16 2010 +0100

    cogl: Don't define the deprecated ref/unref accessors for new types
    
    Previously COGL_OBJECT_DEFINE would always define deprecated
    cogl_$type_{ref,unref} functions even if the type is new or if the
    type is entirely internal. An application would still find it
    difficult to use these because they wouldn't be in the headers, but it
    still looks bad that they are exported from the shared library. This
    patch changes it so that the deprecated ref counting functions are
    defined using a separate macro and only the types that have these
    functions in the headers call this macro.

 cogl/cogl-framebuffer.c        |    1 +
 cogl/cogl-material.c           |    1 +
 cogl/cogl-object-private.h     |    4 +++-
 cogl/cogl-vertex-buffer.c      |    1 +
 cogl/driver/gl/cogl-shader.c   |    1 +
 cogl/driver/gles/cogl-shader.c |    1 +
 6 files changed, 8 insertions(+), 1 deletions(-)

commit ea708094c598fa1b2356c84314e9f349234e3326
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Jul 8 11:49:31 2010 +0100

    material: use common node type for materials and layers
    
    Since 365605cf42, materials and layers are represented in a tree
    structure that allows traversing up through parents and iterating down
    through children.  This re-works the related typedefs and reparenting
    code so that they can be shared.

 cogl/cogl-material-arbfp.c   |   25 ++-
 cogl/cogl-material-private.h |  109 +++++-----
 cogl/cogl-material.c         |  479 ++++++++++++++++++++++--------------------
 3 files changed, 326 insertions(+), 287 deletions(-)

commit 2d20589d8e5f9c1fbdbc463b96cf264367acbf81
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Fri Jul 9 17:55:31 2010 +0100

    cogl-texture-pixmap-x11: This API is new in 1.4, not 1.2
    
    CoglTexturePixmapX11 has been introduced in the 1.3 development cycle. A
    Stability: Unstable tag was missing too, so add it.

 cogl/winsys/cogl-texture-pixmap-x11.h |   11 +++++++----
 1 files changed, 7 insertions(+), 4 deletions(-)

commit c0fb59702c1d32a82cb555c57ccc1813beee321c
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Fri Jul 9 15:59:14 2010 +0100

    cogl: Add Stability tag to new experimental API
    
    Functions guarded with COGL_ENABLE_EXPERIMENTAL API should be also maked
    as being Unstable with the Stability gtk-doc tag.
    
    Fixes: http://bugzilla.clutter-project.org/show_bug.cgi?id=2175

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

commit bf8384baf131242420eb80d260c62745472356c3
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Jul 8 18:37:01 2010 +0100

    Use GL_MAX_TEXTURE_SIZE on GLES when checking supported tex size
    
    Under big GL, _cogl_texture_driver_size_supported uses the proxy
    texture to check whether the given texture size is supported. Proxy
    textures aren't available under GLES so previously this would just
    return TRUE to assume all texture sizes are supported. This patch
    makes it use glGetIntegerv with GL_MAX_TEXTURE_SIZE to give a second
    best guess.
    
    This fixes the sliced texture backend so that it will use slices when
    the texture is too big.

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

commit 0fbdafd318b77ddec4296f6f4fbdf5d1fe329f92
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Jul 8 18:33:45 2010 +0100

    Fix cogl_texture_get_data when an intermediate buffer is used
    
    When an intermediate buffer is used for downloading texture data it
    was using the wrong byte length for a row so the copy back to the
    user's buffer would fail.

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

commit d3ea1ec6f81aee661bb2b3520ad190d1587b5cba
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Jul 8 18:31:29 2010 +0100

    Use GL_NEAREST filter in the draw-and-read get_data texture fallback
    
    The fallback for when glGetTexImage is not available renders the
    texture to the framebuffer to read the data using glReadPixels. This
    patch just sets the COGL_MATERIAL_FILTER_NEAREST filter mode on the
    material before rendering to avoid linear filtering which would alter
    the texture data.

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

commit f8d1955ab783a72d94b77fcf2d48ab3d08c7db72
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Jul 8 18:29:12 2010 +0100

    Use cogl_read_pixels in the cogl texture draw-and-read fallback
    
    The fallback for when glGetTexImage is not available draws parts of
    the texture to the framebuffer and uses glReadPixels to extract the
    data. However it was using cogl_rectangle to draw and then immediately
    using raw glReadPixels to fetch the data. This won't cause a journal
    flush so the rectangle won't necessarily have hit the framebuffer
    yet. Instead it now uses cogl_read_pixels which does flush the
    journal.

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

commit 475a72fd94bc5eec0745df634896cb6b7e230dad
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Jul 8 18:28:11 2010 +0100

    cogl-material: Fix some problems with flushing texture overrides
    
    There were a few problems flushing texture overrides so that sliced
    textures would not work:
    
    * In _cogl_material_set_layer_texture it ignored the 'overriden'
      parameter and always set texture_overridden to FALSE.
    
    * cogl_texture_get_gl_texture wasn't being called correctly in
      override_layer_texture_cb. It returns a gboolean to indicate the
      error status but this boolean was being assigned to gl_target.
    
    * _cogl_material_layer_texture_equal did not take into account the
      override.
    
    * _cogl_material_layer_get_texture_info did not return the overridden
      texture so it would always use the first texture slice.

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

commit 61cbeeacfaaf2e4f548d4500d94118a813fd1ad5
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Jul 8 15:15:22 2010 +0100

    cogl-texture: Share the common code in the set_region virtual
    
    There was a lot of common code that was copied to all of the backends
    to convert the data to a suitable format and wrap it into a CoglBitmap
    so that it can be passed to _cogl_texture_driver_upload_subregion_to_gl.
    This patch moves the common code to cogl-texture.c so that the virtual
    just takes a CoglBitmap that is already in the right format.

 cogl/cogl-atlas-texture.c             |   83 +++++++-------------------------
 cogl/cogl-sub-texture.c               |   21 +++------
 cogl/cogl-texture-2d-sliced.c         |   57 ++++------------------
 cogl/cogl-texture-2d.c                |   58 ++++------------------
 cogl/cogl-texture-private.h           |   19 ++++++--
 cogl/cogl-texture-rectangle.c         |   58 ++++------------------
 cogl/cogl-texture.c                   |   76 +++++++++++++++++++++++++-----
 cogl/winsys/cogl-texture-pixmap-x11.c |    6 +--
 8 files changed, 136 insertions(+), 242 deletions(-)

commit 223317c5006ed5e594f4129b64e64b1ac97be9f2
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Jul 8 13:54:37 2010 +0100

    cogl-texture: Share the common code in the get_data virtual
    
    Previously cogl_texture_get_data would pretty much directly pass on to
    the get_data texture virtual function. This ended up with a lot of
    common code that was copied to all of the backends. For example, the
    method is expected to return the required data size if the data
    pointer is NULL and to calculate its own rowstride if the rowstride is
    0. Also it needs to convert the downloaded data if GL can't support
    that format directly.
    
    This patch moves the common code to cogl-texture.c so the virtual is
    always called with a format that can be downloaded directly by GL and
    with a valid rowstride. If the download fails then the virtual can
    return FALSE in which case cogl-texture will use the draw and read
    fallback.

 cogl/cogl-atlas-texture.c             |    2 +-
 cogl/cogl-sub-texture.c               |   26 ++------
 cogl/cogl-texture-2d-sliced.c         |   93 ++++-------------------------
 cogl/cogl-texture-2d.c                |  102 ++++----------------------------
 cogl/cogl-texture-private.h           |   13 +++-
 cogl/cogl-texture-rectangle.c         |  106 ++++----------------------------
 cogl/cogl-texture.c                   |   98 +++++++++++++++++++++++++++++-
 cogl/winsys/cogl-texture-pixmap-x11.c |    2 +-
 8 files changed, 150 insertions(+), 292 deletions(-)

commit 0e49e4f204f43b9515650aa88da9da7a62de88ee
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Apr 7 11:06:20 2010 +0100

    cogl-vertex-buffer: Default to GL_CLAMP_TO_EDGE for point sprites
    
    For point sprites you are usually drawing the whole texture so you
    most often want GL_CLAMP_TO_EDGE. This patch removes the override for
    COGL_MATERIAL_WRAP_MODE_AUTOMATIC when point sprites are enabled for a
    layer so that it will clamp to edge.

 cogl/cogl-material.h      |    6 +++-
 cogl/cogl-vertex-buffer.c |   57 ++++++++++++++++++++++++--------------------
 2 files changed, 35 insertions(+), 28 deletions(-)

commit da3be3df6b70efc55d27c757629a5efe9cfaaaad
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Mar 22 13:33:55 2010 +0000

    cogl-material: Add support for point sprites
    
    This adds a new API call to enable point sprite coordinate generation
    for a material layer:
    
    void
    cogl_material_set_layer_point_sprite_coords_enabled (CoglHandle material,
                                                         int layer_index,
                                                         gboolean enable);
    
    There is also a corresponding get function.
    
    Enabling point sprite coords simply sets the GL_COORD_REPLACE of the
    GL_POINT_SPRITE glTexEnv when flusing the material. There is no
    separate application control for glEnable(GL_POINT_SPRITE). Instead it
    is left permanently enabled under the assumption that it has no affect
    unless GL_COORD_REPLACE is enabled for a texture unit.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=2047

 cogl/cogl-context.c                     |   14 +++
 cogl/cogl-material-private.h            |   12 ++-
 cogl/cogl-material.c                    |  166 ++++++++++++++++++++++++++++++-
 cogl/cogl-material.h                    |   44 ++++++++
 cogl/cogl-types.h                       |    5 +-
 cogl/driver/gl/cogl-feature-functions.h |    7 ++
 cogl/driver/gles/cogl-gles2-wrapper.c   |   63 +++++++++---
 cogl/driver/gles/cogl-gles2-wrapper.h   |   19 +++--
 cogl/driver/gles/cogl.c                 |    3 +
 doc/reference/cogl/cogl-sections.txt    |    2 +
 10 files changed, 305 insertions(+), 30 deletions(-)

commit 06b58baa10247eacf7a702a5da30ee811069d19a
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Mar 22 09:32:17 2010 +0000

    cogl-material: Add a property for setting the point size
    
    This adds cogl_material_{get,set}_point_size. If the point size is not
    1.0f then glPointSize will be called when the material is flushed.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=2047

 cogl/cogl-context.c                            |    2 +
 cogl/cogl-context.h                            |    2 +
 cogl/cogl-material-private.h                   |   10 ++-
 cogl/cogl-material.c                           |   72 ++++++++++++++++++++++++
 cogl/cogl-material.h                           |   33 +++++++++++
 cogl/driver/gles/cogl-fixed-vertex-shader.glsl |    6 ++
 cogl/driver/gles/cogl-gles2-wrapper.c          |   19 ++++++
 cogl/driver/gles/cogl-gles2-wrapper.h          |    9 +++-
 doc/reference/cogl/cogl-sections.txt           |    2 +
 9 files changed, 151 insertions(+), 4 deletions(-)

commit dcc8c66fdd88b12cc53ad07fc029068ab8a1187a
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Jul 7 20:43:54 2010 +0100

    material: support dumping layer state graph to dot file
    
    Recently I added a _cogl_debug_dump_materials_dot_file function for
    debugging the sparse material state. This extends the state dumped to
    include the graph of layer state also.

 cogl/cogl-material.c |  133 +++++++++++++++++++++++++++++++++++++++++---------
 1 files changed, 110 insertions(+), 23 deletions(-)

commit 093251776f56c3065c69c5a397301f84802e3e29
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Jul 7 19:23:57 2010 +0100

    material: set ->layer_index on new layers for unit0
    
    We were mistakenly only initializing layer->layer_index for new layers
    associated with texture units > 0. This had gone unnoticed because
    normally layers associated with texture unit0 have a layer index of 0
    too. Mutter was hitting this issue because it was initializing layer 1
    before layer 0 for one of its materials so layer 1 was temporarily
    associated with texture unit 0.

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

commit added497f43a6c161ff727122b3e3cefbb43b10c
Merge: 0c3354a 0eb9fc0
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Wed Jul 7 16:06:30 2010 +0100

    Merge branch 'cally-merge'
    
    * cally-merge:
      cally: Add introspection generation
      cally: Improving cally doc
      cally: Cleaning CallyText
      cally: Refactoring "window:create" and "window:destroy" emission code
      cally: Use proper backend information on CallyActor
      cally: Check HAVE_CONFIG_H on cally-util.c
      docs: Fix Cally documentation
      cally: Clean up the headers
      Add binaries of the Cally examples to the ignore file
      docs: Add Cally API reference
      Avoid to load cally module on a11y examples
      Add accessibility tests
      Initialize accessibility support on clutter_init
      Rename some methods and includes to avoid -Wshadow warnings
      Cally initialization code
      Add Cally

commit 0eb9fc04f5a38ab610813ffb930b3d7be44cbf22
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Wed Jul 7 15:57:43 2010 +0100

    cally: Add introspection generation
    
    Toolkits and applications not written in C might still need access to
    the Cally API to write accessibility extensions based on it for their
    own native elements.

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

commit 0c3354acba8be6a628a25f4184fc1f9ec61caabb
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Jul 7 14:41:54 2010 +0100

    framebuffer: Replace CoglHandle with CoglFramebuffer *
    
    One more object converted to stop using CoglHandle re:a8c8cbee513

 cogl/cogl-clip-state.c          |   16 +++---
 cogl/cogl-framebuffer-private.h |   33 ++++++-----
 cogl/cogl-framebuffer.c         |  121 ++++++++++++++++-----------------------
 cogl/cogl-journal.c             |    2 +-
 cogl/cogl-texture.c             |    2 +-
 cogl/cogl.c                     |    2 +-
 cogl/cogl.h                     |   22 ++++----
 7 files changed, 88 insertions(+), 110 deletions(-)

commit 8098052d56e05809732aa1d408a5df4c360f6d92
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Jul 6 20:18:26 2010 +0100

    material: route fogging state through CoglMaterial
    
    Previously cogl_set_fog would cause a flush of the Cogl journal and
    would directly bang the GL state machine to setup fogging. As part of
    the ongoing effort to track most state in CoglMaterial to support
    renderlists this now adds an indirection so that cogl_set_fog now just
    updates ctx->legacy_fog_state. The fogging state then gets enabled as a
    legacy override similar to how the old depth testing API is handled.

 cogl/cogl-context.c          |    3 +-
 cogl/cogl-context.h          |    3 +-
 cogl/cogl-material-arbfp.c   |    2 +-
 cogl/cogl-material-fixed.c   |   48 ++++++++++++++++++++++++++++++++
 cogl/cogl-material-private.h |   20 +++++++++++--
 cogl/cogl-material.c         |   62 ++++++++++++++++++++++++++++++++++++++++++
 cogl/cogl.c                  |   54 +++++++-----------------------------
 7 files changed, 143 insertions(+), 49 deletions(-)

commit a17dfcf1c26ccab01fc73c4354a986fbfedf117d
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Jul 6 01:21:43 2010 +0100

    cogl-buffer: Move malloc fallback logic into CoglBuffer
    
    Since we'll want to share the fallback logic with CoglVertexArray this
    moves the malloc based fallback (for when OpenGL doesn't support vertex
    or pixel buffer objects) into cogl-buffer.c.

 cogl/cogl-buffer-private.h |    9 +--
 cogl/cogl-buffer.c         |  201 +++++++++++++++++++++++++++++++++++++------
 cogl/cogl-pixel-array.c    |  183 ++--------------------------------------
 3 files changed, 182 insertions(+), 211 deletions(-)

commit f8d58446a81cde3080665d93784b8fad3048e2cc
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Jul 5 23:32:55 2010 +0100

    cogl-buffer: consider it an error to free a mapped buffer
    
    Explicitly warn if we detect that a CoglBuffer is being freed while it
    is still mapped. Previously we silently unmapped the buffer, but it's
    not something we want to encourage.

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

commit e98ee6665bf51c679a1aa55e907cfa8962ef05cb
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Jul 5 23:24:34 2010 +0100

    cogl-buffer: Track the last used bind target in CoglBuffer
    
    This makes CoglBuffer track the last used bind target as a private
    property. This is later used when binding a buffer to map instead of
    always using the PIXEL_UNPACK target.
    
    This also adds some additional sanity checks that code doesn't try to
    nest binds to the same target or bind a buffer to multiple targets at
    the same time.

 cogl/cogl-buffer-private.h      |   23 ++++++++++-
 cogl/cogl-buffer.c              |   86 ++++++++++++++++++++++++++++++++-------
 cogl/cogl-context.c             |    6 ++-
 cogl/cogl-context.h             |    4 +-
 cogl/cogl-pixel-array-private.h |    1 -
 cogl/cogl-pixel-array.c         |   35 +++++++++-------
 cogl/cogl-texture.c             |    5 +-
 7 files changed, 121 insertions(+), 39 deletions(-)

commit 7571cc1923a9cbae9797bb70f13d759f7a8a25cd
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Jul 6 02:01:24 2010 +0100

    cogl: expose the semantic differences of gl/gles2 npot textures
    
    This adds three new feature flags COGL_FEATURE_TEXTURE_NPOT_BASIC,
    COGL_FEATURE_TEXTURE_NPOT_MIPMAP and COGL_FEATURE_TEXTURE_NPOT_REPEAT
    that can tell you if your hardware supports non power of two textures,
    npot textures + mipmaps and npot textures + wrap modes other than
    CLAMP_TO_EDGE.
    
    The pre-existing COGL_FEATURE_TEXTURE_NPOT feature implies all of the
    above.
    
    By default GLES 2 core supports npot textures but mipmaps and repeat
    modes can only be used with power of two textures. This patch also makes
    GLES check for the GL_OES_texture_npot extension to determine if mipmaps
    and repeating are supported with npot textures.

 cogl/cogl-types.h                         |   21 +++++++++++++++++++--
 cogl/driver/gl/cogl.c                     |    5 ++++-
 cogl/driver/gles/cogl-feature-functions.h |   10 ++++++++++
 cogl/driver/gles/cogl.c                   |    3 +++
 4 files changed, 36 insertions(+), 3 deletions(-)

commit c243086f449634e5273e1137f89fd321ee4686ef
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Jul 6 16:08:06 2010 +0100

    cogl-vertex-buffer: Fix the #define for glDisableVertexAttribArray
    
    glDisableVertexAttribArray was defined to glEnableVertexAttribArray so
    it would probably cause crashes if it was ever used. Presumably
    nothing is using these yet because the generic attributes are not yet
    tied to shader attributes in a predictable way.

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

commit bf56e798c6094b76fb9734c472b739d1ecc73ff4
Author: Alexandros Frantzis <alexandros.frantzis@linaro.org>
Date:   Tue Jul 6 13:24:00 2010 +0100

    build: Exclude built sources from the dist
    
    http://bugzilla.clutter-project.org/show_bug.cgi?id=2169
    
    Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

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

commit 3b4b5ba01cde888c7e824e24bcc5e1b3615e6a39
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Jul 6 01:30:25 2010 +0100

    debug: Adds a COGL_DEBUG=disable-pbos debug option
    
    For testing purposes, either to identify bugs in Cogl or the driver or
    simulate lack of PBO support COGL_DEBUG=disable-pbos can be used to
    fallback to malloc instead.

 cogl/cogl-debug.c |    2 ++
 cogl/cogl-debug.h |    9 +++++----
 cogl/cogl.c       |    3 +++
 3 files changed, 10 insertions(+), 4 deletions(-)

commit 72e1ff05a867fe55a8e66b5f550aca0265916b4c
Author: Robert Bragg <robert@linux.intel.com>
Date:   Sat Jul 3 19:05:04 2010 +0100

    pango-render: set CLAMP_TO_EDGE wrap mode on glyph_material
    
    The pango renderer was causing lots of override materials to be allocated
    because the vertex_buffer API converts AUTOMATIC mode into REPEAT for
    backwards compatibility. By explicitly setting the wrap mode to
    CLAMP_TO_EDGE when creating the glyph_material then the vertex_buffer
    API will leave it untouched.

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

commit 92d0322766dfb28597894d72a66aa858a84aa66b
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Jul 5 16:14:00 2010 +0100

    pixel-array: Allow passing of hints to cogl_buffer_map
    
    This allows you to tell Cogl that you are planning to replace all the
    buffer's data once it is mapped with cogl_buffer_map. This means if the
    buffer is currently being accessed by the GPU then the driver doesn't
    have to stall and wait for it to finish before it can access it from the
    CPU and can instead potentially allocate a new buffer with undefined
    data and map that.

 cogl/cogl-buffer-private.h |    3 ++-
 cogl/cogl-buffer.c         |    8 +++++---
 cogl/cogl-buffer.h         |   36 +++++++++++++++++++++++++++++++++---
 cogl/cogl-pixel-array.c    |    9 ++++++---
 4 files changed, 46 insertions(+), 10 deletions(-)

commit 51e4245ce1baf12482a6d9b758a640a79dda2e9b
Author: Robert Bragg <robert@linux.intel.com>
Date:   Sat Jul 3 21:11:33 2010 +0100

    cogl-object: cogl_is_XYZ prototype should take void *
    
    This changes the cogl_is_XYZ function prototypes generated when using
    the COGL_OBJECT_DEFINE macro to take a void * argument instead of a
    CoglHandle argument.

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

commit 9e25f8c40de3d6f4d11c5fabe09aba990b2a8e9e
Author: Robert Bragg <robert@linux.intel.com>
Date:   Sun Jul 4 00:49:31 2010 +0100

    pixel-array: Only allow allocation of arrays with a 2D size
    
    This removes cogl_pixel_array_new which just took a size in bytes.
    
    Without the image size and pixel format then the driver often doesn't
    have enough information to allocate optimal GPU memory that can be
    textured from directly. This is because GPUs often have ways to
    spatially alter the layout of a texture to improve cache access patterns
    which may require special alignment and padding dependant in the images
    width, height and bpp.
    
    Although currently we are limited by OpenGL because it doesn't let us
    pass on the width and height when allocating a PBO, the hope is that we
    can define a better extension at some point.

 cogl/cogl-pixel-array.c |    6 +++---
 cogl/cogl-pixel-array.h |   16 ----------------
 2 files changed, 3 insertions(+), 19 deletions(-)

commit daa34aeb0e8b3c124df1e8f2c87d1070ebb32933
Author: Robert Bragg <robert@linux.intel.com>
Date:   Sun Jul 4 00:45:12 2010 +0100

    pixel-array: rename new_from_size to new_with_size
    
    It is more in keeping with other coding conventions in Cogl to use new
    "with" size instead of new "from" size.

 cogl/cogl-pixel-array.c |    8 ++++----
 cogl/cogl-pixel-array.h |   12 ++++++------
 2 files changed, 10 insertions(+), 10 deletions(-)

commit a46cc22c1bf30dbacdc2a86ac84161f2c048a7f5
Author: Robert Bragg <robert@linux.intel.com>
Date:   Sun Jul 4 00:18:10 2010 +0100

    cogl-buffer-private.h: cleanup up the coding style
    
    This file was following the Clutter coding style of arranging prototypes
    into columns which Cogl doesn't copy.

 cogl/cogl-buffer-private.h |   42 +++++++++++++++++++++++++-----------------
 1 files changed, 25 insertions(+), 17 deletions(-)

commit 521d9ca2034a679be753ec7163f779547d73189b
Author: Robert Bragg <robert@linux.intel.com>
Date:   Sat Jul 3 23:46:03 2010 +0100

    rename CoglPixelBuffer to CoglPixelArray
    
    This renames CoglPixelBuffer to CoglPixelArray to be consistent with the
    new CoglVertexArray API.

 cogl/Makefile.am                 |    6 +-
 cogl/cogl-buffer.c               |    2 +-
 cogl/cogl-pixel-array-private.h  |   74 +++++++++
 cogl/cogl-pixel-array.c          |  324 ++++++++++++++++++++++++++++++++++++++
 cogl/cogl-pixel-array.h          |  147 +++++++++++++++++
 cogl/cogl-pixel-buffer-private.h |   73 ---------
 cogl/cogl-pixel-buffer.c         |  323 -------------------------------------
 cogl/cogl-pixel-buffer.h         |  146 -----------------
 cogl/cogl-texture.c              |   14 +-
 cogl/cogl.h                      |    2 +-
 10 files changed, 557 insertions(+), 554 deletions(-)

commit cafeb025313b02472ddaeb5499d84acbb6068264
Author: Robert Bragg <robert@linux.intel.com>
Date:   Sat Jul 3 21:30:33 2010 +0100

    cogl-buffer: make the COGL_BUFFER_USAGE_HINT private
    
    The usage hint should be implied by the CoglBuffer subclass type so the
    public getter and setter APIs for manually changing the usage hint of a
    CoglBuffer have now been removed.

 cogl/cogl-buffer-private.h |    9 +++++++++
 cogl/cogl-buffer.c         |   22 ----------------------
 cogl/cogl-buffer.h         |   44 --------------------------------------------
 3 files changed, 9 insertions(+), 66 deletions(-)

commit 9ceb0edf26654f259eab4be640db491d9b3948a4
Author: Robert Bragg <robert@linux.intel.com>
Date:   Sat Jul 3 23:56:44 2010 +0100

    cogl-buffer: Handle subclass registration like cogl-texture
    
    Instead of having to extend cogl_is_buffer with new buffer types
    manually this now adds a new COGL_BUFFER_DEFINE macro to be used instead
    of COGL_OBJECT_DEFINE for CoglBuffer subclasses. This macro will
    automatically register the new type with ctx->buffer_types which will
    iterated by cogl_is_buffer. This is the same coding pattern used for
    CoglTexture.

 cogl/cogl-buffer-private.h |   12 ++++++++++++
 cogl/cogl-buffer.c         |   28 +++++++++++++++++++++++++---
 cogl/cogl-context.c        |    2 ++
 cogl/cogl-context.h        |    4 ++++
 cogl/cogl-pixel-buffer.c   |    2 +-
 5 files changed, 44 insertions(+), 4 deletions(-)

commit 1b7e362189654db241c927be3f795d90f75ef84d
Author: Robert Bragg <robert@linux.intel.com>
Date:   Sat Jul 3 20:24:36 2010 +0100

    pixel-buffer: Replace CoglHandle with CoglPixelBuffer *
    
    One more file converted to stop using CoglHandle re:a8c8cbee513

 cogl/cogl-buffer-private.h       |    5 +++--
 cogl/cogl-pixel-buffer-private.h |    4 ++--
 cogl/cogl-pixel-buffer.c         |   26 +++++++++++++-------------
 cogl/cogl-pixel-buffer.h         |   18 ++++++++++--------
 4 files changed, 28 insertions(+), 25 deletions(-)

commit 12a76ca4aa796d74e7fdd8459d0d3a8ba3470bba
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Jul 2 18:04:45 2010 +0100

    cogl-material: Adds debug api to dump sparse material graph
    
    This adds a _cogl_debug_dump_materials_dot_file function that can be
    used to dump all the descendants of the default material to a file using
    the dot format which can then be converted to an image to visualize.

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

commit b5f7ab345cb74a5c1fd73a781ff3a8c1db2d75f4
Author: Robert Bragg <robert@linux.intel.com>
Date:   Sun Jul 4 02:44:37 2010 +0100

    cogl-vertex-buffer.h: #include <cogl/cogl-defines.h>
    
    cogl-vertex-buffer.h was assuming that the platforms GL headers had
    already been included but that shouldn't have to be the case.

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

commit 0b3c45396b2b4062b3104b1657bed99ba9874ea4
Author: Robert Bragg <robert@linux.intel.com>
Date:   Sat Jul 3 21:10:05 2010 +0100

    cogl-object-private.h: #include glib.h and cogl-types.h
    
    cogl-object-private.h was only working in places that had already
    included glib.h and cogl-types.h

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

commit cc0b76b405a3e8855efde8ca2ee34fa2e6c227ed
Author: Robert Bragg <robert@linux.intel.com>
Date:   Sat Jul 3 18:44:47 2010 +0100

    material: don't keep extra ref on copy-on-write materials
    
    In _cogl_material_pre_change_notify if a material with descendants is
    modified then we create a new material that is a copy of the one being
    modified and reparent those descendants to the new material.
    
    This patch ensures we drop the reference we get from cogl_material_copy
    since we can rely on the descendants to keep the new material alive.

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

commit 3428633cb30159bdfd3671e6834a4a9792fe8246
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Jul 2 01:07:36 2010 +0100

    build: Fix GLES builds since the material backend split
    
    The commit to split the fragment processing backends out from
    cogl-material.c (3e1323a6362906a95) broke the GLES 1 and 2 builds the
    fix was to guard the code in each backend according to the
    COGL_MATERIAL_BACKEND_XYZ defines which are setup in
    cogl-material-private.h.

 cogl/cogl-material-arbfp.c   |    7 ++++++-
 cogl/cogl-material-fixed.c   |    7 ++++++-
 cogl/cogl-material-glsl.c    |    7 ++++++-
 cogl/cogl-material-private.h |    2 ++
 4 files changed, 20 insertions(+), 3 deletions(-)

commit be6335c87062b629bf228c0b7f53cbbef3f86261
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Fri Jul 2 17:48:19 2010 +0100

    docs: Add a cogl-paths section
    
    The path primitives have a specific section, now, and gtk-doc is loudly
    complaining about it being defined but not referenced.

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

commit cea74d92ea4e053531743cb50eef03015d0d57ac
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Jul 2 16:19:48 2010 +0100

    Convert the ASCII art documentation in cogl-vertex-buffer to PNGs
    
    The documentation for cogl_vertex_buffer_indices_get_for_quads was
    using ugly ASCII art to draw the diagrams. These have now been
    replaced with PNG figures.

 cogl/cogl-vertex-buffer.h                     |   35 ++++++++++---------------
 doc/reference/cogl/Makefile.am                |    4 +++
 doc/reference/cogl/quad-indices-order.png     |  Bin 0 -> 2620 bytes
 doc/reference/cogl/quad-indices-triangles.png |  Bin 0 -> 8018 bytes
 4 files changed, 18 insertions(+), 21 deletions(-)

commit 432c37bd21abf357e28e64b4a337c06c71b2bd32
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Jul 2 13:49:34 2010 +0100

    Add CoglMaterialWrapMode to the Cogl docs and fix docs for the getters
    
    CoglMaterialWrapMode was missing from the cogl-sections.txt file so it
    wasn't getting displayed. There were also no documented return values
    from the getters.

 cogl/cogl-material.h                 |    4 ++++
 doc/reference/cogl/cogl-sections.txt |    1 +
 2 files changed, 5 insertions(+), 0 deletions(-)

commit 59d06d486d599525c4b301941b8a913cbf088da9
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Jul 1 20:34:59 2010 +0100

    Fix building the tesselator code for GLES
    
    The tesselator code uses some defines that it expects to be in the GL
    headers such as GLAPI and GLAPIENTRY. These are used to mark the entry
    points as exportable on each platform. We don't really want the
    tesselator code to use these but we also don't want to modify the C
    files so instead they are #defined to be empty in the stub glu.h. That
    header is only included internally when building the tesselator/ files
    so it shouldn't affect the rest of Cogl.
    
    GLES also doesn't have a GLdouble type so we just #define this to be a
    regular double.

 cogl/cogl-path.c             |    4 ++--
 cogl/tesselator/GL/glu.h     |   14 ++++++++++++++
 cogl/tesselator/tesselator.h |   30 +++++++++++++++---------------
 3 files changed, 31 insertions(+), 17 deletions(-)

commit 7961b1c93dab6b334ce1d4dfdb6e2d1cb0f45d46
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Jul 1 15:27:03 2010 +0100

    cogl-material: Don't doubly ref the parent in cogl_material_copy
    
    cogl_material_copy was taking a reference on the original texture when
    making a copy. However it then calls _cogl_material_set_parent on the
    material which also takes a reference on the parent. The second
    reference is cleaned up whenever _cogl_material_unparent is called and
    this is also called by _cogl_material_free. However, it seems that
    nothing was cleaning up the first reference. I think the reference is
    entirely unnecessary so this patch removes it.

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

commit 137d38962a9a5c14f4432dbf52cc98880d9d305a
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Jul 1 12:21:25 2010 +0100

    cogl: don't include cogl-vector.h twice in cogl.h
    
    cogl-vector.h should only be included by cogl.h when
    COGL_ENABLE_EXPERIMENTAL_API is defined. This removes the unguarded
    duplicate include.

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

commit 1000c80444a3d99d0965632a571b9ae19cb8d048
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Jun 30 18:06:04 2010 +0100

    cogl: declare experimental symbols consistently
    
    We had several different ways of exposing experimental API, in one case
    the symbols had no special suffix, in two other ways the symbols were
    given an _EXP suffix but in different ways.
    
    This makes all experimental API have an _EXP suffix which is handled
    using #defines in the header so the prototypes in the .c and .h files
    don't have the suffix.
    
    The documented reason for the suffix is so that anyone watching Cogl for
    ABI changes who sees symbols disappear will hopefully understand what's
    going on.

 cogl/cogl-buffer.c                    |   32 ++++++-------
 cogl/cogl-buffer.h                    |   67 +++++++--------------------
 cogl/cogl-pixel-buffer.c              |   82 ++++++---------------------------
 cogl/cogl-pixel-buffer.h              |   47 +++++--------------
 cogl/cogl-vector.h                    |   22 +++++++++
 cogl/winsys/cogl-texture-pixmap-x11.h |   56 ++++++-----------------
 6 files changed, 96 insertions(+), 210 deletions(-)

commit a0a06f0342d3acee95cd4927534fdd5affe46b5c
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Jun 30 15:51:52 2010 +0100

    cogl/tesselator: Update to the latest code from GLU
    
    This grabs the latest code for libtess from git Mesa. This is mostly
    so that we can get the following commit which fixes a lot of compiler
    warnings in Clutter:
    
    commit 75acb896c6da758d03e86f8725d6ca0cb2c6ad82
    Author: Neil Roberts <neil@linux.intel.com>
    Date:   Wed Jun 30 12:41:11 2010 +0100
    
        glu: Fix some compiler warnings in libtess
    
        When compiled with the more aggressive compiler warnings such as
        -Wshadow and -Wempty-body the libtess code gives a lot more
        warnings. This fixes the following issues:
    
        * The 'Swap' macro tries to combine multiple statements into one and
          then consume the trailing semicolon by using if(1){/*...*/}else.
          This gives warnings because the else part ends up with an empty
          statement. It also seems a bit dangerous because if the semicolon
          were missed then it would still be valid syntax but it would just
          ignore the following statement. This patch replaces it with the more
          common idiom do { /*...*/ } while(0).
    
        * 'free' was being used as a local variable name but this shadows the
          global function. This has been renamed to 'free_handle'
    
        * TRUE and FALSE were being unconditionally defined. Although this
          isn't currently a problem it seems better to guard them with #ifndef
          because it's quite common for them to be defined in other headers.
    
        https://bugs.freedesktop.org/show_bug.cgi?id=28845

 cogl/tesselator/geom.c           |    2 +-
 cogl/tesselator/mesh.c           |    4 ++++
 cogl/tesselator/normal.c         |    4 ++++
 cogl/tesselator/priorityq-heap.c |   22 +++++++++++++---------
 cogl/tesselator/priorityq.c      |    2 +-
 cogl/tesselator/render.c         |    8 ++++++--
 cogl/tesselator/sweep.c          |    4 ++++
 cogl/tesselator/tess.c           |    4 ++++
 8 files changed, 37 insertions(+), 13 deletions(-)

commit 6fbe92193f85307ba1f0a473c8f242d07bb1f90d
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Wed Jun 30 15:50:47 2010 +0100

    docs: Various fixes for gtk-doc

 cogl/cogl.h                    |   10 +++++-----
 doc/reference/cogl/Makefile.am |   12 ++++++------
 2 files changed, 11 insertions(+), 11 deletions(-)

commit be46b872e9dc962c0cd2c44275e2a39a1de2eedf
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Jun 22 14:02:17 2010 +0100

    material: Replace CoglHandle with CoglMaterial *
    
    As part of the ongoing effort to remove CoglHandle from the API this
    switches the cogl_material API to use a strongly typed CoglMaterial
    pointer instead of CoglHandle.

 cogl/cogl-context.h          |   10 +-
 cogl/cogl-material-private.h |   46 ++---
 cogl/cogl-material.c         |  435 ++++++++++++++++++------------------------
 cogl/cogl-material.h         |  270 ++++++++++++++------------
 4 files changed, 349 insertions(+), 412 deletions(-)

commit 17731b3af1def4981404db85d244e3c8fbd9d29b
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Jun 15 16:44:52 2010 +0100

    material: Split the fragment processing backends out
    
    This splits the fragment processing backends (glsl, arbfp and fixed) out
    from cogl-material.c into their own cogl-material-{glsl,arbfp,fixed}.c
    files in an effort to help and keep cogl-material.c maintainable.

 cogl/Makefile.am                   |    6 +
 cogl/cogl-material-arbfp-private.h |   36 +
 cogl/cogl-material-arbfp.c         | 1029 ++++++++++++++++++++++++++++
 cogl/cogl-material-fixed-private.h |   36 +
 cogl/cogl-material-fixed.c         |  201 ++++++
 cogl/cogl-material-glsl-private.h  |   36 +
 cogl/cogl-material-glsl.c          |  123 ++++
 cogl/cogl-material-private.h       |   83 +++-
 cogl/cogl-material.c               | 1309 ++----------------------------------
 9 files changed, 1587 insertions(+), 1272 deletions(-)

commit e7df75773959a6a11931ef7b0e75d4a8cc6d066e
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Jun 30 03:31:37 2010 +0100

    material: remove a duplicate gtk-doc "Since: 1.4"
    
    The cogl_material_get_depth_writing_enabled documentation had two
    "Since: 1.4" annotations which was confusing the gobject introspection
    scanner.

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

commit cdf5b222db4067f99ce4dd21b36d6faf113a2db9
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Jun 23 13:40:43 2010 +0100

    cogl-path: Allow changing the fill rule
    
    This adds two new API calls- cogl_path_set_fill_rule and
    cogl_path_get_fill_rule. This allows modifying the fill rule of the
    current path. In addition to the previous default fill rule of
    'even-odd' it now supports the 'non-zero' rule. The fill rule is a
    property of the path (not the Cogl context) so creating a new path or
    preserving a path with cogl_path_get_handle affects the fill rule.

 cogl/cogl-path-private.h                  |    3 +
 cogl/cogl-path.c                          |   38 ++++++++++++
 cogl/cogl-path.h                          |   88 +++++++++++++++++++++++-----
 doc/reference/cogl/Makefile.am            |    6 +-
 doc/reference/cogl/cogl-sections.txt      |    3 +
 doc/reference/cogl/fill-rule-even-odd.png |  Bin 0 -> 3121 bytes
 doc/reference/cogl/fill-rule-non-zero.png |  Bin 0 -> 3143 bytes
 doc/reference/cogl/fill-rule.png          |  Bin 3121 -> 0 bytes
 8 files changed, 120 insertions(+), 18 deletions(-)

commit 244a795f43cf2d448b2f41143e57f80ecff7a75a
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Apr 19 11:24:24 2010 +0100

    cogl-debug: Remove the force-scanline-paths option
    
    The scanline path rasterizer has been removed because the paths can be
    drawn with the tesselator instead. The option therefore no longer does
    anything.

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

commit fecaaea132ca2cfe449bd765035a8217c061caa8
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Apr 15 23:56:46 2010 +0100

    cogl-path: Use the GLU tesselator to draw paths
    
    Instead of drawing paths using the stencil buffer trick, it now
    tesselates the path into triangles using the GLU tesselator and
    renders them directly. A vbo is created with one vertex for each node
    on the path. The tesselator is used to generate a series of indices
    into the vbo as triangles. The tesselator's output of strips and fans
    is converted into GL_TRIANGLES so that it can be rendered with a
    single draw call (but the vertices are still shared via the
    indices). The vbo is stored with the path so that if the application
    uses retained paths then Cogl won't have to tessellate again.
    
    The vertices also have texture coordinates associated with them so
    that it can replicate the old behaviour of drawing a material with a
    texture by fitting the texture to the bounding box of the path and
    then clipping it. However if the texture contains waste or is sliced
    then the vertex buffer code will refuse to draw it. In this case it
    will revert back to drawing the path into the stencil buffer and then
    drawing the material as a clipped quad.
    
    The VBO is used even when setting up the stencil buffer for clipping
    to a path because the tessellated geometry may cover less area.
    
    The old scanline rasterizer has been removed because the tesselator
    should work equally well on drivers with no stencil buffer.

 cogl/cogl-path-private.h |    5 +
 cogl/cogl-path.c         |  737 ++++++++++++++++++++++++++++-----------------
 2 files changed, 463 insertions(+), 279 deletions(-)

commit b86e33095757333dd7b2eabdb8c23113135275b1
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Apr 16 00:28:15 2010 +0100

    cogl: Pull in the code for GLU tesselator from Mesa/SGI
    
    This copies the files for the GLU tesselator from Mesa. The Mesa code
    is based on the original SGI code and is released under a BSD license.
    
    The memalloc.h header has been replaced with one that forces the code
    to use g_malloc and friends. The rest of the files are not altered
    from the original so it should be possible to later upgrade the files
    by simply overwriting them.
    
    There is a tesselator.h header which is expected to be included by
    rest of Cogl to use the tesselator. This contains a trimmed down
    version of glu.h that only includes parts that pertain to the
    tesselator. There is also a stub glu.h in the GL directory which is
    just provided so that the tesselator code can include <GL/gl.h>
    without depending on the system header. It just redirects to
    tesselator.h

 cogl/Makefile.am                 |    7 +-
 cogl/tesselator/GL/glu.h         |   26 +
 cogl/tesselator/Makefile.am      |   41 ++
 cogl/tesselator/README           |  446 +++++++++++++
 cogl/tesselator/dict-list.h      |  100 +++
 cogl/tesselator/dict.c           |  111 ++++
 cogl/tesselator/dict.h           |  100 +++
 cogl/tesselator/geom.c           |  264 ++++++++
 cogl/tesselator/geom.h           |   84 +++
 cogl/tesselator/gluos.h          |    1 +
 cogl/tesselator/memalloc.h       |   42 ++
 cogl/tesselator/mesh.c           |  794 ++++++++++++++++++++++
 cogl/tesselator/mesh.h           |  266 ++++++++
 cogl/tesselator/normal.c         |  253 +++++++
 cogl/tesselator/normal.h         |   45 ++
 cogl/tesselator/priorityq-heap.c |  252 +++++++
 cogl/tesselator/priorityq-heap.h |  107 +++
 cogl/tesselator/priorityq-sort.h |  117 ++++
 cogl/tesselator/priorityq.c      |  260 ++++++++
 cogl/tesselator/priorityq.h      |  117 ++++
 cogl/tesselator/render.c         |  498 ++++++++++++++
 cogl/tesselator/render.h         |   52 ++
 cogl/tesselator/sweep.c          | 1357 ++++++++++++++++++++++++++++++++++++++
 cogl/tesselator/sweep.h          |   77 +++
 cogl/tesselator/tess.c           |  628 ++++++++++++++++++
 cogl/tesselator/tess.h           |  165 +++++
 cogl/tesselator/tesselator.h     |  121 ++++
 cogl/tesselator/tessmono.c       |  201 ++++++
 cogl/tesselator/tessmono.h       |   71 ++
 29 files changed, 6601 insertions(+), 2 deletions(-)

commit d99a8bf694072a3230c210206b94bf1983436153
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Jun 28 15:25:19 2010 +0100

    cogl: Add const to some pointer arguments
    
    Some of the arguments to the material and path functions were taking a
    pointer to a CoglColor or an array of floats that was not intended to
    be written to but were not marked with const.

 cogl/cogl-material.c |    6 +++---
 cogl/cogl-material.h |   14 +++++++-------
 cogl/cogl-path.c     |    4 ++--
 cogl/cogl-path.h     |    8 ++++----
 4 files changed, 16 insertions(+), 16 deletions(-)

commit de1f4885ddb1eb510bc9796a008f7a38a105e598
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Jun 23 17:10:03 2010 +0100

    material: Avoid possibly reading invalid memory
    
    in _cogl_material_prune_empty_layer_difference we sometimes unref the
    given layer before dereferencing it to get a pointer to its parent. This
    defers the unref until after we have fetched the parent pointer.

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

commit e33a94bff474d192b74a9e25868950b967a9a98a
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Jun 23 17:29:08 2010 +0100

    cogl: Remove cogl-defines.h.in from the driver make files
    
    Commit 7fae8ac051292 changed cogl-defines.h.in so there is only a
    single copy in clutter/cogl/ instead of one for each driver. However
    the old files were still mentioned in the EXTRA_DIST of the
    Makefile.am so make distcheck was failing.

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

commit e8e5188484bf700af9dc3dc657c40988d4c309b1
Author: Chris Lord <chris@linux.intel.com>
Date:   Wed Jun 23 15:53:50 2010 +0100

    cogl-path: Disable texture coord arrays before drawing
    
    It was possible that the texture co-ord arrays were left enabled during
    stroking, which could possibly cause a crash.

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

commit 857aee2b91e0e01d13251dd6658b4016a78b10ad
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Jun 22 15:42:41 2010 +0100

    texture-pixmap-x11: don't assume anything about the GLXFBConfig type
    
    A pedantic change to get_fbconfig_for_depth() so that we don't need to
    make any assumptions about the GLXFBConfig typedef or what values
    we can overload to indicate an invalid config.
    
    get_fbconfig_for_depth() now simply returns FALSE if it fails to find a
    config.

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

commit c0d42cb0213497de082e1ed4b7d53c31fca704c5
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Tue Jun 22 14:43:36 2010 +0100

    Silence another compiler warning

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

commit 7d206ccdbb93852871047454dca2af27462b0a49
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Jun 22 14:10:44 2010 +0100

    cogl-texture-pixmap-x11: Use NULL instead of None for invalid GLXFBConfig
    
    GLXFBConfigs are opaque pointers not XIDs so it doesn't make sense to
    return None from get_fbconfig_for_depth. Instead it now returns NULL.

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

commit 0244eccfe31e0dba9d3ba9902e97bf72a9e81702
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Tue Jun 22 13:48:53 2010 +0100

    Silence some compiler warnings

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

commit 8458fb7e200ea0ea71b84598aea64e5a1e1bbb45
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue May 25 18:56:14 2010 +0100

    Add a CoglTexturePixmapX11 texture backend
    
    This is a publicly exposed texture backend to create a texture which
    contains the contents of an X11 pixmap. The API is currently marked as
    experimental.
    
    The backend internally holds a handle to another texture. All of the
    backend virtuals simply redirect to the internal texture.
    
    The texture can optionally be automatically updated if the
    automatic_updates parameter is TRUE. If set then Cogl will listen for
    damage events on the pixmap and update the texture accordingly.
    Alternatively a damage object can be created externally and passed
    down to Cogl.
    
    The updates can be performed with XGetImage, XShmGetImage or the
    GLX_EXT_texture_pixmap extension. If the TFP extension is used it will
    optionally try to create a rectangle texture if the driver does not
    support NPOTs or it is forced through the
    COGL_PIXMAP_TEXTURE_RECTANGLE or CLUTTER_PIXMAP_TEXTURE_RECTANGLE
    environment variables.
    
    If the GLXFBConfig does not support mipmapping then it will fallback
    to using X{Shm,}GetImage. It keeps a separate texture around for this
    so that it can later start using the TFP texture again if the texture
    is later drawn with mipmaps disabled.

 cogl/Makefile.am                              |    7 +-
 cogl/cogl-debug.c                             |    4 +-
 cogl/cogl-debug.h                             |    3 +-
 cogl/winsys/cogl-context-winsys.c             |   26 +-
 cogl/winsys/cogl-context-winsys.h             |   40 +-
 cogl/winsys/cogl-texture-pixmap-x11-private.h |   92 ++
 cogl/winsys/cogl-texture-pixmap-x11.c         | 1397 +++++++++++++++++++++++++
 cogl/winsys/cogl-texture-pixmap-x11.h         |  176 ++++
 cogl/winsys/cogl-winsys-feature-functions.h   |   20 +
 9 files changed, 1758 insertions(+), 7 deletions(-)

commit 9c62265939e3a097cdc0da7b40e65608cc863ec9
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Jun 21 12:48:02 2010 +0100

    Add -DCOGL_ENABLE_EXPERIMENTAL_API to Makefiles for Cogl and x11/glx
    
    Cogl and Clutter should be able to use the experimental API so this
    adds the required define to the CPPFLAGS in the Makefiles.

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

commit 9d0962098f44a06565afe1a3e5435f21a8c5352d
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Jun 18 14:30:23 2010 +0100

    cogl-defines.h: Add a COGL_HAS_X11 define
    
    This will be defined in cogl-defines.h whenever Cogl is built using a
    winsys that supports X11. This implies CoglTexturePixmapX11 will be
    available.
    
    To make this work the two separate cogl-defines.h.in files have been
    merged into one. The configure script now makes a @COGL_DEFINES@
    substitution variable which contains the #define lines to put in
    rather than directly having them in the seperate files.

 cogl/Makefile.am                   |    3 --
 cogl/cogl-defines.h.in             |   36 +++++++++++++++++++++++++++++++
 cogl/driver/gl/cogl-defines.h.in   |   37 --------------------------------
 cogl/driver/gles/cogl-defines.h.in |   41 ------------------------------------
 4 files changed, 36 insertions(+), 81 deletions(-)

commit 16c7d12e6c3ffe251ebc80463727b1074d8bdd59
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Jun 4 10:38:30 2010 +0100

    cogl: Add _cogl_xlib_{,un}trap_errors
    
    This is similar to clutter_x11_{,un}trap_errors except that it stores
    the previous trap state in a caller-allocated struct so that it can be
    re-entrant.
    
    Make _cogl_xlib_trap_errors re-entrant
    
    (this will be squashed into an earlier commit)

 cogl/winsys/cogl-context-winsys.c |    2 +
 cogl/winsys/cogl-context-winsys.h |   23 +++++++++++++++++++++
 cogl/winsys/cogl-xlib.c           |   39 +++++++++++++++++++++++++++++++++++++
 cogl/winsys/cogl-xlib.h           |   29 +++++++++++++++++++++++++++
 4 files changed, 93 insertions(+), 0 deletions(-)

commit 6ad668c76b126efec977b09c8796f245f73b85cb
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Jun 1 13:32:57 2010 +0100

    cogl-texture: Avoid premult conversion if the dst format has no alpha
    
    The _cogl_texture_needs_premult_conversion function was already
    checking whether the source format had an alpha channel before
    returning TRUE, but it also doesn't make sense to do the premult
    conversion if the destination format has no alpha. This patch adds
    that check in too.

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

commit 31b5beb2c00bfae83d6cd26e33242887f330e0bd
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Jun 2 17:55:56 2010 +0100

    cogl: Add the infrastructure for checking for winsys extensions
    
    This adds the framework needed to check for winsys specific extensions
    (such as GLX extensions) using a similar mechanism to the
    cogl-feature-functions header. There is a separate
    cogl-winsys-feature-functions header which will contain macros to list
    the extensions and functions. cogl_create_context_winsys now calls
    _cogl_feature_check for each of these functions. _cogl_feature_check
    has had to be changed to accept the driver prefix as the first
    parameter so that it can prepend "GLX" rather than "GL" in this case.

 cogl/Makefile.am                            |    1 +
 cogl/cogl-feature-private.c                 |    7 ++-
 cogl/cogl-feature-private.h                 |    3 +-
 cogl/driver/gl/cogl.c                       |    2 +-
 cogl/driver/gles/cogl.c                     |    2 +-
 cogl/winsys/cogl-context-winsys.c           |   64 +++++++++++++++++++++++++++
 cogl/winsys/cogl-context-winsys.h           |   21 ++++++++-
 cogl/winsys/cogl-winsys-feature-functions.h |   25 ++++++++++
 8 files changed, 118 insertions(+), 7 deletions(-)

commit 9646e85ba77d7ffe5059b4cea1616a79f7fe5f52
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed May 19 16:13:07 2010 +0100

    Pass all Xlib events through Cogl
    
    The Clutter X11 backend now passes all events through
    _cogl_xlib_handle_event. This function can now internally be hooked
    with _cogl_xlib_add_filter. These are added to a list of callbacks
    which are all called in turn by _cogl_xlib_handle_event. This is
    intended to be used internally in Cogl by any parts that need to see
    Xlib events.
    
    Cogl now also has an internally exposed function to set a pointer to
    the Xlib display. This is stored in a global variable. The Clutter X11
    backend sets this.
    
    _cogl_xlib_handle_event and _cogl_xlib_set_display can be removed once
    Cogl gains a proper window system abstraction.

 cogl/Makefile.am                  |   11 +++--
 cogl/cogl-internal.h              |   52 +++++++++++++++++++++++++
 cogl/winsys/cogl-context-winsys.c |   20 ++++++++++
 cogl/winsys/cogl-context-winsys.h |    7 +++
 cogl/winsys/cogl-xlib.c           |   77 +++++++++++++++++++++++++++++++++++++
 cogl/winsys/cogl-xlib.h           |   37 ++++++++++++++++++
 6 files changed, 200 insertions(+), 4 deletions(-)

commit 2e5b4a5b81d92909ad90e554c57c94b7c3f82f57
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Jun 2 15:16:14 2010 +0100

    cogl: Add a struct for winsys-specific data to CoglContext
    
    This creates a separate struct to store the fields of the context that
    are specific to the winsys. This is all stored in one file but ideally
    this could work more like the CoglContextDriver struct and have a
    different header for each winsys.

 cogl/Makefile.am                  |    2 +
 cogl/cogl-context.c               |    8 +++++++
 cogl/cogl-context.h               |    2 +
 cogl/winsys/cogl-context-winsys.c |   38 +++++++++++++++++++++++++++++++++++++
 cogl/winsys/cogl-context-winsys.h |   32 +++++++++++++++++++++++++++++++
 5 files changed, 82 insertions(+), 0 deletions(-)

commit 9a1aa08fda8983420e543056ed8e54397058486e
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Jun 10 15:33:34 2010 +0100

    cogl: Add an internal CoglTextureRectangle backend
    
    This adds an internal rectangle texture backend which is mostly based
    on the CoglTexture2D backend. It will throw assert failures if any
    operations are attempted that rectangle textures don't support, such
    as mipmapping or hardware repeating.

 cogl/Makefile.am                        |    2 +
 cogl/cogl-texture-rectangle-private.h   |   68 ++++
 cogl/cogl-texture-rectangle.c           |  662 +++++++++++++++++++++++++++++++
 cogl/driver/gl/cogl-feature-functions.h |    7 +
 cogl/driver/gl/cogl-texture-driver.c    |   41 ++-
 5 files changed, 763 insertions(+), 17 deletions(-)

commit 82e63a47536e6151e3678df8ac4e47935683b7c8
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Jun 9 17:39:59 2010 +0100

    cogl-texture: Replace the ensure_mipmaps virtual with pre_paint
    
    Instead of the ensure_mipmaps virtual that is only called whenever the
    texture is about to be rendered with a min filter that needs the
    mipmap, there is now a pre_paint virtual that is always called when
    the texture is about to be painted in any way. It has a flags
    parameter which is used to specify whether the mipmap will be needed.
    
    This is useful for CoglTexturePixmapX11 because it needs to do stuff
    before painting that is unrelated to mipmapping.

 cogl/cogl-atlas-texture.c     |   13 +++++++------
 cogl/cogl-material-private.h  |    7 ++++---
 cogl/cogl-material.c          |   33 ++++++++++++++++-----------------
 cogl/cogl-primitives.c        |    4 ++--
 cogl/cogl-sub-texture.c       |    7 ++++---
 cogl/cogl-texture-2d-sliced.c |    9 +++++++--
 cogl/cogl-texture-2d.c        |   27 ++++++++++++++-------------
 cogl/cogl-texture-private.h   |   12 ++++++++++--
 cogl/cogl-texture.c           |    4 ++--
 cogl/cogl-vertex-buffer.c     |    2 +-
 10 files changed, 67 insertions(+), 51 deletions(-)

commit ebb05bcb64ca1799ce12e8262a58169e3acd79cb
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Jun 11 13:50:36 2010 +0100

    cogl-texture: List texture subclass types rather than hardcoding them
    
    Instead of having a hardcoded series of if-statements in
    cogl_is_texture to determine which types should appear as texture
    subclasses, they are now stored in a GSList attached to the Cogl
    context. The list is amended to using a new cogl_texture_register_type
    function. There is a convenience macro called COGL_TEXTURE_DEFINE
    which uses COGL_HANDLE_DEFINE_WITH_CODE to register the texture type
    when the _get_type() function is first called.

 cogl/cogl-atlas-texture.c     |    2 +-
 cogl/cogl-context.c           |    4 ++++
 cogl/cogl-context.h           |    4 ++++
 cogl/cogl-sub-texture.c       |    2 +-
 cogl/cogl-texture-2d-sliced.c |    2 +-
 cogl/cogl-texture-2d.c        |    2 +-
 cogl/cogl-texture-private.h   |   11 +++++++++++
 cogl/cogl-texture.c           |   21 +++++++++++++++++----
 8 files changed, 40 insertions(+), 8 deletions(-)

commit 2f286446af5cf80eb5c43083f76fce6468e54d1f
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Jun 11 13:44:27 2010 +0100

    Add COGL_{OBJECT,HANDLE}_DEFINE_WITH_CODE
    
    This macro is similar to COGL_HANDLE_DEFINE_WITH_CODE except that it
    allows a snippet of code to be inserted into the _get_type()
    function. This is similar to how G_DEFINE_TYPE_WITH_CODE
    works. COGL_HANDLE_DEFINE is now just a wrapper around
    COGL_HANDLE_DEFINE_WITH_CODE.

 cogl/cogl-object-private.h |   17 +++++++++++++----
 1 files changed, 13 insertions(+), 4 deletions(-)

commit f9f2f6bc6c91c5f554617fb1a0b57340d7875d9d
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Jun 3 15:06:47 2010 +0100

    Add _cogl_texture_2d_externally_modified
    
    _cogl_texture_2d_externally_modified is a function specific to the
    CoglTexture2D texture backend that should be called whenever the
    contents of the texture are modified without the backend knowing about
    it. It simply marks the mipmap tree as invalid.

 cogl/cogl-texture-2d-private.h |   11 +++++++++++
 cogl/cogl-texture-2d.c         |    9 +++++++++
 2 files changed, 20 insertions(+), 0 deletions(-)

commit 5a5b3914baef4e9664068f91987f964de799ee93
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Jun 2 15:01:18 2010 +0100

    cogl: Fix the include path in driver/*/Makefile.am
    
    The include path for the winsys and driver folder was given relative
    to $(srcdir) so it would end up relative to the driver folder which is
    wrong. It is now specified as $(srcdir)/../../winsys to get the right
    location. The driver folder is removed because it is actually just
    $(srcdir) and that is already included.

 cogl/driver/gl/Makefile.am   |    3 +--
 cogl/driver/gles/Makefile.am |    3 +--
 2 files changed, 2 insertions(+), 4 deletions(-)

commit 0e43647fedeea6ead91a98a589783666f4701525
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Jun 8 18:38:25 2010 +0100

    gles2: don't disable clip planes for GLES2
    
    GLES2 doesn't provide user clip planes (you would have to use a vertex +
    fragment shader to achieve the same kind of result) so we make sure not
    to call glEnable/Disable with any of the GL_CLIP_PLANE0..3 defines.
    
    http://bugzilla.o-hand.com/show_bug.cgi?id=2177

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

commit 9234757c3591f19e2bbc3d2964f049b6879a972d
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Jun 22 11:21:09 2010 +0100

    material: fix a typo in _cogl_material_journal_unref
    
    The function had a line like:
    
    CoglMaterial *material =
        material = _cogl_material_pointer_from_handle (material_handle);
    
    where the duplicate "material =" wasn't intended, so this patch removes
    it.

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

commit c8aae9a663f46e572da5f124f56c291f1db26353
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Jun 18 04:38:43 2010 +0100

    egl: Consolidates eglx and eglnative into one "egl" winsys
    
    This remove quite a lot of redundant code by consolidating the eglx and
    eglnative window system backends.

 cogl/Makefile.am             |    4 ++--
 cogl/winsys/cogl-egl.c       |   41 +++++++++++++++++++++++++++++++++++++++++
 cogl/winsys/cogl-eglnative.c |   35 -----------------------------------
 cogl/winsys/cogl-eglx.c      |   41 -----------------------------------------
 4 files changed, 43 insertions(+), 78 deletions(-)

commit 270e1e81883f6da4bf4b75aa4619ffc932ee68c0
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Jun 18 15:25:51 2010 +0100

    cogl-context: Use the function pointer for glActiveUnit
    
    Under WGL, any functions that were defined after GL 1.1 are not
    directly exported in the DLL so we need to reference them via the
    function pointers. A new call to glActiveUnit was missed in
    cogl-context.c

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

commit f95cdfc11e756301d3575a657af864d8423d158e
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Jun 18 15:33:03 2010 +0100

    cogl-material: Don't use the symbol 'near'
    
    The window headers contain the line
    
     #define near
    
    so it's not possible to use the symbol 'near' in code that's portable
    to Windows. This replaces it with 'near_val'.
    
    I think the define is meant to improve compatibility with code written
    for Windows 3.1 where near would be a keyword to make it a smaller
    pointer size.

 cogl/cogl-material.c |   20 ++++++++++----------
 cogl/cogl-material.h |   16 ++++++++--------
 2 files changed, 18 insertions(+), 18 deletions(-)

commit 7cd5908ef057099e309e8a7c8e69e2ac8959c6f3
Author: Richard Hughes <richard@hughsie.com>
Date:   Tue Jun 15 22:36:19 2010 +0100

    build: Fix a compiler warning when using make dist
    
    Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

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

commit d3b26f3f4d835a4ebc7d9424178ec578f800cb31
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Tue Jun 15 16:42:30 2010 +0100

    Set the initial value of a variable
    
    Fixes a compiler warning.

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

commit c506b58ecfb6495c93417d3f130ea60aa0e66916
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Jun 14 23:14:15 2010 +0100

    material: Adds arbfp compile counter
    
    This adds a uprof counter to track how many ARBfp programs get compiled
    by an application.

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

commit ba067c3da80d9e1ffe5a988cbf4b4472b2352806
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Jun 10 19:03:57 2010 +0100

    material: Support sparse ARBfp program generation
    
    We don't need to generate a new ARBfp program for every material created
    if we can find an ancestor whos state will result in the same program
    being generated.
    
    The more code we can have adopt the coding pattern of deriving their
    materials from other similar materials using cogl_material_copy() the
    more likely this metric will be good enough on its own to minimize the
    set of arbfp programs necessary to support a given application.

 cogl/cogl-material-private.h |   21 ++-
 cogl/cogl-material.c         |  356 +++++++++++++++++++++++++++++++++++-------
 2 files changed, 316 insertions(+), 61 deletions(-)

commit a38e597aaaab1d14b367006c5b2e2f3ae31aab68
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Jun 14 22:20:27 2010 +0100

    material: free any layer cache in material_set_parent
    
    Previously in _cogl_material_pre_change_notify we manually freed the
    layer caches of a material if we caused a reparent, but it makes more
    sense to have _cogl_material_set_parent do this directly instead.

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

commit 92e8fbfdc6833ea04e3af4c54de668cfa97ed4c6
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu May 27 20:04:49 2010 +0100

    Adds an internal weak material mechanism
    
    This adds a _cogl_material_weak_copy() function that can be used to
    create materials that don't count as strong dependants on their parents.
    This means the parent can be modified without worrying about how it will
    affect weak materials. The material age of the parent can potentially be
    queried to determine if a weak material might need to be re-created.

 cogl/cogl-material-private.h |    6 ++
 cogl/cogl-material.c         |  167 +++++++++++++++++++++++++++++-------------
 2 files changed, 123 insertions(+), 50 deletions(-)

commit 9689ec5aadc4fafdb5f12d3329dc5b87b51177b1
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu May 27 15:19:15 2010 +0100

    material: Adds a simple material age getter
    
    When we add support for weak materials it's expected that Clutter will
    want to attach them as private data to other materials and it needs a
    mechanism to determine when a weak material should be re-created because
    its parent has changed somehow.
    
    This adds the concept of a material age (internal only currently) which
    increments whenever a material is modified. Clutter can then save the
    age of the material which its weak materials are derived from and later
    determine when the weak material may be invalid.

 cogl/cogl-material-private.h |   10 ++++++++++
 cogl/cogl-material.c         |   19 +++++++++++++++++++
 2 files changed, 29 insertions(+), 0 deletions(-)

commit c9702be94e60c6bf7ddef8a25125dee1a4a1c095
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu May 27 15:18:15 2010 +0100

    primitives: we were memsetting the wrong wrap mode overrides pointer
    
    In _cogl_texture_quad_multiple_primitives we weren't memsetting the
    CoglMaterialWrapModeOverrides structure we were memsetting
    &state.wrap_mode_overrides where state.wrap_mode_overrides is just a
    pointer that might potentially later point to the
    CoglMaterialWrapModeOverrides structure.

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

commit 20910a1215a4369c4ef5f7645c04eaa9e478010d
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed May 26 14:13:37 2010 +0100

    material: generalize how we compare simple material properties
    
    In _cogl_material_equal we were repeating the same code pattern to
    compare several of the state groups so this just adds
    simple_property_equal function that's now used instead.

 cogl/cogl-material.c |  134 +++++++++++++++++++++++---------------------------
 1 files changed, 62 insertions(+), 72 deletions(-)

commit dab4ddc7184b25274c24fcec4c1e2d9dfff5e94a
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed May 26 11:33:32 2010 +0100

    material: Make CoglMaterial responsible for depth state
    
    This redirects the legacy depth testing APIs through CoglMaterial and
    adds a new experimental cogl_material_ API for handling the depth
    testing state.
    
    This adds the following new functions:
    cogl_material_set_depth_test_enabled
    cogl_material_get_depth_test_enabled
    cogl_material_set_depth_writing_enabled
    cogl_material_get_depth_writing_enabled
    cogl_material_set_depth_test_function
    cogl_material_get_depth_test_function
    cogl_material_set_depth_range
    cogl_material_get_depth_range
    
    As with other experimental Cogl API you need to define
    COGL_ENABLE_EXPERIMENTAL_API to access them and their stability isn't
    yet guaranteed.

 cogl/cogl-context.c          |    8 +
 cogl/cogl-context.h          |    8 +
 cogl/cogl-material-private.h |   19 ++-
 cogl/cogl-material.c         |  323 ++++++++++++++++++++++++++++++++++++++++--
 cogl/cogl-material.h         |  207 +++++++++++++++++++++++++++
 cogl/cogl-types.h            |   25 +++-
 cogl/cogl.c                  |   28 +++--
 cogl/cogl.h                  |    6 +
 8 files changed, 596 insertions(+), 28 deletions(-)

commit fca054e949476d3434df28f3f0ded9a9ca37f345
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed May 26 03:07:17 2010 +0100

    cogl docs: Improve documentation for cogl_ortho
    
    cogl_ortho is one of those APIs whos style was, for better or worse,
    copied from OpenGL and for some inexplicable reason the near and far
    arguments are inconsistent with the left, right, top, bottom arguments
    because they don't take z coordinates they take a "distance" which
    should be negative for a plane behind the viewer.
    
    This updates the documentation to explain this.

 cogl/cogl.h                       |   21 +++++++++++++++++----
 doc/reference/cogl/Makefile.am    |    6 ++++--
 doc/reference/cogl/cogl_ortho.png |  Bin 0 -> 12650 bytes
 3 files changed, 21 insertions(+), 6 deletions(-)

commit a5d6c02f7c3ee085549d09150788e1209ab9de00
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed May 19 01:02:16 2010 +0100

    primitives: no longer assume _get_layers list remains valid
    
    The internal CoglMaterialLayer pointers associated with a material may
    change whenever layer properties are modified so it's no longer ok to
    assume that a list of layers returned by cogl_material_get_layers
    remains valid if the layers have been changed.

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

commit b57f68245cc4d91229ba3ad6a3e045573c41e014
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed May 19 00:36:31 2010 +0100

    material: Adds simple breadcrumb debugging mechanism
    
    Since it can sometimes be awkward to figure out where a particular
    material came from when debugging, this adds a breadcrumb mechanism that
    lets you associate a const string with a material that may give a clue
    about its origin.

 cogl/cogl-material-private.h |   14 ++++++++++++++
 cogl/cogl-material.c         |   23 ++++++++++++++++++++++-
 2 files changed, 36 insertions(+), 1 deletions(-)

commit 6b5281401c643ace10243ce823656f0443f8967b
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue May 18 23:38:33 2010 +0100

    material: remove override options from _cogl_material_equal
    
    As a follow on to using cogl_material_copy instead of flush options this
    patch now removes the ability to pass flush options to
    _cogl_material_equal which is the final reference to the
    CoglMaterialFlushOptions mechanism.

 cogl/cogl-journal.c          |    4 +--
 cogl/cogl-material-private.h |    2 -
 cogl/cogl-material.c         |   60 +++++++++--------------------------------
 3 files changed, 14 insertions(+), 52 deletions(-)

commit 3979de69823c487ce9cd9455077ce755011fb0dc
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue May 18 22:42:49 2010 +0100

    cogl: remove _cogl_material_flush_gl_state flush options
    
    Since cogl_material_copy should now be cheap to use we can simplify
    how we handle fallbacks and wrap mode overrides etc by simply copying
    the original material and making our override changes on the new
    material. This avoids the need for a sideband state structure that has
    been growing in size and makes flushing material state more complex.
    
    Note the plan is to eventually use weak materials for these override
    materials and attach these as private data to the original materials so
    we aren't making so many one-shot materials.

 cogl/cogl-context.c          |    2 +-
 cogl/cogl-journal-private.h  |    1 -
 cogl/cogl-journal.c          |   68 ++++++++++++++++++++++++++---------------
 cogl/cogl-material-private.h |    6 +++-
 cogl/cogl-material.c         |   38 ++---------------------
 cogl/cogl-path.c             |   24 ++++++++++-----
 cogl/cogl-primitives.c       |   60 ++++++++++++++++++++++++------------
 cogl/cogl-vertex-buffer.c    |   45 +++++++++++++++++++++++++++-
 cogl/cogl.c                  |    4 +--
 9 files changed, 153 insertions(+), 95 deletions(-)

commit 1cc3ae69444d09509d90c454f22802f4d897b5b7
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Apr 8 12:21:04 2010 +0100

    CoglMaterial: Implements sparse materials design
    
    This is a complete overhaul of the data structures used to manage
    CoglMaterial state.
    
    We have these requirements that were aiming to meet:
    (Note: the references to "renderlists" correspond to the effort to
    support scenegraph level shuffling of Clutter actor primitives so we can
    minimize GPU state changes)
    
    Sparse State:
    We wanted a design that allows sparse descriptions of state so it scales
    well as we make CoglMaterial responsible for more and more state. It
    needs to scale well in terms of memory usage and the cost of operations
    we need to apply to materials such as comparing, copying and flushing
    their state. I.e. we would rather have these things scale by the number
    of real changes a material represents not by how much overall state
    CoglMaterial becomes responsible for.
    
    Cheap Copies:
    As we add support for renderlists in Clutter we will need to be able to
    get an immutable handle for a given material's current state so that we
    can retain a record of a primitive with its associated material without
    worrying that changes to the original material will invalidate that
    record.
    
    No more flush override options:
    We want to get rid of the flush overrides mechanism we currently use to
    deal with texture fallbacks, wrap mode changes and to handle the use of
    highlevel CoglTextures that need to be resolved into lowlevel textures
    before flushing the material state.
    
    The flush options structure has been expanding in size and the structure
    is logged with every journal entry so it is not an approach that scales
    well at all. It also makes flushing material state that much more
    complex.
    
    Weak Materials:
    Again for renderlists we need a way to create materials derived from
    other materials but without the strict requirement that modifications to
    the original material wont affect the derived ("weak") material. The
    only requirement is that its possible to later check if the original
    material has been changed.
    
    A summary of the new design:
    
    A CoglMaterial now basically represents a diff against its parent.
    Each material has a single parent and a mask of state that it changes.
    
    Each group of state (such as the blending state) has an "authority"
    which is found by walking up from a given material through its ancestors
    checking the difference mask until a match for that group is found.
    
    There is only one root node to the graph of all materials, which is the
    default material first created when Cogl is being initialized.
    
    All the groups of state are divided into two types, such that
    infrequently changed state belongs in a separate "BigState" structure
    that is only allocated and attached to a material when necessary.
    
    CoglMaterialLayers are another sparse structure. Like CoglMaterials they
    represent a diff against their parent and all the layers are part of
    another graph with the "default_layer_0" layer being the root node that
    Cogl creates during initialization.
    
    Copying a material is now basically just a case of slice allocating a
    CoglMaterial, setting the parent to be the source being copied and
    zeroing the mask of changes.
    
    Flush overrides should now be handled by simply relying on the cheapness
    of copying a material and making changes to it. (This will be done in a
    follow on commit)
    
    Weak material support will be added in a follow on commit.

 cogl/cogl-atlas-texture.c    |   10 +
 cogl/cogl-context.c          |   23 +-
 cogl/cogl-context.h          |   21 +-
 cogl/cogl-debug.c            |    4 +-
 cogl/cogl-debug.h            |    3 +-
 cogl/cogl-internal.h         |    9 +-
 cogl/cogl-journal.c          |    7 +-
 cogl/cogl-material-private.h |  606 +++--
 cogl/cogl-material.c         | 6220 ++++++++++++++++++++++++++++++------------
 cogl/cogl-material.h         |    6 +-
 cogl/cogl-path.c             |    7 +-
 cogl/cogl-primitives.c       |   29 +-
 cogl/cogl-vertex-buffer.c    |   21 +-
 cogl/cogl.c                  |    8 -
 14 files changed, 5024 insertions(+), 1950 deletions(-)

commit 6c8b8cef9e202ab1dd5c5a6894dcdb16c86d1b9b
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Jun 15 14:26:37 2010 +0100

    material: fix #ifdef guard around use of _TEXTURE_RECTANGLE
    
    We were incorrectly guarding the use of GL_TEXTURE_RECTANGLE_ARB with
    ifdef ARB_texture_rectangle instead of ifdef GL_ARB_texture_rectangle
    which broke test-cogl-texture-rectangle.

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

commit 26628553ed395437455ce1aaab15df7d6c4a7769
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Jun 10 14:39:20 2010 +0100

    blend-strings: removes the AUTO_COMPOSITE function enum
    
    This was mistakenly added some time ago because at some point when we
    were discussing how to handle premultiplied alpha in Clutter/Cogl we
    were considering having a magic "just do the right thing" option which
    was later abandoned.

 cogl/cogl-blend-string.c |    2 --
 cogl/cogl-blend-string.h |    1 -
 cogl/cogl-material.c     |    3 ---
 3 files changed, 0 insertions(+), 6 deletions(-)

commit 99bef3116df4c253b9acdf343a39b0404d7eb9ce
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Jun 10 14:17:42 2010 +0100

    cogl-color: add cogl_color_init_from_xyz funcs
    
    This is to try and improve API consistency. Simple cogl structures that
    don't derive from CoglObject and which can be allocated on the stack,
    such as CoglColor and CoglMatrix should all have  "_init" or
    "_init_from" functions to initialize all the structure members. (As
    opposed to a cogl_xyz_new() function for CoglObjects). CoglColor
    previously used the naming scheme "_set_from" for these initializers but
    "_set" is typically reserved for setting individual properties of a
    structure/object.
    
    This adds three _init functions:
    cogl_color_init_from_4ub
    cogl_color_init_from_4f
    cogl_color_init_from_4fv
    
    The _set_from functions are now deprecated but only with a gtk-doc
    annotation for now. This is because the cogl_color_set_from API is quite
    widely used already and so were giving a grace period before enabling a
    GCC deprecated warning just because otherwise the MX maintainers will
    complain to me that I've made their build logs look messy.

 cogl/cogl-color.c |   64 ++++++++++++++++++++++++++++++++++++++++------------
 cogl/cogl-color.h |   61 +++++++++++++++++++++++++++++++++++++++++++++++---
 2 files changed, 106 insertions(+), 19 deletions(-)

commit 49907d62678efb67bd8882151579ac13774a4896
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Jun 10 14:07:40 2010 +0100

    cogl-color: add private _cogl_color_get_rgba_4ubv API
    
    The journal logs colors as 4bytes into a vertex array and since we are
    planning to make CoglMaterial track its color using a CoglColor instead
    of a byte array this convenience will be useful for re-implementing
    _cogl_material_get_colorubv.

 cogl/cogl-color-private.h |   40 ++++++++++++++++++++++++++++++++++++++++
 cogl/cogl-color.c         |    7 +++++++
 2 files changed, 47 insertions(+), 0 deletions(-)

commit 3af1dc18b866ce84ca897b2c310fb3ab07677639
Merge: fcfff3d cce5616
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Fri Jun 11 18:12:54 2010 +0100

    Merge branch 'wip/deform-effect'
    
    * wip/deform-effect:
      docs: Add DeformEffect and PageTurnEffect to the API reference
      effect: Add PageTurnEffect
      effect: Add DeformEffect
      offscreen-effect: Traslate the modelview with the offsets
      docs: Fix Effect subclassing section

commit fcfff3dd042e104c54f500f16e7a7fbf45409254
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Jun 11 14:47:30 2010 +0100

    cogl/winsys/cogl-eglx: Use the right egl header on 1.1
    
    Commit b0cc98fdceb introduced a #include for the egl header in
    cogl-eglx.c The header name is different under GLES 1.1 so it broke
    compilation.

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

commit cc7722389c9b51c218a8a0ff1d3b12d6f262e78c
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Jun 11 14:37:56 2010 +0100

    cogl-program: Add cogl_program_uniform_1i to GLES
    
    The GLES 1.1 backend was missing a stub for cogl_program_uniform_1i.

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

commit 9343cb849a531e28609db1159b8f02b4b6b51e0b
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Jun 11 14:36:38 2010 +0100

    cogl-gles2: Prefix internal GLES 2 wrapper symbols with _
    
    Some internal symbols used for the GLES 2 wrapper were accidentally
    being exported. This prepends an underscore to them so they won't
    appear in the shared library.

 cogl/driver/gles/cogl-context-driver.c           |    2 +-
 cogl/driver/gles/cogl-fixed-fragment-shader.glsl |   30 ++--
 cogl/driver/gles/cogl-fixed-vertex-shader.glsl   |   24 ++--
 cogl/driver/gles/cogl-gles2-wrapper.c            |  201 +++++++++++-----------
 cogl/driver/gles/cogl-gles2-wrapper.h            |  192 ++++++++++----------
 cogl/driver/gles/cogl-texture-driver.c           |    2 +-
 6 files changed, 226 insertions(+), 225 deletions(-)

commit 0bbf50f905f73ccb450f8bf374f2f865a9302fbb
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Apr 22 14:33:47 2010 +0100

    cogl-clip-stack: Always use the scissor when clipping
    
    Whenever a path or a rectangle is added to the clip stack it now also
    stores a screen space bounding box in the entry. Then when the clip
    stack is flushed the bounding box is first used to set up the
    scissor. That way when we eventually come to use the stencil buffer
    the clear will be affected by the scissor so we don't have to clear
    the entire buffer.

 cogl/cogl-clip-stack.c |  179 ++++++++++++++++++++++++++++++++----------------
 cogl/cogl-path.c       |    4 +
 2 files changed, 124 insertions(+), 59 deletions(-)

commit 5a71ff4cdd6e406c80d14c10e0e412236527158e
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Apr 22 14:13:52 2010 +0100

    cogl-path: Export _cogl_path_get_bounds
    
    _cogl_path_get_bounds is no longer static and is exported in
    cogl-path-private.h so that it can be used in the clip stack code. The
    old version of the function returned x/y and width/height. However
    this was mostly used to call cogl_rectangle which takes x1/y1
    x2/y2. The function has been changed to just directly return the
    second form because it is more useful. Anywhere that was previously
    using the function now just directly looks at path->path_nodes_min and
    path->path_nodes_max instead.

 cogl/cogl-path-private.h |    7 ++++
 cogl/cogl-path.c         |   72 +++++++++++++++++++++++++---------------------
 2 files changed, 46 insertions(+), 33 deletions(-)

commit a9da7d72db3328f949a123d3b2a097e88b900fab
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Apr 22 13:48:49 2010 +0100

    cogl-clip-state: Export transform_point internally to Cogl
    
    The transform_point function takes a modelview matrix, projection
    matrix and a viewport and performs all three transformations on a
    point to give a Cogl window coordinate. This is useful in a number of
    places in Cogl so this patch moves it to cogl.c and adds it to
    cogl-internal.h

 cogl/cogl-clip-state.c |   45 +++------------------------------------------
 cogl/cogl-internal.h   |    7 +++++++
 cogl/cogl.c            |   39 +++++++++++++++++++++++++++++++++++++++
 3 files changed, 49 insertions(+), 42 deletions(-)

commit 4abd42aced823a182da8353966cecb2f3783d8f7
Author: Sunil Sadasivan <sunil@kakai.com>
Date:   Thu May 13 00:59:06 2010 -0700

    cogl_texture_get_data() copies using wrong width size.
    
    For sliced 2D textures, _cogl_texture_2d_sliced_get_data() uses the
    bitmap width, instead of the rowstride, when memcpy()ing into the
    dest buffer.
    
    Signed-off-by: Robert Bragg <robert@linux.intel.com>

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

commit 98f2d2516b2e680d8b0081cc34932b4b4d9e7d3a
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Sun Jun 6 23:03:26 2010 +0100

    cogl-color: Provide setters for all the channels
    
    We only had getters for the red, green, blue and alpha channels of a
    color. This meant that, if you wanted to change, say, the alpha
    component of a color, one would need to query the red, green and blue
    channels and use set_from_4ub() or set_from_4f().
    
    Instead of this, just provide some setters for CoglColor, using the same
    naming scheme than the existing getters.

 cogl/cogl-color.c                    |   84 ++++++++++++++++++
 cogl/cogl-color.h                    |  156 ++++++++++++++++++++++++++++++++++
 doc/reference/cogl/cogl-sections.txt |   18 ++++
 3 files changed, 258 insertions(+), 0 deletions(-)

commit 896dd975d19a7df8790cbd82b7d53f13d63587e3
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Sun Jun 6 22:57:02 2010 +0100

    cogl-color: Add cogl_color_unpremultiply()
    
    For some operations on pre-multiplied colors (say, replace the alpha
    value), you need to unpremultiply the color.
    
    This patch provides the counterpart to cogl_color_premultiply().

 cogl/cogl-color.c                    |   11 +++++++++++
 cogl/cogl-color.h                    |   13 +++++++++++++
 doc/reference/cogl/cogl-sections.txt |    1 +
 3 files changed, 25 insertions(+), 0 deletions(-)

commit 2ba6ab6dbc34e04b069fb0c88ed8d392a48a7b91
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Wed May 26 16:32:23 2010 +0100

    cogl: Initialize the framebuffer bits on state flush
    
    The place where we actually change the framebuffer is
    _cogl_framebuffer_flush_state(), so if we changed to a new frame buffer
    we need to initialize the color bits there.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=2094

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

commit 7a7dedebd515c0064809719cdd3a7b8b9f0f1935
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Wed May 26 17:14:53 2010 +0100

    cogl-framebuffer: Use the FBO extension for color sizes
    
    OpenGL 3.0 deprecated querying of the GL_{RED,GREEN,BLUE}_BITS
    constants, and the FBO extension provides a mechanism to query for the
    color buffer sizes which *should* work even with the default
    framebuffer. Unfortunately, this doesn't seem to hold for Mesa - so we
    just use this for the offscreen CoglFramebuffer type, and we fall back
    to glGetIntegerv() for the onscreen one.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=2094

 cogl/cogl-debug.c                         |    4 +-
 cogl/cogl-framebuffer.c                   |   78 +++++++++++++++++++++++++++--
 cogl/driver/gl/cogl-feature-functions.h   |    5 ++
 cogl/driver/gles/cogl-feature-functions.h |    5 ++
 4 files changed, 87 insertions(+), 5 deletions(-)

commit 3c4451cd848cd1f9bc5e4a228d415cddba7c7e81
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Wed May 26 16:31:18 2010 +0100

    cogl: Hide cogl_framebuffer_get_*_bits()
    
    These accessors should be private, for the time being.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=2094

 cogl/cogl-framebuffer.c |    8 ++++----
 cogl/cogl.c             |    8 ++++----
 cogl/cogl.h             |   24 ++++++++++++------------
 3 files changed, 20 insertions(+), 20 deletions(-)

commit cce5616edff223cf81705321d58fa917c6f55d18
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Jun 9 13:53:34 2010 +0100

    cogl-material: Fix the function which sets the enable blend flag
    
    This function had two problems. Firstly it would clear the enable
    blend flag before calling pre_change_notify so that if blending was
    previously enabled the journal would end up being flushed while the
    flag was still cleared. Secondly it would call the pre change notify
    whenever blending is needed regardless of whether it was already
    needed previously.
    
    This was causing problems in test-depth.

 cogl/cogl-material.c |   11 ++++++++---
 1 files changed, 8 insertions(+), 3 deletions(-)

commit 82e80e67650ac8ec119f2d909423ab5b707206a7
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Apr 26 10:01:43 2010 +0100

    material: Avoid redundant glBindTexture calls
    
    This adds a _cogl_bind_gl_texture_transient function that should be used
    instead of glBindTexture so we can have a consistent cache of the
    textures bound to each texture unit so we can avoid some redundant
    binding.

 cogl/cogl-atlas-texture.c              |   10 ++-
 cogl/cogl-material-private.h           |   28 ++++++++
 cogl/cogl-material.c                   |  112 +++++++++++++++++++++++++++++--
 cogl/cogl-sub-texture.c                |    6 +-
 cogl/cogl-texture-2d-sliced.c          |   55 ++++++++++++----
 cogl/cogl-texture-2d.c                 |   32 +++++++--
 cogl/cogl-texture-driver.h             |    2 +
 cogl/cogl-texture-private.h            |   19 ++++++
 cogl/cogl-texture.c                    |   23 +++++++
 cogl/driver/gl/cogl-texture-driver.c   |   11 ++-
 cogl/driver/gles/cogl-texture-driver.c |    9 ++-
 11 files changed, 266 insertions(+), 41 deletions(-)

commit acc44161c108dafef63d730b585b4f68b935f6ad
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Apr 26 10:01:43 2010 +0100

    material: Adds backend abstraction for fragment processing
    
    As part of an effort to improve the architecture of CoglMaterial
    internally this overhauls how we flush layer state to OpenGL by adding a
    formal backend abstraction for fragment processing and further
    formalizing the CoglTextureUnit abstraction.
    
    There are three backends: "glsl", "arbfp" and "fixed". The fixed backend
    uses the OpenGL fixed function APIs to setup the fragment processing,
    the arbfp backend uses code generation to handle fragment processing
    using an ARBfp program, and the GLSL backend is currently only there as
    a formality to handle user programs associated with a material. (i.e.
    the glsl backend doesn't yet support code generation)
    
    The GLSL backend has highest precedence, then arbfp and finally the
    fixed. If a backend can't support some particular CoglMaterial feature
    then it will fallback to the next backend.
    
    This adds three new COGL_DEBUG options:
    * "disable-texturing" as expected should disable all texturing
    * "disable-arbfp" always make the arbfp backend fallback
    * "disable-glsl" always make the glsl backend fallback
    * "show-source" show code generated by the arbfp/glsl backends

 cogl/cogl-buffer.c                      |    2 -
 cogl/cogl-context.c                     |   38 +-
 cogl/cogl-context.h                     |   22 +-
 cogl/cogl-debug.c                       |   10 +-
 cogl/cogl-debug.h                       |    6 +-
 cogl/cogl-internal.h                    |   15 -
 cogl/cogl-journal.c                     |   11 +-
 cogl/cogl-material-private.h            |  234 ++-
 cogl/cogl-material.c                    | 2674 ++++++++++++++++++++++---------
 cogl/cogl-path.c                        |   27 +-
 cogl/cogl-pixel-buffer.c                |    2 -
 cogl/cogl-primitives.c                  |   33 +-
 cogl/cogl-vertex-buffer.c               |   36 +-
 cogl/cogl.c                             |  109 +--
 cogl/driver/gl/cogl-context-driver.h    |    2 +
 cogl/driver/gl/cogl-feature-functions.h |   57 +-
 cogl/driver/gl/cogl-program.c           |  106 +-
 cogl/driver/gl/cogl-program.h           |    2 +-
 cogl/driver/gl/cogl-shader.c            |   26 +-
 cogl/driver/gles/cogl-program.c         |   15 +-
 20 files changed, 2398 insertions(+), 1029 deletions(-)

commit 8ebf76a9a91da0bbbe1208366c1740f0c77d6392
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Jun 9 14:42:18 2010 +0100

    cogl-atlas-texture: Flush the journal before starting blit not after
    
    _cogl_atlas_texture_blit_begin binds a texture to use as the
    destination and it expects it to stay bound until
    _cogl_atlas_texture_end_blit is called. However there was a call to
    _cogl_journal_flush directly after setting up the blit state which
    could cause the wrong texture to be bound. This just moves the flush
    to before the call to _cogl_atlas_texture_blit_begin.
    
    This was breaking test-cogl-sub-texture.

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

commit 4ac3133208af1c3cc502692113e7273c5265df05
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Jun 4 16:42:30 2010 +0100

    atlas: fix some journal flushing issues
    
    1) Always flush when migrating textures out of an atlas because although
    it's true that the original texture data will remain valid in the
    original texture we can't assume that journal entries have resolved the
    GL texture that will be used. This is only true if a layer0_override has
    been used.
    
    2) Don't flush at the point of creating a new atlas simply flush
    immediately before reorganizing an atlas. This means we are now assuming
    that we will never see recursion due to atlas textures being modified
    during a journal flush. This means it's the responsibility of the
    primitives code to _ensure_mipmaps for example not the responsibility of
    _cogl_material_flush_gl_state.

 cogl/cogl-atlas-texture.c |   39 +++++++++++++++++----------------------
 1 files changed, 17 insertions(+), 22 deletions(-)

commit a21d90912905672a52b31d44dad0988f102d29ec
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Jun 4 17:06:32 2010 +0100

    primitives: make sure to update texture storage before drawing
    
    We want to make sure that the material state flushing code will never
    result in changes to the texture storage for that material. So for
    example mipmaps need to be ensured by the primitives code.
    
    Changes to the texture storage will invalidate the texture coordinates
    in the journal and we want to avoid a recursion of journal flushing.

 cogl/cogl-material.c      |    2 -
 cogl/cogl-primitives.c    |   58 +++++++++++++++++++++++++++++++++++++++++----
 cogl/cogl-vertex-buffer.c |    7 +++++
 3 files changed, 60 insertions(+), 7 deletions(-)

commit 1047c1c082dd80a840e408c89ead597ba903f614
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Apr 26 09:55:50 2010 +0100

    matrix: add cogl_matrix_equal API
    
    This adds a way to compare two CoglMatrix structures to see if they
    represent the same transformations. memcmp can't be used because a
    CoglMatrix contains private flags and padding.

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

commit 8ee099d204f2deb7da85b6fc93a1f28704767e35
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Wed Nov 18 00:26:09 2009 +0000

    cogl-material: Use fragment programs instead of texture env combiners
    
                          THIS IS A WORK IN PROGRESS
    
    Mesa is building a big shader when using ARB_texture_env_combine. The
    idea is to bypass that computation, do it ourselves and cache the
    compiled program in a CoglMaterial.
    
    For now that feature can be enabled by setting the COGL_PIPELINE
    environment variable to "arbfp". COGL_SHOW_FP_SOURCE can be set to a non
    empty string to dump the fragment program source too.
    
    TODO:
      * fog (really easy, using OPTION)
      * support tex env combiner operands, DOT3, ADD_SIGNED, INTERPOLATE
        combine modes (need refactoring the generation of temporary
        variables) (not too hard)
      * alpha testing for GLES 2.0?

 cogl/cogl-material-private.h |   11 ++
 cogl/cogl-material.c         |  354 +++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 363 insertions(+), 2 deletions(-)

commit 56dd71dba0aafeb6c0f1c62a021ede1034e5af98
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Sat Nov 14 14:59:59 2009 +0000

    cogl: Introduce private feature flags and check for ARB_fp
    
    The Cogl context has now a feature_flags_private enum that will allow us
    to query and use OpenGL features without exposing them in the public
    API.
    
    The ARB_fragment_program extension is the first user of those flags.
    Looking for this extension only happens in the gl driver as the gles
    drivers will not expose them.
    
    One can use _cogl_features_available_private() to check for the
    availability of such private features.
    
    While at it, reindent cogl-internal.h as described in CODING_STYLE.

 cogl/cogl-context.c                       |    1 +
 cogl/cogl-context.h                       |    5 ++-
 cogl/cogl-feature-private.h               |    3 ++
 cogl/cogl-internal.h                      |    8 +++++
 cogl/cogl.c                               |   11 +++++++
 cogl/driver/gl/cogl-context-driver.c      |    2 +-
 cogl/driver/gl/cogl-context-driver.h      |    2 +-
 cogl/driver/gl/cogl-feature-functions.h   |   42 ++++++++++++++++++++++++----
 cogl/driver/gl/cogl.c                     |   25 +++++++++++------
 cogl/driver/gles/cogl-context-driver.c    |    2 +-
 cogl/driver/gles/cogl-context-driver.h    |    2 +-
 cogl/driver/gles/cogl-feature-functions.h |    6 +++-
 cogl/driver/gles/cogl.c                   |    8 +++--
 13 files changed, 91 insertions(+), 26 deletions(-)

commit 8836c868a433bfae7296e1cb0a9ffb75c952d391
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Jun 8 17:26:26 2010 +0100

    cogl-gles2-wrapper: Fix some cases using the wrong texture unit
    
    At two places in cogl_wrap_prepare_for_draw it was trying to loop over
    the texture units to flush some state. However it was retrieving the
    texture unit pointer using w->active_texture_unit instead of the loop
    index so it would end up with the wrong state.
    
    Also in glEnableClientState it was using the active unit instead of
    the client active unit.

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

commit 2e52c5f67bae148b0061d26f8924cef685ff9e62
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Sat Jun 5 21:05:23 2010 +0100

    doc: Some fixes for the Cogl documentation
    
     • 3 general fixes (typos, copy/paste),
     • ignore cogl-object-private.h,
     • cogl_fixed_atani() was in reality cogl_fixed_atan(), fixed in commit
       43564f05.
     • Fix the cogl-vector section: sections must have a </SECTION> tag at
       the end. Also the cogl-vector section was added in the middle of the
       cogl-buffer one. Let's shiffle it out and add that </SECTION> tag.

 cogl/cogl-types.h                    |    6 +++---
 doc/reference/cogl/Makefile.am       |    1 +
 doc/reference/cogl/cogl-sections.txt |   13 +++++++------
 3 files changed, 11 insertions(+), 9 deletions(-)

commit 7fa011b037e77fea4eb998c8d3950487bcf1cb5e
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Fri Jun 4 17:17:45 2010 +0100

    build: Don't distribute clutter-version.h and cogl-defines.h
    
    As with a351ff2af earlier, distributing headers generated at configure
    time conflicts with out of tree builds as the distributed headers will
    be included first instead of including the generated ones.

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

commit 7dbcb82622f97daa26a7000b0924c7c82bfe1e81
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Jun 1 19:27:07 2010 +0100

    cogl-object-private.h: white space cleanup
    
    simply replaces tabs with spaces

 cogl/cogl-object-private.h |  101 ++++++++++++++++++++++----------------------
 1 files changed, 51 insertions(+), 50 deletions(-)

commit d02d40bf61009bf67d80742c61ddd64c3aa327d3
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Jun 1 18:06:47 2010 +0100

    CoglObject: Adds a COGL_OBJECT macro for casting
    
    This adds a convenience COGL_OBJECT macro for casting CoglObject
    subclasses to (CoglObject *) pointers.

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

commit 5af3ead3a2bbd18f4b1ee35eabffd20d740749c1
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu May 27 22:24:56 2010 +0100

    CoglObject: Adds cogl_object_{get,set}_user_data
    
    This provides a mechanism for associating private data with any
    CoglObject. We expect Clutter will use this to associate weak materials
    with normal materials.

 cogl/Makefile.am                     |    3 +
 cogl/cogl-handle.h                   |    2 +-
 cogl/cogl-object-private.h           |  205 ++++++++++++++++++++++++++++
 cogl/cogl-object.c                   |  246 ++++++++++++++++++++++++++++++++++
 cogl/cogl-object.h                   |  245 +++++++++++++---------------------
 cogl/cogl-util.c                     |   61 ---------
 cogl/cogl.h                          |    1 +
 doc/reference/cogl/cogl-sections.txt |    6 +
 8 files changed, 554 insertions(+), 215 deletions(-)

commit ef08c6369a0bb2a261fa16bf4323a5d524d5d788
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Jun 1 17:53:42 2010 +0100

    cogl-path: Adds missing cogl_is_path prototype
    
    This adds a missing cogl_is_path prototype to the public cogl-path.h
    header.

 cogl/cogl-path.h                     |   12 ++++++++++++
 doc/reference/cogl/cogl-sections.txt |    1 +
 2 files changed, 13 insertions(+), 0 deletions(-)

commit 368dc483723ae213594df202b6651234c0c419fa
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Jun 1 17:34:59 2010 +0100

    cogl-path: Renames cogl_path_get/set cogl_get/set_path
    
    These aren't path methods so aren't consistent with the
    cogl_object_method naming style we are aiming for.

 cogl/cogl-clip-state.c               |    2 +-
 cogl/cogl-path.c                     |   47 +++++++++++++++++----------------
 cogl/cogl-path.h                     |    8 +++---
 doc/reference/cogl/cogl-sections.txt |    4 +-
 4 files changed, 31 insertions(+), 30 deletions(-)

commit 63eeaa86ea7ab9879c39de35ab985cc935057c53
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Thu Jun 3 11:33:54 2010 +0100

    build: Distribute cogl-object.h
    
    cogl-object.h is a new public header. Include it in the right list of
    source files to have it distributed.

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

commit cd7c1dca765ce773a383df6c4469744bd298dc36
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Tue Jun 1 14:14:41 2010 +0100

    docs: Miscellaneous fixes to silence gtk-doc

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

commit 595271ac877e4dffe0599aeaf3d61224215a4ec3
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri May 28 01:01:28 2010 +0100

    clip_stack: Remove use of CoglHandle in the CoglClipStack API
    
    This replaces the use of CoglHandle with strongly type CoglClipStack *
    pointers instead. The only function not converted for now is
    cogl_is_clip_stack which will be done in a later commit.

 cogl/cogl-clip-stack.c |   64 ++++++++++++++++++++---------------------------
 cogl/cogl-clip-stack.h |   26 ++++++++++---------
 2 files changed, 41 insertions(+), 49 deletions(-)

commit 653d1a32542f5be81f136cb51ad1de2d39f88739
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri May 28 00:51:40 2010 +0100

    bitmap: Remove use of CoglHandle in the CoglBitmap API
    
    This replaces the use of CoglHandle with strongly type CoglBitmap *
    pointers instead. The only function not converted for now is
    cogl_is_bitmap which will be done in a later commit.

 cogl/cogl-bitmap-private.h |    4 ++--
 cogl/cogl-bitmap.c         |    6 +++---
 cogl/cogl-bitmap.h         |    8 +++++---
 3 files changed, 10 insertions(+), 8 deletions(-)

commit 817c1cddccf1286e3773ab74a43892484b2bd75f
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri May 28 00:35:47 2010 +0100

    path: Remove use of CoglHandle in the CoglPath API
    
    This replaces the use of CoglHandle with strongly type CoglPath *
    pointers instead. The only function not converted for now is
    cogl_is_path which will be done in a later commit.

 cogl/cogl-path-private.h |    5 +--
 cogl/cogl-path.c         |   52 +++++++++++++++++++++------------------------
 cogl/cogl-path.h         |   41 +++++++++++++++++++----------------
 cogl/cogl.c              |   10 ++++----
 4 files changed, 53 insertions(+), 55 deletions(-)

commit 5f8fadeb1c4956741ab76eb0f19d440a7a50280f
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Jun 1 11:50:02 2010 +0100

    cogl: avoid ‘_cogl_xyz_handle_new’ defined but not used warnings
    
    This patch makes it so that only the backwards compatibility
    COGL_HANDLE_DEFINE macro defines a _cogl_xyz_handle_new function. The
    new COGL_OBJECT_DEFINE macro only defines a _cogl_xyz_object_new
    function.

 cogl/cogl-object.h |   18 ++++++++++--------
 1 files changed, 10 insertions(+), 8 deletions(-)

commit db7cc5b1b416557419b85e06114ed89c7e263039
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Thu May 27 13:30:07 2010 +0100

    analysis: Fix some CoglFixed API
    
    2 functions where not correctly defined/documented, use the actual
    symbol name instead.

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

commit 45a947d226c5d81c2fc8b8d716c9b014d86f4113
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Thu May 27 13:28:43 2010 +0100

    analysis: Use static functions when possible
    
    It's best to ensure the functions only used in one compilation unit are
    marked as static so GCC can inline them if it feels like it.

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

commit 338a37d468dc3d3fc523930b4eeab56b7664b864
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Thu May 27 12:18:29 2010 +0100

    analysis: Make all function declarations be protoypes
    
    It's valid C to declare a function omitting it prototype, but it seems
    to be a good practise to always declare a function with its
    corresponding prototype.

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

commit 58b0028b52f5e9d1eda9747ee262284ba8d9c73b
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Thu May 27 08:28:29 2010 +0100

    analysis: FALSE/0 used in pointer context
    
    While this is totally fine (0 in the pointer context will be converted
    in the right internal NULL representation, which could be a value with
    some bits to 1), I believe it's clearer to use NULL in the pointer
    context.
    
    It seems that, in most case, it's more an overlook than a deliberate
    choice to use FALSE/0 as NULL, eg. copying a _COGL_GET_CONTEXT (ctx, 0)
    or a g_return_val_if_fail (cond, 0) from a function returning a
    gboolean.

 cogl/cogl-buffer.c            |    2 +-
 cogl/cogl-journal.c           |    2 +-
 cogl/cogl-path.c              |    4 ++--
 cogl/cogl-texture-2d-sliced.c |    2 +-
 cogl/cogl-vertex-buffer.c     |   14 +++++++-------
 cogl/driver/gl/cogl-program.c |    2 +-
 6 files changed, 13 insertions(+), 13 deletions(-)

commit 3aaef72e50a1934cc54dec4322cb838295d12c70
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu May 27 23:40:40 2010 +0100

    buffer: Remove use of CoglHandle in the CoglBuffer API
    
    This replaces the use of CoglHandle with strongly type CoglBuffer *
    pointers instead. The only function not converted for now is
    cogl_is_buffer which will be done in a later commit.

 cogl/cogl-buffer-private.h |    1 -
 cogl/cogl-buffer.c         |   62 +++++++++++++++++--------------------------
 cogl/cogl-buffer.h         |   58 +++++++++++++++++++++--------------------
 3 files changed, 55 insertions(+), 66 deletions(-)

commit 7bcea1c64eede09582cf0bbfafaec48cac42744c
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu May 27 23:31:40 2010 +0100

    Start eradicating the CoglHandle typedef
    
    CoglHandle is a common source of complaints and confusion because people
    expect a "handle" to be some form of integer type with some indirection
    to lookup the corresponding objects as opposed to a direct pointer.
    
    This patch starts by renaming CoglHandle to CoglObject * and creating
    corresponding cogl_object_ APIs to replace the cogl_handle ones.
    
    The next step though is to remove all use of CoglHandle in the Cogl APIs
    and replace with strongly typed pointer types such as CoglMaterial * or
    CoglTexture * etc also all occurrences of COGL_INVALID_HANDLE can just
    use NULL instead.
    
    After this we will consider switching to GTypeInstance internally so we
    can have inheritance for our types and hopefully improve how we handle
    bindings.
    
    Note all these changes will be done in a way that maintains the API and
    ABI.

 cogl/cogl-handle.h |  140 +++-------------------------------------
 cogl/cogl-object.h |  183 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 cogl/cogl-types.h  |   21 ++++++
 cogl/cogl-util.c   |   43 +++++++++----
 4 files changed, 244 insertions(+), 143 deletions(-)

commit 0f32fb4acd0835ecc24803a81a2d1a77174a920a
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri May 28 18:12:53 2010 +0100

    cogl-texture-2d: Regenerate the mipmaps when the texture is modified
    
    When the texture is modified by cogl_texture_set_region, it wasn't
    setting mipmaps_dirty so it would never update the mipmaps.

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

commit 4c1a12d824d58876ee70ddd2913bb1580bc7b81a
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Sep 25 19:04:13 2009 +0100

    [material] fix _set_alpha_test_function: missing a glEnable(GL_ALPHA_TEST)
    
    Since the default alpha test function of GL_ALWAYS is equivalent to
    GL_ALPHA_TEST being disabled we don't need to worry about Enabling/Disabling
    it when flushing material state, instead it's enough to leave it always
    enabled.  We will assume that any driver worth its salt wont incur any
    additional cost for glEnable (GL_ALPHA_TEST) + GL_ALWAYS vs
    glDisable (GL_ALPHA_TEST).
    
    This patch simply calls glEnable (GL_ALPHA_TEST) in cogl_create_context

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

commit 5a1cffd0bb8036bd48deab24b9e6d84d8149a7ba
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu May 27 14:54:14 2010 +0100

    cogl-vertex-buffer: Don't disable any texture coord arrays
    
    The enabled state of the texture coord arrays is cached in the cogl
    context so there is no need to disable them when we've finished
    rendering a vbo.

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

commit 97fd2c368e96d5475cda8872f36fadc6f14ef0a4
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu May 27 14:51:44 2010 +0100

    cogl: Record new enabled arrays in _cogl_disable_other_texcoord_arrays
    
    When _cogl_disable_other_texcoord_arrays is called it disables the
    neccessary texcoord arrays and then removes the bits for the disabled
    arrays in ctx->texcoord_arrays_enabled. However none of the places
    that call the function then set any bits in ctx->texcoord_arrays_enabled
    so the arrays would never get marked and they would never get disabled
    again.
    
    This patch just changes it so that _cogl_disable_other_texcoord_arrays
    also sets the corresponding bits in ctx->texcoord_arrays_enabled.

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

commit aaf5600b2d4e1a37b52ba45126b0f31bf2e270f9
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon May 24 12:40:11 2010 +0100

    cogl: Use a CoglBitmask to store the list of used texcoord arrays
    
    Instead of directly using a guint32 to store a bitmask for each used
    texcoord array, it now stores them in a CoglBitmask. This removes the
    limitation of 32 layers (although there are still other places in Cogl
    that imply this restriction). To disable texcoord arrays code should
    call _cogl_disable_other_texcoord_arrays which takes a bitmask of
    texcoord arrays that should not be disabled. There are two extra
    bitmasks stored in the CoglContext which are used temporarily for this
    function to avoid allocating a new bitmask each time.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=2132

 cogl/cogl-context.c       |    8 +++++++-
 cogl/cogl-context.h       |    8 +++++++-
 cogl/cogl-internal.h      |    5 ++++-
 cogl/cogl-journal.c       |    7 +++----
 cogl/cogl-path.c          |    3 ++-
 cogl/cogl-primitives.c    |    7 +++----
 cogl/cogl-vertex-buffer.c |   10 ++++++----
 cogl/cogl.c               |   41 +++++++++++++++++++++++------------------
 8 files changed, 55 insertions(+), 34 deletions(-)

commit 4fb784d111605ac629e1ed63bfb9ff744beb3209
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu May 20 17:31:42 2010 +0100

    cogl: Add an internal CoglBitmask type
    
    This implements a growable array of bits called CoglBitmask. The
    CoglBitmask is intended to be cheap if less than 32 bits are used. If
    more bits are required it will allocate a GArray. The type is meant to
    be allocated on the stack but because it can require additional
    resources it also has a destroy function.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=2132

 cogl/Makefile.am    |    2 +
 cogl/cogl-bitmask.c |  257 +++++++++++++++++++++++++++++++++++++++++++++++++++
 cogl/cogl-bitmask.h |  223 ++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 482 insertions(+), 0 deletions(-)

commit 52cbc93b1870b7734363024318603fbe67030126
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu May 20 00:40:24 2010 +0100

    cogl-material: Fix the count of the number of layers
    
    Previously the counter for the number of layers was only updated
    whenever the texture handle for a layer changes. However there are
    many other ways for a new layer to be created for example by setting a
    layer combine constant. Also by default the texture on a layer is
    COGL_INVALID_HANDLE so if the application tries to create an explicit
    layer with no texture by calling cogl_material_set_layer with
    COGL_INVALID_HANDLE then it also wouldn't update the count.
    
    This patch fixes that by incrementing the count in
    cogl_material_get_layer instead. This function is called by all
    functions that may end up creating a layer so it seems like the most
    appropriate place.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=2132

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

commit 992d5f7fb616870b2f1bce0ac2122cfa4bfe34c9
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu May 20 00:16:49 2010 +0100

    cogl-vertex-buffer: Don't disable layers with no texture coords
    
    It should be quite acceptable to use a texture without defining any
    texture coords. For example a shader may be in use that is doing
    texture lookups without referencing the texture coordinates. Also it
    should be possible to replace the vertex colors using a texture layer
    without a texture but with a constant layer color.
    
    enable_state_for_drawing_buffer no longer sets any disabled layers in
    the overrides. Instead of counting the number of units with texture
    coordinates it now keeps them in a mask. This means there can now be
    gaps in the list of enabled texture coordinate arrays. To cope with
    this, the Cogl context now also stores a mask to track the enabled
    arrays. Instead of code manually iterating each enabled array to
    disable them, there is now an internal function called
    _cogl_disable_texcoord_arrays which disables a given mask.
    
    I think this could also fix potential bugs when a vertex buffer has
    gaps in the texture coordinate attributes that it provides. For
    example if the vertex buffer only had texture coordinates for layer 2
    then the disabling code would not disable the coordinates for layers 0
    and 1 even though they are not used. This could cause a crash if the
    previous data for those arrays is no longer valid.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=2132

 cogl/cogl-context.c       |    2 +-
 cogl/cogl-context.h       |    3 ++-
 cogl/cogl-internal.h      |    3 +++
 cogl/cogl-journal.c       |   14 +++++---------
 cogl/cogl-path.c          |    9 ++-------
 cogl/cogl-primitives.c    |   13 ++++---------
 cogl/cogl-vertex-buffer.c |   21 ++++++---------------
 cogl/cogl.c               |   33 ++++++++++++++++++++++++++-------
 8 files changed, 49 insertions(+), 49 deletions(-)

commit 99c7e51145ad751ae1c4b171e7af687e82247e59
Merge: 94c1614 af591f5
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon May 24 10:42:03 2010 +0100

    Merge branch 'wip/state-machine'
    
    * wip/state-machine:
      Do not use wildcards in test-state
      script: Implement State deserialization
      state: added a "target-state" property
      state: documented data structures
      Add State interactive tests to the ignore file
      state: Documentation and introspection annotation fixes
      state: Minor coding style fixes
      state: Clean up the header's documentation
      state: Constify StateKey accessors
      Do not include clutter.h from a Clutter header file
      state-machine: made clutter_state_change take a boolean animate argument
      state-machine: use clutter_timeline_get_progress
      state-machine: add completed signal
      state machine: added state machine
    
    Conflicts:
    	.gitignore

commit 94c1614164b720b2c06e7252688795137e16cd70
Merge: 6696b4f 676c8a5
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Fri May 21 14:38:37 2010 +0100

    Merge branch 'wip/framebuffer-bits'
    
    * wip/framebuffer-bits:
      Implement accessors for the color bits in a framebuffer

commit 6696b4ff4331b49128bbd933cb72b72d5b10ba20
Merge: fa22ee0 1eddbe8
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Fri May 21 10:55:09 2010 +0100

    Merge branch 'wip/constraints'
    
    * wip/constraints: (24 commits)
      Add the Cogl API reference to the fixxref extra directories
      Document the internal MetaGroup class
      Remove the construct-only flag from ActorMeta:name
      doc: Remove gtk-doc annotations from the json-glib copy
      doc: Fix parameter documentation
      Add named modifiers for Action and Constraint
      Remove a redundant animation
      Set the stage resizable in test-constraints
      Use a 9 grid for the constraints test
      Miscellaneous documentation fixes
      docs: Document animating action and constraint properties
      docs: Document BindConstraint and AlignConstraint
      constraint: Rename BindConstraint:bind-axis
      constraints: Add AlignConstraint
      tests: Add a constraints interactive test
      constraint: Add BindConstraint
      actor: Implement Animatable
      animation: Use the new Animatable API for custom properties
      animatable: Add custom properties to Animatable
      constraint: Add ClutterConstraint base class
      ...
    
    Conflicts:
    	configure.ac

commit fa22ee0e8d7cab726be9534bd7afd851e944ea5c
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu May 20 14:54:44 2010 +0100

    math: Adds an experimental cogl_vector3_* API
    
    This adds a math utility API for handling 3 component, single precision
    float vectors with the following; mostly self explanatory functions:
    
    cogl_vector3_init
    cogl_vector3_init_zero
    cogl_vector3_equal
    cogl_vector3_equal_with_epsilon
    cogl_vector3_copy
    cogl_vector3_free
    cogl_vector3_invert
    cogl_vector3_add
    cogl_vector3_subtract
    cogl_vector3_multiply_scalar
    cogl_vector3_divide_scalar
    cogl_vector3_normalize
    cogl_vector3_magnitude
    cogl_vector3_cross_product
    cogl_vector3_dot_product
    cogl_vector3_distance
    
    Since the API is experimental you will need to define
    COGL_ENABLE_EXPERIMENTAL_API before including cogl.h if you want to use
    the API.

 cogl/Makefile.am                     |    2 +
 cogl/cogl-vector.c                   |  284 ++++++++++++++++++++++++++
 cogl/cogl-vector.h                   |  367 ++++++++++++++++++++++++++++++++++
 cogl/cogl.h                          |    2 +
 doc/reference/cogl/cogl-docs.xml.in  |    1 +
 doc/reference/cogl/cogl-sections.txt |   20 ++
 6 files changed, 676 insertions(+), 0 deletions(-)

commit af591f5c09e0e2a1ce91d94d1d0a08cfb5a54c6b
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu May 20 12:37:56 2010 +0100

    cogl-texture-2d: Optimise _cogl_texture_2d_is_pot
    
    This takes the simple algorithm from here:
    
    http://graphics.stanford.edu/~seander/bithacks.html#DetermineIfPowerOf2
    
    This avoids a loop and is much faster.

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

commit 76d5a1a8589cec5670c7fd2fea351f58049346ba
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Oct 13 15:27:06 2009 +0100

    Stubs out _cogl_xlib_handle_event
    
    This stubs out an xlib event handling mechanism for Cogl. The intention
    is for Clutter to use this to forward all x11 events to Cogl. As we move
    winsys functionality down into Cogl, Cogl will become responsible for
    handling a number of X events: ConfigureNotify events for onscreen
    framebuffers, swap events and Damage events for cogl_x11_texture_pixmap.

 cogl/Makefile.am        |    6 +++-
 cogl/cogl-internal.h    |   39 +++++++++++++++++++++++++++++++++
 cogl/winsys/cogl-xlib.c |   54 +++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 97 insertions(+), 2 deletions(-)

commit 1ed1d4fc6a3faa0a26ea06d0e741549c20010ef2
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Oct 8 12:08:21 2009 +0100

    build: expose automake conditionals for cogl winsys
    
    Expose the ./configured window system/backend options to the Cogl
    automake files via some new SUPPORT_XYZ conditionals.

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

commit 5f94a6bf6e0c3712523b5a06d7d147d43e7cccbd
Author: Brian Tarricone <brian@kakai.com>
Date:   Thu Mar 25 20:55:31 2010 -0700

    eglx: implement cogl_get_proc_address()
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=2124

 cogl/winsys/cogl-eglx.c |    4 +++-
 1 files changed, 3 insertions(+), 1 deletions(-)

commit 1eddbe8e1b89bbd73e7401168268862b865a6ddb
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed May 12 18:57:52 2010 +0100

    cogl-material: Set the blend equation even if blend funcs are the same
    
    Previously it would only try to set the blend equation if the RGB and
    alpha blending functions were different. However it's completely valid
    to use a non-standard blending function when the functions are the
    same. This patch moves the blending equation to outside the if
    statement.

 cogl/cogl-material.c |   28 +++++++++++++---------------
 1 files changed, 13 insertions(+), 15 deletions(-)

commit 9ca68bc37a760c1c8e186316929fa99f3098b392
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed May 12 15:19:09 2010 +0100

    cogl-material: Set blend constant even if alpha and rgb factors are the same
    
    Previously it would only set the blend constant if glBlendFuncSeparate
    was used but it is perfectly acceptable to use the blend constant when
    the same factor is used for each. It now sets the blend constant
    whenever one of the factors would use the constant.

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

commit 837eb54db491bed833f0e57c152e97f3b0658961
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed May 12 17:56:25 2010 +0100

    cogl-blend-string: Don't split combined blend statements into two
    
    When a single statement is used to specify the factors for both the
    RGB and alpha parts it previously split up the statement into
    two. This works but it ends up unnecessarily using glBlendFuncSeparate
    when glBlendFunc would suffice.
    
    For example, the blend statement
    
     RGBA = ADD(SRC_COLOR*(SRC_COLOR), DST_COLOR*(1-SRC_COLOR))
    
    would get split into the two statements
    
     RGBA = ADD(SRC_COLOR*(SRC_COLOR[RGB]), DST_COLOR*(1-SRC_COLOR[RGB]))
     A    = ADD(SRC_COLOR*(SRC_COLOR[A]), DST_COLOR*(1-SRC_COLOR[A]))
    
    That translates to:
    
     glBlendFuncSeparate (GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR,
                          GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    
    This patch makes it so that arg_to_gl_blend_factor can handle the
    combined RGBA mask instead. That way the single statement gets
    translated to the equivalent call:
    
     glBlendFunc (GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR);

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

commit 8193e12546caba1a9799e04b1d4400b59b95de60
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Apr 22 11:58:52 2010 +0100

    cogl-path: Use true copy-on-write semantics
    
    Previously a path copy was implemented such that only the array of
    path nodes was shared with the source and the rest of the data is
    copied. This was so that the copy could avoid a deep copy if the
    source path is appended to because the copy keeps track of its own
    length. This optimisation is probably not worthwhile because it makes
    the copies less cheap. Instead the CoglPath struct now just contains a
    single pointer to a new CoglPathData struct which is separately
    ref-counted. When the path is modified it will be copied if the ref
    count on the data is not 1.

 cogl/cogl-path-private.h |   20 ++--
 cogl/cogl-path.c         |  249 ++++++++++++++++++++++------------------------
 2 files changed, 125 insertions(+), 144 deletions(-)

commit 582bd409dd98f367065866df4e83cf420da0d756
Author: Owen W. Taylor <otaylor@fishsoup.net>
Date:   Sat May 8 16:58:14 2010 -0400

    cogl-framebuffer: Flush journal when creating fbo
    
    Since framebuffer state is not flushed prior to replaying the journal,
    the trick of marking the framebuffer dirty prior to calling
    glBindFramebuffer() doesn't work... the outstanding journal entries
    will get replayed to the newly created framebuffer.
    
    Fix this by flushing the journal as well.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=2110
    
    Signed-off-by: Robert Bragg <robert@linux.intel.com>

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

commit 11532f79ec9283bbf27e13b5909402585a94464d
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu May 6 14:15:04 2010 +0100

    cogl-clip-stack: Set *stencil_used_p when the stack is empty
    
    If the clip stack is empty then _cogl_clip_stack_flush exits
    immediately. This was missing out the assignment of *stencil_used_p at
    the bottom of the function. If a path is then used after the clip is
    cleared then it would think it needs to merge with the clip so the
    stencil would not be cleared correctly.

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

commit 676c8a5fd4e0a9126a1a735f9e89513e5614a838
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Apr 26 18:08:45 2010 +0100

    Implement accessors for the color bits in a framebuffer
    
    Instead of using cogl_get_bitmasks() to query the GL machinery for the
    size of the color bits, we should store the values inside the
    CoglFramebuffer object and query them the first time we set the framebuffer
    as the current one.
    
    Currently, cogl_get_bitmasks() is re-implemented in terms of
    cogl_framebuffer_get_*_bits(). As soon as we are able to expose the
    CoglOnscreen framebuffer object in the public API we'll be able to
    deprecate cogl_get_bitmasks() altogether.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=2094

 cogl/cogl-context.c             |    1 +
 cogl/cogl-framebuffer-private.h |   18 ++++++++++++
 cogl/cogl-framebuffer.c         |   57 +++++++++++++++++++++++++++++++++++++++
 cogl/cogl.c                     |   24 +++++-----------
 cogl/cogl.h                     |   52 +++++++++++++++++++++++++++++++++++
 5 files changed, 135 insertions(+), 17 deletions(-)

commit 36298bbe307385f3fc7e08e80281e0df188952fe
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed May 5 12:05:15 2010 +0100

    gles: Fix the functions names for the GL_OES_framebuffer_object ext
    
    In 91cde78a7 I accidentally changed the function names that get looked
    up for the framebuffer extension under GLES so that they didn't have
    any suffix. The spec for extension specifies that they should have the
    OES suffix.

 cogl/driver/gles/cogl-feature-functions.h |    5 +----
 1 files changed, 1 insertions(+), 4 deletions(-)

commit 6243a5dc340875597cf64b8e1a6c1eb5840b2b72
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Mon May 3 20:41:17 2010 +0200

    debug: Use G_UNLIKELY in the tests
    
    Debugging code is not meant to be run in the nominal code path. Use
    G_UNLIKELY to be reduce the number of bubbles in the instruction
    pipeline.
    
    Took the opportunity to re-indent the macros.

 cogl/cogl-debug.h |   20 ++++++++++----------
 1 files changed, 10 insertions(+), 10 deletions(-)

commit dc4c0e3d3e7a6471a932640554fdd2f171d38f1f
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Apr 30 12:10:16 2010 +0100

    debug: wrap glClear calls with the GE macro
    
    This adds a GE macro wrapper around our calls to glClear so we can
    print a warning for any errors reported by the driver.

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

commit ebe86985fd505d549c8acbfb45ff8d195ebe3eb5
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Apr 26 12:41:26 2010 +0100

    cogl-texture-2d-sliced: Use the converted bitmap when uploading
    
    When uploading texture data the cogl-texture-2d-sliced backend was
    using _cogl_texture_prepare_for_upload to create a bitmap suitable for
    upload but then it was using the original bitmap instead of the new
    bitmap for the data. This was causing any format conversions performed
    by cogl_texture_prepare_for_upload to be ignored.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=2059

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

commit dae6ab7d7918a98975897e3196e4f7dc4da9c128
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Apr 26 12:30:37 2010 +0100

    cogl-texture: Don't attempt to use GL to convert formats under GLES
    
    In commit abe91784c4b I changed cogl-texture so that it would use the
    OpenGL mechanism to specify a different internal texture format from
    the image format so that it can do the conversion instead of
    Cogl. However under GLES the internal format and the image format must
    always be the same and it only supports a limited set of formats. This
    patch changes _cogl_texture_prepare_for_upload so that it does the
    conversion using the cogl bitmap code when compiling for GLES.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=2059

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

commit 3e88dee1a3bdb55e9bd712452d636adf6a9547f7
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Apr 27 16:38:07 2010 +0100

    cogl-material: Fix the check to prevent using too many layers
    
    There was a check at the bottom of the loop which sets up the state
    for each of the layers so that it would break from the loop when the
    maximum number of layers is reached. However after doing this it would
    not increment 'i'. 'i' is later used to disable the remaining layers
    so it would end up disabling the last layer it just set up.
    
    This patch moves the check to be part of the loop condition so that
    the check is performed after incrementing 'i'.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=2064

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

commit d5d98500be9ff7c63bd233c4c968f9b61bc54b9d
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Apr 27 16:35:35 2010 +0100

    cogl-material: Fix the warning for when too many layers are used
    
    The warning displayed when too many layers are used had an off-by-one
    error so that it would display even if exactly the maximum number is
    used. There was also a missing space at the end of the line in the
    message which looked wrong when displayed on the terminal.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=2064

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

commit edf2bf3d8a5d9a37c9221092fd14a45fd4ef2fca
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Apr 22 18:14:40 2010 +0100

    cogl-path: Make cogl_path_arc_rel static
    
    cogl_path_arc_rel was never in any public headers so it isn't part of
    the public API. It also has a slightly inconsistent name because the
    rest of the relative path functions are called cogl_path_rel_*. This
    patch makes it static for now to make it more obvious that it isn't
    public. The name has changed to _cogl_path_rel_arc.

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

commit 2b8abbdaa8af0b340bbbae82aeafe0feccb28710
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Apr 22 18:03:57 2010 +0100

    cogl-path: Add documentation for the angles of cogl_path_arc
    
    This adds documentation for how Cogl interprets the angles given to
    cogl_path_arc.

 cogl/cogl-path.h |   10 ++++++++--
 1 files changed, 8 insertions(+), 2 deletions(-)

commit 308ca6cb14393c553ee77b15b6cf7d0089df7af8
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Apr 21 22:36:43 2010 +0100

    cogl-path: Fix the truncation when adding to a copied path
    
    If a path is copied and then appended to, the copy needs to have the
    last sub path truncated so that it fits in the total path size in case
    the original path was modified. However the path size check was broken
    so if the copied path had more than one sub path it would fail.

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

commit 9d93e250d19334062e6a560f67431c5d49292dd2
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Apr 20 14:58:57 2010 +0100

    cogl-clip-stack: Use orientation of the polygon to set clip planes
    
    Previously the clip stack code was trying to detect when the
    orientation of the on-screen rectangle had changed by checking if the
    order of the y-coordinates on the left edge was different from the
    order the x-coordinates on the top edge. This doesn't work for some
    rotations which was causing the clip planes to clip the wrong side of
    the line. This patch makes it detect the orientation by calculating
    the signed area which is a standard computer graphics algorithm.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=2079

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

commit 17a1595cb0776e20e9fa6708190e65ee3af7b995
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Apr 21 11:49:57 2010 +0100

    cogl-path: Document how a shape is filled
    
    This adds some documentation to cogl_path_fill() describing the fill
    rule Cogl uses.

 cogl/cogl-path.h                 |   28 +++++++++++++++++++++++-----
 doc/reference/cogl/Makefile.am   |    6 +++++-
 doc/reference/cogl/fill-rule.png |  Bin 0 -> 3121 bytes
 3 files changed, 28 insertions(+), 6 deletions(-)

commit 8afea984376fb4aa4af6ee5e3886473b352ebd9f
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Apr 19 18:54:40 2010 +0100

    cogl-path: Don't try to union sub paths
    
    When drawing a path with only a single sub path, Cogl uses the
    'even-odd' fill rule which means that if a part of the path intersects
    with another part then the intersection would be inverted. However
    when combining sub paths it treats them as separate paths and then
    unions them together. This doesn't match the semantics of the even-odd
    rule in SVG and Cairo. This patch makes it so that a new sub path is
    just drawn as another triangle fan so that it will continue to invert
    the stencil buffer. This is also much simpler and more efficient as
    well as being more correct.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=2088

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

commit 7f629f626e25ac7a4678f205c5f0e568582308f8
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Mar 26 22:40:53 2010 +0000

    cogl_read_pixels: Always use GL_RGBA/GL_UNSIGNED_BYTE under GLES
    
    Under GLES glReadPixels is documented to only support GL_RGBA with
    GL_UNSIGNED_BYTE and an implementation specfic format which can be
    fetched with glGet, GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES and
    GL_IMPLEMENTATION_COLOR_READ_TYPE_OES. This patch makes it always read
    using GL_RGBA and GL_UNSIGNED_BYTE and then convert the results if
    neccessary.
    
    This has some room for improvement because it doesn't attempt to use
    the implementation specific format. Also the conversion is somewhat
    wasteful because there are currently no cogl_bitmap_* functions to
    convert without allocating a new buffer so it ends up doing an
    intermediate copy.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=2057

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

commit f944d419a3cb1e893fd9f0166ca17b23d9463452
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Mar 26 22:34:56 2010 +0000

    cogl-bitmap: Fix converting formats with and without alpha channels
    
    _cogl_bitmap_convert_format_and_premult was failing when converting
    from RGBA to RGB and vice versa. _cogl_bitmap_fallback_convert
    converts without altering the premult status so when choosing a new
    format it would copy over the premult bit. However, it did this
    regardless of whether the new format had an alpha channel so when
    converting from RGBA_8888_PRE to RGB_888 it would end up inventing a
    new meaningless format which would be RGB_888_PRE. This patch makes it
    avoid copying the premult flag if the destination has no alpha. It
    doesn't matter if it copies when the source format has no alpha
    because it will always be unset.
    
    _cogl_bitmap_convert_format_and_premult was also breaking when
    converting from RGBA_8888_PRE to RGB_888 because it would think
    RGB_888 is unpremultiplied and try to convert but then
    _cogl_bitmap_fallback_premult wouldn't know how to do the conversion.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=2057

 cogl/cogl-bitmap-fallback.c |    8 ++++++--
 cogl/cogl-bitmap.c          |   10 +++++++++-
 2 files changed, 15 insertions(+), 3 deletions(-)

commit 30c4678ff4c7fdcded9756333cd220a67ba26125
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Apr 15 10:58:28 2010 +0100

    cogl: Implement retained clip stacks
    
    This adds three new internal API functions which can be used to retain
    the clip stack state and restore it later:
    
     _cogl_get_clip_stack
     _cogl_set_clip_stack
     _cogl_clip_stack_copy
    
    The functions are currently internal and not yet used but we may want
    to make them public in future to replace the cogl_clip_stack_save()
    and cogl_clip_stack_restore() APIs.
    
    The get function just returns the handle to the clip stack at the top
    of the stack of stacks and the set function just replaces it.
    
    The copy function makes a cheap copy of an existing stack by taking a
    reference to the top stack entry. This ends up working like a deep
    copy because there is no way to modify entries of a stack but it
    doesn't actually copy the data.

 cogl/cogl-clip-stack.c |   26 ++++++++++++++++++++++++++
 cogl/cogl-clip-stack.h |   19 +++++++++++++++++++
 cogl/cogl-clip-state.c |   34 ++++++++++++++++++++++++++++++++++
 cogl/cogl-clip-state.h |   28 ++++++++++++++++++++++++++++
 4 files changed, 107 insertions(+), 0 deletions(-)

commit 84b87e811e0152dfd6a55930c62d1211f808b8e1
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Apr 15 10:27:43 2010 +0100

    cogl-clip-stack: Convert to be a CoglHandle
    
    CoglClipStacks can now be reference counted via a CoglHandle. The
    ClipClipState now stores handles in the list rather than CoglClipStack
    pointers.

 cogl/cogl-clip-stack.c |   28 +++++++++++++++++++++-------
 cogl/cogl-clip-stack.h |   17 ++++++-----------
 cogl/cogl-clip-state.c |   16 ++++++++--------
 3 files changed, 35 insertions(+), 26 deletions(-)

commit f6f375cb369266b34a5c766b6d964356981dd852
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Apr 14 19:41:08 2010 +0100

    Separate out CoglClipStackState from cogl-clip-stack.c
    
    CoglClipStackState has now been renamed to CoglClipState and is moved
    to a separate file. CoglClipStack now just maintains a stack and
    doesn't worry about the rest of the state. CoglClipStack sill contains
    the code to flush the stack to GL.

 cogl/Makefile.am                |    2 +
 cogl/cogl-clip-stack.c          |  349 +++-------------------------------
 cogl/cogl-clip-stack.h          |   37 +++--
 cogl/cogl-clip-state.c          |  405 +++++++++++++++++++++++++++++++++++++++
 cogl/cogl-clip-state.h          |   50 +++++
 cogl/cogl-framebuffer-private.h |    6 +-
 cogl/cogl-framebuffer.c         |   10 +-
 cogl/cogl-path.c                |    4 +-
 cogl/cogl.c                     |    2 +-
 9 files changed, 519 insertions(+), 346 deletions(-)

commit 07a76aacfbdb8ac1d1e19c18eaacf41b87cee1a5
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Apr 14 18:47:25 2010 +0100

    cogl-slip-stack: Store clip window rect entries in Cogl coordinates
    
    When glScissor is called it needs to pass coordinates in GL's
    coordinate space where the origin is the bottom left. Previously this
    conversion was done before storing the window rect in the clip
    stack. However this might make it more difficult if we want to be able
    to grab a handle to a clip stack and use it in different circumstances
    later. This patch moves the coordinate conversion to inside the clip
    state flushing code.

 cogl/cogl-clip-stack.c |   57 +++++++++++++++++++++++++++---------------------
 1 files changed, 32 insertions(+), 25 deletions(-)

commit 2f631464743400ee4447ac872012fa85cc2c30ff
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Apr 14 15:42:57 2010 +0100

    cogl-clip-stack: Store window rect entries as ints not floats
    
    The window rectangles are passed in as integers so there is no point
    in converting them to floats when storing a stack entry for them.

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

commit 71fdc54dde65f87f55a7c3da795a5b3d81ee06e2
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Apr 14 13:17:26 2010 +0100

    cogl-clip-stack: Use reference counted stack entries
    
    The stack is now stored as a list of reference counted entries.
    Instead of using a GList, each entry now contains a link with a
    reference to its parent. The idea is that this would allow copying
    stacks with a shared ancestry.
    
    Previously the code flushed the state by finding the bottom of the
    stack and then applying each entry by walking back up to the top. This
    is slightly harder to do now because the list is no longer
    doubly-linked. However I don't think it matters which order the
    entries are applied so I've just changed it to apply them in reverse
    order.
    
    There was also a restriction that if ever the stencil buffer is used
    then we could no longer use clip planes for any subsequent entries. I
    don't think this makes sense because it should always work as long as
    it doesn't attempt to use the clip planes more than once. I've
    therefore removed the restriction.

 cogl/cogl-clip-stack.c |  207 ++++++++++++++++++++++++++++++++++--------------
 1 files changed, 149 insertions(+), 58 deletions(-)

commit ecf65cd4a5c904918aba419db2461c9a4527c83b
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Apr 13 17:26:03 2010 +0100

    cogl-atlas-texture: Fix a memory leak
    
    The CoglAtlasTexture struct was not being freed in
    _cogl_atlas_texture_free so there would be a small leak whenever a
    texture was destroyed.
    
    Thanks to Robert Bragg for spotting this.

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

commit 3769862323f71fc04d8352e32fc385b1c916e37f
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Apr 1 18:35:32 2010 +0100

    cogl-material: Use CLAMP_TO_EDGE for WRAP_AUTOMATIC unless overriden
    
    CoglMaterial now sets GL_CLAMP_TO_EDGE if WRAP_MODE_AUTOMATIC is used
    unless it is overridden when the material is flushed. The primitives
    are still expected to expose repeat semantics so no user visible
    changes are made. The idea is that drawing non-repeated textures is
    the most common case so if we make clamp_to_ege the default then we
    will reduce the number of times we have to override the
    material. Avoiding overrides will become important if the overriding
    mechanism is replaced with one where the primitive is expected to copy
    the material and change that instead.

 cogl/cogl-material.c      |    6 +-
 cogl/cogl-primitives.c    |  104 ++++++++++++++++++++++++++++++++++----------
 cogl/cogl-vertex-buffer.c |   35 ++++++++++++++-
 3 files changed, 115 insertions(+), 30 deletions(-)

commit e007bc5358e19612bb5c8176733c1d1bb9dd66c8
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Apr 1 11:31:33 2010 +0100

    cogl-material: Add support for setting the wrap mode for a layer
    
    Previously, Cogl's texture coordinate system was effectively always
    GL_REPEAT so that if an application specifies coordinates outside the
    range 0→1 it would get repeated copies of the texture. It would
    however change the mode to GL_CLAMP_TO_EDGE if all of the coordinates
    are in the range 0→1 so that in the common case that the whole texture
    is being drawn with linear filtering it will not blend in edge pixels
    from the opposite sides.
    
    This patch adds the option for applications to change the wrap mode
    per layer. There are now three wrap modes: 'repeat', 'clamp-to-edge'
    and 'automatic'. The automatic map mode is the default and it
    implements the previous behaviour. The wrap mode can be changed for
    the s and t coordinates independently. I've tried to make the
    internals support setting the r coordinate but as we don't support 3D
    textures yet I haven't exposed any public API for it.
    
    The texture backends still have a set_wrap_mode virtual but this value
    is intended to be transitory and it will be changed whenever the
    material is flushed (although the backends are expected to cache it so
    that it won't use too many GL calls). In my understanding this value
    was always meant to be transitory and all primitives were meant to set
    the value before drawing. However there were comments suggesting that
    this is not the expected behaviour. In particular the vertex buffer
    drawing code never set a wrap mode so it would end up with whatever
    the texture was previously used for. These issues are now fixed
    because the material will always set the wrap modes.
    
    There is code to manually implement clamp-to-edge for textures that
    can't be hardware repeated. However this doesn't fully work because it
    relies on being able to draw the stretched parts using quads with the
    same values for tx1 and tx2. The texture iteration code doesn't
    support this so it breaks. This is a separate bug and it isn't
    trivially solved.
    
    When flushing a material there are now extra options to set wrap mode
    overrides. The overrides are an array of values for each layer that
    specifies an override for the s, t or r coordinates. The primitives
    use this to implement the automatic wrap mode. cogl_polygon also uses
    it to set GL_CLAMP_TO_BORDER mode for its trick to render sliced
    textures. Although this code has been added it looks like the sliced
    trick has been broken for a while and I haven't attempted to fix it
    here.
    
    I've added a constant to represent the maximum number of layers that a
    material supports so that I can size the overrides array. I've set it
    to 32 because as far as I can tell we have that limit imposed anyway
    because the other flush options use a guint32 to store a flag about
    each layer. The overrides array ends up adding 32 bytes to each flush
    options struct which may be a concern.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=2063

 cogl/cogl-journal-private.h          |    2 +
 cogl/cogl-journal.c                  |    7 +
 cogl/cogl-material-private.h         |   56 +++++++--
 cogl/cogl-material.c                 |  221 ++++++++++++++++++++++++++++++++-
 cogl/cogl-material.h                 |  104 ++++++++++++++++
 cogl/cogl-primitives.c               |  174 ++++++++++++++++++++++-----
 cogl/cogl-texture-2d-sliced.c        |    4 -
 cogl/cogl-texture-2d.c               |    4 -
 doc/reference/cogl/cogl-sections.txt |    5 +
 9 files changed, 524 insertions(+), 53 deletions(-)

commit fb7f1a7fd63c537d473a33557603bcd63745398e
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Mar 25 17:29:22 2010 +0000

    Split the wrap mode of _cogl_texture_set_wrap_mode into three
    
    GL supports setting different wrap modes for the s, t and r
    coordinates so we should design the backend interface to support that
    also. The r coordinate is not currently used by any of the backends
    but we might as well have it to make life easier if we ever add
    support for 3D textures.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=2063

 cogl/cogl-atlas-texture.c             |   13 +++++++++----
 cogl/cogl-primitives.c                |   16 ++++++++++++----
 cogl/cogl-sub-texture.c               |   13 +++++++++----
 cogl/cogl-texture-2d-private.h        |    3 ++-
 cogl/cogl-texture-2d-sliced-private.h |    3 ++-
 cogl/cogl-texture-2d-sliced.c         |   31 ++++++++++++++++++++-----------
 cogl/cogl-texture-2d.c                |   26 ++++++++++++++++----------
 cogl/cogl-texture-private.h           |   13 +++++++++----
 cogl/cogl-texture.c                   |   11 ++++++++---
 9 files changed, 87 insertions(+), 42 deletions(-)

commit 908be0480cb8f1d9f3da50a962e9064f2252b261
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Apr 1 20:06:30 2010 +0100

    cogl: Make private members really hard to accidentally use
    
    CoglColor and CoglMatrix have public declarations with private members
    so that we are free to change the implementation but the structures
    could still be allocated on the stack in applications. However it's
    quite easy not to realise the members are private and then access them
    directly. This patch wraps the members in a macro which redefines the
    symbol name when including the header outside of the clutter source.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=2065

 cogl/cogl-matrix.h |    9 +++++----
 cogl/cogl-types.h  |   24 +++++++++++++++++-------
 2 files changed, 22 insertions(+), 11 deletions(-)

commit dedb753d3075353939840a13ab3c6e850dabfc6f
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Apr 12 15:16:58 2010 +0100

    CoglMatrix: Don't make the matrix fields private
    
    The xx, yx, zx etc fields are meant to be read-only but they were
    marked as private with the gtk-doc annotation. This patch moves the
    private marker so that the 16 float member fields are public but the
    type, inverted matrix, flags and padding are not.

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

commit 232c960b67f1802b6bfe61ae70f3b6df5332762d
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Apr 12 12:06:03 2010 +0100

    Fix indentation in CoglMatrix
    
    The members of CoglMatrix were indented by 4 characters instead of 2.

 cogl/cogl-matrix.h |   54 ++++++++++++++++++++++++++--------------------------
 1 files changed, 27 insertions(+), 27 deletions(-)

commit 067a520f26116759fc9717bbbb74b4c2c1590092
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Apr 8 17:43:27 2010 +0100

    cogl: Support retained paths
    
    This adds three new API calls:
    
      CoglHandle cogl_path_get()
      void cogl_path_set(CoglHandle path)
      CoglHandle cogl_path_copy(CoglHandle path)
    
    All of the fields relating to the path have been moved from the Cogl
    context to a new CoglPath handle type. The cogl context now just
    contains a CoglPath handle. All of the existing path commands
    manipulate the data in the current path handle. cogl_path_new now just
    creates a new path handle and unrefs the old one.
    
    The path handle can be stored for later with cogl_path_get. The path
    can then be copied with cogl_path_copy. Internally it implements
    copy-on-write semantics with an extra optimisation that it will only
    copy the data if the new path is modified, but not if the original
    path is modified. It can do this because the only way to modify a path
    is by appending to it so the copied path is able to store its own path
    length and only render the nodes up to that length. For this to work
    the copied path also needs to keep its own copies of the path extents
    because the parent path may change these by adding nodes.
    
    The clip stack now uses the cogl_path_copy mechanism to store paths in
    the stack instead of directly copying the data. This should save some
    memory and processing time.

 cogl/Makefile.am                     |    1 +
 cogl/cogl-clip-stack.c               |   37 +---
 cogl/cogl-context.c                  |    8 +-
 cogl/cogl-context.h                  |    7 +-
 cogl/cogl-internal.h                 |   28 ---
 cogl/cogl-path-private.h             |   96 ++++++++++
 cogl/cogl-path.c                     |  333 +++++++++++++++++++++++++---------
 cogl/cogl-path.h                     |   46 +++++
 doc/reference/cogl/cogl-sections.txt |    3 +
 9 files changed, 413 insertions(+), 146 deletions(-)

commit d1353b3c1a6ec020ce74c30255fc3777313571c1
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Apr 8 14:37:01 2010 +0100

    cogl: renames cogl_multiply_matrix to cogl_transform
    
    Although cogl_multiply_matrix was consistent with OpenGL, after further
    consideration it was agreed that cogl_transform is a better name. Given
    that it's in the global cogl_ namespace cogl_transform seems more self
    documenting.

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

commit 58e4ec07988433f6f17a1a45cd96ce25aa641aca
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Apr 1 13:15:12 2010 +0100

    docs: This improves the documentation for cogl_push_framebuffer
    
    This adds an example of how to setup a Clutter style 2D coordinate space
    and clarifies what state is owned by a framebuffer. (projection,
    modelview, viewport and clip stack)
    
    When we expose more cogl_framebuffer API this example will hopefully be
    migrated into a more extensive introduction to using framebuffers.

 cogl/cogl.h |   85 ++++++++++++++++++++++++++++++++++++++++++++++++++++-------
 1 files changed, 75 insertions(+), 10 deletions(-)

commit c49aeed2bf2de0e59b15a8a8f45d290fded6bc77
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Mar 19 09:55:30 2010 +0000

    cogl: move cogl_set_source* funcs into cogl.c
    
    Previously cogl_set_source and cogl_set_source_texture were in
    cogl-material.c and the cogl_set_source_color* funcs were in
    cogl-color.c. Originally this was because cogl.c was duplicated between
    the GL and GLES backends and we didn't want to add to the amount of
    duplicated code, but these files have since been consolidated into one
    cogl.c.

 cogl/cogl-color.c    |   24 --------------------
 cogl/cogl-material.c |   36 ------------------------------
 cogl/cogl.c          |   60 +++++++++++++++++++++++++++++++++++++++++++++++++-
 3 files changed, 59 insertions(+), 61 deletions(-)

commit 6c8c0714f67866c42e1d7b4e1e5da60f16647f77
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Mar 19 09:30:59 2010 +0000

    cogl: adds convenience cogl_multiply_matrix function
    
    Quite often it's desirable to be able to multiply the current modelview
    matrix by an arbitrary matrix. Currently though you have to first
    explicitly call cogl_get_modelview_matrix to get the current modelview
    into a temporary variable, then you need to multiply it with your matrix
    using cogl_matrix_multiply and finally use cogl_set_modelview_matrix to
    make the result be the new modelview. This new convenience function lets
    more efficiently skip the first get and last set steps.

 cogl/cogl.c |    8 ++++++++
 cogl/cogl.h |   11 +++++++++++
 2 files changed, 19 insertions(+), 0 deletions(-)

commit 1f715ad153faf54b8c772ac7e3b770316f6d79f0
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Mar 19 09:16:08 2010 +0000

    cogl: rename cogl_enable to _cogl_enable
    
    Every now and then someone sees the cogl_enable API and gets confused,
    thinking its public API so this renames the symbol to be clear that it's
    is an internal only API.

 cogl/cogl-context.c       |    2 +-
 cogl/cogl-internal.h      |    4 +-
 cogl/cogl-journal.c       |    6 ++--
 cogl/cogl-material.c      |    2 +-
 cogl/cogl-path.c          |   10 ++++----
 cogl/cogl-primitives.c    |    2 +-
 cogl/cogl-vertex-buffer.c |    2 +-
 cogl/cogl.c               |   52 ++++++++++++++++++++++----------------------
 8 files changed, 40 insertions(+), 40 deletions(-)

commit 40155e64d8c604de5b120dfe75330e632b517955
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Thu Mar 25 09:45:59 2010 +0000

    docs: Add 1.4 index to the API references
    
    Now that master has branched for the 1.3 development cycle.

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

commit 93754d8dc04d7841e0b51e1750f68f015c9e4e71
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Thu Mar 25 09:33:26 2010 +0000

    Use begin/end macros in cogl-primitives.h
    
    Protect the people using a C++ compiler from the dark abyss of C code.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=2049

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

commit e573eaf2ed8c928d9cfa5a7db393cf00b75dba67
Author: Owen W. Taylor <otaylor@fishsoup.net>
Date:   Tue Mar 16 20:38:53 2010 -0400

    Switch texture units before calling _cogl_texture_set_filters()
    
    When setting up the state for a layer, we need to switch texture
    units before we do anything that might bind the texture, or
    we'll bind the wrong texture to the previous unit.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=2033
    
    Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

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

commit e1aec639800046236605a27f662744b245e72c7b
Author: Owen W. Taylor <otaylor@fishsoup.net>
Date:   Wed Mar 17 15:39:55 2010 -0400

    Set pixel store parameters before calling glGetTexImage
    
    We need to set up the rowstride and alignment properly in
    CoglTexture2D before reading texture data.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=2036
    
    Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

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

commit 89519a1d33e51d6db06c89a9e9d43dd7473210de
Author: Colin Walters <walters@verbum.org>
Date:   Fri Mar 12 17:39:27 2010 -0500

    Return and warn if a handle's refcount is <= 0
    
    This makes it more likely consumers notice invalid unreferences.
    GObject has the same assertion.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=2029
    
    Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

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

commit 9fc9aa562e7ca0def0d1118802860333e3cbdb89
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Mar 9 16:37:52 2010 -0800

    cogl-texture-2d: Determine format before checking texture support
    
    When entering cogl_texture_2d_new_from_bitmap the internal format can
    be COGL_PIXEL_FORMAT_ANY. This was causing _cogl_texture_2d_can_create
    to use an invalid GL format type. Mesa apparently ignores this but it
    was causing errors when Cogl is compiled with debugging under NVidia.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=2026

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

commit 770ca1311d5c4638b435ece90843f89b4d3fa0d7
Author: Owen W. Taylor <otaylor@fishsoup.net>
Date:   Mon Mar 1 16:49:04 2010 -0500

    Fix checks for out-of-bounds coordinates and repeats
    
    Add a return result from CoglTexture.transform_quad_coords_to_gl(),
    so that we can properly determine the nature of repeats in
    the face of GL_TEXTURE_RECTANGLE_ARB, where the returned
    coordinates are not normalized.
    
    The comment "We also work out whether any of the texture
    coordinates are outside the range [0.0,1.0]. We need to do
    this after calling transform_coords_to_gl in case the texture
    backend is munging the coordinates (such as in the sub texture
    backend)." is disregarded and removed, since it's actually
    the virtual coordinates that determine whether we repeat,
    not the GL coordinates.
    
    Warnings about disregarded layers are used in all cases where
    applicable, including for subtextures.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=2016
    
    Signed-off-by: Neil Roberts <neil@linux.intel.com>

 cogl/cogl-atlas-texture.c     |    2 +-
 cogl/cogl-primitives.c        |   40 ++++++++++++++--------------------------
 cogl/cogl-sub-texture.c       |    9 ++++-----
 cogl/cogl-texture-2d-sliced.c |   22 +++++++++++++++++++---
 cogl/cogl-texture-2d.c        |   15 ++++++++++++---
 cogl/cogl-texture-private.h   |   18 +++++++++++++++---
 cogl/cogl-texture.c           |    2 +-
 7 files changed, 66 insertions(+), 42 deletions(-)

commit ec9adfd1d400e3c783cd75ea2893575585f08ce3
Author: Owen W. Taylor <otaylor@fishsoup.net>
Date:   Mon Mar 1 14:04:20 2010 -0500

    CoglTexture2DSliced: Handle TEXTURE_RECTANGLE_ARB
    
    In _cogl_texture_2d_sliced_foreach_sub_texture_in_region(), don't
    assert that the target is GL_TEXTURE_2D; instead conditionalize
    normalization on the target.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=2015

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

commit edecd668c86486409dce168655a3ea0f9b675df2
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Wed Mar 3 17:02:51 2010 +0000

    Update stb_image.c
    
    Upstream "released" 1.18.

 cogl/stb_image.c | 1605 +++++++++++++++++++++++++++++-------------------------
 1 files changed, 862 insertions(+), 743 deletions(-)
