[docs] Update the animations tutorial

Bring the Animation framework introduction/tutorial up to the 1.0
API for timelines and animations.

Fix copy-and-paste errors in the deprecation macros

Fixes bug:

  http://bugzilla.openedhand.com/show_bug.cgi?id=1704

[docs] Fix typo in the effects migration guide

Fixes bug:

  http://bugzilla.openedhand.com/show_bug.cgi?id=1706

[docs] Improve the Units to and from string conversion

Make sure to document the conversion to and from strings for ClutterUnits,
with negative examples and with the behaviour for fractionary bits.

[doc] Miscellaneous documentation fixes

Remove private symbols, and add missing public ones.

[cogl] Make the blend string error domain public

The error domain and codes must present in a publicly installed header
otherwise they won't be usable to match a GError.

[gitignore] Add test-materials

Allow disabling motion event throttling

It might be desirable for some applications and/or platforms to get
every motion event that was delivered to Clutter from the windowing
backend. By adding a per-stage flag we can bypass the throttling
done when processing the events.

  http://bugzilla.openedhand.com/show_bug.cgi?id=1665

[docs] Move the releasing process to a separate file

The documentation on how to release Clutter should be in a separate
file from the documentation on how to hack on Clutter.

[doc] Remove references to cogl_vertex_buffer_delete_indices

These referencese were left over from before indices got CoglHandles to
uniquely identify them.  cogl_handle_unref can be used to delete indices
now.

[cogl/gles] Fix missing symbols in CoglContext

Keep the CoglContext in sync between GL and GLES backends. We ought
to find a way to have a generic context, though, and have backend
specific sections.

Fixes bug:

  http://bugzilla.openedhand.com/show_bug.cgi?id=1698

Fix parallel build of introspection

We need to explicitly force order so that ClutterJson.gir and Cogl.gir
are present in the parent directory before we try to build Clutter.typelib.

http://bugzilla.openedhand.com/show_bug.cgi?id=1700

Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

Fix building introspection when dolt is not in use

On some platforms (anything but Linux, and on obscure Linux
architectures) dolt isn't used, so $(top_builddir)/doltlibtool
won't exist. $(top_builddir)/libtool will always be generated
even if dolt is used, so just use that unconditionally. We don't
need the extra speed when linking the single program for
introspection.

http://bugzilla.openedhand.com/show_bug.cgi?id=1699

Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

Post-release bump to 0.9.9

[release] 0.9.8

Update NEWS file

Fix comments inside configure.ac

[stage] Force an allocation before showing the stage

A lot of applications change the size of the stage from the default
before the stage is initially shown. The size change won't take affect
until the first allocation run. However we want the window to be at
the correct size when we first map it so we should force an allocation
run before showing the stage.

There was an explicit call to XResizeWindow in
clutter_stage_x11_show. This is not needed anymore because
XResizeWindow will already have been called by the allocate method.

[win32] Compilation fixes

Remove the usage of the old CLUTTER_UNITS_* macros and put back a
missing ';'.

Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

[osx] Enable motion event dispatch

By default NSWindow does not listen to mousemoved events and hence the
default behaviour for Actors using the "motion-event" signal  differs
from backend to backend.

Using setAcceptsMouseMovedEvents seems to fix it; unfortunately, I
cannot verify it, but since nobody is currently working on the Quartz
backend I guess it cannot get more broken than how currently is.

Thanks to: Michael <michael@f3k.org>

Fixes bug:

  http://bugzilla.openedhand.com/show_bug.cgi?id=1687

[osx] Remove old units macros

Remove the usage of CLUTTER_UNITS_* macros and at least get the
chance to make the OSX backend compile.

Hopefully, since I can't currently test it.

[actor] Allow querying whether we are painted by a Clone

It would be useful inside a custom actor's paint function to be able to
tell if this is a primary paint call, or if we are in fact painting on
behalf of a clone.

In Mutter we have an optimization not to paint occluded windows; this is
desirable for the windows per se, to conserve bandwith to the card, but
if something like an application switcher is using clones of these windows,
they will not get painted either; currently we have no way of
differentiating between the two.

Fixes bug:

  http://bugzilla.openedhand.com/show_bug.cgi?id=1685

Remove unused TEXTURE_IN_CLONE_PAINT private flag

The CLUTTER_TEXTURE_IN_CLONE_PAINT was used with the old CloneTexture
actor; now that we have ClutterClone nothing sets the private flag
anymore, and the flag itself is not needed.

[x11] update_wm_hints after unsetting WITHDRAWN

Updating the WM hints on the stage window shortcircuits if the stage
is in WITHDRAWN state, so we need to move the update_wm_hints() call
after the flag has been unset.

Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

[glx] Make the wait_for_vblank function private

Nobody should be using the function to wait for the vblank outside
of the GLX backend.

Call glFinish() before manually waiting for VBLANK

If we manually wait for the VBLANK with:

  - SGI_video_sync
  - Direct usage of the DRM ioctl

Then we should call glFinish() first, or otherwise the swap-buffers
may be delayed by pending drawing and cause a tear.

http://bugzilla.openedhand.com/show_bug.cgi?id=1636

Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

[tests] Remove test-perspective

The perspective test was used essentially to determine whether the
perspective set up in COGL worked correctly. The perspective code
has been changed a lot since Clutter 0.3: we rely on client-side
matrices and we use floating point; so, all the conditions the test
was supposed to verify do not exist anymore.

[docs] Fix typos and remove mentions of SVN

Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

Use correct signal detail

The Animation should connect to the notify::alpha signal, not to
the non-existing notify::value signal.

Fixes bugs:

  http://bugzilla.openedhand.com/show_bug.cgi?id=1674
  http://bugzilla.openedhand.com/show_bug.cgi?id=1688

Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

Small code clean up

Make ClutterTexture slightly more similar to the rest of the code base.

[cogl] Fix more brokeness with _cogl_material_equal

commit e2c4a2a9f83 fixed one thing but broke many others things :-/
hopfully this fixes that.

It turned out that the journal was mistakenly setting the OVERRIDE_LAYER0
flush option for all entries, but some other logic errors were also
uncovered in _cogl_material_equal.

serialize upload of asyncronously loaded textures

Rate limit the uploading of textures to stop if it uses more than 5ms
during one master clock iteration.

ensure next iteration

Added an internal clutter function, _clutter_master_clock_ensure_next_iteration
that ensures another iteration of the master clock, can be called from repaint
functions as well as other threads.

[cogl] Fix drawing with sliced textures using material layer0 overrides

To help us handle sliced textures; When flushing materials there is an
override option that can be given to replace the texture name for layer0
so we may iterate the slices without needing to modify the material
in use.

Since improving the journal's ability to batch state changes we added a
_cogl_material_equals function that is used by the journal to compare
materials and identify when a state change is required, but this wasn't
correctly considering the layer0 override resulting in false positives that
meant the journal wouldn't update the GL state and the first texture name
was used for all slices.

[cogl matrix stack] Create a client side matrix stack for the projection matrix

The cost of glGetFloatv with Mesa is still representing a majority of our
time in OpenGL for some applications, and the last thing left using this is
the current-matrix API when getting the projection matrix.

This adds a matrix stack for the projection matrix, so all getting, setting
and modification of the projection matrix is now managed by Cogl and it's only
when we come to draw that we flush changes to the matrix to OpenGL.

This also brings us closer to being able to drop internal use of the
deprecated OpenGL matrix functions, re: commit 54159f5a1d02

Add more (allow-none) annotations

Use the (allow-none) annotation for clutter_init*

We accept NULL for some parameters in the initialization functions.

Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

Post-release bump to 0.9.7

[release] 0.9.6

[docs] Update the NEWS and README files

[actor] Remove the unused get_allocation_coords()

The clutter_actor_get_allocation_coords() is not used, and since
the switch to floats in the Actor's API, it returns exactly what
the get_allocation_box() returns.

[actor] Allow changing the transformations matrix

Currently, the transformation matrix for an actor is constructed
from scenegraph-related accessors. An actor, though, can call COGL
API to add new transformations inside the paint() implementation,
for instance:

  static void
  my_foo_paint (ClutterActor *a)
  {
    ...
    cogl_translate (-scroll_x, -scroll_y, 0);
    ...
  }

Unfortunately these transformations will be completely ignored by
the scenegraph machinery; for instance, getting the actor-relative
coordinates from event coordinates is going to break badly because
of this.

In order to make the scenegraph aware of the potential of additional
transformations, we need a ::apply_transform() virtual function. This
vfunc will pass a CoglMatrix which can be used to apply additional
operations:

  static void
  my_foo_apply_transform (ClutterActor *a, CoglMatrix *m)
  {
    CLUTTER_ACTOR_CLASS (my_foo_parent_class)->apply_transform (a, m);
    ...
    cogl_matrix_translate (m, -scroll_x, -scroll_y, 0);
    ...
  }

The ::paint() implementation will be called with the actor already
using the newly applied transformation matrix, as expected:

  static void
  my_foo_paint (ClutterActor *a)
  {
    ...
  }

The ::apply_transform() implementations *must* chain up, so that the
various transformations of each class are preserved. The default
implementation inside ClutterActor applies all the transformations
defined by the scenegraph-related accessors.

Actors performing transformations inside the paint() function will
continue to work as previously.

Split the typdef to avoid confusing scanners

Scanners like gtk-doc and g-ir-scanner get confused by:

  typedef struct _Foo {
    ...
  } Foo;

And expect instead:

  typedef struct _Foo Foo;

  struct _Foo {
    ...
  };

CoglMatrix definition should be changed to avoid the former type.

[x11] Fix the race between resize and glViewport calls

The race we were experiencing in the X11 backends is apparently
back after the fix in commit 00a3c698.

This time, just delaying the setting of the SYNC_MATRICES flag
is not enough, so we can resume the use of a STAGE_IN_RESIZE
private flag.

This should also fix bug:

  http://bugzilla.openedhand.com/show_bug.cgi?id=1668

Add debug notes for calls to glViewport()

In order to validate the sequence of:

        XResizeWindow
        ConfigureNotify
        glViewport

that should happen on X11 we need to add debug annotations to the
calls to glViewport() done through COGL.

[cogl] cache the viewport width and height

This avoids some calls to glGetFloatv, which have at least proven to be very
in-efficient in mesa at this point in time, since it always updates all derived
state even when it may not relate to the state being requested.

[cogl] Ensure well defined semantics for COGL_INVALID_HANDLE material layers

Fixes and adds a unit test for creating and drawing using materials with
COGL_INVALID_HANDLE texture layers.

This may be valid if for example the user has set a texture combine string
that only references a constant color.

_cogl_material_flush_layers_gl_state will bind the fallback texture for any
COGL_INVALID_HANDLE layer, later though we could explicitly check when the
current blend mode does't actually reference a texture source in which case
binding the fallback texture is redundant.

This tests drawing using cogl_rectangle, cogl_polygon and
cogl_vertex_buffer_draw.

Merge branch 'cogl-journal-batching'

[cogl] Improve ability to break out into raw OpenGL via begin/end mechanism
Adds a cogl_flush() to give developers breaking into raw GL a fighting chance
[cogl-material] Be more carefull about flushing in cogl_material_remove_layer
Revert "[rectangle] Avoid modifying materials mid scene"
Revert "[actor] Avoid modifying materials mid-scene to improve journal batching"
[cogl-vertex-buffer] Disable unused client tex coord arrays
[cogl] disable all client tex coord arrays in _cogl_add_path_to_stencil_buffer
[cogl] flush matrices in _cogl_add_path_to_stencil_buffer
[journal] Don't resize a singlton VBO; create and destroy a VBO each flush
[cogl] avoid using the journal in _cogl_add_path_to_stencil_buffer
[pango-display-list] Use the Cogl journal for short runs of text
[material] _cogl_material_equal: catch the simplest case of matching handles
[material] avoid flushing the journal when just changing the color
[cogl journal] Perform software modelview transform on logged quads.
[Cogl journal] use G_UNLIKLEY around runtime debugging conditions
[cogl journal] Adds a --cogl-debug=batching option to trace batching
[Cogl journal] Adds a --cogl-debug=journal option for tracing the journal
[cogl] Adds a debug option for disabling use of VBOs --cogl-debug=disable-vbos
[cogl] Force Cogl to always use the client side matrix stack
[cogl-debug] Adds a "client-side-matrices" Cogl debug option
[cogl-color] Adds a cogl_color_equal() function
[cogl material] optimize logging of material colors in the journal
[rectangle] Avoid modifying materials mid scene
[actor] Avoid modifying materials mid-scene to improve journal batching
[journal] Always pad our vertex data as if at least 2 layers are enabled
[cogl] Improving Cogl journal to minimize driver overheads + GPU state changes

The Cogl journal is a mechanism Cogl uses to batch geometry resulting from
any of the cogl_rectangle* functions before sending it to OpenGL.  This aims
to improve the Cogl journal so that it can reduce the number of state
changes and draw calls we issue to the OpenGL driver and hopfully improve
performance.

Previously each call to any of the cogl_rectangle* functions would imply an
immediate GL draw call, as well as a corresponding modelview change;
material state changes and gl{Vertex,Color,TexCoord}Pointer calls.  Now
though we have tried to open the scope for batching up as much as possible
so we only have to flush the geometry either before calling glXSwapBuffers,
or when we change state that isn't tracked by the journal.

As a basic example, it's now possible for us to batch typical picking
renders into a single draw call for the whole scene.

Some key points about this change:
- We now perform transformations of quads in software (except for long runs of
  text which continue to use VBOs)
    * It might seem surprising at first, but when you consider that so many
      Clutter actors are little more than textured quads and each actor
      typically implies a modelview matrix change; the costs involved in
      setting up the GPU with the new modelview can easily out weigh the cost
      of simply transforming 4 vertices.
- We always use Cogl's own client side matrix API now.
    * We found the performance of querying the OpenGL driver for matrix state
      was often worse than using the client matrix code, and also - discussing
      with Mesa developers - agreed that since khronos has essentially
      deprecated the GL matrix API (by removing it from OpenGL 3 and
      OpenGL-ES 2) it was appropriate to take full responsibility for all our
      matrix manipulation.
- Developers should avoid modifying materials mid-scene.
    * With the exception of material color changes, if you try and modify a
      material that is referenced in the journal we will currently force a
      journal flush. Note: you can assume that re-setting the same value for
      a material property won't require a flush though.
- Several new --cogl-debug options have been added
    * "disable-batching" can be used to identify bugs in the way that the
      journal does its batching; of could this shouldn't ever be needed :-)
    * "disable-vbos" can be used to test the VBO fallback paths where we
      simply use malloc()'d buffers instead.
    * "batching" lets you get an overview of how the journal is batching
      your geometry and may help you identify ways to improve your
      application performance.
    * "journal" lets you trace all the geometry as it gets logged in the
      journal, and all the geometry as its flushed from the journal.
      Obviously an inconsistency can identify a bug, but the numbers may
      help you verify application logic too.
    * "disable-software-transform" as implied will instead use the driver
      /GPU to transform quads by the modelview matrix.
    Although committed separately a --clutter-debug=nop-picking option was
    also added that lets you remove picking from the equation, which can
    sometimes help make problem analysis more deterministic.

[cogl] Improve ability to break out into raw OpenGL via begin/end mechanism

Although we wouldn't recommend developers try and interleve OpenGL drawing
with Cogl drawing - we would prefer patches that improve Cogl to avoid this
if possible - we are providing a simple mechanism that will at least give
developers a fighting chance if they find it necissary.

Note: we aren't helping developers change OpenGL state to modify the
behaviour of Cogl drawing functions - it's unlikley that can ever be
reliably supported - but if they are trying to do something like:

   - setup some OpenGL state.
   - draw using OpenGL (e.g. glDrawArrays() )
   - reset modified OpenGL state.
   - continue using Cogl to draw

They should surround their blocks of raw OpenGL with cogl_begin_gl() and
cogl_end_gl():

   cogl_begin_gl ();
   - setup some OpenGL state.
   - draw using OpenGL (e.g. glDrawArrays() )
   - reset modified OpenGL state.
   cogl_end_gl ();
   - continue using Cogl to draw

Again; we aren't supporting code like this:
   - setup some OpenGL state.
   - use Cogl to draw
   - reset modified OpenGL state.
When the internals of Cogl evolves, this is very liable to break.

cogl_begin_gl() will flush all internally batched Cogl primitives, and emit
all internal Cogl state to OpenGL as if it were going to draw something
itself.

The result is that the OpenGL modelview matrix will be setup; the state
corresponding to the current source material will be setup and other world
state such as backface culling, depth and fogging enabledness will be also
be sent to OpenGL.

Note: no special material state is flushed, so if developers want Cogl to setup
a simplified material state it is the their responsibility to set a simple
source material before calling cogl_begin_gl. E.g. by calling
cogl_set_source_color4ub().

Note: It is the developers responsibility to restore any OpenGL state that they
modify to how it was after calling cogl_begin_gl() if they don't do this then
the result of further Cogl calls is undefined.

Adds a cogl_flush() to give developers breaking into raw GL a fighting chance

This function should only need to be called in exceptional circumstances
since Cogl can normally determine internally when a flush is necessary.

As an optimization Cogl drawing functions may batch up primitives
internally, so if you are trying to use raw GL outside of Cogl you stand a
better chance of being successful if you ask Cogl to flush any batched
geometry before making your state changes.

cogl_flush() ensures that the underlying driver is issued all the commands
necessary to draw the batched primitives.  It provides no guarantees about
when the driver will complete the rendering.

This provides no guarantees about the GL state upon returning and to avoid
confusing Cogl you should aim to restore any changes you make before
resuming use of Cogl.

If you are making state changes with the intention of affecting Cogl drawing
primitives you are 100% on your own since you stand a good chance of
conflicting with Cogl internals.  For example clutter-gst which currently
uses direct GL calls to bind ARBfp programs will very likely break when Cogl
starts to use ARBfb programs internally for the material API, but for now it
can use cogl_flush() to at least ensure that the ARBfp program isn't applied
to additional primitives.

This does not provide a robust generalized solution supporting safe use of
raw GL, its use is very much discouraged.

[cogl-material] Be more carefull about flushing in cogl_material_remove_layer

Previously we would call _cogl_material_pre_change_notify unconditionally, but
now we wait until we really know we are removing a layer before notifying the
change, which will require a journal flush.

Since the convenience functions cogl_set_source_color4ub and
cogl_set_source_texture share a single material, cogl_set_source_color4ub
always calls cogl_material_remove_layer.  Often this is a NOP though and
shouldn't require a journal flush.

This gets performance back to where it was before reverting the per-actor
material commits.

Revert "[rectangle] Avoid modifying materials mid scene"

This reverts commit 8cf42ea8ac5c05f6b443c453f9c6c2a3cd75acfa.

Since the journal puts material colors in the vertex array accumulated for
drawing we don't need to flush the journal simply due to color changes which
means using cogl_set_source_color4ub is no longer a concern.

Revert "[actor] Avoid modifying materials mid-scene to improve journal batching"

This reverts commit 85243da382025bd516937c76a61b8381f6e74689.

Since the journal puts material colors in the vertex array accumulated for
drawing we don't need to flush the journal simply due to color changes
which means using cogl_set_source_color4ub is no longer a concern.

[cogl-vertex-buffer] Disable unused client tex coord arrays

Before any cogl vertex buffer drawing we call
enable_state_for_drawing_buffer which sets up the GL state, but we weren't
disabling unsed client texture coord arrays.

[cogl] disable all client tex coord arrays in _cogl_add_path_to_stencil_buffer

After flushing the journal an unknown number of client side texture arrays
may be left enabled. Disable them all before using glDrawArrays.

[cogl] flush matrices in _cogl_add_path_to_stencil_buffer

Before calling glRectf we need to ensure we flush the modelview and
projection matrices.

[journal] Don't resize a singlton VBO; create and destroy a VBO each flush

This simplifies the vertex data uploading in the journal, and could improve
performance.  Modifying a VBO mid-scene could reqire synchronizing with the
GPU or some form of shadowing/copying to avoid modifying data that the GPU
is currently processing; the buffer was also being marked as GL_STATIC_DRAW
which could have made things worse.

Now we simply create a GL_STATIC_DRAW VBO for each flush and and delete it
when we are finished.

[cogl] avoid using the journal in _cogl_add_path_to_stencil_buffer

Using cogl_rectangle (and thus the journal) in
_cogl_add_path_to_stencil_buffer means we have to consider all the state
that the journal may change in case it may interfer with the direct GL calls
used.  This has proven to be error prone and in this case the journal is an
unnecissary overhead.  We now simply call glRectf instead of using
cogl_rectangle.

[pango-display-list] Use the Cogl journal for short runs of text

For small runs of text like icon labels, we can get better performance
going through the Cogl journal since text may then be batched together
with other geometry.

For larger runs of text though we still use VBOs since the cost of logging
the quads becomes too expensive, including the software transform which
isn't at all optimized at this point.  VBOs also have the further advantage
of avoiding repeated validation of vertices by the driver and repeated
mapping of data into the GPU so long as the text doesn't change.

Currently the threshold is 100 vertices/25 quads. This number was plucked
out of thin air and should be tuned later.

With this change I see ~180% fps improvment for test-text. (x61s + i965 +
Mesa 7.6-devel)

[material] _cogl_material_equal: catch the simplest case of matching handles

We were missing the simplest test of all: are the two CoglHandles equal and
are the flush option flags for each material equal?  This should improve
batching for some common cases.

[material] avoid flushing the journal when just changing the color

Whenever we modify a material we call _cogl_material_pre_change_notify which
checks to see if the material is referenced by the journal and if so flushes
if before we modify the material.

Since the journal logs material colors directly into a vertex array (to
avoid us repeatedly calling glColor) then we know we never need to flush
the journal when material colors change.

[cogl journal] Perform software modelview transform on logged quads.

Since most Clutter actors aren't much more than textured quads; flushing the
journal typically involves lots of 'change modelview; draw quad' sequences.

The amount of overhead involved in uploading a new modelview and queuing
that primitive is huge in comparison to simply transforming 4 vertices by
the current modelview when logging quads.  (Note if your GPU supports HW
vertex transform, then it still does the projective and viewport transforms)

At the same time a --cogl-debug=disable-software-transform option has been
added for comparison and debugging.

This change allows typical pick scenes to be batched into a single draw call
and I'm seeing test-pick run over 200% faster with this.  (i965 + Mesa
7.6-devel)

[Cogl journal] use G_UNLIKLEY around runtime debugging conditions

May as well improve the branch prediction around runtime debugging code.

[cogl journal] Adds a --cogl-debug=batching option to trace batching

Enabling this option makes Cogl trace how the journal is managing to batch
your rectangles.  The journal staggers how it emmits state to the GL driver
and the batches will normally get smaller for each stage, but ideally you
don't want to be in a situation where Cogl is only able to draw one quad per
modelview change and draw call.

E.g. this is a fairly ideal example:
BATCHING: journal len = 101
BATCHING:  vbo offset batch len = 101
BATCHING:   material batch len = 101
BATCHING:    modelview batch len = 101

This isn't:
BATCHING: journal len = 1
BATCHING:  vbo offset batch len = 1
BATCHING:   material batch len = 1
BATCHING:    modelview batch len = 1
BATCHING: journal len = 1
BATCHING:  vbo offset batch len = 1
BATCHING:   material batch len = 1
BATCHING:    modelview batch len = 1
<repeat>

[Cogl journal] Adds a --cogl-debug=journal option for tracing the journal

When this option is used Cogl will print a trace of all quads that get
logged into the journal, and a trace of quads as they get flushed.

If you are seeing a bug with the geometry being drawn by Cogl this may give
some clues by letting you sanity check the numbers being logged vs the
numbers being emitted.

[cogl] Adds a debug option for disabling use of VBOs --cogl-debug=disable-vbos

For testing the VBO fallback paths it helps to be able to disable the
COGL_FEATURE_VBOS feature flag.  When VBOs aren't available Cogl should use
client side malloc()'d buffers instead.

[cogl] Force Cogl to always use the client side matrix stack

Previously we only used the Cogl matrix stack API for indirect contexts, but
it's too costly to keep on requesting modelview matrices from GL (for
logging in the journal) even for direct rendering.

I also experimented with a patch for mesa to improve performance and
discussed this with upstream, but we agreed to consider the GL matrix API
essentially deprecated.  (For reference the GLES 2 and GL 3 specs have
removed the matrix APIs)

[cogl-debug] Adds a "client-side-matrices" Cogl debug option

This allows us to force Cogl to use the client side matrix stack even when
direct rendering.

[cogl-color] Adds a cogl_color_equal() function

CoglColors shouldn't be compared using memcmp since they may contain
uninitialized padding bytes.

The prototype is also suitable for passing to g_hash_table_new as the
key_equal_func.

_cogl_pango_display_list_add_texture now uses this instead of memcmp.

[cogl material] optimize logging of material colors in the journal

We now put the color of materials into the vertex array used by the journal
instead of calling glColor() but the number of requests for the material
color were quite expensive so we have changed the material color to
internally be byte components instead of floats to avoid repeat conversions
and added _cogl_material_get_colorubv as a fast-path for the journal to
copy data into the vertex array.

[rectangle] Avoid modifying materials mid scene

To improve batching of geometry in the Cogl journal we need to avoid modifying
materials midscene.

Currently cogl_set_source_color and cogl_set_source_texture simply modify a
single shared material. In the future we can improve this so they use a pool
of materials that gets recycled as the journal is flushed, but for now we
give all ClutterRectangles their own private materials for painting with.

[actor] Avoid modifying materials mid-scene to improve journal batching

Currently cogl_set_source_color uses a single shared material which means
each actor that uses it causes the journal to flush if the color changes.
Until we improve cogl_set_source_color to use a pool of materials that can
be recycled as the journal is flushed we avoid mid-scene material changes by
giving all actors a private material instead.

[journal] Always pad our vertex data as if at least 2 layers are enabled

The number of material layers enabled when logging a quad in the journal
determines the stride of the corresponding vertex data (since we need a set
of texture coordinates for each layer.) By padding data in the case where we
have only one layer we can avoid a change in stride if we are mixing single
and double layer primitives in a scene (e.g.  relevent for a composite
manager that may use 2 layers for all shaped windows) Avoiding stride
changes means we can minimize calls to gl{Vertex,Color}Pointer when flushing
the journal.

Since we need to update the texcoord pointers when the actual number of
layers changes, this adds another batch_and_call() stage to deal with
glTexCoordPointer and enabling/disabling the client arrays.

[cogl] Improving Cogl journal to minimize driver overheads + GPU state changes

Previously the journal was always flushed at the end of
_cogl_rectangles_with_multitexture_coords, (i.e.  the end of any
cogl_rectangle* calls) but now we have broadened the potential for batching
geometry.  In ideal circumstances we will only flush once per scene.

In summary the journal works like this:

When you use any of the cogl_rectangle* APIs then nothing is emitted to the
GPU at this point, we just log one or more quads into the journal.  A
journal entry consists of the quad coordinates, an associated material
reference, and a modelview matrix.  Ideally the journal only gets flushed
once at the end of a scene, but in fact there are things to consider that
may cause unwanted flushing, including:

- modifying materials mid-scene
    This is because each quad in the journal has an associated material
    reference (i.e. not copy), so if you try and modify a material that is
    already referenced in the journal we force a flush first)

    NOTE: For now this means you should avoid using cogl_set_source_color()
      since that currently uses a single shared material. Later we
  should change it to use a pool of materials that is recycled
  when the journal is flushed.

- modifying any state that isn't currently logged, such as depth, fog and
  backface culling enables.

The first thing that happens when flushing, is to upload all the vertex data
associated with the journal into a single VBO.

We then go through a process of splitting up the journal into batches that
have compatible state so they can be emitted to the GPU together.  This is
currently broken up into 3 levels so we can stagger the state changes:

1) we break the journal up according to changes in the number of material layers
   associated with logged quads. The number of layers in a material determines
   the stride of the associated vertices, so we have to update our vertex
   array offsets at this level. (i.e. calling gl{Vertex,Color},Pointer etc)
2) we further split batches up according to material compatability. (e.g.
   materials with different textures) We flush material state at this level.
3) Finally we split batches up according to modelview changes. At this level
   we update the modelview matrix and actually emit the actual draw command.

This commit is largely about putting the initial design in-place; this will be
followed by other changes that take advantage of the extended batching.

[texture] fix load-async and load-data-async properties.

Removed the G_PARAM_CONSTRUCT from the property registration of
"load-async" and "load-data-async". It made it impossible to use only
load-data-async, as the async loading state would be unset when
load-async got set it's default FALSE value.

[clip-stack] Use signed integers while combining window space clip rectangles

Use signed integers while combining window space clip rectangles, so we avoid
arithmatic errors later resulting in glScissor getting negative width and
height arguments.

[cogl] Remove unused ctx->polygon_vertices array

This array used to be used by cogl_polygon but was changed to use
ctx->logged_vertices some time ago.

[cogl] Give the default (fallback) texture a format of RGBA_8888_PRE

Previously this was RGBA_8888. It souldn't really make a difference but for
consistency we expect almost all textures in use to have an internaly
premultiplied pixel format.

[cogl-texture] use the right format when downloading sliced textures from GL

_cogl_texture_download_from_gl needs to create transient CoglBitmaps when
downloading sliced textures from GL, and then copies these as subregions
into the final target_bitmap. _cogl_texture_download_from_gl also supports
target_bitmaps with a different format to the source CoglTexture being
downloaded.

The problem was that in the case of slice textures we were always looking
at the format of the CoglTexture, not of the target_bitmap when setting
up the transient slice bitmap.

[cogl] Adds cogl_read_pixels to replace direct use of glReadPixels

To allow for flushing of batched geometry within Cogl we can't support users
directly calling glReadPixels.  glReadPixels is also awkward, not least
because it returns upside down image data.

All the unit tests have been swithed over and clutter_stage_read_pixels now
sits on top of this too.

[cogl matrix] Adds ability to dirty state cached by the client matrix apis

To be able to load matrices to GL manually within Cogl we need a way to
dirty the state cached by the client matrix stack API.

[debug] Adds a "nop-picking" clutter debug option to NOP _clutter_do_pick()

I've found this is something I do quite often when debugging rendering
problems since its a simple way to wipe out lots of geometry and removes a
lot of unpredictable noise when logging geometry passing through the Cogl
journal.

[cogl_polygon] fixes a buffer overrun and color format bug

We were calculating our vertex stride and allocating our vertex array
differently depending on whether the user passed TRUE for use_color or not.
The problem was that we were always writting color data to the array
regardless of use_color.

There was also a bug with _cogl_texture_sliced_polygon in that it was
writing byte color components but we were expecting float components.  We
now use byte components in _cogl_multitexture_unsliced_polygon too and pass
GL_UNSIGNED_BYTE to glColorPointer.

[test-cogl-tex-getset] Assume a premultiplied pixel format

test-cogl-tex-getset was assuming it was dealing with
COGL_PIXEL_FORMAT_RGBA_8888 but since merging the premultiplcation branch
the pixel format is actually COGL_PIXEL_FORMAT_RGBA_8888_PRE

[vertex-buffer] Add cogl_vertex_buffer_indices_get_type API

cogl_vertex_buffer_indices lets you query back the data type used for the
given indices handle.

[vertex-buffer] Remove the COGL_INDICES_TYPE_UNSIGNED_INT indicies type

Since some embedded GPUs may not support 32bit integer indices we wont
include it until there is a particular need.

[cogl] Add COGL_HAS_GL and COGL_HAS_GLES

Cogl already add similar defines but with the CLUTTER namespace
(CLUTTER_COGL_HAS_GL and CLUTTER_COGL_HAS_GLES). Let's just add two
similar defines with the COGL namespace. Removing the CLUTTER_COGL ones
could break applications silently for no real good reason.

[misc] Update headers #endif comments

While grepping through the public headers looking for invalid use of
private HAVE_* defines, I stumbled upon two out of sync comments. Yes
it's a very minor trivial change.

[actor] Remove unused clutter_actor_pick()

The clutter_actor_pick() function just emits the ::pick signal
on the actor. Nobody should be using it, since the paint() method
is already context sensitive and will result in a ::pick emission
by itself. The clutter_actor_pick() is just confusing things.

Add more debug notes inside the master clock

[docs] Update after the Input API changes

[docs] Add an initial porting guide

The Clutter API reference should have a section on how to port
applications from older version of Clutter to the new API.

The first guide deals on how to port animations created with
ClutterEffect to clutter_actor_animate().

[docs] Fix the ActorBox annotations

The ClutterActorBox API is incorrectly annotated and gtk-doc is unable
to pick it up.

[test-shader] Fix some of the shaders to use premultiplied colors

Texture data is now in premultiplied format and the shader should
output a premultiplied color if the default blend mode is being
used. Shaders that directly manipulate the rgb values now
unpremultiply and premultiply again afterwards.

Add element-type annotations for animate*v functions

Fixes bug:

  http://bugzilla.openedhand.com/show_bug.cgi?id=1653

Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

[master clock] Fix MT safety issues

Fix MT issues when enabling threading in Clutter.

Fixes bug:

  http://bugzilla.openedhand.com/show_bug.cgi?id=1655

Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

[texture] Revert to integer parameters in ::size-change

In the int-to-float switch for actor properties, the ::size-change signal
was moved to use floats instead of integers. Sub-pixel precision for image
size is meaningless, though, so we should revert it back to ints.

Fixes bug:

  http://bugzilla.openedhand.com/show_bug.cgi?id=1659

Post-release bump to 0.9.5

[release] 0.9.4

Update the NEWS file