spec=1.0.0..1.2.0
commit c3917c8da587f7ad0e5a6ffe6b383355fcf2821b
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Mar 2 02:07:40 2010 +0000

    cogl debug: Adds missing guards around debug cogl_args[]
    
    commit 511e5ceb516dc accidentally removed the #ifdef COGL_ENABLE_DEBUG
    guards around the "cogl-debug" and "cogl-no-debug" cogl_args[] which
    this patch restores.

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

commit d32b4b1c127cf019787e6cf0dae608f9175a88da
Merge: d29b3c8 84223c8
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Tue Mar 2 12:25:45 2010 +0000

    Merge branch 'eglnative-update'
    
    * eglnative-update:
      eglnative: Add CLUTTER_FB_DEVICE
      eglnative: Update implementation

commit d29b3c8f81d235aeac648df330bbd1a3acedfee6
Author: Owen W. Taylor <otaylor@fishsoup.net>
Date:   Mon Mar 1 13:54:03 2010 -0500

    Fall back in _cogl_texture_2d_new_from_bitmap()
    
    Just like _cogl_texture_2d_new_with_size(),
    _cogl_texture_2d_new_from_bitmap() needs to check if an unsliced
    texture can be created at the given size, or if hardware
    limitations prevent this.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=2014
    
    Signed-off-by: Neil Roberts <neil@linux.intel.com>

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

commit 84223c855db7b574240b76a0eb2925f99f7cde15
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Mar 1 18:08:41 2010 +0000

    cogl: Support any format in cogl_read_pixels
    
    cogl_read_pixels() no longer asserts that the format passed in is
    RGBA_8888 but instead accepts any format. The appropriate GL enums for
    the format are passed to glReadPixels so OpenGL should be perform a
    conversion if neccessary.
    
    It currently assumes glReadPixels will always give us premultiplied
    data. This will usually be correct because the result of the default
    blending operations for Cogl ends up with premultiplied data in the
    framebuffer. However it is possible for the framebuffer to be in
    whatever format depending on what CoglMaterial is used to render to
    it. Eventually we may want to add a way for an application to inform
    Cogl that the framebuffer is not premultiplied in case it is being
    used for some special purpose.
    
    If the requested format is not premultiplied then Cogl will convert
    it. The tests have been changed to read the data as premultiplied so
    that they won't be affected by the conversion. Picking in Clutter has
    been changed to use COGL_PIXEL_FORMAT_RGB_888 because it doesn't need
    the alpha component. clutter_stage_read_pixels is left unchanged
    because the application can't specify a format for that so it seems to
    make most sense to store unpremultiplied values.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=1959

 cogl/cogl.c |   84 ++++++++++++++++++++++++++++++++++++++++-------------------
 cogl/cogl.h |    8 +++++-
 2 files changed, 64 insertions(+), 28 deletions(-)

commit 672a77453f93c53df8a3855fbdfcd09d1861fe89
Merge: 72f4ddf 984c19a
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Mar 1 15:37:12 2010 +0000

    Merge branch 'stage-min-size-rework'
    
    * stage-min-size-rework:
      docs: Update minimum size accessors
      actor: Use the TOPLEVEL flag instead of a type check
      [stage] Use min-width/height props for min size

commit 72f4ddf5324137f451bd54192f687f2eae8efee4
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Mar 1 12:56:10 2010 +0000

    Remove mentions of the FSF address
    
    Since using addresses that might change is something that finally
    the FSF acknowledge as a plausible scenario (after changing address
    twice), the license blurb in the source files should use the URI
    for getting the license in case the library did not come with it.
    
    Not that URIs cannot possibly change, but at least it's easier to
    set up a redirection at the same place.
    
    As a side note: this commit closes the oldes bug in Clutter's bug
    report tool.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=521

 cogl/cogl-atlas-texture-private.h         |    6 +++---
 cogl/cogl-atlas-texture.c                 |    6 +++---
 cogl/cogl-atlas.c                         |    6 +++---
 cogl/cogl-atlas.h                         |    6 +++---
 cogl/cogl-bitmap-fallback.c               |    6 +++---
 cogl/cogl-bitmap-pixbuf.c                 |    6 +++---
 cogl/cogl-bitmap-private.h                |    6 +++---
 cogl/cogl-bitmap.c                        |    6 +++---
 cogl/cogl-bitmap.h                        |    6 +++---
 cogl/cogl-blend-string.c                  |    6 +++---
 cogl/cogl-blend-string.h                  |    6 +++---
 cogl/cogl-buffer-private.h                |    6 +++---
 cogl/cogl-buffer.c                        |    6 +++---
 cogl/cogl-buffer.h                        |    6 +++---
 cogl/cogl-clip-stack.c                    |    6 +++---
 cogl/cogl-clip-stack.h                    |    6 +++---
 cogl/cogl-color.c                         |    6 +++---
 cogl/cogl-color.h                         |    6 +++---
 cogl/cogl-context.c                       |    6 +++---
 cogl/cogl-context.h                       |    6 +++---
 cogl/cogl-debug.c                         |    6 +++---
 cogl/cogl-debug.h                         |    6 +++---
 cogl/cogl-deprecated.h                    |    6 +++---
 cogl/cogl-feature-private.c               |    6 +++---
 cogl/cogl-feature-private.h               |    6 +++---
 cogl/cogl-fixed.c                         |    6 +++---
 cogl/cogl-fixed.h                         |    6 +++---
 cogl/cogl-framebuffer-private.h           |    6 +++---
 cogl/cogl-framebuffer.c                   |    6 +++---
 cogl/cogl-handle.h                        |    6 +++---
 cogl/cogl-internal.h                      |    6 +++---
 cogl/cogl-journal-private.h               |    6 +++---
 cogl/cogl-journal.c                       |    6 +++---
 cogl/cogl-material-private.h              |    6 +++---
 cogl/cogl-material.c                      |    6 +++---
 cogl/cogl-material.h                      |    6 +++---
 cogl/cogl-matrix-mesa.c                   |    6 +++---
 cogl/cogl-matrix-mesa.h                   |    6 +++---
 cogl/cogl-matrix-private.h                |    6 +++---
 cogl/cogl-matrix-stack.c                  |    6 +++---
 cogl/cogl-matrix-stack.h                  |    6 +++---
 cogl/cogl-matrix.c                        |    6 +++---
 cogl/cogl-matrix.h                        |    6 +++---
 cogl/cogl-offscreen.h                     |    6 +++---
 cogl/cogl-path.c                          |    6 +++---
 cogl/cogl-path.h                          |    6 +++---
 cogl/cogl-pixel-buffer-private.h          |    6 +++---
 cogl/cogl-pixel-buffer.c                  |    6 +++---
 cogl/cogl-pixel-buffer.h                  |    6 +++---
 cogl/cogl-primitives.c                    |    6 +++---
 cogl/cogl-primitives.h                    |    6 +++---
 cogl/cogl-profile.h                       |    6 +++---
 cogl/cogl-shader.h                        |    6 +++---
 cogl/cogl-spans.c                         |    6 +++---
 cogl/cogl-spans.h                         |    6 +++---
 cogl/cogl-sub-texture-private.h           |    6 +++---
 cogl/cogl-sub-texture.c                   |    6 +++---
 cogl/cogl-texture-2d-private.h            |    6 +++---
 cogl/cogl-texture-2d-sliced-private.h     |    6 +++---
 cogl/cogl-texture-2d-sliced.c             |    6 +++---
 cogl/cogl-texture-2d.c                    |    6 +++---
 cogl/cogl-texture-driver.h                |    6 +++---
 cogl/cogl-texture-private.h               |    6 +++---
 cogl/cogl-texture.c                       |    6 +++---
 cogl/cogl-texture.h                       |    6 +++---
 cogl/cogl-types.h                         |    6 +++---
 cogl/cogl-util.c                          |    6 +++---
 cogl/cogl-util.h                          |    6 +++---
 cogl/cogl-vertex-buffer-private.h         |    6 +++---
 cogl/cogl-vertex-buffer.c                 |    6 +++---
 cogl/cogl-vertex-buffer.h                 |    6 +++---
 cogl/cogl.c                               |    6 +++---
 cogl/cogl.h                               |    6 +++---
 cogl/driver/gl/cogl-context-driver.c      |    6 +++---
 cogl/driver/gl/cogl-context-driver.h      |    6 +++---
 cogl/driver/gl/cogl-defines.h.in          |    6 +++---
 cogl/driver/gl/cogl-feature-functions.h   |    6 +++---
 cogl/driver/gl/cogl-program.c             |    6 +++---
 cogl/driver/gl/cogl-program.h             |    6 +++---
 cogl/driver/gl/cogl-shader-private.h      |    6 +++---
 cogl/driver/gl/cogl-shader.c              |    6 +++---
 cogl/driver/gl/cogl-texture-driver.c      |    6 +++---
 cogl/driver/gl/cogl.c                     |    6 +++---
 cogl/driver/gles/cogl-context-driver.c    |    6 +++---
 cogl/driver/gles/cogl-context-driver.h    |    6 +++---
 cogl/driver/gles/cogl-defines.h.in        |    6 +++---
 cogl/driver/gles/cogl-feature-functions.h |    6 +++---
 cogl/driver/gles/cogl-gles2-wrapper.c     |    6 +++---
 cogl/driver/gles/cogl-gles2-wrapper.h     |    6 +++---
 cogl/driver/gles/cogl-program.c           |    6 +++---
 cogl/driver/gles/cogl-program.h           |    6 +++---
 cogl/driver/gles/cogl-shader-private.h    |    6 +++---
 cogl/driver/gles/cogl-shader.c            |    6 +++---
 cogl/driver/gles/cogl-texture-driver.c    |    6 +++---
 cogl/driver/gles/cogl.c                   |    6 +++---
 cogl/winsys/cogl-eglnative.c              |    6 +++---
 cogl/winsys/cogl-eglx.c                   |    6 +++---
 cogl/winsys/cogl-fruity.c                 |    6 +++---
 cogl/winsys/cogl-glx.c                    |    6 +++---
 cogl/winsys/cogl-osx.c                    |    6 +++---
 cogl/winsys/cogl-sdl.c                    |    6 +++---
 cogl/winsys/cogl-win32.c                  |    6 +++---
 cogl/winsys/cogl-winsys.h                 |    6 +++---
 103 files changed, 309 insertions(+), 309 deletions(-)

commit 82fd07c54af5f6641fbf5e0952c930ec32ef70c6
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Feb 23 14:45:44 2010 +0000

    cogl-vertex-buffer: Add support for unsigned int indices
    
    This adds a COGL_INDICES_TYPE_UNSIGNED_INT enum value so that unsigned
    ints can be used with cogl_vertex_buffer_indices_new.  Unsigned ints
    are not supported in core on GLES so a feature flag has also been
    added to advertise this. GLES only sets the feature if the
    GL_OES_element_index_uint extension is available. It is an error to
    call indices_new() with unsigned ints unless the feature is
    advertised.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=1998

 cogl/cogl-types.h                         |    6 +++++-
 cogl/cogl-vertex-buffer.c                 |   17 ++++++++++++++++-
 cogl/cogl-vertex-buffer.h                 |    8 ++++++++
 cogl/driver/gl/cogl.c                     |    3 ++-
 cogl/driver/gles/cogl-feature-functions.h |    6 ++++++
 5 files changed, 37 insertions(+), 3 deletions(-)

commit b583083a3fc4ec5368ee662b9338c8f32a59daaf
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Feb 24 11:13:55 2010 +0000

    gles2: Remove the special wrapper for glBindTexture
    
    Previously the GLES2 backend needed a special wrapper for
    glBindTexture because it needed to know the internal GL format of the
    texture in order to correctly implement the GL_MODULATE texture env
    mode. When GL_MODULATE is used then the RGB values are taken from the
    previous texture layer rather than being fetched from the
    texture. However since the material API was added Cogl no longer uses
    the GL_MODULATE texture env mode but instead always uses GL_COMBINE.
    
    Compiling the GLES2 backend broke since the more-texture-backends
    branch merge because the cogl_get_internal_gl_format function was
    removed and there was one place in GLES2 specific code that was using
    this to bind the texture.

 cogl/cogl-material.c                   |   10 ----------
 cogl/cogl-texture-2d-sliced.c          |    5 ++---
 cogl/cogl-texture-driver.h             |    7 -------
 cogl/driver/gl/cogl-texture-driver.c   |   12 ------------
 cogl/driver/gles/cogl-gles2-wrapper.c  |   22 ----------------------
 cogl/driver/gles/cogl-gles2-wrapper.h  |   12 ------------
 cogl/driver/gles/cogl-texture-driver.c |   13 -------------
 7 files changed, 2 insertions(+), 79 deletions(-)

commit cb7a99ac69ac76b62b7cab082105d41442214312
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Feb 24 16:50:32 2010 +0000

    cogl-gles2-wrapper: Add support for the layer combine operations
    
    The texture layer combine functions are now hard coded to GL_COMBINE
    instead of GL_MODULATE. The combine function can be customized with
    all the parameters of GL_COMBINE. A shader is generated to implement
    the given parameters.
    
    Currently it will try to generate code for the constant color but it
    will use a uniform which does not exist.

 cogl/cogl-blend-string.c              |    9 -
 cogl/driver/gles/cogl-gles2-wrapper.c |  382 ++++++++++++++++++++++++++++++---
 cogl/driver/gles/cogl-gles2-wrapper.h |   16 ++
 3 files changed, 371 insertions(+), 36 deletions(-)

commit 7dce5d937290a01c425ace6199e18fce5580f84e
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Feb 24 10:42:59 2010 +0000

    gles2: Implement a wrapper for glGetIntegerv(GL_MAX_TEXTURE_UNITS)
    
    The GLES2 backend for Cogl is failing to compile because
    GL_MAX_TEXTURE_UNITS is not defined. Let's define it and provide a
    wrapper which uses GL_MAX_TEXTURE_IMAGE_UNITS or
    COGL_GLES2_MAX_TEXTURE_UNITS, whichever is the smallest.

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

commit 984c19a6f7b75d0e9068a22b15545260dafba4a5
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Wed Feb 24 11:28:44 2010 +0000

    docs: Detail replacement for cogl_check_extension()
    
    The cogl_check_extension() function has been deprecated, but it's easily
    replaceable with a simple strstr() call.

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

commit f9fe4526ebb79de87c4bf456efbf6f544525f1a6
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Feb 17 18:45:08 2010 +0000

    cogl debug: Adds glViewport call tracing
    
    To aid in the debugging of Clutter stage resize issues this adds a
    COGL_DEBUG=opengl option that will trace "some select OpenGL calls"
    (currently just glViewport calls)

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

commit 5751e4875624d6a68e635f1e20486e54bb17f47e
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Feb 17 17:53:28 2010 +0000

    cogl debug: hint that all debugging paths are G_UNLIKELY
    
    Most Cogl debugging code conditions are marked as G_UNLIKELY with the
    intention of having the CPU branch prediction always assume the
    path is disabled so having debugging support in release binaries has
    negligible overhead.
    
    This patch simply fixes a few cases where we weren't using G_UNLIKELY.

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

commit 210e618e6dc4dcbb302c23d507df889582a8b85e
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Feb 17 14:38:11 2010 +0000

    cogl debug: Makes COGL_DEBUG=all|verbose|help more useful
    
    COGL_DEBUG=all wasn't previously useful as there are several options
    that change the behaviour of Cogl and all together wouldn't help anyone
    debug anything.
    
    This patch makes it so COGL_DEBUG=all|verbose now only enables options
    that don't change the behaviour of Cogl, i.e. they only affect the
    amount of noise we'll print to a terminal.
    
    In addition to that this patch also improves the output from
    COGL_DEBUG=help so we now print a table of options including one liner
    descriptions of what each option enables.

 cogl/cogl-debug.c             |  121 +++++++++++++++++++++++++++++++----------
 cogl/cogl-debug.h             |   37 ++++++-------
 cogl/cogl-texture-2d-sliced.c |    2 +-
 3 files changed, 111 insertions(+), 49 deletions(-)

commit e8eb65319c1b01cf6cf61a0d7a796ca1d304791e
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Tue Feb 23 16:51:26 2010 +0000

    cogl: Add deprecation annotation to CoglMaterial ref/unref
    
    The G_GNUC_DEPRECATED annotation was missing from the material ref and
    unref functions.

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

commit d3a51df0fa23b5c5de9048e317c31df10b856d10
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Feb 17 22:16:17 2010 +0000

    cogl-vertex-buffer: Fix the malloc fallback for indices
    
    The size of the malloc'd buffer for indices when VBOs are not
    available was too small so memory corruption would result if it was
    used.
    
    http://bugzilla.o-hand.com/show_bug.cgi?id=1996

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

commit a4dfa70a0e218f5215fd26935fb3f76be33676e7
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Feb 16 14:53:10 2010 +0000

    cogl_texture_new_from_foreign: improve docs
    
    Improve the explanation of what the x_pot_waste and y_pot_waste
    arguments can be used for.

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

commit e96072c90ac0c800bf9bddaa1d09885f161d229b
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Feb 16 14:23:11 2010 +0000

    cogl-texture: for foreign textures; always trust user geom
    
    We now never query the width and height of the given texture object
    from OpenGL. The problem is that the user may be creating a Cogl
    texture from a texture_from_pixmap object where glTexImage2D was
    never called and the texture_from_pixmap spec doesn't clarify that
    it's reliable to query the width from OpenGL.
    
    This should address:
    http://bugzilla.openedhand.com/show_bug.cgi?id=1502
    
    Thanks to Johan Bilien for reporting

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

commit 1d54ecb8a1fa22b11d23498085ce6404e7baf391
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Feb 17 15:58:32 2010 +0000

    cogl-clip-stack: Round the coords when clipping to a window rect
    
    The size and position of the window rectangle for clipping in
    try_pushing_rect_as_window_rect is calculated by projecting the
    rectangle coordinates. Due to rounding errors, this can end up with
    slightly off numbers like 34.999999. These were then being cast
    directly to an integer so it could end up off by one.
    
    This uses a new macro called COGL_UTIL_NEARBYINT which is a
    replacement for the C99 nearbyint function.

 cogl/cogl-clip-stack.c |    6 +++++-
 cogl/cogl-util.h       |    8 ++++++++
 2 files changed, 13 insertions(+), 1 deletions(-)

commit 47f1b2ebc917f5a6d6e4122c165bd9155acd3fe9
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Feb 16 12:01:18 2010 +0000

    cogl-atlas-texture: Don't use the atlas if FBOs aren't supported
    
    If FBOs aren't supported then it will end up very slow to reorganize
    the atlas. Also currently the CoglTexture2D backend will refuse to
    create any textures anyway so the full atlas texture won't be created.

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

commit 0238be686a51a9a663460ebd2709a14d8791eebd
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Feb 16 11:58:47 2010 +0000

    cogl-atlas-texture: Check for errors when creating the atlas texture
    
    cogl_texture_2d_new may fail in certain circumstances so
    cogl_atlas_texture_reserve_space should detect this and also
    fail. This will cause cogl_texture_new to fallback to a sliced
    texture.
    
    Thanks to Vladimir Ivakin for reporting this problem.

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

commit 9e74b04fbd7f93109ed86bb1de0be7d5a8f09d86
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Mon Feb 8 19:18:36 2010 +0000

    docs: Add 2010 in COGL's Copyright notice
    
    While at it, fix the usage of <year> in <copyright> to let the
    stylesheet do the collation when having several years.

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

commit 3946a91e686cc5746289b25e52d43098e0997722
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Fri Feb 12 17:24:15 2010 +0000

    cogl-buffer: fix compilation for GL ES
    
    In the frenzy of the last 10mins before API freeze, I obviously forgot
    to update the OpenGL path for _cogl_buffer_hints_to_gl_enum(). This
    commit fixes this.

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

commit 1499535fd0f07224a49d6bda118b58487ebdf92c
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Feb 12 15:33:56 2010 +0000

    cogl-atlas-texture: Flush the journal before adding a new texture
    
    When the atlas is reorganised we could potentially be moving around
    textures that are already referenced in the journal. We therefore need
    to flush the journal otherwise they will be rendered with incorrect
    texture coordinates. We also need to flush the journal even if we are
    not reorganizing so that we can rely on the old texture contents
    remaining in the atlas after migrating a texture out.

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

commit 8119c184dabdb31d89cde3fdcdd856c915e9400f
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Feb 12 10:08:51 2010 +0000

    cogl-sub-texture: Optimise taking a sub texture of a sub texture
    
    When creating a Cogl sub-texture, if the full texture is also a sub
    texture it will now just offset the x and y and reference the full
    texture instead. This avoids one level of indirection when rendering
    the texture which reduces the chances of getting rounding errors in
    the calculations.

 cogl/cogl-sub-texture-private.h |   17 +++++++++++++++--
 cogl/cogl-sub-texture.c         |   29 +++++++++++++++++++++++------
 cogl/cogl-texture.h             |    4 ++++
 3 files changed, 42 insertions(+), 8 deletions(-)

commit 395518fb34d5ed1c5555e0c2ce099fdfde20a464
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Fri Feb 12 15:52:07 2010 +0000

    docs: Fixes for Cogl

 cogl/cogl-material.h                 |    1 +
 cogl/cogl-pixel-buffer.h             |    2 +-
 doc/reference/cogl/Makefile.am       |    3 ++-
 doc/reference/cogl/cogl-sections.txt |    8 ++++----
 4 files changed, 8 insertions(+), 6 deletions(-)

commit 6e32d0afdab4dc80b49abb39e7285bca772113f5
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Thu Feb 11 15:24:17 2010 +0000

    analysis: CoglPangoRenderer
    
    Remove unused variables.

 pango/cogl-pango-render.c |   17 +++++++----------
 1 files changed, 7 insertions(+), 10 deletions(-)

commit fbe9e80a07d131a2db663726da5acce814fa4e31
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Feb 12 14:26:33 2010 +0000

    cogl: Cache the value for GL_MAX_TEXTURE_UNITS
    
    The function _cogl_get_max_texture_units is called quite often while
    rendering and it returns a constant value so we might as well cache
    the result. Calling glGetInteger on Mesa can be expensive because it
    flushes a lot of state.

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

commit e48b817b0a674613065d0a6e4b185b8a2bb07c5e
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Feb 11 16:12:26 2010 +0000

    cogl: resolves some low hanging issues flagged by clang
    
    An initial pass over the Cogl source code using the Clang static
    analysis tool flagged a few low hanging issues such as un-used variables
    or redundant initializing of variables which this patch fixes.

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

commit 142128e10730fd6d1485b0756fac53895f313f49
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Feb 11 15:33:01 2010 +0000

    cogl_rectangle: avoid redundant copy of geometry
    
    All the cogl_rectangle* APIs normalize their input into into an array of
    _CoglMutiTexturedRect rectangles and pass these on to our work horse;
    _cogl_rectangles_with_multitexture_coords. The definition of
    _CoglMutiTexturedRect had 4 separate float members, x_1, y_1, x_2 and
    y_2 which meant for some common cases we were having to copy out from an
    array into these members. We are now able to simply point into the users
    array avoiding a copy which seems desirable when submiting lots of
    rectangles.

 cogl/cogl-journal-private.h |    5 +-
 cogl/cogl-journal.c         |   31 ++++++----
 cogl/cogl-primitives.c      |  135 ++++++++++++++++++++++--------------------
 3 files changed, 91 insertions(+), 80 deletions(-)

commit f93e50a2819426c6c921ea7da8d0b232e5ad8285
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Feb 10 22:47:49 2010 +0000

    cogl: explicitly mark cogl_<object>_ref/unref APIs as deprecated
    
    This uses the G_GNUC_DEPRECATED macros to mark the
    cogl_{texture,vertex_buffer,shader}_ref and unref APIs as deprecated.
    Since this flagged that cogl-pango-display-list.c and
    clutter-glx-texture-pixmap.c were still using deprecated _ref/_unref
    APIs they have now been changed to use the cogl_handle_ref/unref API
    instead.

 cogl/cogl-shader.h              |    8 ++++++--
 cogl/cogl-texture.h             |    4 ++--
 cogl/cogl-vertex-buffer.h       |    4 ++--
 pango/cogl-pango-display-list.c |    8 ++++----
 4 files changed, 14 insertions(+), 10 deletions(-)

commit 7d9b733446438d301cf45de539097e236b4b1b1e
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Feb 10 22:30:37 2010 +0000

    cogl: cleanly separate primitives + paths code
    
    The function prototypes for the primitives API were spread between
    cogl-path.h and cogl-texture.h and should have been in a
    cogl-primitives.h.
    
    As well as shuffling the prototypes around into more sensible places
    this commit splits the cogl-path API out from cogl-primitives.c into
    a cogl-path.c

 cogl/Makefile.am       |    3 +
 cogl/cogl-internal.h   |   28 ++
 cogl/cogl-path.c       | 1121 ++++++++++++++++++++++++++++++++++++++++++++++++
 cogl/cogl-path.h       |   35 +--
 cogl/cogl-primitives.c | 1078 ----------------------------------------------
 cogl/cogl-primitives.h |  188 +++++++--
 cogl/cogl-texture.h    |  133 ------
 cogl/cogl.h            |    1 +
 8 files changed, 1317 insertions(+), 1270 deletions(-)

commit ba4b00be42874e3a1af59efaf5426b20ead7519b
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Feb 10 18:18:30 2010 +0000

    cogl: remove redundant _cogl_journal_flush prototype
    
    There was a redundant _cogl_journal_flush function prototype in
    cogl-primitives.h

 cogl/cogl-clip-stack.c        |    1 +
 cogl/cogl-framebuffer.c       |    1 +
 cogl/cogl-journal-private.h   |    5 +++--
 cogl/cogl-material.c          |    1 +
 cogl/cogl-primitives.h        |    3 ---
 cogl/cogl-texture-2d-sliced.c |    1 +
 cogl/cogl-texture-2d.c        |    1 +
 cogl/cogl-vertex-buffer.c     |    1 +
 cogl/driver/gl/cogl-program.c |    1 +
 9 files changed, 10 insertions(+), 5 deletions(-)

commit 0f5f4e8645d12eb6c5ff99c13503f2380740bb10
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Feb 10 01:57:32 2010 +0000

    cogl: improves header and coding style consistency
    
    We've had complaints that our Cogl code/headers are a bit "special" so
    this is a first pass at tidying things up by giving them some
    consistency. These changes are all consistent with how new code in Cogl
    is being written, but the style isn't consistently applied across all
    code yet.
    
    There are two parts to this patch; but since each one required a large
    amount of effort to maintain tidy indenting it made sense to combine the
    changes to reduce the time spent re indenting the same lines.
    
    The first change is to use a consistent style for declaring function
    prototypes in headers. Cogl headers now consistently use this style for
    prototypes:
    
     return_type
     cogl_function_name (CoglType arg0,
                         CoglType arg1);
    
    Not everyone likes this style, but it seems that most of the currently
    active Cogl developers agree on it.
    
    The second change is to constrain the use of redundant glib data types
    in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all
    been replaced with int, unsigned int, float, long, unsigned long and char
    respectively. When talking about pixel data; use of guchar has been
    replaced with guint8, otherwise unsigned char can be used.
    
    The glib types that we continue to use for portability are gboolean,
    gint{8,16,32,64}, guint{8,16,32,64} and gsize.
    
    The general intention is that Cogl should look palatable to the widest
    range of C programmers including those outside the Gnome community so
    - especially for the public API - we want to minimize the number of
    foreign looking typedefs.

 cogl/cogl-atlas-texture.c              |   52 +++---
 cogl/cogl-atlas.c                      |   22 ++-
 cogl/cogl-atlas.h                      |   18 +-
 cogl/cogl-bitmap-fallback.c            |   82 +++++-----
 cogl/cogl-bitmap-pixbuf.c              |   60 +++---
 cogl/cogl-bitmap-private.h             |   30 ++--
 cogl/cogl-bitmap.c                     |   34 ++--
 cogl/cogl-bitmap.h                     |   15 +-
 cogl/cogl-blend-string.c               |   12 +-
 cogl/cogl-blend-string.h               |    4 +-
 cogl/cogl-buffer-private.h             |   14 +-
 cogl/cogl-buffer.c                     |    8 +-
 cogl/cogl-buffer.h                     |   26 ++--
 cogl/cogl-clip-stack.c                 |   16 +-
 cogl/cogl-clip-stack.h                 |   14 +-
 cogl/cogl-color.h                      |   75 +++++---
 cogl/cogl-context.c                    |    2 +-
 cogl/cogl-context.h                    |   10 +-
 cogl/cogl-debug.c                      |    8 +-
 cogl/cogl-debug.h                      |    4 +-
 cogl/cogl-feature-private.c            |   19 +-
 cogl/cogl-feature-private.h            |   14 +-
 cogl/cogl-fixed.c                      |   24 ++--
 cogl/cogl-fixed.h                      |   72 +++++---
 cogl/cogl-handle.h                     |    2 +-
 cogl/cogl-internal.h                   |   32 ++--
 cogl/cogl-journal.c                    |   26 ++--
 cogl/cogl-material-private.h           |   67 ++++---
 cogl/cogl-material.c                   |   22 ++--
 cogl/cogl-material.h                   |  175 +++++++++++-------
 cogl/cogl-matrix.h                     |  110 +++++++-----
 cogl/cogl-path.h                       |  138 ++++++++------
 cogl/cogl-pixel-buffer-private.h       |    9 +-
 cogl/cogl-pixel-buffer.c               |   53 +++---
 cogl/cogl-pixel-buffer.h               |   46 +++---
 cogl/cogl-primitives.c                 |   48 +++---
 cogl/cogl-primitives.h                 |   13 +-
 cogl/cogl-shader.h                     |   96 ++++++----
 cogl/cogl-sub-texture-private.h        |   14 +-
 cogl/cogl-sub-texture.c                |   70 ++++----
 cogl/cogl-texture-2d-private.h         |    4 +-
 cogl/cogl-texture-2d-sliced-private.h  |    6 +-
 cogl/cogl-texture-2d-sliced.c          |  163 +++++++++---------
 cogl/cogl-texture-2d.c                 |   34 ++--
 cogl/cogl-texture-private.h            |    6 +-
 cogl/cogl-texture.c                    |  106 ++++++------
 cogl/cogl-texture.h                    |  220 +++++++++++++----------
 cogl/cogl-types.h                      |   15 +-
 cogl/cogl-util.c                       |   30 ++--
 cogl/cogl-vertex-buffer-private.h      |    2 +-
 cogl/cogl-vertex-buffer.c              |   18 +-
 cogl/cogl-vertex-buffer.h              |    6 +-
 cogl/cogl.c                            |   52 +++---
 cogl/cogl.h                            |  310 +++++++++++++++++++-------------
 cogl/driver/gl/cogl-program.c          |   18 +-
 cogl/driver/gl/cogl-shader.c           |    2 +-
 cogl/driver/gl/cogl-texture-driver.c   |    2 +-
 cogl/driver/gl/cogl.c                  |    8 +-
 cogl/driver/gles/cogl-gles2-wrapper.c  |    6 +-
 cogl/driver/gles/cogl-gles2-wrapper.h  |   12 +-
 cogl/driver/gles/cogl-program.c        |   42 +++---
 cogl/driver/gles/cogl-shader.c         |    4 +-
 cogl/driver/gles/cogl-texture-driver.c |    4 +-
 doc/CODING_STYLE                       |   49 +++++
 64 files changed, 1491 insertions(+), 1184 deletions(-)

commit 10fa7c7ce9a69b733e4652a51e101a98911d5bb8
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Feb 5 16:32:19 2010 +0000

    cogl: deprecates cogl_check_extension
    
    OpenGL is an implementation detail for Cogl so it's not appropriate to
    expose OpenGL extensions through the Cogl API.
    
    Note: Clutter is currently still using this API, because it is still
    doing raw GL calls in ClutterGLXTexturePixmap, so this introduces a
    couple of (legitimate) build warnings while compiling Clutter.

 cogl/cogl-feature-private.c |    4 ++--
 cogl/cogl-internal.h        |    1 +
 cogl/cogl.c                 |   32 ++++++++++++++++++++++++++++++++
 cogl/cogl.h                 |   11 ++++++++++-
 cogl/driver/gl/cogl.c       |   31 +++----------------------------
 cogl/driver/gles/cogl.c     |   25 -------------------------
 6 files changed, 48 insertions(+), 56 deletions(-)

commit f74f4bdc2bcf885c53d8c07c9a25dac7d5ce9505
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Feb 11 14:20:48 2010 +0000

    cogl: Add a fallback for when the signbit macro is missing
    
    The signbit macro is defined in C99 so it should be available but some
    versions of GCC don't appear to define it by default. If it's not
    available we can use a hack to test the bit directly.

 cogl/cogl-sub-texture.c |    2 +-
 cogl/cogl-texture-2d.c  |    2 +-
 cogl/cogl-util.h        |   27 ++++++++++++++++++++++++++-
 3 files changed, 28 insertions(+), 3 deletions(-)

commit a0a40f07b35015a46b4dcd927da13c1639a27fd0
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Feb 10 12:41:09 2010 +0000

    cogl-material: Layers are not equal if the filters aren't equal
    
    A material layer can not be considered equal if it is using different
    texture filtering modes. This was causing problems where rectangles
    with different filters would end up batched together and then rendered
    with the wrong filter mode.

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

commit 282abe91f79fc37ec5ed840e248f7bc563b1cfaa
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Tue Feb 9 17:07:08 2010 +0000

    cogl: Move material_copy() out of the deprecated section
    
    We strongly suggest people should be using cogl_material_copy(), but it
    was hidden behind the deprecation guards.

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

commit 0145562cadf233492a5e37cee7bca7e1762f125d
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Tue Feb 9 16:57:14 2010 +0000

    Fix some compiler warnings
    
    GCC complains that some variable might be used uninitialized.

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

commit d3948fab8c3d3e63e2b4da3ffa9100cca99031e4
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Feb 9 16:30:28 2010 +0000

    cogl-bitmap: Remove const from premult_alpha_last_four_pixels_sse2
    
    The function modifies the pixels pointed by p in-place so the pointer
    can not be constant. The compiler was accepting this because the
    modification is done from inline assembler.

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

commit 62fa1f9c2892df70477b7746a3a5f197d63dcbf7
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Tue Feb 9 15:29:29 2010 +0000

    docs: Clean up the unused symbols for Cogl
    
    Gtk-doc is reporting a lot of false positives in the unused text file,
    mostly because of new private files that have been added to Cogl but not
    to the gtk-doc ignore list for the Cogl API reference.
    
    Once the false positives have been removed we have a couple of really
    missing symbols that should be added to the cogl-sections.txt file.

 doc/reference/cogl/Makefile.am       |   54 +++++++++++++++++++---------------
 doc/reference/cogl/cogl-sections.txt |    7 ++++
 2 files changed, 37 insertions(+), 24 deletions(-)

commit 82c6be52690e33359ab8fb1ea08b94afdcbc753d
Author: Bastian Winkler <buz@netbuz.org>
Date:   Tue Feb 9 15:19:03 2010 +0100

    cogl-buffer: Use correct argument types in cogl_buffer_set_data_EXP
    
    offset and size arguments are gsize in cogl-buffer.h
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=1980
    
    Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

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

commit ea0d0f12312d7c21a28e3c428a799fd09e895f72
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Tue Feb 9 14:48:11 2010 +0000

    docs: Move some Cogl defines in the private section
    
    The PixelFormat bit and mask #defines should not be used and are there
    mostly for convenience, so we can push them to the "private" sub-section
    of the API reference.
    
    This pushed Cogl's API reference coverage to 100%.

 doc/reference/cogl/cogl-sections.txt |   16 ++++++++--------
 1 files changed, 8 insertions(+), 8 deletions(-)

commit 2674a1ead2a0c0ad1803acdfc7bf8e1ee188d60d
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Tue Feb 9 14:41:37 2010 +0000

    docs: Fixes for Cogl API reference
    
      98% symbol docs coverage.
      335 symbols documented.
      0 symbols incomplete.
      8 not documented.
    
    Not bad, if I may say so.

 cogl/cogl-buffer.h                   |   12 +++++++--
 cogl/cogl-color.h                    |   41 ++++++++++++++++++++++++++++++++++
 cogl/cogl-fixed.h                    |    2 +-
 cogl/cogl-material-private.h         |    2 +-
 cogl/cogl-matrix.h                   |    3 +-
 cogl/cogl-types.h                    |   23 ++++++++++++++++++-
 doc/reference/cogl/cogl-sections.txt |   16 +++----------
 7 files changed, 80 insertions(+), 19 deletions(-)

commit 2938ae0475f7630a7be721c5f2d81feb34564182
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Feb 9 12:21:10 2010 +0000

    cogl-texture-2d: Use _cogl_texture_driver_gen to generate the GL tex
    
    _cogl_texture_driver_gen is needed to set the texture minification
    mode to Cogl's default of GL_LINEAR. There was also a line to set this
    in _cogl_texture_2d_new_with_size but it wasn't working because it was
    called *before* the texture was bound. If the texture was later
    rendered with the default material it then it would end up with GL's
    default mipmap filtering mode but without mipmaps so it would render
    white squares instead.

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

commit f16fd0ddbb0fcf1285ba77cbcb23e57ab70d3df7
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Dec 18 21:17:21 2009 +0000

    cogl: Use SSE2 when possible for premultiplying
    
    This adds a fast path for premultiplying an RGBA image using SSE2
    instructions. SSE registers are 128-bit and we need at least 16-bits
    per component for the intermediate result of the multiplication so we
    can do two pixels in parallel with one register. The function
    interleaves 2 SSE registers to multiply 4 pixels in one function call
    with the hope that this will pipeline better.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=1939
    Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

 cogl/cogl-bitmap-fallback.c |  104 ++++++++++++++++++++++++++++++++++++++++++-
 1 files changed, 103 insertions(+), 1 deletions(-)

commit 2ecb6f7b20a501818f1bc6fea3406b9fce557a27
Author: Halton Huo <halton.huo@gmail.com>
Date:   Tue Feb 9 10:21:37 2010 +0000

    Remove return from void functions
    
    This patch fixes compilation on suncc.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=1978
    
    Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

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

commit 23717452bfdd9ae2f4328f3fefb30cd0eafea8c1
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Mon Feb 8 17:11:43 2010 +0000

    cogl-buffer: Use TEXTURE as the only value for CoglBufferUsageHint
    
    We should try to use more explicit defines than GL for our hints. For
    now we only support using a CoglBuffer to generate textures.

 cogl/cogl-buffer.c       |   38 +++++++++-----------------------------
 cogl/cogl-buffer.h       |   12 +++---------
 cogl/cogl-pixel-buffer.c |    2 +-
 3 files changed, 13 insertions(+), 39 deletions(-)

commit 273fd23742876183544be9fa83b1f3e369e63a1c
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Tue Feb 2 16:44:16 2010 +0000

    cogl-buffer: make sure the code compiles on GL ES
    
    OpenGL ES has no PBO extension, so we fallback to using a malloc'ed
    buffer. Make sure the OpenGL-only defines don't leak into the OpenGL ES
    compilation.

 cogl/cogl-buffer.c       |   28 ++++++++++++++++++++++++++++
 cogl/cogl-pixel-buffer.c |    7 +++++++
 cogl/cogl-texture.c      |    5 ++++-
 3 files changed, 39 insertions(+), 1 deletions(-)

commit ca80e8802b3a1ea52e62294de841a236065c0db8
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Tue Feb 2 12:59:51 2010 +0000

    cogl-pixel-buffer: Add a fallback path
    
    First, let's add a new public feature called, surprisingly,
    COGL_FEATURE_PBOS to check the availability of PBOs and provide a
    fallback path when running on older GL implementations or on OpenGL ES
    
    In case the underlying OpenGL implementation does not provide PBOs, we
    need a fallback path (a malloc'ed buffer). The CoglPixelBufer
    constructors will instanciate a subclass of CoglBuffer that handles
    map/unmap and set_data() with a malloc'ed buffer.
    
    The public feature is useful to check before using set_data() on a
    buffer as it will mean doing a memcpy() when not supporting PBOs (in
    that case, it's better to create the texture directly instead of using a
    CoglBuffer).

 cogl/cogl-pixel-buffer.c                |   56 +++++++++++++++++++++++++++++--
 cogl/cogl-texture.c                     |   38 +++++++++++++++------
 cogl/cogl-types.h                       |    4 ++-
 cogl/driver/gl/cogl-feature-functions.h |    5 +++
 4 files changed, 88 insertions(+), 15 deletions(-)

commit cf960cfb3d8f0be32559eab35727f285e686c234
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Fri Jan 22 15:07:27 2010 +0000

    cogl-texture: Add a new constructor to turn CoglBuffers into textures
    
    The only goal of using COGL buffers is to use them to create
    textures. cogl_texture_new_from_buffer() is the new symbol to create
    textures out of buffers.

 cogl/cogl-texture.c                  |   55 +++++++++++++++++++++++++++++++
 cogl/cogl-texture.h                  |   60 ++++++++++++++++++++++++++++++++++
 doc/reference/cogl/cogl-sections.txt |    3 ++
 3 files changed, 118 insertions(+), 0 deletions(-)

commit 47cc5a4e4344f94e5a32b68e18a44e33f1cfb332
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Sun Jan 10 18:04:29 2010 +0000

    cogl-pixel-buffer: add a pixel buffer object class
    
    This subclass of CoglBuffer aims at wrapping PBOs or other system
    surfaces like DRM buffer objects. Two constructors are available:
    
    cogl_pixel_buffer_new() with a size when you only care about the size of
    the buffer (such a buffer can be used to store several texture data such
    as the three planes of a I420 frame).
    
    cogl_pixel_buffer_new_full() is more a 1:1 mapping between the data and
    an underlying surface, with the possibility of having access to a low
    level memory buffer that may have a stride.

 cogl/Makefile.am                     |    3 +
 cogl/cogl-pixel-buffer-private.h     |   72 ++++++++
 cogl/cogl-pixel-buffer.c             |  317 ++++++++++++++++++++++++++++++++++
 cogl/cogl-pixel-buffer.h             |  165 ++++++++++++++++++
 cogl/cogl.h                          |    1 +
 doc/reference/cogl/cogl-sections.txt |    6 +
 6 files changed, 564 insertions(+), 0 deletions(-)

commit 40b73a8c0c295400a0e4fd8402ec1a170db9a66a
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Sun Jan 10 17:28:24 2010 +0000

    cogl-buffer: add an abstract class around openGL's buffer objects
    
    Buffer objects are cool! This abstracts the buffer API first introduced
    by GL_ARB_vertex_buffer_object and then extended to other objects.
    
    The coglBuffer abstract class is intended to be the base class of all
    the buffer objects, letting the user map() buffers. If the underlying
    implementation does not support buffer objects (or only support VBO but
    not FBO for instance), fallback paths should be provided.

 cogl/Makefile.am                     |    3 +
 cogl/cogl-buffer-private.h           |  102 ++++++++++++
 cogl/cogl-buffer.c                   |  282 +++++++++++++++++++++++++++++++++
 cogl/cogl-buffer.h                   |  287 ++++++++++++++++++++++++++++++++++
 cogl/cogl-context.c                  |    2 +
 cogl/cogl-context.h                  |    5 +
 cogl/cogl.h                          |    4 +
 doc/reference/cogl/cogl-docs.xml.in  |   21 +++
 doc/reference/cogl/cogl-sections.txt |   17 ++
 9 files changed, 723 insertions(+), 0 deletions(-)

commit dbef77cd8bfad02a5f2cf4b9c7343e42e584de6a
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Mon Jan 25 11:21:05 2010 +0000

    cogl: new textures sould have GL_TEXTURE_MIN_FILTER set to GL_LINEAR
    
    The only way the user has to set the mipmap filters is through the
    material/layer API. This API defaults to GL_LINEAR/GL_LINEAR for the max
    and min filters. With the main use case of cogl being 2D interfaces, it
    makes sense do default to GL_LINEAR for the min filter.
    
    When creating new textures, we did not set any filter on them, using
    OpenGL defaults': GL_NEAREST_MIPMAP_LINEAR for the min filter and
    GL_LINEAR for the max filter. This will make the driver allocate memory
    for the mipmap tree, memory that will not be used in the nominal case
    (as the material API defaults to GL_LINEAR).
    
    This patch tries to ensure that the min filter is set to GL_LINEAR
    before any glTexImage*() call is done on the texture by setting the
    filter when generating new OpenGL handles.

 cogl/cogl-texture-2d-sliced.c          |    9 ++++-----
 cogl/cogl-texture-2d.c                 |    9 +++++----
 cogl/cogl-texture-driver.h             |    9 +++++++++
 cogl/driver/gl/cogl-texture-driver.c   |   27 +++++++++++++++++++++++++++
 cogl/driver/gles/cogl-texture-driver.c |   27 +++++++++++++++++++++++++++
 5 files changed, 72 insertions(+), 9 deletions(-)

commit 0adc2c458d5fadbff99d6341093043b5863219a1
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Mon Jan 11 00:15:25 2010 +0000

    cogl: Introduce the GE_RET() debug macro
    
    Some GL functions have a return value that the GE() macro is not able to
    handle. Let's define a new Ge_RET() macro which will be able to handle
    functions such as glMapBuffer().
    
    While at it, removed the unused variadic dots to the GE() macro.

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

commit 5b4957a81046b75348f98060a78ef837f67b17fe
Merge: b31f2dd b39d1b7
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Feb 8 16:53:11 2010 +0000

    Merge branch 'animator-parser'
    
    * animator-parser:
      docs: Describe the Animation definition syntax
      animator: Provide a ClutterScript parser
      animator: Allow retrieving type property type from a key
      script: Use a node when resolving an animation mode

commit b31f2dd4a2d6df62f1049cd8c57dea627193f0d4
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Jan 14 18:11:57 2010 +0000

    cogl path: make sure marking the clip state dirty takes affect
    
    When we trashed the contents of the stencil buffer during
    _cogl_path_fill_nodes we marked the clip stack state as dirty and expected
    the clip stack code would clean up our glStencilFunc state.
    
    The problem is that we only try and update the clip state during
    _cogl_journal_init (when we flush the framebuffer state) which is only
    called when the journal first gets something logged in it.
    
    To make sure the stencil state is cleaned up we now also flush the journal
    so _cogl_journal_init will be called for the next logged rectangle.

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

commit 286ca56d4f0c3fa6929876235f5d54f92eea2a26
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Feb 8 10:34:22 2010 +0000

    Merge remote branch 'origin/cwiiis-stage-resize'
    
    * origin/cwiiis-stage-resize:
      [stage-x11] Set the default size differently
      [stage] Set default size correctly
      Revert "[x11] Don't set actor size on ConfigureNotify"
      [x11] Don't set actor size on ConfigureNotify
      [stage] Now that get_geometry works, use it
      [stage-x11] make get_geometry always get geometry
      [stage] Get the current size correctly
      [stage] Set minimum width/height to 1x1
      [stage] Add set/get_minumum_size

commit b39d1b788a793a4ea0d9b5e9686fac91039be7a3
Merge: a73ac7b b9a9bf6
Author: Neil Roberts <neil@linux.intel.com>
Date:   Sat Feb 6 00:20:07 2010 +0000

    Merge branch 'more-texture-backends'
    
    This adds three new texture backends.
    
    - CoglTexture2D: This is a trimmed down version of CoglTexture2DSliced
      which only supports a single texture and only works with the
      GL_TEXTURE_2D target. The code is a lot simpler so it has a less
      overheads than dealing with slices. Cogl will use this wherever
      possible.
    
    - CoglSubTexture: This is used to get a CoglHandle to represent a
      subregion of another texture. The texture can be used as if it was a
      standalone texture but it does not need to copy the resources.
    
    - CoglAtlasTexture: This collects RGB and RGBA textures into a single
      GL texture with the aim of reducing texture state changes and
      increasing batching. The backend will try to manage the atlas and
      may move the textures around to close gaps in the texture. By
      default all textures will be placed in the atlas.

commit b9a9bf60b7b6b0d80f0b97a43527d7d6fd83b9f8
Author: Neil Roberts <neil@linux.intel.com>
Date:   Sat Feb 6 00:12:10 2010 +0000

    cogl-bitmap: Update the format after (un)premultiplying
    
    The pixel format of the bitmap needs to have its premult flag cleared
    or set after the premult conversion otherwise it may get converted
    again.

 cogl/cogl-bitmap-fallback.c |    4 ++++
 cogl/cogl-texture.c         |    3 +--
 2 files changed, 5 insertions(+), 2 deletions(-)

commit 45215cb42640dc094f002dd7d84bcc2c9af22cea
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Feb 5 17:03:04 2010 +0000

    cogl-atlas-texture: Fix a cut and paste error when getting the height
    
    There was a typo in getting the height of the full texture to check
    whether the sub region fits so that it was using the width
    instead. This was causing crashes when debugging is enabled for some
    apps.

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

commit a73ac7bf574efa3136d6a14a73c7d2d054474eb1
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Thu Feb 4 21:10:02 2010 +0000

    docs: Use % for defines not #
    
    Some links to defines in the gtk-doc annotations were using '#' instead
    of '%'.

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

commit 8ef5e82dfa02bc45c145970337dffc495542c1da
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Wed Jan 27 16:03:28 2010 +0000

    docs: fix new line in the cogl xml top level document
    
    A comma in the FSF address is wrong. Supreme Offence.

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

commit 264f0f0f05746e8e92100022fdd09934882fad77
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Feb 3 23:08:30 2010 +0000

    cogl-texture: Avoid copying the bitmap when premultiplying from a file
    
    In cogl_texture_new_from_file we create and own a temporary
    bitmap. There's no need to copy this data if we need to do a premult
    conversion so instead it just does conversion before passing it on to
    cogl_texture_new_from_bitmap.

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

commit e83e0c3e5b78e6e220f27c3648d84a0f92eb2d23
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Feb 3 22:54:44 2010 +0000

    cogl-texture: Split out _cogl_texture_prepare_for_upload
    
    The Cogl atlas code was using _cogl_texture_prepare_for_upload with a
    NULL pointer for the dst_bmp to determine the internal format of the
    texture without converting the bitmap. It needs to do this to decide
    whether the texture will go in the atlas before wasting time on the
    conversion. This use of the function is a little confusing so that
    part of it has been split out into a new function called
    _cogl_texture_determine_internal_format. The code to decide whether a
    premult conversion is needed has also been split out.

 cogl/cogl-atlas-texture.c   |   11 +-----
 cogl/cogl-texture-private.h |    7 ++++
 cogl/cogl-texture.c         |   81 +++++++++++++++++++++++++-----------------
 3 files changed, 57 insertions(+), 42 deletions(-)

commit ef9781d7dadb7431c5420764d9a33b9bddcf1a5a
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Feb 3 19:54:12 2010 +0000

    cogl-atlas: Make the cogl_atlas_* API internal
    
    This just adds an underscore to every entry point for the CoglAtlas
    API so that it's not exported.

 cogl/cogl-atlas-texture.c |   89 ++++++++++++++--------------
 cogl/cogl-atlas.c         |  140 ++++++++++++++++++++++----------------------
 cogl/cogl-atlas.h         |   32 +++++-----
 cogl/cogl-context.c       |    2 +-
 4 files changed, 132 insertions(+), 131 deletions(-)

commit 76f4696e437d69a96ec8bddedb109f05dc1bb19e
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Thu Dec 3 17:13:44 2009 +0000

    Delay default stage creation
    
    The default stage creation should be delayed as much as possible,
    ideally at the end of the init() process.

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

commit e337bd2370d181f9bd37c5006dbf2bd9d5396ddb
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Thu Dec 3 17:35:19 2009 +0000

    cogl-debug: Remove redundant newlines
    
    The debugging notes wrapping g_debug() already have an implicit newline
    at the end of the passed message.

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

commit 44431da16430ba0f69f0b4c78f3d4fe148e2eaed
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Feb 3 14:31:12 2010 +0000

    cogl-vertex-buffer: Refix disabling texture coord arrays
    
    Commit 92a375ab4 changed the initial value of max_texcoord_attrib_unit
    to -1 so that it could disable the texture coord array for the first
    texture unit when there are no texture coords used in the vbo. However
    max_texcoord_attrib_unit was an unsigned value so this actually became
    G_MAXUINT. The disabling loop at the bottom still worked because
    G_MAXUINT+1==0 but the check for whether any texture unit is greater
    than max_texcoord_attrib_unit was failing so it would always end up
    disabling all texture units. This is now fixed by changing
    max_texcoord_attrib_unit to be signed.

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

commit efcbd20320712de9785d8361f5483cecc96cf0df
Merge: e445504 f7bd5af
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Feb 1 13:37:19 2010 +0000

    Merge remote branch 'master' into texture-debugging
    
    Conflicts:
    	clutter/cogl/cogl/cogl-context.h

commit e4455041c8439ce9f5b5e1f9ee9c7e0a4927a4ec
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Feb 1 13:25:19 2010 +0000

    cogl-material: Compare GL texture numbers for material layer textures
    
    When deciding if a material layer is equal it now compares the GL
    target and texture number if the textures are not sliced. This is
    needed to get batching across atlased textures.

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

commit e20c98e54899497fce26f60e10a8787e1ed6fec4
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Feb 1 12:11:58 2010 +0000

    cogl: Let GL do the format conversion when uploading texture data
    
    Cogl accepts a pixel format for both the data in memory and the
    internal format to be used for the texture. If they do not match then
    it would convert them using the CoglBitmap functions before uploading
    the data. However, GL also lets you specify both formats so it makes
    more sense to let GL do the conversion. The driver may need the
    texture in a specific format so it may end up being converted anyway.
    
    The cogl_texture_upload_data functions have been removed and replaced
    with a single function to prepare the bitmap. This will only do the
    premultiplication conversion because that is the only part that GL
    can't do directly.

 cogl/cogl-atlas-texture.c     |  111 ++++++++++-----------
 cogl/cogl-texture-2d-sliced.c |  220 ++++++++++++++++++++++------------------
 cogl/cogl-texture-2d.c        |   92 ++++++++----------
 cogl/cogl-texture-private.h   |   44 +++------
 cogl/cogl-texture.c           |  134 +++++++++++--------------
 5 files changed, 289 insertions(+), 312 deletions(-)

commit a6f061e41fa97267c35e15869ba91d21de2ad1f2
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Jan 29 15:15:08 2010 +0000

    cogl: Do the premult conversion in-place rather than copying to a new buffer
    
    The premult part of _cogl_convert_premult has now been split out as
    _cogl_convert_premult_status. _cogl_convert_premult has been renamed
    to _cogl_convert_format to make it less confusing. The premult
    conversion is now done in-place instead of copying the
    buffer. Previously it was copying the buffer once for the format
    conversion and then copying it again for the premult conversion. The
    premult conversion never changes the size of the buffer so it's quite
    easy to do in place. We can also use the separated out function
    independently.

 cogl/cogl-atlas-texture.c     |    6 +-
 cogl/cogl-bitmap-fallback.c   |  142 ++++++++++++++++-------------------------
 cogl/cogl-bitmap-pixbuf.c     |    6 +-
 cogl/cogl-bitmap-private.h    |   22 +++---
 cogl/cogl-bitmap.c            |  102 +++++++++++------------------
 cogl/cogl-texture-2d-sliced.c |   12 ++--
 cogl/cogl-texture-2d.c        |   12 ++--
 cogl/cogl-texture.c           |    6 +-
 8 files changed, 123 insertions(+), 185 deletions(-)

commit 406c203b422bd492235ffa91816671f4fd26e44c
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Jan 29 12:19:42 2010 +0000

    cogl-atlas-texture: Use a single atlas for both RGB and RGBA textures
    
    The internal format of the atlas texture is still set to the
    appropriate format so Cogl will disable blending for textures that are
    intended to be RGB. This should end up ignoring the alpha channel from
    the texture in the atlas. This makes the code slightly easier to
    maintain and should also improve the chances of batching.

 cogl/cogl-atlas-texture.c |  134 ++++++++++++++++----------------------------
 cogl/cogl-context.c       |   18 ++----
 cogl/cogl-context.h       |    8 +--
 3 files changed, 57 insertions(+), 103 deletions(-)

commit f7bd5af4a6e1b1f9145df58fe7ca8cf6a8d65a37
Merge: 4fcbbfe 18b96c8
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Feb 1 11:26:56 2010 +0000

    Merge branch 'device-manager'
    
    * device-manager: (37 commits)
      x11: Re-enable XI1 extension keyboards
      x11: Always handle core device events before XI events
      docs: Documentation fixes for DeviceManager
      device-manager: Fix the signals definition
      docs: Add sections for InputDevice and DeviceManager
      docs: Add clutter_input_device_get_device_name()
      tests: Print out the device details on motion
      Always register core devices
      device: Remove unused is_default member
      win32: Experimental implementation of device support
      tests: Print the device name, as well as its Id
      x11: Fill out the :name property of the InputDevices
      device: Add the :name property to InputDevice
      x11: Store core devices on the X11 Backend singleton
      device: Unset the cursor actor when leaving the stage
      device: Add pointer actor getter
      x11: Discard the LeaveNotify for off-stage ButtonRelease
      device: Do not overwrite the stage for an InputDevice
      event: Off-stage button releases have a click count of 1
      event: Scroll events do not have click count
      ...

commit 4fcbbfeedcb1641d283743acb712b567a757efce
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Wed Jan 27 21:26:26 2010 +0000

    Whitespace fixes in cogl-util

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

commit 47df6724b2893936033777fd2eec1cd0b8c7499c
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Jan 22 18:14:57 2010 +0000

    cogl: Use the colours of COGL_DEBUG=rectangles to debug batching
    
    Instead of assigning a new colour to each quad of a batch, the
    rectangle debugging code now assigns a new colour to each batch so
    that it can be used to visually see what is being batched. The colour
    is stored in a global variable that is reset during cogl_clear. This
    improves the chances that the same colour will be used for a batch in
    the next frames to avoid flickering.

 cogl/cogl-context.h |    6 +++++
 cogl/cogl-journal.c |   54 ++++++++++++++++++++++++++++++++++----------------
 cogl/cogl.c         |   11 ++++++++++
 3 files changed, 54 insertions(+), 17 deletions(-)

commit 1718b1d42ef167779e7cefa18e01023b64e57cf9
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Jan 26 13:46:27 2010 +0000

    cogl-vertex-buffer: Fix disabling the texture arrays from previous prim
    
    When setting up the state for the vertex buffer,
    enable_state_for_drawing_buffer tries to keep track of the highest
    numbered texture unit in use. It then disables any texture arrays for
    units that were previously enabled if they are greater than that
    number. However if there is no texturing in the VBO then the max used
    unit would be left at 0 which it would later think meant unit 0 is
    still in use so it wouldn't disable it. To fix this it now initialises
    the max used unit to -1 which it should interpret as ‘no units are in
    use’ so it will later disable the arrays for all units.
    
    Thanks to Jon Mayo for reporting the bug.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=1957

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

commit 548ed1cdf241ac0d324e2b289964f371f859b408
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Jan 27 12:06:22 2010 +0000

    docs: Add some notes about the CoglPixelFormat enums
    
    The pixel format enums didn't explain what order in memory the
    components should be so it was difficult to use them.

 cogl/cogl-types.h |   22 +++++++++++++++++++---
 1 files changed, 19 insertions(+), 3 deletions(-)

commit 9d45e9641c57a890474fa76178d3eba316aa445a
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Tue Jan 26 18:47:25 2010 +0000

    cogl: Fix checks of the number of available texture units
    
    We were checking the number of texture units against the GL enum that is
    used in glGetInteger() to query that number. Let's abstract this in a
    little function.
    
    Took the opportunity to dig a bit on the usage of GL limits for the
    number of texture (image) units and document our use of them. We'll need
    something finer grained if we want to fully exploit texture image units
    with a programmable pipeline.

 cogl/cogl-internal.h |    2 ++
 cogl/cogl-material.c |   10 ++--------
 cogl/cogl.c          |   30 ++++++++++++++++++++++++++++++
 3 files changed, 34 insertions(+), 8 deletions(-)

commit 84a438be55b13c6411f0f854987356235d7db91e
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Sun Nov 15 20:17:47 2009 +0000

    cogl: Fix gl equivalent of blend string
    
    An example of what could be the equivalent of
        "RBG = REPLACE(TEXTURE)
         A   = MODULATE(PREVIOUS,TEXTURE)"
    using the ARB_texture_env_combine extension was given, but it seems that
    a few typo were left:
        * remove a spurius GL_COMBINE_ALPHA
        * use the _ALPHA variant of SRCN and OPERANDN when setting up the
          alpha combiner

 doc/reference/cogl/blend-strings.xml |    9 ++++-----
 1 files changed, 4 insertions(+), 5 deletions(-)

commit 3069ad640926e8f70e3a406acce518282b58b345
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Sun Nov 15 19:54:17 2009 +0000

    cogl: Create CoglTextureUnit with its associated unit number
    
    The index field of CoglTextureUnit was never set, leading to the
    creation of units with index set to 0. When trying to retrieve a texture
    unit by its index (!= 0) with _cogl_get_texture_unit(), a new one was
    created as it could not find it back in the list of textures units:
    ctx->texture_units.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=1958

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

commit 67fc6ead78645b112485e3e5854113e1c9dd0074
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Jan 21 15:34:19 2010 +0000

    cogl-atlas-texture: Add a debug option to disable the atlas
    
    If the user specifies the 'disable-atlas' debug option then no texture
    will be put in the atlas.

 cogl/cogl-atlas-texture.c |    5 +++++
 cogl/cogl-debug.c         |    3 ++-
 cogl/cogl-debug.h         |    3 ++-
 3 files changed, 9 insertions(+), 2 deletions(-)

commit 41a915ec002342d881f0bdbc6ecb99bc73537587
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Jan 19 17:06:28 2010 +0000

    cogl-atlas-texture: Don't create atlas textures with the premult bit
    
    Previously the atlas textures were being created with whatever format
    the first sub texture is in. Only three formats are supported so this
    only matters if the first texture is a premultiplied alpha
    texture. Instead it now masks out the premultiplied bit so that the
    textures are always either RGB_888 or RGBA_8888.

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

commit a78246b4032f362dc98fbd11e86a8fe350669693
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Jan 18 10:53:00 2010 +0000

    cogl-atlas-texture: Fix premultiplied texture formats
    
    When uploading texture data it was just calling cogl_texture_set_data
    on the large texture. This would attempt to convert the data to the
    format of the large texture. All of the textures with alpha channels
    are stored together regardless of whether they are premultiplied so
    this was causing premultiplied textures to be unpremultiplied
    again. It now just uploads the data ignoring the premult bit of the
    format so that it only gets converted once.

 cogl/cogl-atlas-texture.c |  232 ++++++++++++++++++++++++++++++--------------
 1 files changed, 158 insertions(+), 74 deletions(-)

commit 12b45aaa3067ccb1bcf6785fc59bfd43b0164120
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Jan 14 17:57:43 2010 +0000

    cogl-primitives: Ensure the mipmaps for a layer before logging quads
    
    With the atlas texture backend ensuring the mipmaps can make it become
    a completely different texture which will have different texture
    coordinates or may even be sliced. Therefore we need to ensure the
    mipmaps before deciding which quads to log in the journal. This adds a
    new private function to cogl-material which ensures the mipmaps if
    needed.

 cogl/cogl-material-private.h |    6 ++++++
 cogl/cogl-material.c         |   19 +++++++++++++++----
 cogl/cogl-primitives.c       |    6 ++++++
 3 files changed, 27 insertions(+), 4 deletions(-)

commit ae7825275e0b67a2cdab3d3208e16b2b3c11498c
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Jan 18 09:22:04 2010 +0000

    cogl: Make CoglSubTexture only work for quad rendering
    
    The sub texture backend doesn't work well as a completely general
    texture backend because for example when rendering with cogl_polygon
    it needs to be able to tranform arbitrary texture coordinates without
    reference to the other coordintes. This can't be done when the texture
    coordinates are a multiple of one because sometimes the coordinate
    should represent the left or top edge and sometimes it should
    represent the bottom or top edge. For example if the s coordinates are
    0 and 1 then 1 represents the right edge but if they are 1 and 2 then
    1 represents the left edge.
    
    Instead the sub-textures are now documented not to support coordinates
    outside the range [0,1]. The coordinates for the sub-region are now
    represented as integers as this helps avoid rounding issues. The
    region can no longer be a super-region of the texture as this
    simplifies the code quite a lot.
    
    There are two new texture virtual functions:
    
    transform_quad_coords_to_gl - This transforms two pairs of coordinates
         representing a quad. It will return FALSE if the coordinates can
         not be transformed. The sub texture backend uses this to detect
         coordinates that require repeating which causes cogl-primitives
         to use manual repeating.
    
    ensure_non_quad_rendering - This is used in cogl_polygon and
         cogl_vertex_buffer to inform the texture backend that
         transform_quad_to_gl is going to be used. The atlas backend
         migrates the texture out of the atlas when it hits this.

 cogl/cogl-atlas-texture.c       |   57 ++++-
 cogl/cogl-primitives.c          |   21 +-
 cogl/cogl-sub-texture-private.h |   15 +-
 cogl/cogl-sub-texture.c         |  498 +++++++++++++--------------------------
 cogl/cogl-texture-2d-sliced.c   |   21 ++
 cogl/cogl-texture-2d.c          |   17 ++
 cogl/cogl-texture-private.h     |   10 +
 cogl/cogl-texture.c             |   33 +++-
 cogl/cogl-texture.h             |   22 +-
 cogl/cogl-vertex-buffer.c       |    5 +
 10 files changed, 325 insertions(+), 374 deletions(-)

commit 963afa88c51ba69820e570560fffc5c1650d16a6
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Jan 11 16:23:38 2010 +0000

    cogl-texture: Fix manual repeating for negative coordinates
    
    When calculating the next integer position for negative coordinates it
    would not increment if the position is already a multiple of one so we
    need to manually add one.

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

commit f1c289378e7f557ad5227417c22d7c0ce4fcecf2
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Jan 11 16:21:56 2010 +0000

    cogl-texture-2d: Fix the coordinate wrapping for negative coordinates
    
    The formula to wrap the coordinates to the [0,1] range was broken when
    the coordinates were negative.

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

commit f5d809f1e83f65651c65566db87ee6a3876ac79e
Merge: 568b6fb 18b96c8
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Jan 15 12:15:46 2010 +0000

    Merge branch 'master' into more-texture-backends

commit 18b96c84bf188e211cb3c21be2603c56f279332e
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Jan 12 21:44:40 2010 +0000

    cogl-framebuffer: Return gboolean from try_creating_fbo
    
    When try_creating_fbo fails it returns 0 to report the error and if it
    succeeds it returns ‘flags’. However cogl_offscreen_new_to_texture
    also passes in 0 for the flags as the last fallback to create the fbo
    with nothing but the color buffer. In that case it will return 0
    regardless of whether it succeeded so the last fallback will always be
    considered a failure.
    
    To fix this it now just returns a gboolean to indicate whether it
    succeeded and the flags used for each attempt is assigned when passing
    the argument rather than from the return value of the function.
    
    Also if the only configuration that succeeded was with flags==0 then
    it would always try all combinations because last_working_flags would
    also be zero. To avoid this it now uses a separate gboolean to mark
    whether we found a successful set of flags.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=1873

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

commit deecf83c4a120b8db311566154af2a37c8613111
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Wed Jan 13 15:40:36 2010 +0000

    build: Clean up COGL build flags

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

commit d1c56ae9a718cddb7c985b046709ff1e59a1b35b
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Jan 12 14:49:55 2010 +0000

    cogl-framebuffer: Add some missing GL defines
    
    Since 755cce33a7 the framebuffer code is using the GL enums
    GL_DEPTH_ATTACHMENT and GL_DEPTH_COMPONENT16. These aren't available
    directly under GLES except with the OES suffix so we need to define
    them manually as we do with the other framebuffer constants.

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

commit dfc3dd9c439b33ca655b00223ec387c3316e9371
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Jan 12 14:43:36 2010 +0000

    cogl: Remove the CGL_* defines
    
    These macros used to define Cogl wrappers for the GLenum values. There are
    now Cogl enums everywhere in the API where these were required so we
    shouldn't need them anymore. They were in the public headers but as
    they are not neccessary and were not in the API docs for Clutter 1.0
    it should be safe to remove them.

 cogl/cogl-material.c                  |   10 +-
 cogl/cogl-primitives.c                |    2 +-
 cogl/cogl-shader.h                    |    2 +-
 cogl/cogl-texture.h                   |    7 +-
 cogl/driver/gl/cogl-defines.h.in      |  655 ---------------------------------
 cogl/driver/gl/cogl-texture-driver.c  |    2 +-
 cogl/driver/gles/cogl-defines.h.in    |  597 ------------------------------
 cogl/driver/gles/cogl-gles2-wrapper.c |    4 +-
 cogl/driver/gles/cogl-gles2-wrapper.h |   65 ++--
 9 files changed, 51 insertions(+), 1293 deletions(-)

commit e2fcb62990c7f72c9ffcff5b39b2794352eaa610
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Jan 12 11:02:09 2010 +0000

    journal: Fixes logging of multiple sets of texture coordinates
    
    If a user supplied multiple groups of texture coordinates with
    cogl_rectangle_with_multitexture_coords() then we would repeatedly log only
    the first group in the journal.  This fixes that bug and adds a conformance
    test to verify the fix.
    
    Thanks to Gord Allott for reporting this bug.

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

commit 9690913fefdad782c74efa5c546ece0d873c05e4
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Nov 30 20:04:41 2009 +0000

    cogl: Support multiple fallbacks in cogl_offscreen_new_to_texture()
    
    The Intel drivers in Mesa 7.6 (and possibly earlier versions) don't
    support creating FBOs with a stencil buffer but without a depth
    buffer. This reworks framebuffer allocation so that we try a number
    of fallback options before failing.
    
    The options we try in order are:
    - the same options that were sucessful last time if available
    - combined depth and stencil
    - separate depth and stencil
    - just stencil, no depth
    - just depth, no stencil
    - neither depth or stencil

 cogl/cogl-framebuffer-private.h |    2 +-
 cogl/cogl-framebuffer.c         |  238 +++++++++++++++++++++++++--------------
 2 files changed, 156 insertions(+), 84 deletions(-)

commit 05ce533fc8b865ed45f60abdf50625003b841576
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Nov 25 14:26:32 2009 +0000

    framebuffers: cogl_offscreen_new_to_texture should take a ref on the texture
    
    We weren't taking a reference on the texture to be used as the color buffer
    for offscreen rendering, so it was possible to free the texture leaving the
    framebuffer in an inconsistent state.

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

commit fbad0a75b684cebbff874ba689810c2ff763b6e8
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Jul 3 16:22:35 2009 +0100

    profiling: Adds initial UProf accounting to Cogl
    
    This adds gives Cogl a dedicated UProf context which will be linked together
    with Clutter's context during clutter_init_real().
    
    Initial timers cover _cogl_journal_flush and _cogl_journal_log_quad
    
    You can explicitly ask for a report of Cogl statistics by exporting
    COGL_PROFILE_OUTPUT_REPORT=1 but since the context is linked with Clutter's
    the statisitcs will also be shown in the automatic Clutter reports.

 cogl/Makefile.am    |    2 +
 cogl/cogl-journal.c |   19 +++++++++++++++++
 cogl/cogl-profile.c |   30 ++++++++++++++++++++++++++++
 cogl/cogl-profile.h |   54 +++++++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 105 insertions(+), 0 deletions(-)

commit e9c4a0467b8f65531e5f8670332f3c7af07359ee
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Tue Jan 5 18:02:29 2010 +0000

    Covert stb_image.c to Unix format
    
    The file is still in DOS format (CRLF instead of LF) and this confuses
    the hell out of some versions of Git.

 cogl/stb_image.c | 7544 +++++++++++++++++++++++++++---------------------------
 1 files changed, 3772 insertions(+), 3772 deletions(-)

commit 932a9e16abccfd409f14f6fa8977923a9fdcacdb
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Tue Jan 5 17:54:45 2010 +0000

    Include cogl-defines.h before using GL types
    
    If we are using GL* types we should also be including cogl-defines.h, as
    that will include the right GL header.

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

commit 928e1adc3d26ae648b5b7bad617c700e0aec65eb
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Tue Jan 5 16:11:45 2010 +0000

    cogl: Fix array annotations
    
    The arrays in the cogl_program_set_uniform_* API should be marked as
    such, and have their length arguments specified.

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

commit 493bdb48fd782c006e38564daa6fa7b8beb6c7af
Merge: 9b441ec ade4e58
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Tue Jan 5 11:04:50 2010 +0000

    Merge branch 'matrix-mode'
    
    * matrix-mode:
      build: Move CoglMatrixMode to cogl-matrix-stack.h

commit ade4e5839d1c94941d7485ba1483b421e4e226e2
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Jan 4 11:58:32 2010 +0000

    build: Move CoglMatrixMode to cogl-matrix-stack.h
    
    This avoids a redeclaration of _cogl_matrix_stack_flush_to_gl() from
    using GLenum to CoglMatrixMode.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=1928

 cogl/cogl-internal.h     |    7 -------
 cogl/cogl-matrix-stack.h |    9 +++++++--
 2 files changed, 7 insertions(+), 9 deletions(-)

commit 9b441ec30954c7f9dffa1df5f2adac70076ccc26
Author: Halton Huo <halton.huo@sun.com>
Date:   Mon Jan 4 11:49:50 2010 +0000

    cogl-texture: Remove return in void functions
    
    http://bugzilla.o-hand.com/show_bug.cgi?id=1929
    
    Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

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

commit 2e510c4ef26858f2766db0f60c833e4c84833f03
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Jan 4 11:49:13 2010 +0000

    build: Maintainer cflags go in the _CFLAGS target
    
    The maintainer compiler flags are not pre-processor flags.

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

commit de5c84c4536f4d46ad555ec73895c90a2b773b14
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Jan 4 11:43:00 2010 +0000

    cogl: Const-ify vertices in cogl_polygon()
    
    The CoglTextureVertex array passed to cogl_polygon() is a pure
    in-argument and should be const-ified.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=1917

 cogl/cogl-primitives.c |   27 ++++++++++++++-------------
 cogl/cogl-texture.h    |    6 +++---
 2 files changed, 17 insertions(+), 16 deletions(-)

commit c6e20029643f4fb6581c3fe89efb2b676bef982f
Merge: 1567ab1 5441440
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Wed Dec 23 10:38:02 2009 +0000

    Merge branch 'animate-layout-manager' into ebassi-next
    
    * animate-layout-manager:
      layout-manager: Document the animation support
      layout-manager: Rewind the timeline in begin_animation()
      box-layout: Remove the allocations hash table
      docs: Clean up the README file
      layout: Let begin_animation() return the Alpha
      box-layout: Add knobs for controlling animations
      box-layout: Animate layout properties
      layout: Add animation support to LayoutManager
      Add ActorBox animation methods

commit 1567ab144b3d9c27b467dc7711f3e345d1bc2ece
Merge: 9640384 08139ac
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Sun Dec 20 17:39:12 2009 +0000

    Merge branch 'stage-use-alpha' into ebassi-next
    
    * stage-use-alpha:
      tests: Use accessor methods for :use-alpha
      stage: Add accessors for :use-alpha
      tests: Allow setting the stage opacity in test-paint-wrapper
      stage: Premultiply the stage color
      stage: Composite the opacity with the alpha channel
      glx: Always request an ARGB visual
      stage: Add :use-alpha property
      materials: Get the right blend function for alpha

commit 96403842d0d2ef5bbba01c974f10f03d492f1d9a
Merge: cddad17 5441440
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Sun Dec 20 17:33:51 2009 +0000

    Merge branch 'internal-flag' into ebassi-next
    
    * internal-flag:
      conform: Add test unit for the destruction of Containers
      actor: Add internal child flag
      Clean up whitespace, indentation and comments

commit cddad17059313a4445082d47c59f6c52ad001a1c
Merge: 5b614a8 5441440
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Thu Dec 10 23:36:04 2009 +0000

    Merge branch 'get-current-event' into ebassi-next
    
    * get-current-event:
      Add clutter_get_current_event

commit 5b614a87efbba6e10cd8481df44d6fb7f4196dc5
Merge: db881bb 5441440
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Wed Dec 9 23:32:41 2009 +0000

    Merge branch 'no-layout-flag' into ebassi-next
    
    * no-layout-flag:
      actor: Add a NO_LAYOUT flag for actors

commit db881bb3eeab7d059c4db72bcd701bb181a7a6ea
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Wed Dec 9 23:32:18 2009 +0000

    Merge branch 'size-cache' into ebassi-next
    
    * size-cache:
      tests: Clean up the BoxLayout interactive test
      actor: Add debugging notes for size cache
      Add a cache of size requests

commit 568b6fbda1b3992baeddedf9f9856185ca826036
Author: Neil Roberts <neil@linux.intel.com>
Date:   Sat Dec 5 14:20:00 2009 +0000

    cogl-material: Ensure mipmaps before doing anything else on a texture
    
    When the texture is in the atlas, ensuring the mipmaps can effectively
    make it become a completely different texture so we should do this
    before getting the GL handle.

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

commit 9139f21e093d9d809ecaa16a0e1d84afea93da32
Author: Neil Roberts <neil@linux.intel.com>
Date:   Sat Dec 5 13:48:03 2009 +0000

    cogl-atlas-texture: Remove textures from the atlas when mipmapping is required
    
    Mipmaps don't work very well in the current atlas because there is not
    enough padding between the textures. If ensure_mipmaps is called it
    will now create a new texture and migrate the atlased texture to
    it. It will use the same blit mechanism as when migrating so it will
    try to use an FBO for a fast blit. However if this is not possible it
    will end up downloading the data for the entire atlas which is not
    ideal.

 cogl/cogl-atlas-texture.c |   66 ++++++++++++++++++++++++++++++++++++++------
 1 files changed, 57 insertions(+), 9 deletions(-)

commit 3ebe48105d0254a4d5b4be6831975c0aa7914290
Author: Neil Roberts <neil@linux.intel.com>
Date:   Sat Dec 5 13:24:01 2009 +0000

    cogl-atlas-texture: Try to do texture blits using an FBO
    
    When reorganizing the textures, we can avoid downloading the entire
    texture data if we bind the source texture in a framebuffer object and
    copy the destination using glCopyTexSubImage2D. This is also
    implemented using a much faster path in Mesa.
    
    Currently it is calling the GL framebuffer API directly but ideally it
    would use the Cogl offscreen API. However there is no way to tell Cogl
    not to create a stencil renderbuffer which seems like a waste in this
    situation.
    
    If FBOs are not available it will fallback to reading back the entire
    texture data as before.

 cogl/cogl-atlas-texture.c |  198 ++++++++++++++++++++++++++++++++++++++-------
 1 files changed, 168 insertions(+), 30 deletions(-)

commit 636cef1bd64754e544971c7d691d6179b7d11109
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Dec 4 19:43:39 2009 +0000

    cogl-atlas: Add a debug option to visualize the atlas
    
    This adds a 'dump-atlas-image' debug category. When enabled, CoglAtlas
    will use Cairo to create a png which visualizes the leaf rectangles of
    the atlas.

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

commit f5d43d9b024f1e94e6e7adfef4c3916a9da3d39d
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Dec 4 18:55:53 2009 +0000

    cogl-texture-atlas: Add some debugging notes
    
    This adds an 'atlas' category to the COGL_DEBUG environment
    variable. When enabled Cogl will display messages when textures are
    added to the atlas and when the atlas is reorganized.

 cogl/cogl-atlas-texture.c |   62 ++++++++++++++++++++++++++++++++++++++++----
 cogl/cogl-debug.c         |    3 +-
 cogl/cogl-debug.h         |    3 +-
 3 files changed, 60 insertions(+), 8 deletions(-)

commit ec547b7ce03a021346e7ff1d3e3c30999025a9ce
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Dec 4 18:24:15 2009 +0000

    cogl-atlas-texture: Support reorganizing the atlas when it is full
    
    When space can't be found in the atlas for a new texture it will now
    try to reorganize the atlas to make space. A new CoglAtlas is created
    and all of the textures are readded in decreasing size order. If the
    textures still don't fit then the size of the atlas is doubled until
    either we find a space or we reach the texture size limits. If we
    successfully find an organization that fits then all of the textures
    will be migrated to a new texture. This involves copying the texture
    data into CPU memory and then uploading it again. Potentially it could
    eventually use a PBO or an FBO to transfer the image without going
    through the CPU.
    
    The algorithm for laying out the textures works a lot better if the
    rectangles are added in order so we might eventually want some API for
    creating multiple textures in one go to avoid reorganizing the atlas
    as far as possible.

 cogl/cogl-atlas-texture.c |  315 ++++++++++++++++++++++++++++++++++++++++-----
 1 files changed, 280 insertions(+), 35 deletions(-)

commit bec2600087dc127619688a593c41e60633f4cba5
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Dec 4 13:06:32 2009 +0000

    cogl: Add an atlased texture backend
    
    This adds a CoglAtlas type which is a data structure that keeps track
    of unused sub rectangles of a larger rectangle. There is a new atlased
    texture backend which uses this to put multiple textures into a single
    larger texture.
    
    Currently the atlas is always sized 256x256 and the textures are never
    moved once they are put in. Eventually it needs to be able to
    reorganise the atlas and grow it if necessary. It also needs to
    migrate the textures out of the atlas if mipmaps are required.

 cogl/Makefile.am                  |    4 +
 cogl/cogl-atlas-texture-private.h |   64 +++++
 cogl/cogl-atlas-texture.c         |  488 ++++++++++++++++++++++++++++++++++
 cogl/cogl-atlas.c                 |  520 +++++++++++++++++++++++++++++++++++++
 cogl/cogl-atlas.h                 |   76 ++++++
 cogl/cogl-context.c               |   14 +
 cogl/cogl-context.h               |    8 +
 cogl/cogl-texture.c               |   30 ++-
 cogl/cogl-types.h                 |    3 +-
 9 files changed, 1194 insertions(+), 13 deletions(-)

commit 63c984f193739622b2f1523604d841227eeea63e
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Dec 3 14:46:20 2009 +0000

    cogl-sub-texture: Fix the height of sub textures
    
    The code which is used to get the texture height was accidentally
    using the width due to a cut-and-paste fail.

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

commit 05d42ed390232b14a40511bae985c2f58a474859
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Nov 27 18:45:36 2009 +0000

    cogl: Add a CoglTexture2D backend
    
    This is an optimised version of CoglTexture2DSliced that always deals
    with a single texture and always uses the GL_TEXTURE_2D
    target. cogl_texture_new_from_bitmap now tries to use this backend
    first. If it can't create a texture with that size then it falls back
    the sliced backend.
    
    cogl_texture_upload_data_prepare has been split into two functions
    because the sliced backend needs to know the real internal format
    before the conversion is performed. Otherwise the converted bitmap
    will be wasted if the backend can't support the size.

 cogl/Makefile.am               |    2 +
 cogl/cogl-texture-2d-private.h |   69 +++++
 cogl/cogl-texture-2d.c         |  623 ++++++++++++++++++++++++++++++++++++++++
 cogl/cogl-texture-private.h    |    9 +
 cogl/cogl-texture.c            |   75 ++++--
 5 files changed, 755 insertions(+), 23 deletions(-)

commit f17767e4c105d1d172d9496646ec22105e107e31
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Nov 30 12:15:05 2009 +0000

    cogl: Add _cogl_texture_driver_upload_to_gl
    
    This provides a way to upload the entire data for a texture without
    having to first call glTexImage and then glTexSubImage. This should be
    faster especially with indirect rendering where it would needlessy
    send the data for the texture twice.

 cogl/cogl-texture-driver.h             |   14 +++++++++
 cogl/driver/gl/cogl-texture-driver.c   |   26 +++++++++++++++++
 cogl/driver/gles/cogl-texture-driver.c |   47 ++++++++++++++++++++++++++++++++
 3 files changed, 87 insertions(+), 0 deletions(-)

commit 8753422ef53608b90cef24e35dee10b01dede14e
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Nov 27 16:59:51 2009 +0000

    cogl: Move some of the texture_2d_sliced_new_* functions into cogl-texture
    
    new_from_data and new_from_file can be implemented in terms of
    new_from_bitmap so it makes sense to move these to cogl-texture rather
    than having to implement them in every texture backend.

 cogl/cogl-texture-2d-sliced-private.h |   16 ------
 cogl/cogl-texture-2d-sliced.c         |   84 ---------------------------------
 cogl/cogl-texture.c                   |   44 +++++++++++++----
 3 files changed, 33 insertions(+), 111 deletions(-)

commit c9cafc798c5245a034a9537cbf390b652e17ac16
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Nov 27 16:39:16 2009 +0000

    cogl: Add a sub texture backend
    
    This adds a new texture backend which represents a sub texture of a
    larger texture. The texture is created with a reference to the full
    texture and a set of coordinates describing the region. The backend
    simply defers to the full texture for all operations and maps the
    coordinates to the other range. You can also use coordinates outside
    the range [0,1] to create a repeated version of the full texture.
    
    A new public API function called cogl_texture_new_from_sub_texture is
    available to create the sub texture.

 cogl/Makefile.am                     |    2 +
 cogl/cogl-sub-texture-private.h      |   56 +++
 cogl/cogl-sub-texture.c              |  699 ++++++++++++++++++++++++++++++++++
 cogl/cogl-texture.c                  |   15 +-
 cogl/cogl-texture.h                  |   27 ++
 doc/reference/cogl/cogl-sections.txt |    1 +
 6 files changed, 798 insertions(+), 2 deletions(-)

commit 7c5aea9b688e7fb3d57cd5a8c5bf2b8095f5f71a
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Dec 2 17:17:24 2009 +0000

    cogl: Make the callback for foreach_sub_texture_in_region use const
    
    The CoglTextureSliceCallback function pointer now takes const pointers
    for the texture coordinates. This makes it clearer that the callback
    should not modify the array and therefore the backend can use the same
    array for both sets of coords.

 cogl/cogl-journal-private.h |    2 +-
 cogl/cogl-journal.c         |    2 +-
 cogl/cogl-primitives.c      |   14 +++++++-------
 cogl/cogl-texture-private.h |    4 ++--
 4 files changed, 11 insertions(+), 11 deletions(-)

commit 6bc3319c86be6b74e7e0701e11e34d4acfb56017
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Dec 2 13:41:49 2009 +0000

    cogl: Add a texture utility function for manually repeating
    
    Given a region of texture coordinates this utility invokes a callback
    enough times to cover the region with a subregion that spans the
    texture at most once. Eg, if called with tx1 and tx2 as 0.5 and 3.0 it
    it would invoke the callback with:
    
    0.5,1.0  1.0,2.0  2.0,3.0
    
    Manual repeating is needed by all texture backends regardless of
    whether they can support hardware repeating because when Cogl calls
    the foreach_sub_texture_in_region method then it sets the wrap mode to
    GL_CLAMP_TO_EDGE and no hardware repeating is possible.

 cogl/cogl-texture-private.h |   14 ++++++
 cogl/cogl-texture.c         |  102 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 116 insertions(+), 0 deletions(-)

commit 28e37e9f57275887ae47b83bc87375b91926c534
Author: Neil Roberts <neil@linux.intel.com>
Date:   Fri Nov 27 15:47:22 2009 +0000

    cogl-primitives: Check for repeating after the coordinate transform
    
    In _cogl_multitexture_quad_single_primitive we use a wrap mode of
    GL_CLAMP_TO_EDGE if the texture coordinates are all in the range [0,1]
    or GL_REPEAT otherwise. This is to avoid pulling in pixels from either
    side when using GL_LINEAR filter mode and rendering the entire
    texture. Previously it was checking using the unconverted texture
    coordinates. This is ok unless the texture backend is radically
    transforming the texture coordinates, such as in the sub texture
    backend where the coordinates may map to something completely
    different. We now check whether the coordinates are in range after
    converting them.

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

commit 25f3b993c61957801fcd2071d4d0cf060b02c886
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Nov 26 18:58:17 2009 +0000

    cogl: Move all of the fields from CoglTexture to CoglTexture2DSliced
    
    Most of the fields that were previously in CoglTexture are specific to
    the implementation of CoglTexture2DSliced so they should be placed
    there instead. For example, the 'mipmaps_dirty' flag is an
    implementation detail of the ensure_mipmaps function so it doesn't
    make sense to force all texture backends to have this function.
    
    Other fields such as width, height, gl_format and format may make
    sense for all textures but I've added them as virtual functions
    instead. This may make more sense for a sub-texture backend for
    example where it can calculate these based on the full texture.

 cogl/cogl-texture-2d-sliced-private.h |   25 +++-
 cogl/cogl-texture-2d-sliced.c         |  204 +++++++++++++++++++--------------
 cogl/cogl-texture-private.h           |   21 +---
 cogl/cogl-texture.c                   |   19 +--
 4 files changed, 149 insertions(+), 120 deletions(-)

commit 5030356e0e2a216df803643c00fb18e504fa765b
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Nov 26 17:32:52 2009 +0000

    cogl: Move data only used for upload out of CoglTexture
    
    The CoglTexture struct previously contained some fields which are only
    used to upload data such as the CoglBitmap and the source GL
    format. These are now moved to a separate CoglTextureUploadData struct
    which only exists for the duration of one of the cogl_texture_*_new
    functions. In cogl-texture there are utility functions which operate
    on this new struct rather than on CoglTexture directly.
    
    Some of the fields that were previously stored in the CoglBitmap
    struct are now copied to the CoglTexture such as the width, height,
    format and internal GL format.
    
    The rowstride was previously stored in CoglTexture and this was
    publicly accessible with the cogl_texture_get_rowstride
    function. However this doesn't seem to be a useful function because
    there is no need to use the same rowstride again when uploading or
    downloading new data. Instead cogl_texture_get_rowstride now just
    calculates a suitable rowstride from the format and width of the
    texture.

 cogl/cogl-texture-2d-sliced.c          |  344 +++++++++++++++-----------------
 cogl/cogl-texture-driver.h             |    6 +-
 cogl/cogl-texture-private.h            |   51 +++--
 cogl/cogl-texture.c                    |   93 +++++-----
 cogl/driver/gl/cogl-texture-driver.c   |   14 +-
 cogl/driver/gles/cogl-texture-driver.c |   16 +-
 6 files changed, 262 insertions(+), 262 deletions(-)

commit 5441440f4790e972ac2f8dd81e61adc5c98c8e58
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Dec 2 21:54:22 2009 +0000

    cogl: Use #ifdef GL around GL_TEXTURE_RECTANGLE_ARB
    
    Commit 558b17ee1e added support for rectangle textures to the
    framebuffer code. Under GLES there is no GL_TEXTURE_RECTANGLE_ARB
    definition so this was breaking the build. The rest of Cogl uses
    ifdef's around that constant so we should do the same here.

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

commit d75559b91b939611ae3857edb36dfd98a084987a
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Wed Dec 2 11:37:13 2009 +0000

    Remove a gtk-doc annotation
    
    The Mesa matrix code still has a comment that looks like a gtk-doc
    annotation.

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

commit 08139ace98fbb322dff13a686c2140ecab6ebac5
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Tue Dec 1 16:22:45 2009 +0000

    materials: Get the right blend function for alpha
    
    The correct blend function for the alpha channel is:
    
      GL_ONE, GL_ONE_MINUS_SRC_ALPHA
    
    As per bug 1406. This fix was dropped when the switch to premultiplied
    alpha was merged.

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

commit ca7f3fb883e872e76894f85fff20959949b2719c
Merge: a8b563b 6c5110c
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Tue Dec 1 14:55:19 2009 +0000

    Merge branch 'text-direction'
    
    * text-direction:
      docs: Add text-direction accessors
      Set the default language on the Pango context
      actor: Set text direction on parenting
      tests: Display the index inside text-box-layout
      box-layout: Honour :text-direction
      text: Dirty layout cache on text direction changes
      actor: Add :text-direction property
      Use the newly added ClutterTextDirection enumeration
      Add ClutterTextDirection enumeration

commit a8b563b622e5061dd6d0d1164ca5fa79b24ab008
Author: Neil Roberts <neil@linux.intel.com>
Date:   Sun Nov 29 20:06:36 2009 +0000

    cogl: Enable blending if a lighting colour is semi-transparent
    
    We currently enable blending if the material colour has
    transparency. This patch makes it also enable blending if any of the
    lighting colours have transparency. Arguably this isn't neccessary
    because we don't expose any API to enable lighting so there is no
    bug. However it is currently possible to enable lighting with a direct
    call to glEnable and this otherwise works so it is a shame not to have
    it.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=1907

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

commit 120f94d073cb2b005592c26f75e117b28f390a94
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Nov 27 15:24:09 2009 +0000

    primitives: Don't use dynamic arrays since VS2008 can't cope with them :-(
    
    This changes _cogl_path_fill_nodes_scanlines to use g_alloca instead of
    using a variable to declare an array length.

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

commit 944423a8d99d384635b3d13c1ea18f1fed2e59c3
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Nov 26 19:06:35 2009 +0000

    cogl: deprecate cogl_draw_buffer API and replace with a cogl_framebuffer API
    
    cogl_push_draw_buffer, cogl_set_draw_buffer and cogl_pop_draw_buffer are now
    deprecated and new code should use the new cogl_framebuffer_* API instead.
    
    Code that previously did:
        cogl_push_draw_buffer ();
        cogl_set_draw_buffer (COGL_OFFSCREEN_BUFFER, buffer);
        /* draw */
        cogl_pop_draw_buffer ();
    should now be re-written as:
        cogl_push_framebuffer (buffer);
        /* draw */
        cogl_pop_framebuffer ();
    
    As can be seen from the example above the rename has been used as an
    opportunity to remove the redundant target argument from
    cogl_set_draw_buffer; it now only takes one call to redirect to an offscreen
    buffer, and finally the term framebuffer may be a bit more familiar to
    anyone coming from an OpenGL background.

 cogl/Makefile.am                     |    4 +-
 cogl/cogl-clip-stack.c               |   74 ++--
 cogl/cogl-context.c                  |   13 +-
 cogl/cogl-context.h                  |    4 +-
 cogl/cogl-draw-buffer-private.h      |  133 --------
 cogl/cogl-draw-buffer.c              |  603 ---------------------------------
 cogl/cogl-framebuffer-private.h      |  124 +++++++
 cogl/cogl-framebuffer.c              |  618 ++++++++++++++++++++++++++++++++++
 cogl/cogl-journal.c                  |   12 +-
 cogl/cogl-matrix-stack.c             |    6 +-
 cogl/cogl-primitives.c               |   30 +-
 cogl/cogl-texture.c                  |   12 +-
 cogl/cogl-vertex-buffer.c            |    6 +-
 cogl/cogl.c                          |   80 +++---
 cogl/cogl.h                          |   73 ++++-
 doc/reference/cogl/cogl-sections.txt |    3 +
 16 files changed, 928 insertions(+), 867 deletions(-)

commit 7fee8a309bbf4a8dc55a4cb93ee735dec4979173
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Nov 26 17:47:17 2009 +0000

    cogl_offscreen: deprecate cogl_offscreen_ref/unref.
    
    New code should use cogl_handle_ref/unref

 cogl/cogl-offscreen.h |   34 +++++++++++++++++++++-------------
 1 files changed, 21 insertions(+), 13 deletions(-)

commit 1df0e36c6c700ab80943ea0e171b1134ce0ce963
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Nov 25 13:39:45 2009 +0000

    cogl: Use a vtable for the texture backends instead of a type and switch
    
    Instead of storing an enum with the backend type for each texture and
    then using a switch statement to decide which function to call, we
    should store pointers to all of the functions in a struct and have
    each texture point to that struct. This is potentially slightly faster
    when there are more backends and it makes implementing new backends
    easier because it's more obvious which functions have to be
    implemented.

 cogl/cogl-texture-2d-sliced-private.h |   62 ----------------
 cogl/cogl-texture-2d-sliced.c         |  122 +++++++++++++++-----------------
 cogl/cogl-texture-private.h           |   97 +++++++++++++++++++------
 cogl/cogl-texture.c                   |  124 ++++++--------------------------
 4 files changed, 154 insertions(+), 251 deletions(-)

commit 95fed739d5bc66e8b382a69c7890e2d325ba820e
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Nov 25 02:47:52 2009 +0000

    offscreen: cogl_offscreen_new_to_texture now supports GL_TEXTURE_RECTANGLE_ARB
    
    cogl_offscreen_new_to_texture previously bailed out if the given texture's
    GL target was anything but GL_TEXTURE_2D, but it now also allows
    foreign GL_TEXTURE_RECTANGLE_ARB textures.
    
    Thanks to Owen for reporting this issue, ref:
    https://bugzilla.gnome.org/show_bug.cgi?id=601032

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

commit 32bc0f208852fcf7324b3323cbc094785a432e9b
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Nov 24 18:24:07 2009 +0000

    debug: remove the COGL_DEBUG=client-side-matrices option
    
    Cogl only supports client side matrices so this debug option is no longer
    useful.

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

commit 16a09763efcf5067975e9036ebba6aaf405260e3
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Nov 11 12:50:48 2009 +0000

    [cogl-material] Adds cogl_material_copy() API
    
    cogl_material_copy can be used to create a new CoglHandle referencing a copy
    of some given material.
    
    From now on we will advise that developers always aim to use this function
    instead of cogl_material_new() when creating a material that is in any way
    derived from another.
    
    By using cogl_material_copy, Cogl can maintain an ancestry for each material
    and keep track of "similar" materials.  The plan is that Cogl will use this
    information to minimize the cost of GPU state transitions.

 cogl/cogl-context.c          |   13 ++++++---
 cogl/cogl-context.h          |    4 ++-
 cogl/cogl-material-private.h |    9 ++++++
 cogl/cogl-material.c         |   62 +++++++++++++++++++++++++++++++++++------
 cogl/cogl-material.h         |   18 ++++++++++++
 cogl/cogl.c                  |    6 ++--
 6 files changed, 95 insertions(+), 17 deletions(-)

commit 78fb882a4bd782d54d99c373e5c294f4883dfbc1
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Nov 11 12:52:08 2009 +0000

    [cogl] remove unused gles/cogl-utils.[c,h]
    
    The only function in gles/cogl-utils.c was cogl_util_next_p2() and it's
    redundant since we also have a cogl/cogl-utils.[c,h]

 cogl/driver/gles/cogl-util.c |   49 ------------------------------------------
 cogl/driver/gles/cogl-util.h |   30 -------------------------
 2 files changed, 0 insertions(+), 79 deletions(-)

commit d2ce4f71379f2a2aed2b0e50e80f5c0583ea2866
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Nov 23 11:30:32 2009 +0000

    docs: Don't document cogl_flush_gl_state as public API
    
    This function was #if 0'd before we released Clutter 1.0 so there's no
    implementation of it.  At some point we thought it might assist with
    developers breaking out into raw OpenGL.  Breaking out to raw GL is a
    difficult problem though so we decided instead we will wait for a specific
    use case to arrise before trying to support it.

 cogl/cogl.c                          |    8 --------
 cogl/cogl.h                          |   22 ----------------------
 doc/reference/cogl/cogl-sections.txt |    1 -
 3 files changed, 0 insertions(+), 31 deletions(-)

commit d2f8f6c58184fa24c19646bd9f7ed4c314cdc7f2
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Nov 19 16:07:38 2009 +0000

    Minor fix to cogl material
    
    _cogl_material_get_layer expects a CoglMaterial* pointer but it was
    being called with a CoglHandle. This doesn't matter because the
    CoglHandle is actually just the CoglMaterial* pointer anyway but it
    breaks the ability to change the _cogl_material_pointer_from_handle
    macro.

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

commit 421b85fcd5585df2177f1e71c436d12274b9e999
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Thu Nov 19 14:30:01 2009 +0000

    docs: Add indices to the Cogl API reference
    
    The Clutter API reference has an index of the symbols for each minor
    version, and a list of deprecated symbols. The Cogl API reference
    should have the same layout.

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

commit 03439aede831649822c115ebe3dc9eb410cf1c65
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Thu Nov 19 13:55:10 2009 +0000

    docs: Increase consistency in Cogl documentation

 cogl/cogl-texture.h       |   66 +++++++++++++---------
 cogl/cogl-vertex-buffer.h |  134 ++++++++++++++++++++++++---------------------
 cogl/cogl.h               |   90 ++++++++++++++++--------------
 3 files changed, 157 insertions(+), 133 deletions(-)

commit fab83d14f4508b2f1e305328dda7a21abbfc9618
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Thu Nov 19 13:33:26 2009 +0000

    docs: Documentation fixes for CoglMatrix
    
    Clean up the references, the docbook tags, and the style to fit in
    with the rest of the API references for Cogl and Clutter.

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

commit 800e100c20c1898d623a899d2179e0731089eb5c
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Thu Nov 19 13:33:08 2009 +0000

    Whitespace fix for cogl-color.h

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

commit 80783abf890f672c1bb2de4d5b319d7d02a6cdfd
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Thu Nov 19 13:31:38 2009 +0000

    docs: Documentation fixes for CoglMaterial
    
    Clean up the references, the docbook tags, and the style to fit in
    with the rest of the API references for Cogl and Clutter.

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

commit 3f9e26f084b06c0f3b7d821ed49825bb9826cb38
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Thu Nov 19 13:29:02 2009 +0000

    docs: Documentation fixes for CoglBitmap
    
    • Use the same style for the Cogl API reference as the one used for
      the Clutter API reference.
    
    • Fix the introspection annotations for cogl_bitmap_get_size_from_file()

 cogl/cogl-bitmap.h |   25 +++++++++++++------------
 1 files changed, 13 insertions(+), 12 deletions(-)

commit bae4b213d3fe22063e0b0a152f812e9df5d28597
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Thu Nov 19 12:34:06 2009 +0000

    docs: Fix Cogl API reference build
    
    • Ignore all the private header files
    
    • Add all missing/unused symbols
    
    • Remove deprecated symbols from 0.*

 doc/reference/cogl/Makefile.am       |   30 ++++++++++++++++++++++--------
 doc/reference/cogl/cogl-sections.txt |   29 ++++++++++++++++++++++++-----
 2 files changed, 46 insertions(+), 13 deletions(-)

commit feff0213ea0d4b83d9b90e2012f45cf1ab7a107d
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Thu Nov 19 12:32:59 2009 +0000

    docs: Remove non-gtk-doc annotations
    
    The imported Mesa matrix code has some documentation annotations
    that make gtk-doc very angry. Since it's all private anyway we
    can safely make gtk-doc ignore the offending stuff.

 cogl/cogl-matrix-mesa.c |  136 +++++++++++++++++++++++-----------------------
 cogl/cogl-matrix-mesa.h |   12 ++--
 2 files changed, 74 insertions(+), 74 deletions(-)

commit 8f21013ee6a31ea09d457a33d50cca3cf8616169
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Nov 19 11:51:21 2009 +0000

    docs: Fix the 'Since' annotation for some functions
    
    The 'Since' annotation needs to have a colon after it or gtk-doc won't
    pick it up.

 cogl/cogl-material.h |   40 ++++++++++++++++++++--------------------
 cogl/cogl-texture.h  |    6 +++---
 cogl/cogl.h          |    4 ++--
 3 files changed, 25 insertions(+), 25 deletions(-)

commit b4fc8faaabcface6421ffe4acc47cc5c99706cff
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Nov 18 19:09:10 2009 +0000

    cogl: Use APIENTRY for GL function pointer declarations
    
    This matters for platforms such as Windows that use a different
    calling covention from the default for GL functions.

 cogl/driver/gl/cogl-context-driver.h   |    6 +++++-
 cogl/driver/gles/cogl-context-driver.h |    6 +++++-
 2 files changed, 10 insertions(+), 2 deletions(-)

commit 0f37570e93b894fcd0b3f7dc90586f6c0685ad94
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Nov 18 19:23:57 2009 +0000

    build: Fix out-of-tree builds for cogl-defines.h
    
    $(COGL_DRIVER)/cogl-defines.h is generated in the configure script so
    it ends up in the build directory. Therefore the build rule for
    cogl/cogl-defines.h should depend on the file in $(builddir) not
    $(srcdir).

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

commit 2d51159281844fc2a1551065f78007b9e9b8f516
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Wed Nov 18 18:04:13 2009 +0000

    docs: Clean up deprecation notices
    
    The deprecation notices in gtk-doc should also refer to the
    release that added the deprecation, and if the deprecated
    symbol has been replaced by something else then the new symbol
    should be correctly referenced.

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

commit 2f2c3fb8392eaf6f570dc713a811bde7e4f34ac9
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Wed Nov 18 17:35:07 2009 +0000

    build: Make cogl.h not conditional on driver defines
    
    The main COGL header cogl.h is currently created at configure time
    because it conditionally includes the driver-dependent defines. This
    sometimes leads to a stale cogl.h with old definitions which can
    break the build until you clean out the whole tree and start from
    scratch.
    
    We can generate a stable cogl-defines.h at build time from the
    equivalent driver-dependent header and let cogl.h include that
    file instead.

 cogl/Makefile.am |   18 +-
 cogl/cogl.h      |  991 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 cogl/cogl.h.in   |  991 ------------------------------------------------------
 3 files changed, 1003 insertions(+), 997 deletions(-)

commit b91e8a828feac9f4459aac77c4fa93aff734903d
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Wed Nov 18 14:37:43 2009 +0000

    build: Add cogl-matrix-private.h to the dist

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

commit 7372e1d4f91c148a717be32501944bc69f4050f5
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Wed Nov 18 14:34:33 2009 +0000

    build: Add cogl-feature-functions.h to the dist

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

commit 0e112c3371050c727cfc37da093650a95b0048a4
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Nov 18 13:23:10 2009 +0000

    cogl: Add the missing terminators for the arrays of feature functions
    
    _cogl_feature_check expects the array of function names to be
    terminated with a NULL pointer but I forgot to add this. This was
    causing crashes depending on what happened to be in memory after the
    array.

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

commit 0927f35e7a3373a88207cabfefcc4c9716061854
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Nov 17 18:06:31 2009 +0000

    cogl: Use the GL_EXT_blend_{func,equation}_separate extensions
    
    We should use these extensions to check for glBlendFuncSeparate and
    glBlendEquationSeparate as well as checking the GL version number.

 cogl/driver/gl/cogl-feature-functions.h |   12 ++++++------
 1 files changed, 6 insertions(+), 6 deletions(-)

commit 2a53b84d18fb4e2839ca8c9f6bccf51f09845424
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Nov 17 17:22:22 2009 +0000

    cogl: Don't bother checking for NPOTs or VBOs on later GLs
    
    For VBOs, we don't need to check for the extension if the GL version
    is greater than 1.5. Non-power-of-two textures are given in 2.0.
    
    We could also assume shader support in GL 2.0 except that the function
    names are different from those in the extension so it wouldn't work
    well with the current mechanism.

 cogl/driver/gl/cogl-feature-functions.h |    4 +++-
 cogl/driver/gl/cogl.c                   |    3 ++-
 2 files changed, 5 insertions(+), 2 deletions(-)

commit 058d79dce2a30aab7457b237ff6d42872fe9d4e9
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Nov 17 13:52:40 2009 +0000

    cogl: Make it easier to add checks for GL extensions
    
    Previously if you need to depend on a new GL feature you had to:
    
    - Add typedefs for all of the functions in cogl-defines.h.in
    
    - Add function pointers for each of the functions in
      cogl-context-driver.h
    
    - Add an initializer for the function pointers in
      cogl-context-driver.c
    
    - Add a check for the extension and all of the functions in
      cogl_features_init. If the extension is available under multiple
      names then you have to duplicate the checks.
    
    This is quite tedious and error prone. This patch moves all of the
    features and their functions into a list of macro invocations in
    cogl-feature-functions.h. The macros can be redefined to implement all
    of the above tasks from the same header.
    
    The features are described in a struct with a pointer to a table of
    functions. A new function takes the feature description from this
    struct and checks for its availability. The feature can take a list of
    extension names with a list of alternate namespaces (such as "EXT" or
    "ARB"). It can also detect the feature from a particular version of
    GL.
    
    The typedefs are now gone and instead the function pointer in the Cogl
    context just directly contains the type.
    
    Some of the functions in the context were previously declared with the
    'ARB' extension. This has been removed so that now all the functions
    have no suffix. This makes more sense when the extension could
    potentially be merged into GL core as well.

 cogl/Makefile.am                          |    2 +
 cogl/cogl-feature-private.c               |  141 +++++++++++
 cogl/cogl-feature-private.h               |   71 ++++++
 cogl/cogl-journal.c                       |   10 +-
 cogl/cogl-vertex-buffer.c                 |   21 +-
 cogl/driver/gl/cogl-context-driver.c      |   58 +----
 cogl/driver/gl/cogl-context-driver.h      |   81 +------
 cogl/driver/gl/cogl-defines.h.in          |  361 ----------------------------
 cogl/driver/gl/cogl-feature-functions.h   |  326 +++++++++++++++++++++++++
 cogl/driver/gl/cogl-program.c             |   89 ++++----
 cogl/driver/gl/cogl-shader.c              |   27 +-
 cogl/driver/gl/cogl.c                     |  369 +++--------------------------
 cogl/driver/gles/cogl-context-driver.c    |   19 +-
 cogl/driver/gles/cogl-context-driver.h    |   25 +-
 cogl/driver/gles/cogl-defines.h.in        |   70 ------
 cogl/driver/gles/cogl-feature-functions.h |   72 ++++++
 cogl/driver/gles/cogl.c                   |   82 +++----
 17 files changed, 794 insertions(+), 1030 deletions(-)

commit 8b4a861093583cc7d978aa9128abf3c24c13b743
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Nov 11 16:42:53 2009 +0000

    Use the GL_ARB_multitexture extension on GL 1.2
    
    Cogl requires multi-texturing support. This is only available as an
    extension in GL 1.2 so we should check for it before accepting the
    driver.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=1875

 cogl/driver/gl/cogl.c |   46 +++++++++++++++++++++++++++++++++++++++-------
 1 files changed, 39 insertions(+), 7 deletions(-)

commit 6b0b07a8a600030b4dfdb6d72dc09f269465540b
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Nov 11 13:38:52 2009 +0000

    cogl-material: Fallback to BlendFunc if BlendFuncSeparate is unavailable
    
    glBlendFuncSeparate is only available in OpenGL 1.4. If we
    conditionally check for this then Clutter will work with OpenGL 1.2.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=1875

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

commit a50907848fa6d05c33688d434675f4a14a6e6f2d
Author: Neil Roberts <neil@linux.intel.com>
Date:   Wed Nov 11 13:26:54 2009 +0000

    Validate that the GL version is >= 1.2
    
    There is a new internal Cogl function called _cogl_check_driver_valid
    which looks at the value of the GL_VERSION string to determine whether
    the driver is supported. Clutter now calls this after the stage is
    realized. If it fails then the stage is marked as unrealized and a
    warning is shown.
    
    _cogl_features_init now also checks the version number before getting
    the function pointers for glBlendFuncSeparate and
    glBlendEquationSeparate. It is not safe to just check for the presence
    of the functions because some drivers may define the function without
    fully implementing the spec.
    
    The GLES version of _cogl_check_driver_valid just always returns TRUE
    because there are no version requirements yet.
    
    Eventually the function could also check for mandatory extensions if
    there were any.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=1875

 cogl/cogl.c             |    5 +++
 cogl/cogl.h.in          |    9 +++++
 cogl/driver/gl/cogl.c   |   87 +++++++++++++++++++++++++++++++++++++++++++----
 cogl/driver/gles/cogl.c |    6 +++
 4 files changed, 100 insertions(+), 7 deletions(-)

commit d30927290110b1f6443ee8331c272e097217b0b2
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Oct 5 13:37:11 2009 +0100

    [cogl-primitives] Don't clear the whole stencil buffer
    
    When _cogl_add_path_to_stencil_buffer is used to draw a path we don't
    need to clear the entire stencil buffer. Instead it can clear just the
    bounding box of the path. This adds an extra parameter called
    'need_clear' which is only set if the stencil buffer is being used for
    clipping.
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=1829

 cogl/cogl-clip-stack.c |    6 ++++--
 cogl/cogl-primitives.c |   37 ++++++++++++++++++++++++++++++-------
 2 files changed, 34 insertions(+), 9 deletions(-)

commit c49edf00979f1f89a3b3a2bc783d543f6d3754f5
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Nov 12 17:00:15 2009 +0000

    Remove _cogl_flush_matrix_stacks from cogl-internal.h
    
    The definition for this function was removed in f7d64e5abvoid so it
    should be removed from the header too.

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

commit 57d9c3c6689b7d1f10575c6fb049c24f6e408f55
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Wed Nov 11 10:32:39 2009 +0000

    cogl: Declare cogl_is_bitmap()
    
    The function is automatically defined by the CoglHandle type
    definition macro, but it still requires to be declared in the
    header file to be used.

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

commit 6c5110cb4b80faf671b49c0eb98b689e18826a7c
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Nov 9 11:50:16 2009 +0000

    cogl: Add an initialiser for enable_flags in cogl_begin_gl
    
    This fixes a warning about an uninitialised value. It could also
    potentially fix some crashes for example if the enable_flags value
    happened to include a bit for enabling a vertex array if no vertex
    buffer pointer was set.

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

commit 2fca6087e9bd5f4e453e8b3137476268634aeda2
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Fri Nov 6 15:06:39 2009 +0000

    Clean up cogl.h template
    
    The inclusion order is mostly random, and it should really be
    in alphabetic order, just like clutter.h.
    
    Also, cogl-vertex-buffer.h is included twice.

 cogl/cogl.h.in |   17 +++++++++--------
 1 files changed, 9 insertions(+), 8 deletions(-)

commit 544543e249d59750a0ed8fdb3ac2d9e333d89d79
Author: Tim Horton <hortont424@gmail.com>
Date:   Fri Nov 6 11:57:43 2009 +0000

    osx: CGBitmapContextCreate can't make 24bpp, alphaless offscreen pixmaps
    
    While loading a JPEG from disk (with clutter_texture_new_from_file),
    I got the following:
    
    <Error>: CGBitmapContextCreate: unsupported parameter combination: 8
    integer bits/component; 24 bits/pixel; 3-component colorspace;
    kCGImageAlphaNone; 3072 bytes/row.
    <Error>: CGContextDrawImage: invalid context
    
    Looking around, I found that CGBitmapContextCreate can't make 24bpp
    offscreen pixmaps without an alpha channel...
    
    This fixes the bug, and seems to not break other things...
    
    http://bugzilla.openedhand.com/show_bug.cgi?id=1159
    
    Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

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

commit 339b447075218847f376301010cd9dc6478cff37
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Fri Nov 6 14:04:36 2009 +0000

    Do not pass flags to g_module_open(NULL)
    
    The flags are ignored when opening the main module, so we
    should pass 0 to avoid confusion when reading the source.

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

commit eb0adfe2bcf04987eec40582945592844f0fa310
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Fri Nov 6 11:50:22 2009 +0000

    Merge branch 'josh-osx-fixes'
    
    * josh-osx-fixes:
      osx: Fix a warning on Snow Leopard
      docs: Fix OS X docs to install Ports in correct order
      osx: Implement the updated ClutterStageWindow interface

commit b0c60ce77a21ff1a7916f9601aefd6b26d9cc98d
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Nov 5 10:56:24 2009 +0000

    [clip-stack] stop using deprecated cogl_clip_push_window_rect API
    
    try_pushing_rect_as_window_rect now uses the new
    cogl_clip_push_window_rectangle API.

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

commit 2e0e441031fb404310eaf82bc81b4d53350ca277
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Nov 4 19:31:43 2009 +0000

    [cogl-clip] deprecate parts and cleanup the API
    
    cogl_clip_push() which accepts a rectangle in model space shouldn't have
    been defined to take x,y,width,height arguments because this isn't consistant
    with other Cogl API dealing with model space rectangles.  If you are using a
    coordinate system with the origin at the center and the y+ extending up,
    then x,y,width,height isn't as natural as (x0,y0)(x1,y1). This API has
    now been replace with cogl_clip_push_rectangle()
    
    (As a general note: the Cogl API should only use the x,y,width,height style
    when the appropriate coordinate space is defined by Cogl to have a top left
    origin.  E.g.  window coordinates, or potentially texture coordinates)
    
    cogl_clip_push_window_rect() shouldn't have been defined to take float
    arguments since we only clip with integral pixel precision. We also
    shouldn't have abbreviated "rectangle". This API has been replaced with
    cogl_clip_push_window_rectangle()
    
    cogl_clip_ensure() wasn't documented at all in Clutter 1.0 and probably
    no one even knew it existed. This API isn't useful, and so it's now
    deprecated. If no one complains we may remove the API altogether for
    Clutter 1.2.
    
    cogl_clip_stack_save() and cogl_clip_stack_restore() were originally added
    to allow us to save/restore the clip when switching to/from offscreen
    rendering.  Now that offscreen draw buffers are defined to own their clip
    state and the state will be automatically saved and restored this API is now
    redundant and so deprecated.

 cogl/cogl-clip-stack.c               |   44 +++++++++-------
 cogl/cogl.h.in                       |   92 ++++++++++++++++++++++++++++++++--
 doc/reference/cogl/cogl-sections.txt |    9 ++-
 3 files changed, 117 insertions(+), 28 deletions(-)

commit 1af8be2f7076165911e72b10965c92e170e38f30
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Nov 4 20:17:56 2009 +0000

    [clip-stack] Internally track model space clip rects as (x0,y0)(x1,y1) pairs
    
    Don't track the rectangles as x0,y0,width,height. This is in preparation
    for some API tidy up.

 cogl/cogl-clip-stack.c |  113 +++++++++++++++++++++++++-----------------------
 1 files changed, 59 insertions(+), 54 deletions(-)

commit 6ca49145f4986f6ae8d1a2f4cdd202e9b52d5a18
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Nov 4 19:42:17 2009 +0000

    [clip-stack] move lots of supporting code from cogl.c to cogl-clip-stack.c
    
    There was quite a bit of code in cogl.c that was only used to support
    cogl-clip-stack.c, so this has now been moved to cogl-clip-stack.c

 cogl/cogl-clip-stack.c |  277 +++++++++++++++++++++++++++++++++++++++++++-----
 cogl/cogl.c            |  237 -----------------------------------------
 2 files changed, 250 insertions(+), 264 deletions(-)

commit d4ffa2f819737b0f06e7a1b1e83c6c648b11b8ca
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Nov 4 16:55:18 2009 +0000

    [debug] Adds a COGL_DEBUG=force-scanline-paths
    
    For a long time now the GLES driver for Cogl has supported a fallback
    scanline rasterizer for filling paths when no stencil buffer is available,
    but now that we build the same cogl-primitives code for GL and GLES I
    thought it may sometimes be useful for debugging to force Cogl to use the
    scanline rasterizer instead of the current stencil buffer approach.

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

commit b49f90acb6a2d19a01e567a16928351f7db0747c
Author: Robert Bragg <robert@linux.intel.com>
Date:   Sat Oct 17 04:06:56 2009 +0100

    [cogl-primitives] Get rid of driver specific cogl-primitives code
    
    These files were practically identical, except the gles code had additional
    support for filling paths without a stencil buffer.  All the driver code has
    now been moved into cogl/cogl-primitives.c

 cogl/cogl-primitives.c             |  488 +++++++++++++++++++++++++++++++++-
 cogl/driver/gl/Makefile.am         |    1 -
 cogl/driver/gl/cogl-primitives.c   |  313 ----------------------
 cogl/driver/gles/Makefile.am       |    1 -
 cogl/driver/gles/cogl-primitives.c |  516 ------------------------------------
 5 files changed, 482 insertions(+), 837 deletions(-)

commit 9cfc8acb771e181685c28f02e957c93846a1f0e3
Merge: df920a4 61654a9
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Nov 4 03:46:45 2009 +0000

    Merge commit 'cogl-reorg-draw-buffers'
    
    * cogl-reorg-draw-buffers: (38 commits)
      [test-fbo] greatly simplify the test
      [tests] test-backface-culling: test culling with offscreen rendering
      [tests] Adds test-cogl-readpixels.c for very basic cogl_read_pixels testing
      [tests] Adds test-cogl-offscreen to validate offscreen draw buffer
      [tests] test-cogl-viewport tests semantics of over/under size viewports
      [test-texture-fbo] comment the colors defined in corner_colors
      Add a conformance test for clutter_texture_new_from_actor
      [cogl-texture-2d-sliced] allow COGL_FORMAT_ANY with _new_with_size()
      [texture] fix rounding when calculating update_fbo viewport offset
      [texture] switch to a new design for handling offscreen rendering
      [texture] split out fbo update code from cluter_texture_paint
      [texture] push/pop draw buffer when painting actors to a texture
      [texture] Avoid redundant use of cogl_clip_stack_save when drawing offscreen
      [cogl-draw-buffer] fix Cogl -> GL viewport coord conversion
      [cogl_clip_push_window_rect] fix Cogl -> GL coordinate conversion
      [matrix] Adds cogl_matrix_get_inverse API
      [debug] Adds a COGL_DEBUG=matrices debug option
      [cogl-matrix] Import Mesa's matrix manipulation code
      [cogl] avoid any state changes when cogl_set_backface_culling_enable is a nop
      [cogl] Use clockwise face winding for offscreen buffers with culling enabled
      ...

commit 61654a9ab448d17a03d5b65cacf667c7364f29b9
Author: Robert Bragg <robert@linux.intel.com>
Date:   Sat Oct 31 00:01:44 2009 +0000

    [cogl-texture-2d-sliced] allow COGL_FORMAT_ANY with _new_with_size()
    
    It's useful when initialzing offscreen draw buffers to be able to ask
    Cogl to create a texture of a given size and with the default internal
    pixel format.

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

commit f910ce2ee55b45d069febab9f78abe45bdb84872
Author: Robert Bragg <robert@linux.intel.com>
Date:   Sat Oct 31 00:00:33 2009 +0000

    [cogl-draw-buffer] fix Cogl -> GL viewport coord conversion
    
    Before we call glViewport we need to convert Cogl viewport coordinates
    (where the origin is defined to be top left) to OpenGL coordinates
    (where the origin is defined to be bottom left)
    
    We weren't considering that offscreen rendering is always upside down
    and in this case Cogl coordinates == OpenGL coordinates.

 cogl/cogl-draw-buffer.c |   15 +++++++++++----
 1 files changed, 11 insertions(+), 4 deletions(-)

commit 57bd250a71742ca9ab704fb0a5466f4b210a6db8
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Oct 30 23:57:56 2009 +0000

    [cogl_clip_push_window_rect] fix Cogl -> GL coordinate conversion
    
    Firstly this now uses the draw buffer height not the viewport height
    when we need to perform a y = height - y conversion, since (as the
    name suggests) we are dealing with window coordinates not viewport
    coordinates.
    
    Secondly this skips any conversion when the current draw buffer is an
    offscreen draw buffer since offscreen rendering is always forced to be
    upside down and in this case Cogl window coordinates == GL window
    coordinates.

 cogl/cogl-clip-stack.c |   32 ++++++++++++++++++++++++++------
 1 files changed, 26 insertions(+), 6 deletions(-)

commit 28c7e940bf322f96233534f6b769ccd1bcd3b14e
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Oct 26 17:51:34 2009 +0000

    [matrix] Adds cogl_matrix_get_inverse API
    
    This new API takes advantage of the recently imported Mesa code to support
    inverse matrix calculation.  The matrix code keeps track (via internal
    flags) of the transformations a matrix represents so that it can select an
    optimized inversion function.
    
    Note: although other aspects of the Cogl matrix API have followed a similar
    style to Cairo's matrix API we haven't added a cogl_matrix_invert API
    because the inverse of a CoglMatrix is actually cached as part of the
    CoglMatrix structure meaning a destructive API like cogl_matrix_invert
    doesn't let users take advantage of this caching design.

 cogl/cogl-context.h      |    3 --
 cogl/cogl-matrix-stack.c |   11 ++++++++++
 cogl/cogl-matrix-stack.h |    3 ++
 cogl/cogl-matrix.c       |   33 ++++++++++++++++++++-----------
 cogl/cogl-matrix.h       |   21 ++++++++++++++++++++
 cogl/cogl.c              |   47 ++++++++-------------------------------------
 6 files changed, 65 insertions(+), 53 deletions(-)

commit 2126bf60fde7d0d1944fe217adb9eab17179493b
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Oct 26 11:01:33 2009 +0000

    [debug] Adds a COGL_DEBUG=matrices debug option
    
    This adds a COGL_DEBUG=matrices debug option that can be used to trace all
    matrix manipulation done using the Cogl API.  This can be handy when you
    break something in such a way that a trace is still comparable with a
    previous working version since you can simply diff a log of the broken
    version vs the working version to home in on the bug.

 cogl/cogl-debug.c          |    3 +-
 cogl/cogl-debug.h          |    3 +-
 cogl/cogl-matrix-private.h |   47 ++++++++++++++++++++++++++++++++++++++++++++
 cogl/cogl-matrix.c         |   20 ++++++++++++++++++
 cogl/cogl.c                |    5 ++++
 5 files changed, 76 insertions(+), 2 deletions(-)

commit 0a1db7c4d878b35dc5b3986b6392643f067b6ffa
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Oct 26 08:23:21 2009 +0000

    [cogl-matrix] Import Mesa's matrix manipulation code
    
    This pulls in code from Mesa to improve our matrix manipulation support. It
    includes support for calculating the inverse of matrices based on top of a
    matrix categorizing system that allows optimizing certain matrix types.
    (the main thing we were after) but also adds some optimisations for
    rotations.
    
    Changes compared to the original code from Mesa:
    
    - Coding style is consistent with the rest of Cogl
    - Instead of allocating matrix->m and matrix->inv using malloc, our public
      CoglMatrix typedef is large enough to directly contain the matrix, its
      inverse, a type and a set of flags.
    - Instead of having a _math_matrix_analyse which updates the type, flags and
      inverse, we have _math_matrix_update_inverse which essentially does the
      same thing (internally making use of _math_matrix_update_type_and_flags())
      but with additional guards in place to bail out when the inverse matrix is
      still valid.
    - When initializing a matrix with the identity matrix we don't immediately
      initialize the inverse matrix; rather we just set the dirty flag for the
      inverse (since it's likely the user won't request the inverse of the
      identity matrix)

 cogl/Makefile.am        |    2 +
 cogl/cogl-matrix-mesa.c | 1698 +++++++++++++++++++++++++++++++++++++++++++++++
 cogl/cogl-matrix-mesa.h |  226 +++++++
 cogl/cogl-matrix.c      |   39 ++-
 cogl/cogl-matrix.h      |    6 +-
 5 files changed, 1967 insertions(+), 4 deletions(-)

commit 8ca17f52627f6d6191973352ee5c2624bc0b93bf
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Oct 22 19:09:20 2009 +0100

    [cogl] avoid any state changes when cogl_set_backface_culling_enable is a nop
    
    This is a simple optimization to bail out of cogl_set_backface_culling_enable
    if it's not resulting in a change of state.

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

commit 181bf920868847d523438e69cfb36c8975d5ccae
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Oct 22 19:01:52 2009 +0100

    [cogl] Use clockwise face winding for offscreen buffers with culling enabled
    
    Because Cogl defines the origin for texture as top left and offscreen draw
    buffers can be used to render to textures, we (internally) force all
    offscreen rendering to be upside down. (because OpenGL defines the origin
    to be bottom left)
    
    By forcing the users scene to be rendered upside down though we also reverse
    the winding order of all the drawn triangles which may interfere with the
    users use of backface culling.  This patch ensures that we reverse the
    winding order for a front face (if culling is in use) while rendering
    offscreen so we don't conflict with the users back face culling.

 cogl/cogl-context.c       |    2 ++
 cogl/cogl-context.h       |    1 +
 cogl/cogl-internal.h      |    9 +++++++++
 cogl/cogl-journal.c       |    1 +
 cogl/cogl-primitives.c    |    1 +
 cogl/cogl-vertex-buffer.c |    1 +
 cogl/cogl.c               |   33 +++++++++++++++++++++++++++++++++
 7 files changed, 48 insertions(+), 0 deletions(-)

commit 1acf5cc36f9ca8c92ea12f3f6d0e62c8e159804b
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Nov 3 12:54:45 2009 +0000

    [cogl_read_pixels] don't force a 4 byte pack alignment
    
    Technically this change shouldn't make a difference since we are
    calling glReadPixels with GL_RGBA GL_UNSIGNED_BYTE which is a 4
    byte format and it should always result in the same value according
    to how OpenGL calculates the location of sequential rows.
    
    i.e. k  = a/s * ceil(snl/a) where:
     a = alignment
     s = component size (1)
     n = number of components per pixel (4)
     l = number of pixels in a row
    gives:
    k = 4/1 * ceil(4l/4) and k = 1/1 * ceil(4l/1) which are equivalent
    
    I'm changing it because I've seen i915 driver code that bails out of
    hardware accelerated paths if the alignment isn't 1, and because
    conceptually we have no alignment constraints here so even if the current
    value has no effect, when we start reading back other formats it may upset
    things.

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

commit f59180d073bf1a4e975367860b1f0030dcef3476
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Nov 2 01:11:21 2009 +0000

    [cogl_read_pixels] call cogl_flush() before changing glPixelStore state
    
    We were previously calling cogl_flush() after setting up the glPixelStore
    state for calling glReadPixels, but flushing the journal could itself
    change the glPixelStore state.

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

commit d1de286109a66797a0b3badd4fbb3064a5b1335f
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Nov 2 01:10:02 2009 +0000

    [cogl_read_pixels] ensure we flush the current draw buffer state before reading
    
    Make sure we call _cogl_draw_buffer_flush_state() before glReadPixels() to
    be sure we have bound the correct framebuffer.

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

commit b8fe310b6d3b13d00d8380c28f24c1ecf59c8616
Author: Robert Bragg <robert@linux.intel.com>
Date:   Mon Nov 2 01:12:10 2009 +0000

    [cogl_read_pixels] fixes for calculating the y offset when rendering offscreen
    
    Since offscreen rendering is forced to be upside down we don't need to do
    any conversion of the users coordinates to go from Cogl window coordinates
    to OpenGL window coordinates.

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

commit 800d18bc196e97d7fb606efe2adc69424effccb4
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Oct 22 16:55:07 2009 +0100

    [read-pixels] don't flip data when reading from offscreen draw buffers
    
    Since we do all offscreen rendering upside down (so that we can have the
    origin for texture coordinates be the top left of textures for the cases
    where offscreen draw buffers are bound to textures) we don't need to flip
    data read back from an offscreen framebuffer before we we return it to the
    user.

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

commit 0f86470eefcf77794180e638d5f098b01bbfb020
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Oct 21 23:22:45 2009 +0100

    [clip-stack] tidy up transform_point() code
    
    I was originally expecting the code not to handle offset viewports or
    viewports with a different size to the framebuffer, but it turns out the
    code worked fine.  In the process though I think I made the code slightly
    more readable.

 cogl/cogl-clip-stack.c |   32 +++++++++++++++++++++-----------
 1 files changed, 21 insertions(+), 11 deletions(-)

commit 78ee3f71b2daad28fd686b5dfa9f056b65bd4238
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Nov 3 13:26:58 2009 +0000

    [cogl] deprecate cogl_viewport() in favour of cogl_set_viewport()
    
    cogl_viewport only accepted a viewport width and height, but there are times
    when it's also desireable to have a viewport offset so that a scene can be
    translated after projection but before hitting the framebuffer.

 cogl/cogl.c    |   12 ++++++------
 cogl/cogl.h.in |   22 +++++++++++++++++++++-
 2 files changed, 27 insertions(+), 7 deletions(-)

commit c2a982cf9c7ccd2c2b110c464d86881b5b1689d1
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Oct 21 23:24:28 2009 +0100

    [cogl_read_pixels] use buffer not viewport height to calculate y offset
    
    glReadPixel takes window coordinates not viewport coordinates so we
    shouldn't have been assuming that the viewport height == window height.

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

commit e4fe65552195ffd0e91c9a357731554b177acb03
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Oct 21 23:20:44 2009 +0100

    [draw-buffer] Adds cogl_draw_buffer_get_{width,height} API
    
    Simply adds missing API to query the width and height of any Cogl draw buffer.

 cogl/cogl-draw-buffer-private.h |    4 ++++
 cogl/cogl-draw-buffer.c         |   14 ++++++++++++++
 2 files changed, 18 insertions(+), 0 deletions(-)

commit b4770c1e9b27f7816572342b3899b117e5a91adb
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Oct 21 23:24:49 2009 +0100

    [cogl] Make sure Cogl always knows the current window geometry
    
    Because Cogl defines the origin of viewport and window coordinates to be
    top-left it always needs to know the size of the current window so that Cogl
    window/viewport coordinates can be transformed into OpenGL coordinates.
    
    This also fixes cogl_read_pixels to use the current draw buffer height
    instead of the viewport height to determine the OpenGL y coordinate to use
    for glReadPixels.

 cogl/cogl-context.c     |    2 +-
 cogl/cogl-context.h     |    2 +-
 cogl/cogl-draw-buffer.c |   36 +++++++++++++++++++++++++++++++-----
 cogl/cogl.h.in          |    3 +++
 4 files changed, 36 insertions(+), 7 deletions(-)

commit 2d610c230035d39cb6ebfa0bdd9af35f69bda347
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Oct 22 16:13:01 2009 +0100

    [cogl] Make sure we draw upside down to offscreen draw buffers
    
    First a few notes about Cogl coordinate systems:
    - Cogl defines the window origin, viewport origin and texture coordinates
    origin to be top left unlike OpenGL which defines them as bottom left.
    - Cogl defines the modelview and projection identity matrices in exactly the
    same way as OpenGL.
    - I.e. we believe that for 2D centric constructs: windows/framebuffers,
    viewports and textures developers are more used to dealing with a top left
    origin, but when modeling objects in 3D; an origin at the center with y
    going up is quite natural.
    
    The way Cogl handles textures is by uploading data upside down in OpenGL
    terms so that bottom left becomes top left.  (Note: This also has the
    benefit that we don't need to flip the data we get from image decoding
    libraries since they typically also consider top left to be the image
    origin.)
    
    The viewport and window coords are mostly handled with various y =
    height - y tweaks before we pass y coordinates to OpenGL.
    
    Generally speaking though the handling of coordinate spaces in Cogl is a bit
    fragile.  I guess partly because none of it was design to be, it just
    evolved from how Clutter defines its coordinates without much consideration
    or testing.  I hope to improve this over a number of commits; starting here.
    
    This commit deals with the fact that offscreen draw buffers may be bound to
    textures but we don't "upload" the texture data upside down, and so if you
    texture from an offscreen draw buffer you need to manually flip the texture
    coordinates to get it the right way around.  We now force offscreen
    rendering to be flipped upside down by tweaking the projection matrix right
    before we submit it to OpenGL to scale y by -1.  The tweak is entirely
    hidden from the user such that if you call cogl_get_projection you will not
    see this scale.

 cogl/cogl-context.c             |    4 ++++
 cogl/cogl-context.h             |    4 ++++
 cogl/cogl-draw-buffer-private.h |    3 +++
 cogl/cogl-matrix-stack.c        |   36 ++++++++++++++++++++++++++----------
 4 files changed, 37 insertions(+), 10 deletions(-)

commit 4bc947cfcc73f7a44d8e1c715471dc7805def9aa
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Oct 22 12:35:33 2009 +0100

    [cogl] Ensure features are initialized first in cogl_create_context
    
    Previously some context initializing was being done without valid feature
    flags.

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

commit 49db9f4f775c2308c31bc3bacf64cd9263f70b55
Author: Robert Bragg <robert@linux.intel.com>
Date:   Sat Oct 17 00:31:26 2009 +0100

    [clip-stack] Handle flipped rectangles in try_pushing_rect_as_window_rect()
    
    We were ignoring the possibility that the current modelview matrix may flip
    the incoming rectangle in which case we didn't calculate a valid scissor
    rectangle for clipping.
    
    This fixes: http://bugzilla.o-hand.com/show_bug.cgi?id=1809
    (Clipping doesn't work within an FBO)

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

commit bb3a008318c97f573d98b09d7e8fe911548947fa
Author: Robert Bragg <robert@linux.intel.com>
Date:   Fri Sep 25 14:34:34 2009 +0100

    [draw-buffers] First pass at overhauling Cogl's framebuffer management
    
    Cogl's support for offscreen rendering was originally written just to support
    the clutter_texture_new_from_actor API and due to lack of documentation and
    several confusing - non orthogonal - side effects of using the API it wasn't
    really possible to use directly.
    
    This commit does a number of things:
    - It removes {gl,gles}/cogl-fbo.{c,h} and adds shared cogl-draw-buffer.{c,h}
      files instead which should be easier to maintain.
    - internally CoglFbo objects are now called CoglDrawBuffers. A
      CoglDrawBuffer is an abstract base class that is inherited from to
      implement CoglOnscreen and CoglOffscreen draw buffers.  CoglOffscreen draw
      buffers will initially be used to support the
      cogl_offscreen_new_to_texture API, and CoglOnscreen draw buffers will
      start to be used internally to represent windows as we aim to migrate some
      of Clutter's backend code to Cogl.
    - It makes draw buffer objects the owners of the following state:
      - viewport
      - projection matrix stack
      - modelview matrix stack
      - clip state
    (This means when you switch between draw buffers you will automatically be
     switching to their associated viewport, matrix and clip state)
    
    Aside from hopefully making cogl_offscreen_new_to_texture be more useful
    short term by having simpler and well defined semantics for
    cogl_set_draw_buffer, as mentioned above this is the first step for a couple
    of other things:
    - Its a step toward moving ownership for windows down from Clutter backends
      into Cogl, by (internally at least) introducing the CoglOnscreen draw
      buffer.  Note: the plan is that cogl_set_draw_buffer will accept on or
      offscreen draw buffer handles, and the "target" argument will become
      redundant since we will instead query the type of the given draw buffer
      handle.
    - Because we have a common type for on and offscreen framebuffers we can
      provide a unified API for framebuffer management. Things like:
      - blitting between buffers
      - managing ancillary buffers (e.g. attaching depth and stencil buffers)
      - size requisition
      - clearing

 cogl/Makefile.am                       |    2 +
 cogl/cogl-clip-stack.c                 |  199 +++++++++----
 cogl/cogl-clip-stack.h                 |    9 +-
 cogl/cogl-context.c                    |   34 +--
 cogl/cogl-context.h                    |   20 +-
 cogl/cogl-draw-buffer-private.h        |  126 +++++++
 cogl/cogl-draw-buffer.c                |  555 ++++++++++++++++++++++++++++++++
 cogl/cogl-journal.c                    |   33 ++-
 cogl/cogl-primitives.c                 |   19 +-
 cogl/cogl-texture.c                    |   19 +-
 cogl/cogl-vertex-buffer.c              |   14 +-
 cogl/cogl.c                            |  220 ++++++++-----
 cogl/cogl.h.in                         |    1 +
 cogl/driver/gl/Makefile.am             |    2 -
 cogl/driver/gl/cogl-context-driver.c   |   19 +-
 cogl/driver/gl/cogl-context-driver.h   |   23 +-
 cogl/driver/gl/cogl-defines.h.in       |   28 +-
 cogl/driver/gl/cogl-fbo.c              |  315 ------------------
 cogl/driver/gl/cogl-fbo.h              |   39 ---
 cogl/driver/gl/cogl-primitives.c       |   99 ++++--
 cogl/driver/gl/cogl-texture-driver.c   |    2 +-
 cogl/driver/gl/cogl.c                  |  114 ++++----
 cogl/driver/gles/Makefile.am           |    2 -
 cogl/driver/gles/cogl-context-driver.c |   10 +
 cogl/driver/gles/cogl-context-driver.h |   17 +-
 cogl/driver/gles/cogl-defines.h.in     |   70 ++++
 cogl/driver/gles/cogl-fbo.c            |  328 -------------------
 cogl/driver/gles/cogl-fbo.h            |   39 ---
 cogl/driver/gles/cogl-primitives.c     |  121 ++++++--
 cogl/driver/gles/cogl.c                |   75 +++++
 30 files changed, 1469 insertions(+), 1085 deletions(-)

commit 6b2ff320cab3404a532e194cae853ee9823568f7
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Sep 15 22:19:01 2009 +0100

    [cogl-fbo] Bring the gles code more in line with gl code
    
    Over time the two cogl-fbo.c files have needlessly diverged as bug fixes or
    cleanups went into one version but not the other.  This tries to bring them
    back in line with each other.  It should actually be simple enough to move
    cogl-fbo.c to be a common file, and simply not build it for GLES 1.1, so
    maybe I'll follow up with such a patch soon.

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

commit cc0af441f2fe3a731a5338d6fc2c585f4bc017f4
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Sep 15 22:15:03 2009 +0100

    [cogl-fbo] Remove poorly documented workaround for unknown driver/hardware
    
    The comment just said: "Some implementation require a clear before drawing
    to an fbo.  Luckily it is affected by scissor test." and did a scissored
    clear, which is clearly a driver bug workaround, but for what driver?  The
    fact that it was copied into the gles backend (or vica versa is also
    suspicious since it seems unlikely that the workaround is necessary for both
    backends.)
    
    We can easily restore the workaround with a better comment if this problem
    really still exists on current drivers, but for now I'd rather minimize
    hand-wavey workaround code that can't be tested.

 cogl/driver/gl/cogl-fbo.c   |   10 ----------
 cogl/driver/gles/cogl-fbo.c |   19 -------------------
 2 files changed, 0 insertions(+), 29 deletions(-)

commit df920a42df2ad112cc89fa780466b878a4f5b2f4
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Fri Oct 30 12:11:19 2009 +0000

    build: Add missing gles/cogl-context-driver.h to dist
    
    The gles/cogl-context-driver.h header file is missing from the
    dist target, which means it's not in the tarballs.

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

commit 435d415a45862046ec3e4a16095887fe96c873b3
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Oct 27 13:18:51 2009 +0000

    [cogl_polygon] Enable COGL_ENABLE_BLEND when use_color is set
    
    Otherwise you can't use the alpha channel of the vertex colors unless
    the material has a texture with alpha or the material's color has
    alpha less than 255.

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

commit 67a896e5df5500112da2e144d7754301af825ad5
Author: Neil Roberts <neil@linux.intel.com>
Date:   Tue Oct 27 12:38:10 2009 +0000

    build: Add $(top_buiddir)/clutter/cogl to the include path in clutter/cogl/cogl
    
    Some files try to include "cogl/cogl-defines-gl.h" so
    $(top_builddir)/clutter/cogl needs to be in the include path for out of
    tree builds to work.

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

commit be06fe0b757a08fd4b7ac74a340ab229ca52e774
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Fri Oct 23 16:44:28 2009 +0100

    cogl: Avoid C99-isms
    
    Do not declare variables after statements.

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

commit edeca915cdbdf295cf38cd39f1e058520db1c00e
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Fri Oct 23 15:46:25 2009 +0100

    cogl: Remove cogl-current-matrix.c
    
    The cogl-current-matrix.c file is unused since commit
    5e5d94dfbed18bf2b4c8c7a7ff9847952b2c4ae2 and it's not compiled
    or distributed anymore.

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

commit fcce83360627eb40b6ada3026f6d4dff264abd73
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Fri Oct 23 12:15:25 2009 +0100

    build: Make COGL pass distcheck
    
    Some changes to make COGL pass distcheck with Automake 1.11 and
    anal-retentiveness turned up to 11.
    
    The "major" change is the flattening of the winsys/ part of COGL,
    which is built directly inside libclutter-cogl.la instead of an
    intermediate libclutter-cogl-winsys.la object.
    
    Ideally, the whole COGL should be flattened out using a
    quasi-non-recursive Automake layout; unfortunately, the driver/
    sub-section ships with identical targets and Automake cannot
    distinguish GL and GLES objects.

 cogl/Makefile.am        |  196 +++++++++++++++++++++++-----------------------
 cogl/winsys/Makefile.am |   43 ----------
 2 files changed, 98 insertions(+), 141 deletions(-)

commit 6cff24f437566e217fdb87beb6e178758a652072
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Oct 22 16:55:29 2009 +0100

    Fix some compilation errors in cogl-gles2-wrapper.c
    
    The changes in 74f2122b6 introduced some syntax errors which were
    preventing the GLES2 backend from compiling.

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

commit aeaf50ec114a15d15c18b92db650d8de3c5ffdd0
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Oct 22 15:39:30 2009 +0100

    Remove cogl/{gl,gles}/Makefile.am
    
    These are no longer used anywhere.

 gl/Makefile.am   |   62 --------------------------------------
 gles/Makefile.am |   88 ------------------------------------------------------
 2 files changed, 0 insertions(+), 150 deletions(-)

commit c02e10c68842be125a56b3f59b4c6e14bc0a51dd
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Sep 29 02:56:23 2009 +0100

    [gles2] remove lots of redundant matrix stack code
    
    Since we no longer depend on the GL matrix API in Cogl we can remove a lot
    of wrapper code from the GLES 2 backend.  This is particularly nice given
    that there was no code shared between the cogl-matrix-stack API and gles2
    wrappers so we had a lot of duplicated logic.

 cogl/driver/gles/cogl-gles2-wrapper.c |  287 ++++-----------------------------
 cogl/driver/gles/cogl-gles2-wrapper.h |    9 +-
 2 files changed, 34 insertions(+), 262 deletions(-)

commit eed247955632173f4628d6c18ece26e79e6be98c
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Oct 13 23:09:42 2009 +0100

    [cogl] Removes the cogl-current-matrix abstraction
    
    The indirection through this API isn't necessary since we no longer
    arbitrate between the OpenGL matrix API and Cogl's client side API.  Also it
    doesn't help to maintain an OpenGL style matrix mode API for internal use
    since it's awkward to keep restoring the MODELVIEW mode and easy enough to
    directly work with the matrix stacks of interest.
    
    This replaces use of the _cogl_current_matrix API with direct use of the
    _cogl_matrix_stack API.  All the unused cogl_current_matrix API is removed
    and the matrix utility code left in cogl-current-matrix.c was moved to
    cogl.c.

 cogl/Makefile.am                   |    2 -
 cogl/cogl-clip-stack.c             |   15 ++-
 cogl/cogl-context.c                |    8 +-
 cogl/cogl-context.h                |    4 +-
 cogl/cogl-current-matrix.h         |   95 ---------------
 cogl/cogl-internal.h               |   14 ++-
 cogl/cogl-material.c               |    2 +
 cogl/cogl-texture.c                |   28 ++---
 cogl/cogl-util.c                   |    1 -
 cogl/cogl.c                        |  228 ++++++++++++++++++++++++++++++-----
 cogl/driver/gl/cogl-fbo.c          |   26 ++---
 cogl/driver/gl/cogl-primitives.c   |   24 +---
 cogl/driver/gles/cogl-fbo.c        |   27 ++---
 cogl/driver/gles/cogl-primitives.c |   24 +---
 doc/reference/cogl/Makefile.am     |    1 -
 15 files changed, 271 insertions(+), 228 deletions(-)

commit 01887460f6051cb107b3a03934eee411ac382a3f
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Oct 14 10:53:48 2009 +0100

    [matrix-stack] Adds ctx->flushed_matrix_mode to cache the gl matrix mode
    
    This cache of the gl matrix mode lets us avoid repeat calls to glMatrixMode
    in _cogl_matrix_stack_flush_to_gl when we have lots of sequential modelview
    matrix modifications.

 cogl/cogl-context.c      |    1 +
 cogl/cogl-context.h      |    1 +
 cogl/cogl-matrix-stack.c |   30 ++++++++++++++++++------------
 3 files changed, 20 insertions(+), 12 deletions(-)

commit 43f8032a7f658245edee77133f3cc970aa6820ed
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Oct 6 12:36:32 2009 +0100

    matrix-stack: more optimization for load_identity case
    
    This goes a bit further than the previous patch, and as a special case
    we now simply represent identity matrices using a boolean, and only
    lazily initialize them when they need to be modified.

 cogl/cogl-matrix-stack.c |   82 +++++++++++++++++++++++++++++++++++++++------
 1 files changed, 71 insertions(+), 11 deletions(-)

commit d15331604501dae4d6071de4092b91e88c02b3f8
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Oct 6 10:52:07 2009 +0100

    [matrix-stack] avoid redundant clearing of matrix when using load_identity
    
    The journal always uses an identity matrix since it uses software
    transformation.  Currently it manually uses glLoadMatrix since previous
    experimentation showed that the cogl-matrix-stack gave bad performance, but
    it would be nice to fix performance so we only have to care about one path
    for loading matrices.
    
    For the common case where we do:
    cogl_matrix_stack_push()
    cogl_matrix_stack_load_identity()
    we were effectively initializing the matrix 3 times. Once due to use of
    g_slice_new0, then we had a cogl_matrix_init_identity in
    _cogl_matrix_state_new for good measure, and then finally in
    cogl_matrix_stack_load_identity we did another cogl_matrix_init_identity.
    
    We don't use g_slice_new0 anymore, _cogl_matrix_state_new is documented as
    not initializing the matrix (instead _cogl_matrix_stack_top_mutable now
    takes a boolean to choose if new stack entries should be initialised) and so
    we now only initialize once in cogl_matrix_stack_load_identity.

 cogl/cogl-matrix-stack.c |   54 ++++++++++++++++++++++-----------------------
 1 files changed, 26 insertions(+), 28 deletions(-)

commit 1402d1eb3c9fd2d9207b7089fb29b34eb594e059
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Sep 29 02:58:27 2009 +0100

    [current-matrix] Adds texture matrix stacks + removes GL matrix API usage
    
    This relates back to an earlier commitment to stop using the OpenGL matrix
    API which is considered deprecated. (ref 54159f5a1d029db)
    
    The new texture matrix stacks are hung from a list of (internal only)
    CoglTextureUnit structures which the CoglMaterial code internally references
    via _cogl_get_texure_unit ().
    
    So we would be left with only the cogl-matrix-stack code being responsible
    for glMatrixMode, glLoadMatrix and glLoadIdentity this commit updates the
    journal code so it now uses the matrix-stack API instead of GL directly.

 cogl/cogl-context.c        |    4 +
 cogl/cogl-context.h        |    5 +-
 cogl/cogl-current-matrix.c |  236 +++++++++-----------------------------------
 cogl/cogl-internal.h       |   12 +++
 cogl/cogl-journal.c        |   33 ++++---
 cogl/cogl-material.c       |   22 +++--
 cogl/cogl-matrix-stack.c   |   15 +++-
 cogl/cogl.c                |   59 +++++++++++
 8 files changed, 174 insertions(+), 212 deletions(-)

commit d8107c5ef52eb28b7e25626830bed20ab1cadea1
Merge: 861766f 76480b4
Author: Emmanuele Bassi <ebassi@gnome.org>
Date:   Mon Oct 19 11:45:15 2009 +0100

    Merge branch 'layout-manager'
    
    * layout-manager: (50 commits)
      docs: Reword a link
      layout, docs: Add more documentation to LayoutManager
      layout, docs: Fix description of Bin properties
      layout, bin: Use ceilf() instead of casting to int
      layout, docs: Add long description for FlowLayout
      layout, box: Clean up
      layout, box: Write long description for Box
      layout, docs: Remove unused functions
      layout: Document BoxLayout
      layout: Add BoxLayout, a single line layout manager
      layout: Report the correct size of FlowLayout
      layout: Resizing the stage resizes the FlowLayout box
      layout: Use the get_request_mode() getter in BinLayout
      layout: Change the request-mode along with the orientation
      actor: Add set_request_mode() method
      [layout] Remove FlowLayout:wrap
      [layout] Rename BinLayout and FlowLayout interactive tests
      [layout] Skip invisible children in FlowLayout
      [layout] Clean up and document FlowLayout
      [layout] Snap children of FlowLayout to column/row
      ...

commit 861766f4ad8f8d984e37643dcb7db0914c2e9b1b
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Sep 16 14:01:57 2009 +0100

    [cogl-primitives] Split the journal out from cogl-primitives.c
    
    The Journal can be considered a standalone component, so even though
    it's currently only used to log quads, it seems better to split it
    out into its own file.

 cogl/Makefile.am            |    2 +
 cogl/cogl-context.c         |    1 +
 cogl/cogl-journal-private.h |   57 ++++
 cogl/cogl-journal.c         |  744 +++++++++++++++++++++++++++++++++++++++++++
 cogl/cogl-primitives.c      |  705 +----------------------------------------
 cogl/cogl-texture-private.h |   14 -
 6 files changed, 805 insertions(+), 718 deletions(-)

commit 5387aa0e9e509f962f6007f6860e1168db43583c
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Sep 23 15:11:55 2009 +0100

    [cogl-spans] split out cogl-spans code from cogl-texture-2d-sliced
    
    When we implement atlas textures we will probably want to use the spans API
    to handle texture repeating so it doesn't make sense to leave the code in
    cogl-texture-2d-sliced.c.  Since it's a standalone set of data structures
    and algorithms it also seems reasonable to split out from cogl-texture.

 cogl/Makefile.am                      |    2 +
 cogl/cogl-spans.c                     |  132 ++++++++++++++++++++++
 cogl/cogl-spans.h                     |   70 ++++++++++++
 cogl/cogl-texture-2d-sliced-private.h |   27 -----
 cogl/cogl-texture-2d-sliced.c         |  195 ++++++++-------------------------
 5 files changed, 248 insertions(+), 178 deletions(-)

commit 65015a137e8e1b2957e219c08dc9ae823ef5b527
Author: Vladimir Nadvornik <nadvornik@suse.cz>
Date:   Sun Aug 30 12:36:11 2009 +0200

    [cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced
    
    cogl-texture-2d-sliced provides an implementation of CoglTexture and this
    seperation lays the foundation for potentially supporting atlas textures,
    pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path
    GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.

 cogl/Makefile.am                       |    2 +
 cogl/cogl-context.c                    |    2 +
 cogl/cogl-context.h                    |    2 +
 cogl/cogl-handle.h                     |    4 +-
 cogl/cogl-texture-2d-sliced-private.h  |  191 ++++
 cogl/cogl-texture-2d-sliced.c          | 1871 +++++++++++++++++++++++++++++++
 cogl/cogl-texture-driver.h             |   12 +
 cogl/cogl-texture-private.h            |   80 +-
 cogl/cogl-texture.c                    | 1926 +++++++-------------------------
 cogl/driver/gl/cogl-texture-driver.c   |   97 +--
 cogl/driver/gles/cogl-context-driver.c |    2 -
 cogl/driver/gles/cogl-context-driver.h |    2 -
 cogl/driver/gles/cogl-texture-driver.c |  217 +----
 13 files changed, 2551 insertions(+), 1857 deletions(-)

commit c40d5ae9eaff0f7ace613a4c530a2219f6cbe6c3
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Sep 16 11:56:17 2009 +0100

    [cogl-texture] Seal CoglTexture internals from cogl-primitives.c
    
    cogl-primitives.c was previously digging right into CoglTextures so it could
    manually iterate the texture slices for texturing quads and polygons and
    because we were missing some state getters we were lazily just poking into
    the structures directly.
    
    This adds some extra state getter functions, and adds a higher level
    _cogl_texture_foreach_slice () API that hopefully simplifies the way in
    which sliced textures may be used to render primitives.  This lets you
    specify a rectangle in "virtual" texture coords and it will call a given
    callback for each slice that intersects that rectangle giving the virtual
    coords of the current slice and corresponding "real" texture coordinates for
    the underlying gl texture.
    
    At the same time a noteable bug in how we previously iterated sliced
    textures was fixed, whereby we weren't correctly handling inverted texture
    coordinates.  E.g.  with the previous code if you supplied texture coords of
    tx1=100,ty1=0,tx2=0,ty2=100 (inverted along y axis) that would result in a
    back-facing quad, which could be discarded if using back-face culling.

 cogl/cogl-material.c        |    9 +-
 cogl/cogl-primitives.c      |  736 +++++++++++++++++++++----------------------
 cogl/cogl-texture-private.h |   47 ++--
 cogl/cogl-texture.c         |  239 +++++++++++++-
 cogl/cogl-vertex-buffer.c   |    6 +-
 cogl/driver/gl/cogl-fbo.c   |   29 +-
 cogl/driver/gles/cogl-fbo.c |   29 +-
 7 files changed, 640 insertions(+), 455 deletions(-)

commit c943b34cbeda803c66783976c5aec80601901dca
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Jul 30 12:06:02 2009 +0100

    [docs] switch gl_handle+gl_target docs for cogl_texture_new_from_foreign
    
    The descriptions for gl_handle and gl_target were inverted.
    
    Thanks to Young-Ho Cha for spotting that.
    
    Signed-off-by: Robert Bragg <robert@linux.intel.com>

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

commit 17e899a49d7d657f57103804bc2c59f526528a34
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Jul 29 17:21:07 2009 +0100

    [cogl] move clutter/pango to clutter/cogl/pango
    
    As part of the re-organisation of Cogl; move clutter/pango to be part of the
    cogl sub-project.

 Makefile.am                     |    2 +-
 pango/Makefile.am               |   33 ++
 pango/cogl-pango-display-list.c |  417 +++++++++++++++++++++++
 pango/cogl-pango-display-list.h |   70 ++++
 pango/cogl-pango-fontmap.c      |  209 ++++++++++++
 pango/cogl-pango-glyph-cache.c  |  352 ++++++++++++++++++++
 pango/cogl-pango-glyph-cache.h  |   78 +++++
 pango/cogl-pango-private.h      |   38 +++
 pango/cogl-pango-render.c       |  697 +++++++++++++++++++++++++++++++++++++++
 pango/cogl-pango.h              |   85 +++++
 10 files changed, 1980 insertions(+), 1 deletions(-)

commit 0bce7eac5375936d9ac6486f13cef94298f8590e
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Jul 28 02:02:02 2009 +0100

    Intial Re-layout of the Cogl source code and introduction of a Cogl Winsys
    
    As part of an incremental process to have Cogl be a standalone project we
    want to re-consider how we organise the Cogl source code.
    
    Currently this is the structure I'm aiming for:
    cogl/
        cogl/
    	<put common source here>
    	winsys/
    	   cogl-glx.c
    	   cogl-wgl.c
    	driver/
    	    gl/
    	    gles/
    	os/ ?
        utils/
    	cogl-fixed
    	cogl-matrix-stack?
            cogl-journal?
            cogl-primitives?
        pango/
    
    The new winsys component is a starting point for migrating window system
    code (i.e.  x11,glx,wgl,osx,egl etc) from Clutter to Cogl.
    
    The utils/ and pango/ directories aren't added by this commit, but they are
    noted because I plan to add them soon.
    
    Overview of the planned structure:
    
    * The winsys/ API is the API that binds OpenGL to a specific window system,
      be that X11 or win32 etc.  Example are glx, wgl and egl. Much of the logic
      under clutter/{glx,osx,win32 etc} should migrate here.
    
    * Note there is also the idea of a winsys-base that may represent a window
      system for which there are multiple winsys APIs.  An example of this is
      x11, since glx and egl may both be used with x11.  (currently only Clutter
      has the idea of a winsys-base)
    
    * The driver/ represents a specific varient of OpenGL. Currently we have "gl"
      representing OpenGL 1.4-2.1 (mostly fixed function) and "gles" representing
      GLES 1.1 (fixed funciton) and 2.0 (fully shader based)
    
    * Everything under cogl/ should fundamentally be supporting access to the
      GPU.  Essentially Cogl's most basic requirement is to provide a nice GPU
      Graphics API and drawing a line between this and the utility functionality
      we add to support Clutter should help keep this lean and maintainable.
    
    * Code under utils/ as suggested builds on cogl/ adding more convenient
      APIs or mechanism to optimize special cases. Broadly speaking you can
      compare cogl/ to OpenGL and utils/ to GLU.
    
    * clutter/pango will be moved to clutter/cogl/pango
    
    How some of the internal configure.ac/pkg-config terminology has changed:
    backendextra -> CLUTTER_WINSYS_BASE # e.g. "x11"
    backendextralib -> CLUTTER_WINSYS_BASE_LIB # e.g. "x11/libclutter-x11.la"
    clutterbackend -> {CLUTTER,COGL}_WINSYS # e.g. "glx"
    CLUTTER_FLAVOUR -> {CLUTTER,COGL}_WINSYS
    clutterbackendlib -> CLUTTER_WINSYS_LIB
    CLUTTER_COGL -> COGL_DRIVER # e.g. "gl"
    
    Note: The CLUTTER_FLAVOUR and CLUTTER_COGL defines are kept for apps
    
    As the first thing to take advantage of the new winsys component in Cogl;
    cogl_get_proc_address() has been moved from cogl/{gl,gles}/cogl.c into
    cogl/common/cogl.c and this common implementation first trys
    _cogl_winsys_get_proc_address() but if that fails then it falls back to
    gmodule.

 Makefile.am                                      |   89 +-
 TODO                                             |   25 -
 cogl-bitmap.h                                    |   80 -
 cogl-color.h                                     |  261 --
 cogl-debug.h                                     |   79 -
 cogl-deprecated.h                                |   36 -
 cogl-fixed.h                                     |  782 -----
 cogl-material.h                                  |  781 -----
 cogl-matrix.h                                    |  290 --
 cogl-offscreen.h                                 |   96 -
 cogl-path.h                                      |  347 --
 cogl-shader.h                                    |  313 --
 cogl-texture.h                                   |  465 ---
 cogl-types.h                                     |  328 --
 cogl-vertex-buffer.h                             |  452 ---
 cogl.h.in                                        |  875 -----
 cogl.pc.in                                       |   15 -
 cogl/Makefile.am                                 |  161 +
 cogl/cogl-bitmap-fallback.c                      |  460 +++
 cogl/cogl-bitmap-pixbuf.c                        |  368 +++
 cogl/cogl-bitmap-private.h                       |  115 +
 cogl/cogl-bitmap.c                               |  208 ++
 cogl/cogl-bitmap.h                               |   80 +
 cogl/cogl-blend-string.c                         | 1005 ++++++
 cogl/cogl-blend-string.h                         |  138 +
 cogl/cogl-clip-stack.c                           |  503 +++
 cogl/cogl-clip-stack.h                           |   43 +
 cogl/cogl-color.c                                |  201 ++
 cogl/cogl-color.h                                |  261 ++
 cogl/cogl-context.c                              |  215 ++
 cogl/cogl-context.h                              |  131 +
 cogl/cogl-current-matrix.c                       |  549 ++++
 cogl/cogl-current-matrix.h                       |   95 +
 cogl/cogl-debug.c                                |  131 +
 cogl/cogl-debug.h                                |   79 +
 cogl/cogl-deprecated.h                           |   36 +
 cogl/cogl-enum-types.c.in                        |   41 +
 cogl/cogl-enum-types.h.in                        |   25 +
 cogl/cogl-fixed.c                                |  950 ++++++
 cogl/cogl-fixed.h                                |  782 +++++
 cogl/cogl-handle.h                               |  157 +
 cogl/cogl-internal.h                             |   88 +
 cogl/cogl-material-private.h                     |  255 ++
 cogl/cogl-material.c                             | 1972 +++++++++++
 cogl/cogl-material.h                             |  781 +++++
 cogl/cogl-matrix-stack.c                         |  363 +++
 cogl/cogl-matrix-stack.h                         |   82 +
 cogl/cogl-matrix.c                               |  282 ++
 cogl/cogl-matrix.h                               |  290 ++
 cogl/cogl-offscreen.h                            |   96 +
 cogl/cogl-path.h                                 |  347 ++
 cogl/cogl-primitives.c                           | 2329 +++++++++++++
 cogl/cogl-primitives.h                           |   62 +
 cogl/cogl-shader.h                               |  313 ++
 cogl/cogl-texture-driver.h                       |  157 +
 cogl/cogl-texture-private.h                      |  151 +
 cogl/cogl-texture.c                              | 1682 ++++++++++
 cogl/cogl-texture.h                              |  465 +++
 cogl/cogl-types.h                                |  328 ++
 cogl/cogl-util.c                                 |  252 ++
 cogl/cogl-util.h                                 |   30 +
 cogl/cogl-vertex-buffer-private.h                |  169 +
 cogl/cogl-vertex-buffer.c                        | 2016 ++++++++++++
 cogl/cogl-vertex-buffer.h                        |  452 +++
 cogl/cogl.c                                      |  879 +++++
 cogl/cogl.h.in                                   |  875 +++++
 cogl/cogl.pc.in                                  |   17 +
 cogl/driver/Makefile.am                          |    7 +
 cogl/driver/gl/Makefile.am                       |   39 +
 cogl/driver/gl/cogl-context-driver.c             |   84 +
 cogl/driver/gl/cogl-context-driver.h             |  103 +
 cogl/driver/gl/cogl-defines.h.in                 | 1053 ++++++
 cogl/driver/gl/cogl-fbo.c                        |  330 ++
 cogl/driver/gl/cogl-fbo.h                        |   39 +
 cogl/driver/gl/cogl-primitives.c                 |  282 ++
 cogl/driver/gl/cogl-program.c                    |  255 ++
 cogl/driver/gl/cogl-program.h                    |   39 +
 cogl/driver/gl/cogl-shader-private.h             |   39 +
 cogl/driver/gl/cogl-shader.c                     |  177 +
 cogl/driver/gl/cogl-texture-driver.c             |  454 +++
 cogl/driver/gl/cogl.c                            |  443 +++
 cogl/driver/gles/Makefile.am                     |   62 +
 cogl/driver/gles/cogl-context-driver.c           |   41 +
 cogl/driver/gles/cogl-context-driver.h           |   44 +
 cogl/driver/gles/cogl-defines.h.in               |  638 ++++
 cogl/driver/gles/cogl-fbo.c                      |  343 ++
 cogl/driver/gles/cogl-fbo.h                      |   39 +
 cogl/driver/gles/cogl-fixed-fragment-shader.glsl |   62 +
 cogl/driver/gles/cogl-fixed-vertex-shader.glsl   |   65 +
 cogl/driver/gles/cogl-gles2-wrapper.c            | 1635 ++++++++++
 cogl/driver/gles/cogl-gles2-wrapper.h            |  433 +++
 cogl/driver/gles/cogl-primitives.c               |  453 +++
 cogl/driver/gles/cogl-program.c                  |  338 ++
 cogl/driver/gles/cogl-program.h                  |   43 +
 cogl/driver/gles/cogl-shader-private.h           |   40 +
 cogl/driver/gles/cogl-shader.c                   |  221 ++
 cogl/driver/gles/cogl-texture-driver.c           |  481 +++
 cogl/driver/gles/cogl-util.c                     |   49 +
 cogl/driver/gles/cogl-util.h                     |   30 +
 cogl/driver/gles/cogl.c                          |   64 +
 cogl/driver/gles/stringify.sh                    |   94 +
 cogl/stb_image.c                                 | 3772 ++++++++++++++++++++++
 cogl/winsys/Makefile.am                          |   43 +
 cogl/winsys/cogl-eglnative.c                     |   35 +
 cogl/winsys/cogl-eglx.c                          |   35 +
 cogl/winsys/cogl-fruity.c                        |   35 +
 cogl/winsys/cogl-glx.c                           |   78 +
 cogl/winsys/cogl-osx.c                           |   35 +
 cogl/winsys/cogl-sdl.c                           |   35 +
 cogl/winsys/cogl-win32.c                         |   35 +
 cogl/winsys/cogl-winsys.h                        |   30 +
 common/Makefile.am                               |   96 -
 common/cogl-bitmap-fallback.c                    |  460 ---
 common/cogl-bitmap-pixbuf.c                      |  368 ---
 common/cogl-bitmap-private.h                     |  115 -
 common/cogl-bitmap.c                             |  208 --
 common/cogl-blend-string.c                       | 1005 ------
 common/cogl-blend-string.h                       |  138 -
 common/cogl-clip-stack.c                         |  503 ---
 common/cogl-clip-stack.h                         |   43 -
 common/cogl-color.c                              |  201 --
 common/cogl-context.c                            |  215 --
 common/cogl-context.h                            |  131 -
 common/cogl-current-matrix.c                     |  549 ----
 common/cogl-current-matrix.h                     |   95 -
 common/cogl-debug.c                              |  131 -
 common/cogl-enum-types.c.in                      |   41 -
 common/cogl-enum-types.h.in                      |   25 -
 common/cogl-fixed.c                              |  950 ------
 common/cogl-handle.h                             |  157 -
 common/cogl-internal.h                           |   88 -
 common/cogl-material-private.h                   |  255 --
 common/cogl-material.c                           | 1972 -----------
 common/cogl-matrix-stack.c                       |  363 ---
 common/cogl-matrix-stack.h                       |   81 -
 common/cogl-matrix.c                             |  282 --
 common/cogl-primitives.c                         | 2329 -------------
 common/cogl-primitives.h                         |   62 -
 common/cogl-texture-driver.h                     |  157 -
 common/cogl-texture-private.h                    |  151 -
 common/cogl-texture.c                            | 1682 ----------
 common/cogl-util.c                               |  252 --
 common/cogl-util.h                               |   30 -
 common/cogl-vertex-buffer-private.h              |  169 -
 common/cogl-vertex-buffer.c                      | 2016 ------------
 common/cogl.c                                    |  858 -----
 common/stb_image.c                               | 3772 ----------------------
 doc/reference/cogl/Makefile.am                   |   11 +-
 gl/cogl-context-driver.c                         |   84 -
 gl/cogl-context-driver.h                         |  103 -
 gl/cogl-defines.h.in                             | 1053 ------
 gl/cogl-fbo.c                                    |  330 --
 gl/cogl-fbo.h                                    |   39 -
 gl/cogl-primitives.c                             |  282 --
 gl/cogl-program.c                                |  255 --
 gl/cogl-program.h                                |   39 -
 gl/cogl-shader-private.h                         |   39 -
 gl/cogl-shader.c                                 |  177 -
 gl/cogl-texture-driver.c                         |  454 ---
 gl/cogl.c                                        |  515 ---
 gles/cogl-context-driver.c                       |   41 -
 gles/cogl-context-driver.h                       |   44 -
 gles/cogl-defines.h.in                           |  638 ----
 gles/cogl-fbo.c                                  |  343 --
 gles/cogl-fbo.h                                  |   39 -
 gles/cogl-fixed-fragment-shader.glsl             |   62 -
 gles/cogl-fixed-vertex-shader.glsl               |   65 -
 gles/cogl-gles2-wrapper.c                        | 1635 ----------
 gles/cogl-gles2-wrapper.h                        |  433 ---
 gles/cogl-primitives.c                           |  453 ---
 gles/cogl-program.c                              |  338 --
 gles/cogl-program.h                              |   43 -
 gles/cogl-shader-private.h                       |   40 -
 gles/cogl-shader.c                               |  221 --
 gles/cogl-texture-driver.c                       |  481 ---
 gles/cogl-util.c                                 |   49 -
 gles/cogl-util.h                                 |   30 -
 gles/cogl.c                                      |   74 -
 gles/stringify.sh                                |   94 -
 179 files changed, 34125 insertions(+), 33762 deletions(-)

commit b85af722f4890e5d22ccd429441b6c6b82d2a391
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Jul 28 01:34:33 2009 +0100

    Make the CoglContext structure a bit more maintainable
    
    This moves most of cogl-context.{c.h} to cogl/common with some driver
    specific members now living in a CoglContextDriver struct.  Driver specific
    context initialization and typedefs now live in
    cogl/{gl,gles}/cogl-context-driver.{c,h}
    
    Driver specific members can be found under ctx->drv.stuff

 common/Makefile.am          |    2 +
 common/cogl-blend-string.c  |    2 +-
 common/cogl-context.c       |  215 +++++++++++++++++++++++++++++++++++
 common/cogl-context.h       |  131 ++++++++++++++++++++++
 common/cogl-material.c      |   14 +-
 common/cogl-primitives.c    |   12 +-
 common/cogl-vertex-buffer.c |   26 ++--
 common/cogl.c               |    2 +-
 gl/Makefile.am              |    2 +-
 gl/cogl-context-driver.c    |   84 ++++++++++++++
 gl/cogl-context-driver.h    |  103 +++++++++++++++++
 gl/cogl-context.c           |  259 -------------------------------------------
 gl/cogl-context.h           |  197 --------------------------------
 gl/cogl-fbo.c               |   24 ++--
 gl/cogl-primitives.c        |    2 +-
 gl/cogl-program.c           |   50 ++++----
 gl/cogl-shader.c            |   12 +-
 gl/cogl-texture-driver.c    |    2 +-
 gl/cogl.c                   |  224 +++++++++++++++++++-------------------
 gles/Makefile.am            |    2 +-
 gles/cogl-context-driver.c  |   41 +++++++
 gles/cogl-context-driver.h  |   44 ++++++++
 gles/cogl-context.c         |  214 -----------------------------------
 gles/cogl-context.h         |  136 ----------------------
 gles/cogl-fbo.c             |    8 +-
 gles/cogl-gles2-wrapper.c   |    2 +-
 gles/cogl-program.c         |   16 ++--
 gles/cogl-texture-driver.c  |   14 +-
 28 files changed, 828 insertions(+), 1012 deletions(-)

commit 739b460c7a16693fb98fea5af4dc0daa9688c47a
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Jul 28 00:37:11 2009 +0100

    Improve cogl-texture maintainability by moving 90% into cogl/common
    
    This splits the limited components that differed between
    cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files
    and the rest that can now be shared into cogl/common/cogl-texture.c

 common/Makefile.am            |    3 +
 common/cogl-internal.h        |    1 +
 common/cogl-texture-driver.h  |  157 ++++
 common/cogl-texture-private.h |  151 +++
 common/cogl-texture.c         | 1682 +++++++++++++++++++++++++++++++++
 gl/Makefile.am                |    3 +-
 gl/cogl-texture-driver.c      |  454 +++++++++
 gl/cogl-texture-private.h     |  145 ---
 gl/cogl-texture.c             | 1996 ---------------------------------------
 gles/Makefile.am              |    3 +-
 gles/cogl-gles2-wrapper.h     |    1 +
 gles/cogl-texture-driver.c    |  481 ++++++++++
 gles/cogl-texture-private.h   |  144 ---
 gles/cogl-texture.c           | 2066 -----------------------------------------
 14 files changed, 2932 insertions(+), 4355 deletions(-)

commit 4f5e6b77d51b902bb7b54eee0d153492544e1b25
Merge: 4221e13 76480b4
Author: Emmanuele Bassi <ebassi@gnome.org>
Date:   Fri Oct 16 15:55:05 2009 +0100

    Merge branch 'bug-1846'
    
    * bug-1846:
      Fix warning message in the ParamSpec validation

commit 4221e13feb3d5a6e49cc3f4a57e76b14fe04bcb2
Author: Emmanuele Bassi <ebassi@gnome.org>
Date:   Fri Oct 16 15:55:04 2009 +0100

    Merge branch 'bug-1845'
    
    * bug-1845:
      Add a warning when ClutterInterval can't compute progress

commit 76480b466f61f8938d0c424685218ac9e351be1d
Author: Emmanuele Bassi <ebassi@gnome.org>
Date:   Wed Oct 7 17:35:11 2009 +0100

    docs: Add the "clipping" section to the COGL API reference
    
    All the clip-related API in COGL is missing from the API reference
    because the cogl-clipping section is not included inside the main
    index file.

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

commit b5c120dda328c308bd30e44cd4f877bb7cc5328b
Merge: c21f73f 0b4837d
Author: Emmanuele Bassi <ebassi@gnome.org>
Date:   Mon Oct 5 12:37:08 2009 +0100

    Merge branch 'stage-window-object'
    
    * stage-window-object:
      [x11] Fix Stage user-initiated resize
      [x11] Remove a useless forced paint
      [stage] Rework the Stage implementation class

commit c21f73ff884e87b399cfe6dc4a819b5d288f2720
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Jul 28 00:40:29 2009 +0100

    [cogl-debug] avoid warnings when using COGL_NOTE with unbraced else clauses
    
    When not building a debug build the compiler was warning about empty
    else clauses with no braces due to code like:
      if (blah)
    	do_foo();
      else
    	COGL_NOTE (DRAW, "a-wibble");
    
    This simply ensures that even for non debug builds COGL_NOTE will expand to
    a single statement.

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

commit 61e6c57bdd95ec22a04c440ec6087e4bb24c2095
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Sep 24 17:34:26 2009 +0100

    [cogl-vertex-buffer] fix n_components validation for GL's builtin attributes
    
    glVertexPointer expects positions with 2, 3 or 4 components, glColorPointer
    expects colors with 3 or 4 components and glNormalPointer expects normals
    with three components so when adding vertex buffer atributes with the names
    "gl_Vertex", "gl_Color" or "gl_Normal" we assert these constraints and print
    an explanation to the developer if not met.
    
    This also fixes the previosly incorrect constraint that gl_Normal attributes
    must have n_components == 1; thanks to Cat Sidhe for reporting this:
    
    Bug: http://bugzilla.openedhand.com/show_bug.cgi?id=1819

 common/cogl-vertex-buffer.c |   19 +++++++++++++++----
 1 files changed, 15 insertions(+), 4 deletions(-)

commit 84441610de4e58d358f9a94c568609d79c8ce8fb
Author: Damien Lespiau <damien.lespiau@intel.com>
Date:   Mon Sep 21 15:21:21 2009 +0100

    Add a few annotations on Cogl primitives functions
    
    By default, float * is considered as an out argument by gobject
    introspection which is wrong for quite a few Cogl symbols. Start adding
    annotations to fix that for the ones in the "Primitives" gtk-doc
    section.

 cogl-path.h    |    8 ++++----
 cogl-texture.h |   15 ++++++++-------
 2 files changed, 12 insertions(+), 11 deletions(-)

commit e7ee24048343269244651ec024db6918558046d1
Author: Neil Roberts <neil@linux.intel.com>
Date:   Thu Sep 17 18:29:03 2009 +0100

    [cogl] Remove CoglContext->journal_vbo{,_len}
    
    The lifetime of the journal VBO is entirely within the scope of the
    cogl_journal_flush function so there is no need to store it globally
    in the Cogl context. Instead, upload_vertices_to_vbo just returns the
    new VBO. cogl_journal_flush stores this in a local variable and
    destroys it before returning.
    
    This also fixes an assertion when using the GLES backend which was
    caused by nothing initialising the journal_vbo variable.

 common/cogl-primitives.c |   20 ++++++++++----------
 gl/cogl-context.c        |    2 --
 gl/cogl-context.h        |    2 --
 gles/cogl-context.h      |    1 -
 4 files changed, 10 insertions(+), 15 deletions(-)

commit 83fc188f73fa23345fc593d66cee965f1991e1ea
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Wed Sep 16 17:43:58 2009 +0100

    [build] Split out the custom silent rules
    
    The silent rules we use for custom targets should be moved into a
    separate Makefile.am that gets included from all the others.

 Makefile.am        |    8 ++------
 common/Makefile.am |    8 ++------
 gl/Makefile.am     |    2 ++
 gles/Makefile.am   |    2 ++
 4 files changed, 8 insertions(+), 12 deletions(-)

commit eb6728f0623955207bcbccc49bf6cf4da8095fd1
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Sep 15 16:27:45 2009 +0100

    [cogl-fbo] Disable mipmap filters before calling glCheckFramebufferStatusEXT
    
    The framebuffer_object spec isn't clear in defining whether attaching a
    texture as a renderbuffer with mipmap filtering enabled while the mipmaps
    have not been uploaded should result in an incomplete framebuffer object.
    (different drivers make different decisions)
    
    To avoid an error with drivers that do consider this a problem we explicitly
    set non mipmapped filters before calling glCheckFramebufferStatusEXT.  The
    filters will later be reset when the texture is actually used for rendering
    according to the filters set on the corresponding CoglMaterial.

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

commit d07ab704d4a0d9b6d6d6827aae30315f7b21577e
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Sep 7 11:44:44 2009 +0100

    [docs] Small annotation fixes

 cogl-material.h |   29 ++++++++++++++++++-----------
 cogl-texture.h  |    7 ++++---
 2 files changed, 22 insertions(+), 14 deletions(-)

commit 0b4837d8a299d9c7702c6e73aabbc4a8091f6737
Author: Samuel Degrande <samuel.degrande@lifl.fr>
Date:   Wed Sep 2 16:27:22 2009 +0100

    DOT3_RGB[A] cannot be used in a Blend String
    
    The blend string compiler checks that the syntax of a function name is
    [A-Za-z_]*, preventing the use of DOT3_RGB[A].
    
    Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

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

commit e72747cbb879b23b26a1f89433a7b7c202481c4f
Author: Neil Roberts <neil@linux.intel.com>
Date:   Mon Aug 24 12:50:57 2009 +0100

    [cogl-texture] Set GL_PACK_ROW_LENGTH when downloading texture data
    
    Otherwise the rowstride passed in from an application is not used
    correctly so you can not download to an area with a much larger
    rowstride.

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

commit 5f566c2833c096d890f6c73695d28b70e43ec209
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Aug 20 12:53:32 2009 +0100

    Revert "[cogl] Allow Cogl to create NPOT textures for GLES2"
    
    This reverts commit 3c47a3beb51462ef8af1070b75123660059e97d0.
    
    Of course I remembered just after pushing the patch why we hadn't done
    this before :-) If you look in the glsl spec:
    http://www.khronos.org/registry/gles/specs/2.0/es_full_spec_2.0.24.pdf
    Section 3.7.10 Texture Completeness and Non-Power-Of-Two Textures
    you can see GLES 2.0 doesn't support mipmaps for npot textures.
    
    There is possibly some way we could support this in Cogl but at least
    it's not as simple as or-ing in the feature flag, sadly.

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

commit bf1ed7d67e86a3ed19e8ce1e57d38129ff7263a1
Author: Robert Bragg <robert@linux.intel.com>
Date:   Thu Aug 20 12:15:21 2009 +0100

    [cogl] Allow Cogl to create NPOT textures for GLES2
    
    The core GLES2 API supports NPOT textures, i.e. there is no extension as for
    OpenGL, so we now add COGL_FEATURE_TEXTURE_NPOT to the feature flags in
    _cogl_features_init.
    
    Thanks to Gordon Williams for spotting this.

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

commit 391477e67ba76ee7119b71a23350e2c1c4752811
Author: Robert Bragg <robert@linux.intel.com>
Date:   Wed Aug 19 15:38:25 2009 +0100

    [cogl] %.c: %.glsl codegen: use BUILT_SOURCES var + fix stringify.sh
    
    Don't let stringify.sh write to the $srcdir + use the BUILT_SOURCES var in
    Makefile.am so as to ensure all .c.  and .h files get generated from their
    corresponding .glsl files before building other targets.

 gles/Makefile.am  |   14 +++++++++-----
 gles/stringify.sh |   40 +++++++++++++++++++---------------------
 2 files changed, 28 insertions(+), 26 deletions(-)

commit 0aa31b4ebc4938627a9993e109043da6184939ad
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Aug 10 12:45:44 2009 +0200

    Use AM_SILENT_RULES if automake >= 1.11 is installed
    
    Fixes bug:
    
      http://bugzilla.openedhand.com/show_bug.cgi?id=1756
    
    Based on a patch by: Javier Jardón <javierjc1982@gmail.com>

 Makefile.am        |    6 ++++--
 common/Makefile.am |    7 ++++---
 2 files changed, 8 insertions(+), 5 deletions(-)

commit 9a55b0c3ff10d940fae95fd66501a93e32da95b9
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Aug 18 16:13:13 2009 +0100

    [cogl-material] Fix some brackets in _layer_flush_gl_sampler_state
    
    The wrong part of an expression was bracketed in the test to determine
    when a new texture matrix needed to be loaded which resulted in the
    first pass through _cogl_material_layer_flush_gl_sampler_state
    not uploading any user matrix.

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

commit ffd47f5b56fe2f02a4ee350be913f2ba5fdf3d51
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Tue Aug 18 11:11:29 2009 +0100

    [docs] texture_polygon() is called polygon()
    
    Remove the mentions to the old name of cogl_polygon().

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

commit 7f1659f9c78ab58c311839da573189400af250b0
Author: Götz Waschk <waschk@mandriva.org>
Date:   Mon Aug 17 14:12:21 2009 +0100

    Update Clutter to use G-I 0.6.4
    
    Following bug #1762, the syntax of g-ir-scanner was changed in
    gobject-introspection, so Clutter does not build anymore with 0.6.4.
    
    See the bugzilla bug:
    
      http://bugzilla.gnome.org/show_bug.cgi?id=591669
    
    GObject-Introspection now uses a different mechanism to extract the
    SONAME when building the gir file and it needs the libtool archive as
    option.
    
    Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

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

commit 7feae6702696e70bb0f98ba58682772833b25fb3
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Thu Aug 13 16:15:04 2009 +0100

    [docs] Remove the version number from the title
    
    The version number in the title made sense when we were breaking
    API with every minor release. Now that we're API stable we can
    drop that and make the output in Devhelp and on the website slightly
    more good looking.

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

commit c460786e9e43698d6fbe45c52dda7d1398096c3d
Author: zhou jiangwei <dyllan.zhou@samsung.com>
Date:   Tue Aug 11 14:17:28 2009 +0100

    [cogl] Fix the GLES 2.0 backend
    
    Update the GLES 2.0 backend to the new COGL API after the breakage
    introduced by the journal.
    
    Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

 common/cogl-primitives.c    |    5 +++--
 gles/cogl-context.h         |    5 ++++-
 gles/cogl-gles2-wrapper.h   |    5 +++++
 gles/cogl-primitives.c      |   10 +++++-----
 gles/cogl-texture-private.h |    3 +++
 5 files changed, 20 insertions(+), 8 deletions(-)

commit 1bdfb9e6d4740c8de9fd0490d5b08676ce6b2441
Author: Robert Bragg <robert@linux.intel.com>
Date:   Tue Aug 11 13:49:12 2009 +0100

    [cogl_clear] Also pass the alpha component of the CoglColor to glClearColor
    
    Previously we were passing a constant of 0.0 for the alpha component which
    wasn't as flexible.

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

commit 23bd5ecd47c02d54bb616efcaa78c207ba10d6cc
Merge: ac5314c 5d43728
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Mon Aug 10 17:21:20 2009 +0100

    Merge branch 'system-json-glib'
    
    * system-json-glib:
      [script] Simplify the parser code
      Update JSON-GLib dependency

commit ac5314c6d2e550aebe99afcfadd62197956952f3
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Tue Aug 4 11:38:48 2009 +0100

    [docs] Fix a missing parameter

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

commit ff833fa068ba0ba3125485159ad53302edf40ca6
Author: Emmanuele Bassi <ebassi@linux.intel.com>
Date:   Tue Aug 4 11:10:55 2009 +0100

    [cogl] Expose cogl_is_vertex_buffer()
    
    The function is public and available in the shared object, but
    it's not present in the header, so this is not an API/ABI change.

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