cogl_matrix_stack_new ()

CoglMatrixStack *
cogl_matrix_stack_new (CoglContext *ctx);

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().

cogl_matrix_stack_push ()

void
cogl_matrix_stack_push (CoglMatrixStack *stack);

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.

cogl_matrix_stack_pop ()

void
cogl_matrix_stack_pop (CoglMatrixStack *stack);

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.

cogl_matrix_stack_load_identity ()

void
cogl_matrix_stack_load_identity (CoglMatrixStack *stack);

Resets the current matrix to the identity matrix.

cogl_matrix_stack_scale ()

void
cogl_matrix_stack_scale (CoglMatrixStack *stack,
                         float x,
                         float y,
                         float z);

Multiplies the current matrix by one that scales the x, y and z axes by the given values.

cogl_matrix_stack_translate ()

void
cogl_matrix_stack_translate (CoglMatrixStack *stack,
                             float x,
                             float y,
                             float z);

Multiplies the current matrix by one that translates along all three axes according to the given values.

cogl_matrix_stack_rotate ()

void
cogl_matrix_stack_rotate (CoglMatrixStack *stack,
                          float angle,
                          float x,
                          float y,
                          float z);

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.

cogl_matrix_stack_rotate_quaternion ()

void
cogl_matrix_stack_rotate_quaternion (CoglMatrixStack *stack,
                                     const CoglQuaternion *quaternion);

Multiplies the current matrix by one that rotates according to the rotation described by quaternion .

cogl_matrix_stack_rotate_euler ()

void
cogl_matrix_stack_rotate_euler (CoglMatrixStack *stack,
                                const CoglEuler *euler);

Multiplies the current matrix by one that rotates according to the rotation described by euler .

cogl_matrix_stack_multiply ()

void
cogl_matrix_stack_multiply (CoglMatrixStack *stack,
                            const CoglMatrix *matrix);

Multiplies the current matrix by the given matrix.

cogl_matrix_stack_frustum ()

void
cogl_matrix_stack_frustum (CoglMatrixStack *stack,
                           float left,
                           float right,
                           float bottom,
                           float top,
                           float z_near,
                           float z_far);

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.

cogl_matrix_stack_perspective ()

void
cogl_matrix_stack_perspective (CoglMatrixStack *stack,
                               float fov_y,
                               float aspect,
                               float z_near,
                               float z_far);

Replaces the current matrix with a perspective matrix based on the provided values.

cogl_matrix_stack_orthographic ()

void
cogl_matrix_stack_orthographic (CoglMatrixStack *stack,
                                float x_1,
                                float y_1,
                                float x_2,
                                float y_2,
                                float near,
                                float far);

Replaces the current matrix with an orthographic projection matrix.

cogl_matrix_stack_get_inverse ()

CoglBool
cogl_matrix_stack_get_inverse (CoglMatrixStack *stack,
                               CoglMatrix *inverse);

Gets the inverse transform of the current matrix and uses it to initialize a new CoglMatrix.

cogl_matrix_stack_get_entry ()

CoglMatrixEntry *
cogl_matrix_stack_get_entry (CoglMatrixStack *stack);

Gets a reference to the current transform represented by a CoglMatrixEntry pointer.

cogl_matrix_stack_get ()

CoglMatrix *
cogl_matrix_stack_get (CoglMatrixStack *stack,
                       CoglMatrix *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 .

cogl_matrix_entry_get ()

CoglMatrix *
cogl_matrix_entry_get (CoglMatrixEntry *entry,
                       CoglMatrix *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 .

cogl_matrix_stack_set ()

void
cogl_matrix_stack_set (CoglMatrixStack *stack,
                       const CoglMatrix *matrix);

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.

cogl_matrix_entry_calculate_translation ()

CoglBool
cogl_matrix_entry_calculate_translation
                               (CoglMatrixEntry *entry0,
                                CoglMatrixEntry *entry1,
                                float *x,
                                float *y,
                                float *z);

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.

cogl_matrix_entry_is_identity ()

CoglBool
cogl_matrix_entry_is_identity (CoglMatrixEntry *entry);

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.

cogl_matrix_entry_equal ()

CoglBool
cogl_matrix_entry_equal (CoglMatrixEntry *entry0,
                         CoglMatrixEntry *entry1);

Compares two arbitrary CoglMatrixEntry transforms for equality returning TRUE if they are equal or FALSE otherwise.

cogl_matrix_entry_ref ()

CoglMatrixEntry *
cogl_matrix_entry_ref (CoglMatrixEntry *entry);

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()

cogl_matrix_entry_unref ()

void
cogl_matrix_entry_unref (CoglMatrixEntry *entry);

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().

CoglMatrixStack

typedef struct _CoglMatrixStack 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.

CoglMatrixEntry

typedef struct _CoglMatrixEntry 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.