clutter 2.2.4-x64-mingw32

data/vendor/local/include/cogl/cogl/cogl-matrix-stack.h

@@ -0,0 +1,645 @@
+/*
+ * Cogl
+ *
+ * A Low Level GPU Graphics and Utilities API
+ *
+ * Copyright (C) 2009,2010,2012 Intel Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy,
+ * modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ *
+ *
+ * Authors:
+ *   Havoc Pennington <hp@pobox.com> for litl
+ *   Robert Bragg <robert@linux.intel.com>
+ */
+
+#ifndef _COGL_MATRIX_STACK_H_
+#define _COGL_MATRIX_STACK_H_
+
+#if !defined(__COGL_H_INSIDE__) && !defined(COGL_COMPILATION)
+#error "Only <cogl/cogl.h> can be included directly."
+#endif
+
+#include "cogl-matrix.h"
+#include "cogl-context.h"
+
+
+/**
+ * SECTION:cogl-matrix-stack
+ * @short_description: Functions for efficiently tracking many
+ *                     related transformations
+ *
+ * Matrices can be used (for example) to describe the model-view
+ * transforms of objects, texture transforms, and projective
+ * transforms.
+ *
+ * The #CoglMatrix api provides a good way to manipulate individual
+ * matrices representing a single transformation but if you need to
+ * track many-many such transformations for many objects that are
+ * organized in a scenegraph for example then using a separate
+ * #CoglMatrix for each object may not be the most efficient way.
+ *
+ * A #CoglMatrixStack enables applications to track lots of
+ * transformations that are related to each other in some kind of
+ * hierarchy.  In a scenegraph for example if you want to know how to
+ * transform a particular node then you usually have to walk up
+ * through the ancestors and accumulate their transforms before
+ * finally applying the transform of the node itself. In this model
+ * things are grouped together spatially according to their ancestry
+ * and all siblings with the same parent share the same initial
+ * transformation. The #CoglMatrixStack API is suited to tracking lots
+ * of transformations that fit this kind of model.
+ *
+ * Compared to using the #CoglMatrix api directly to track many
+ * related transforms, these can be some advantages to using a
+ * #CoglMatrixStack:
+ * <itemizedlist>
+ *   <listitem>Faster equality comparisons of transformations</listitem>
+ *   <listitem>Efficient comparisons of the differences between arbitrary
+ *   transformations</listitem>
+ *   <listitem>Avoid redundant arithmetic related to common transforms
+ *   </listitem>
+ *   <listitem>Can be more space efficient (not always though)</listitem>
+ * </itemizedlist>
+ *
+ * For reference (to give an idea of when a #CoglMatrixStack can
+ * provide a space saving) a #CoglMatrix can be expected to take 72
+ * bytes whereas a single #CoglMatrixEntry in a #CoglMatrixStack is
+ * currently around 32 bytes on a 32bit CPU or 36 bytes on a 64bit
+ * CPU. An entry is needed for each individual operation applied to
+ * the stack (such as rotate, scale, translate) so if most of your
+ * leaf node transformations only need one or two simple operations
+ * relative to their parent then a matrix stack will likely take less
+ * space than having a #CoglMatrix for each node.
+ *
+ * Even without any space saving though the ability to perform fast
+ * comparisons and avoid redundant arithmetic (especially sine and
+ * cosine calculations for rotations) can make using a matrix stack
+ * worthwhile.
+ */
+
+/**
+ * CoglMatrixStack:
+ *
+ * Tracks your current position within a hierarchy and lets you build
+ * up a graph of transformations as you traverse through a hierarchy
+ * such as a scenegraph.
+ *
+ * A #CoglMatrixStack always maintains a reference to a single
+ * transformation at any point in time, representing the
+ * transformation at the current position in the hierarchy. You can
+ * get a reference to the current transformation by calling
+ * cogl_matrix_stack_get_entry().
+ *
+ * When a #CoglMatrixStack is first created with
+ * cogl_matrix_stack_new() then it is conceptually positioned at the
+ * root of your hierarchy and the current transformation simply
+ * represents an identity transformation.
+ *
+ * As you traverse your object hierarchy (your scenegraph) then you
+ * should call cogl_matrix_stack_push() whenever you move down one
+ * level and call cogl_matrix_stack_pop() whenever you move back up
+ * one level towards the root.
+ *
+ * At any time you can apply a set of operations, such as "rotate",
+ * "scale", "translate" on top of the current transformation of a
+ * #CoglMatrixStack using functions such as
+ * cogl_matrix_stack_rotate(), cogl_matrix_stack_scale() and
+ * cogl_matrix_stack_translate(). These operations will derive a new
+ * current transformation and will never affect a transformation
+ * that you have referenced using cogl_matrix_stack_get_entry().
+ *
+ * Internally applying operations to a #CoglMatrixStack builds up a
+ * graph of #CoglMatrixEntry structures which each represent a single
+ * immutable transform.
+ */
+typedef struct _CoglMatrixStack CoglMatrixStack;
+
+#ifdef COGL_HAS_GTYPE_SUPPORT
+/**
+ * cogl_matrix_stack_get_gtype:
+ *
+ * Returns: a #GType that can be used with the GLib type system.
+ */
+GType cogl_matrix_stack_get_gtype (void);
+#endif
+
+/**
+ * CoglMatrixEntry:
+ *
+ * Represents a single immutable transformation that was retrieved
+ * from a #CoglMatrixStack using cogl_matrix_stack_get_entry().
+ *
+ * Internally a #CoglMatrixEntry represents a single matrix
+ * operation (such as "rotate", "scale", "translate") which is applied
+ * to the transform of a single parent entry.
+ *
+ * Using the #CoglMatrixStack api effectively builds up a graph of
+ * these immutable #CoglMatrixEntry structures whereby operations
+ * that can be shared between multiple transformations will result
+ * in shared #CoglMatrixEntry nodes in the graph.
+ *
+ * When a #CoglMatrixStack is first created it references one
+ * #CoglMatrixEntry that represents a single "load identity"
+ * operation. This serves as the root entry and all operations
+ * that are then applied to the stack will extend the graph
+ * starting from this root "load identity" entry.
+ *
+ * Given the typical usage model for a #CoglMatrixStack and the way
+ * the entries are built up while traversing a scenegraph then in most
+ * cases where an application is interested in comparing two
+ * transformations for equality then it is enough to simply compare
+ * two #CoglMatrixEntry pointers directly. Technically this can lead
+ * to false negatives that could be identified with a deeper
+ * comparison but often these false negatives are unlikely and
+ * don't matter anyway so this enables extremely cheap comparisons.
+ *
+ * <note>#CoglMatrixEntry<!-- -->s are reference counted using
+ * cogl_matrix_entry_ref() and cogl_matrix_entry_unref() not with
+ * cogl_object_ref() and cogl_object_unref().</note>
+ */
+typedef struct _CoglMatrixEntry CoglMatrixEntry;
+
+#ifdef COGL_HAS_GTYPE_SUPPORT
+/**
+ * cogl_matrix_entry_get_gtype:
+ *
+ * Returns: a #GType that can be used with the GLib type system.
+ */
+GType cogl_matrix_entry_get_gtype (void);
+#endif
+
+
+/**
+ * cogl_matrix_stack_new:
+ * @ctx: A #CoglContext
+ *
+ * Allocates a new #CoglMatrixStack that can be used to build up
+ * transformations relating to objects in a scenegraph like hierarchy.
+ * (See the description of #CoglMatrixStack and #CoglMatrixEntry for
+ * more details of what a matrix stack is best suited for)
+ *
+ * When a #CoglMatrixStack is first allocated it is conceptually
+ * positioned at the root of your scenegraph hierarchy. As you
+ * traverse your scenegraph then you should call
+ * cogl_matrix_stack_push() whenever you move down a level and
+ * cogl_matrix_stack_pop() whenever you move back up a level towards
+ * the root.
+ *
+ * Once you have allocated a #CoglMatrixStack you can get a reference
+ * to the current transformation for the current position in the
+ * hierarchy by calling cogl_matrix_stack_get_entry().
+ *
+ * Once you have allocated a #CoglMatrixStack you can apply operations
+ * such as rotate, scale and translate to modify the current transform
+ * for the current position in the hierarchy by calling
+ * cogl_matrix_stack_rotate(), cogl_matrix_stack_scale() and
+ * cogl_matrix_stack_translate().
+ *
+ * Return value: (transfer full): A newly allocated #CoglMatrixStack
+ */
+CoglMatrixStack *
+cogl_matrix_stack_new (CoglContext *ctx);
+
+/**
+ * cogl_matrix_stack_push:
+ * @stack: A #CoglMatrixStack
+ *
+ * Saves the current transform and starts a new transform that derives
+ * from the current transform.
+ *
+ * This is usually called while traversing a scenegraph whenever you
+ * traverse one level deeper. cogl_matrix_stack_pop() can then be
+ * called when going back up one layer to restore the previous
+ * transform of an ancestor.
+ */
+void
+cogl_matrix_stack_push (CoglMatrixStack *stack);
+
+/**
+ * cogl_matrix_stack_pop:
+ * @stack: A #CoglMatrixStack
+ *
+ * Restores the previous transform that was last saved by calling
+ * cogl_matrix_stack_push().
+ *
+ * This is usually called while traversing a scenegraph whenever you
+ * return up one level in the graph towards the root node.
+ */
+void
+cogl_matrix_stack_pop (CoglMatrixStack *stack);
+
+/**
+ * cogl_matrix_stack_load_identity:
+ * @stack: A #CoglMatrixStack
+ *
+ * Resets the current matrix to the identity matrix.
+ */
+void
+cogl_matrix_stack_load_identity (CoglMatrixStack *stack);
+
+/**
+ * cogl_matrix_stack_scale:
+ * @stack: A #CoglMatrixStack
+ * @x: Amount to scale along the x-axis
+ * @y: Amount to scale along the y-axis
+ * @z: Amount to scale along the z-axis
+ *
+ * Multiplies the current matrix by one that scales the x, y and z
+ * axes by the given values.
+ */
+void
+cogl_matrix_stack_scale (CoglMatrixStack *stack,
+                         float x,
+                         float y,
+                         float z);
+
+/**
+ * cogl_matrix_stack_translate:
+ * @stack: A #CoglMatrixStack
+ * @x: Distance to translate along the x-axis
+ * @y: Distance to translate along the y-axis
+ * @z: Distance to translate along the z-axis
+ *
+ * Multiplies the current matrix by one that translates along all
+ * three axes according to the given values.
+ */
+void
+cogl_matrix_stack_translate (CoglMatrixStack *stack,
+                             float x,
+                             float y,
+                             float z);
+
+/**
+ * cogl_matrix_stack_rotate:
+ * @stack: A #CoglMatrixStack
+ * @angle: Angle in degrees to rotate.
+ * @x: X-component of vertex to rotate around.
+ * @y: Y-component of vertex to rotate around.
+ * @z: Z-component of vertex to rotate around.
+ *
+ * Multiplies the current matrix by one that rotates the around the
+ * axis-vector specified by @x, @y and @z. The rotation follows the
+ * right-hand thumb rule so for example rotating by 10 degrees about
+ * the axis-vector (0, 0, 1) causes a small counter-clockwise
+ * rotation.
+ */
+void
+cogl_matrix_stack_rotate (CoglMatrixStack *stack,
+                          float angle,
+                          float x,
+                          float y,
+                          float z);
+
+/**
+ * cogl_matrix_stack_rotate_quaternion:
+ * @stack: A #CoglMatrixStack
+ * @quaternion: A #CoglQuaternion
+ *
+ * Multiplies the current matrix by one that rotates according to the
+ * rotation described by @quaternion.
+ */
+void
+cogl_matrix_stack_rotate_quaternion (CoglMatrixStack *stack,
+                                     const CoglQuaternion *quaternion);
+
+/**
+ * cogl_matrix_stack_rotate_euler:
+ * @stack: A #CoglMatrixStack
+ * @euler: A #CoglEuler
+ *
+ * Multiplies the current matrix by one that rotates according to the
+ * rotation described by @euler.
+ */
+void
+cogl_matrix_stack_rotate_euler (CoglMatrixStack *stack,
+                                const CoglEuler *euler);
+
+/**
+ * cogl_matrix_stack_multiply:
+ * @stack: A #CoglMatrixStack
+ * @matrix: the matrix to multiply with the current model-view
+ *
+ * Multiplies the current matrix by the given matrix.
+ */
+void
+cogl_matrix_stack_multiply (CoglMatrixStack *stack,
+                            const CoglMatrix *matrix);
+
+/**
+ * cogl_matrix_stack_frustum:
+ * @stack: A #CoglMatrixStack
+ * @left: X position of the left clipping plane where it
+ *   intersects the near clipping plane
+ * @right: X position of the right clipping plane where it
+ *   intersects the near clipping plane
+ * @bottom: Y position of the bottom clipping plane where it
+ *   intersects the near clipping plane
+ * @top: Y position of the top clipping plane where it intersects
+ *   the near clipping plane
+ * @z_near: The distance to the near clipping plane (Must be positive)
+ * @z_far: The distance to the far clipping plane (Must be positive)
+ *
+ * Replaces the current matrix with a perspective matrix for a given
+ * viewing frustum defined by 4 side clip planes that all cross
+ * through the origin and 2 near and far clip planes.
+ */
+void
+cogl_matrix_stack_frustum (CoglMatrixStack *stack,
+                           float left,
+                           float right,
+                           float bottom,
+                           float top,
+                           float z_near,
+                           float z_far);
+
+/**
+ * cogl_matrix_stack_perspective:
+ * @stack: A #CoglMatrixStack
+ * @fov_y: Vertical field of view angle in degrees.
+ * @aspect: The (width over height) aspect ratio for display
+ * @z_near: The distance to the near clipping plane (Must be positive,
+ *   and must not be 0)
+ * @z_far: The distance to the far clipping plane (Must be positive)
+ *
+ * Replaces the current matrix with a perspective matrix based on the
+ * provided values.
+ *
+ * <note>You should be careful not to have too great a @z_far / @z_near
+ * ratio since that will reduce the effectiveness of depth testing
+ * since there wont be enough precision to identify the depth of
+ * objects near to each other.</note>
+ */
+void
+cogl_matrix_stack_perspective (CoglMatrixStack *stack,
+                               float fov_y,
+                               float aspect,
+                               float z_near,
+                               float z_far);
+
+/**
+ * cogl_matrix_stack_orthographic:
+ * @stack: A #CoglMatrixStack
+ * @x_1: The x coordinate for the first vertical clipping plane
+ * @y_1: The y coordinate for the first horizontal clipping plane
+ * @x_2: The x coordinate for the second vertical clipping plane
+ * @y_2: The y coordinate for the second horizontal clipping plane
+ * @near: The <emphasis>distance</emphasis> to the near clipping
+ *   plane (will be <emphasis>negative</emphasis> if the plane is
+ *   behind the viewer)
+ * @far: The <emphasis>distance</emphasis> to the far clipping
+ *   plane (will be <emphasis>negative</emphasis> if the plane is
+ *   behind the viewer)
+ *
+ * Replaces the current matrix with an orthographic projection matrix.
+ */
+void
+cogl_matrix_stack_orthographic (CoglMatrixStack *stack,
+                                float x_1,
+                                float y_1,
+                                float x_2,
+                                float y_2,
+                                float near,
+                                float far);
+
+/**
+ * cogl_matrix_stack_get_inverse:
+ * @stack: A #CoglMatrixStack
+ * @inverse: (out): The destination for a 4x4 inverse transformation matrix
+ *
+ * Gets the inverse transform of the current matrix and uses it to
+ * initialize a new #CoglMatrix.
+ *
+ * Return value: %TRUE if the inverse was successfully calculated or %FALSE
+ *   for degenerate transformations that can't be inverted (in this case the
+ *   @inverse matrix will simply be initialized with the identity matrix)
+ */
+CoglBool
+cogl_matrix_stack_get_inverse (CoglMatrixStack *stack,
+                               CoglMatrix *inverse);
+
+/**
+ * cogl_matrix_stack_get_entry:
+ * @stack: A #CoglMatrixStack
+ *
+ * Gets a reference to the current transform represented by a
+ * #CoglMatrixEntry pointer.
+ *
+ * <note>The transform represented by a #CoglMatrixEntry is
+ * immutable.</note>
+ *
+ * <note>#CoglMatrixEntry<!-- -->s are reference counted using
+ * cogl_matrix_entry_ref() and cogl_matrix_entry_unref() and you
+ * should call cogl_matrix_entry_unref() when you are finished with
+ * and entry you get via cogl_matrix_stack_get_entry().</note>
+ *
+ * Return value: (transfer none): A pointer to the #CoglMatrixEntry
+ *               representing the current matrix stack transform.
+ */
+CoglMatrixEntry *
+cogl_matrix_stack_get_entry (CoglMatrixStack *stack);
+
+/**
+ * cogl_matrix_stack_get:
+ * @stack: A #CoglMatrixStack
+ * @matrix: (out): The potential destination for the current matrix
+ *
+ * Resolves the current @stack transform into a #CoglMatrix by
+ * combining the operations that have been applied to build up the
+ * current transform.
+ *
+ * There are two possible ways that this function may return its
+ * result depending on whether the stack is able to directly point
+ * to an internal #CoglMatrix or whether the result needs to be
+ * composed of multiple operations.
+ *
+ * If an internal matrix contains the required result then this
+ * function will directly return a pointer to that matrix, otherwise
+ * if the function returns %NULL then @matrix will be initialized
+ * to match the current transform of @stack.
+ *
+ * <note>@matrix will be left untouched if a direct pointer is
+ * returned.</note>
+ *
+ * Return value: A direct pointer to the current transform or %NULL
+ *               and in that case @matrix will be initialized with
+ *               the value of the current transform.
+ */
+CoglMatrix *
+cogl_matrix_stack_get (CoglMatrixStack *stack,
+                       CoglMatrix *matrix);
+
+/**
+ * cogl_matrix_entry_get:
+ * @entry: A #CoglMatrixEntry
+ * @matrix: (out): The potential destination for the transform as
+ *                 a matrix
+ *
+ * Resolves the current @entry transform into a #CoglMatrix by
+ * combining the sequence of operations that have been applied to
+ * build up the current transform.
+ *
+ * There are two possible ways that this function may return its
+ * result depending on whether it's possible to directly point
+ * to an internal #CoglMatrix or whether the result needs to be
+ * composed of multiple operations.
+ *
+ * If an internal matrix contains the required result then this
+ * function will directly return a pointer to that matrix, otherwise
+ * if the function returns %NULL then @matrix will be initialized
+ * to match the transform of @entry.
+ *
+ * <note>@matrix will be left untouched if a direct pointer is
+ * returned.</note>
+ *
+ * Return value: A direct pointer to a #CoglMatrix transform or %NULL
+ *               and in that case @matrix will be initialized with
+ *               the effective transform represented by @entry.
+ */
+CoglMatrix *
+cogl_matrix_entry_get (CoglMatrixEntry *entry,
+                       CoglMatrix *matrix);
+
+/**
+ * cogl_matrix_stack_set:
+ * @stack: A #CoglMatrixStack
+ * @matrix: A #CoglMatrix replace the current matrix value with
+ *
+ * Replaces the current @stack matrix value with the value of @matrix.
+ * This effectively discards any other operations that were applied
+ * since the last time cogl_matrix_stack_push() was called or since
+ * the stack was initialized.
+ */
+void
+cogl_matrix_stack_set (CoglMatrixStack *stack,
+                       const CoglMatrix *matrix);
+
+/**
+ * cogl_is_matrix_stack:
+ * @object: a #CoglObject
+ *
+ * Determines if the given #CoglObject refers to a #CoglMatrixStack.
+ *
+ * Return value: %TRUE if @object is a #CoglMatrixStack, otherwise
+ *               %FALSE.
+ */
+CoglBool
+cogl_is_matrix_stack (void *object);
+
+/**
+ * cogl_matrix_entry_calculate_translation:
+ * @entry0: The first reference transform
+ * @entry1: A second reference transform
+ * @x: (out): The destination for the x-component of the translation
+ * @y: (out): The destination for the y-component of the translation
+ * @z: (out): The destination for the z-component of the translation
+ *
+ * Determines if the only difference between two transforms is a
+ * translation and if so returns what the @x, @y, and @z components of
+ * the translation are.
+ *
+ * If the difference between the two translations involves anything
+ * other than a translation then the function returns %FALSE.
+ *
+ * Return value: %TRUE if the only difference between the transform of
+ *                @entry0 and the transform of @entry1 is a translation,
+ *                otherwise %FALSE.
+ */
+CoglBool
+cogl_matrix_entry_calculate_translation (CoglMatrixEntry *entry0,
+                                         CoglMatrixEntry *entry1,
+                                         float *x,
+                                         float *y,
+                                         float *z);
+
+/**
+ * cogl_matrix_entry_is_identity:
+ * @entry: A #CoglMatrixEntry
+ *
+ * Determines whether @entry is known to represent an identity
+ * transform.
+ *
+ * If this returns %TRUE then the entry is definitely the identity
+ * matrix. If it returns %FALSE it may or may not be the identity
+ * matrix but no expensive comparison is performed to verify it.
+ *
+ * Return value: %TRUE if @entry is definitely an identity transform,
+ *               otherwise %FALSE.
+ */
+CoglBool
+cogl_matrix_entry_is_identity (CoglMatrixEntry *entry);
+
+/**
+ * cogl_matrix_entry_equal:
+ * @entry0: The first #CoglMatrixEntry to compare
+ * @entry1: A second #CoglMatrixEntry to compare
+ *
+ * Compares two arbitrary #CoglMatrixEntry transforms for equality
+ * returning %TRUE if they are equal or %FALSE otherwise.
+ *
+ * <note>In many cases it is unnecessary to use this api and instead
+ * direct pointer comparisons of entries are good enough and much
+ * cheaper too.</note>
+ *
+ * Return value: %TRUE if @entry0 represents the same transform as
+ *               @entry1, otherwise %FALSE.
+ */
+CoglBool
+cogl_matrix_entry_equal (CoglMatrixEntry *entry0,
+                         CoglMatrixEntry *entry1);
+
+/**
+ * cogl_debug_matrix_entry_print:
+ * @entry: A #CoglMatrixEntry
+ *
+ * Allows visualizing the operations that build up the given @entry
+ * for debugging purposes by printing to stdout.
+ */
+void
+cogl_debug_matrix_entry_print (CoglMatrixEntry *entry);
+
+/**
+ * cogl_matrix_entry_ref:
+ * @entry: A #CoglMatrixEntry
+ *
+ * Takes a reference on the given @entry to ensure the @entry stays
+ * alive and remains valid. When you are finished with the @entry then
+ * you should call cogl_matrix_entry_unref().
+ *
+ * It is an error to pass an @entry pointer to cogl_object_ref() and
+ * cogl_object_unref()
+ */
+CoglMatrixEntry *
+cogl_matrix_entry_ref (CoglMatrixEntry *entry);
+
+/**
+ * cogl_matrix_entry_unref:
+ * @entry: A #CoglMatrixEntry
+ *
+ * Releases a reference on @entry either taken by calling
+ * cogl_matrix_entry_unref() or to release the reference given when
+ * calling cogl_matrix_stack_get_entry().
+ */
+void
+cogl_matrix_entry_unref (CoglMatrixEntry *entry);
+
+#endif /* _COGL_MATRIX_STACK_H_ */