diff --git a/cogl/cogl/cogl-framebuffer.c b/cogl/cogl/cogl-framebuffer.c index a032feb8c..1120b2538 100644 --- a/cogl/cogl/cogl-framebuffer.c +++ b/cogl/cogl/cogl-framebuffer.c @@ -1545,19 +1545,6 @@ cogl_framebuffer_rotate (CoglFramebuffer *framebuffer, COGL_FRAMEBUFFER_STATE_MODELVIEW; } -void -cogl_framebuffer_rotate_quaternion (CoglFramebuffer *framebuffer, - const CoglQuaternion *quaternion) -{ - CoglMatrixStack *modelview_stack = - _cogl_framebuffer_get_modelview_stack (framebuffer); - cogl_matrix_stack_rotate_quaternion (modelview_stack, quaternion); - - if (framebuffer->context->current_draw_buffer == framebuffer) - framebuffer->context->current_draw_buffer_changes |= - COGL_FRAMEBUFFER_STATE_MODELVIEW; -} - void cogl_framebuffer_rotate_euler (CoglFramebuffer *framebuffer, const graphene_euler_t *euler) diff --git a/cogl/cogl/cogl-framebuffer.h b/cogl/cogl/cogl-framebuffer.h index c3fc28d9b..99ed6bde9 100644 --- a/cogl/cogl/cogl-framebuffer.h +++ b/cogl/cogl/cogl-framebuffer.h @@ -52,7 +52,6 @@ typedef struct _CoglFramebuffer CoglFramebuffer; #include #include #include -#include #include #include @@ -363,21 +362,6 @@ cogl_framebuffer_rotate (CoglFramebuffer *framebuffer, float y, float z); -/** - * cogl_framebuffer_rotate_quaternion: - * @framebuffer: A #CoglFramebuffer pointer - * @quaternion: A #CoglQuaternion - * - * Multiplies the current model-view matrix by one that rotates - * according to the rotation described by @quaternion. - * - * Since: 2.0 - * Stability: unstable - */ -void -cogl_framebuffer_rotate_quaternion (CoglFramebuffer *framebuffer, - const CoglQuaternion *quaternion); - /** * cogl_framebuffer_rotate_euler: * @framebuffer: A #CoglFramebuffer pointer diff --git a/cogl/cogl/cogl-matrix-stack-private.h b/cogl/cogl/cogl-matrix-stack-private.h index f510d97d7..0678d199e 100644 --- a/cogl/cogl/cogl-matrix-stack-private.h +++ b/cogl/cogl/cogl-matrix-stack-private.h @@ -45,7 +45,6 @@ typedef enum _CoglMatrixOp COGL_MATRIX_OP_LOAD_IDENTITY, COGL_MATRIX_OP_TRANSLATE, COGL_MATRIX_OP_ROTATE, - COGL_MATRIX_OP_ROTATE_QUATERNION, COGL_MATRIX_OP_ROTATE_EULER, COGL_MATRIX_OP_SCALE, COGL_MATRIX_OP_MULTIPLY, @@ -93,15 +92,6 @@ typedef struct _CoglMatrixEntryRotateEuler graphene_euler_t euler; } CoglMatrixEntryRotateEuler; -typedef struct _CoglMatrixEntryRotateQuaternion -{ - CoglMatrixEntry _parent_data; - - /* This doesn't store an actual CoglQuaternion in order to avoid the - * padding */ - float values[4]; -} CoglMatrixEntryRotateQuaternion; - typedef struct _CoglMatrixEntryScale { CoglMatrixEntry _parent_data; @@ -143,7 +133,6 @@ typedef union _CoglMatrixEntryFull CoglMatrixEntryTranslate translate; CoglMatrixEntryRotate rotate; CoglMatrixEntryRotateEuler rotate_euler; - CoglMatrixEntryRotateQuaternion rotate_quaternion; CoglMatrixEntryScale scale; CoglMatrixEntryMultiply multiply; CoglMatrixEntryLoad load; diff --git a/cogl/cogl/cogl-matrix-stack.c b/cogl/cogl/cogl-matrix-stack.c index 5bacb7e51..3b9300f05 100644 --- a/cogl/cogl/cogl-matrix-stack.c +++ b/cogl/cogl/cogl-matrix-stack.c @@ -180,21 +180,6 @@ cogl_matrix_stack_rotate (CoglMatrixStack *stack, entry->z = z; } -void -cogl_matrix_stack_rotate_quaternion (CoglMatrixStack *stack, - const CoglQuaternion *quaternion) -{ - CoglMatrixEntryRotateQuaternion *entry; - - entry = _cogl_matrix_stack_push_operation (stack, - COGL_MATRIX_OP_ROTATE_QUATERNION); - - entry->values[0] = quaternion->w; - entry->values[1] = quaternion->x; - entry->values[2] = quaternion->y; - entry->values[3] = quaternion->z; -} - void cogl_matrix_stack_rotate_euler (CoglMatrixStack *stack, const graphene_euler_t *euler) @@ -354,7 +339,6 @@ cogl_matrix_entry_unref (CoglMatrixEntry *entry) case COGL_MATRIX_OP_LOAD_IDENTITY: case COGL_MATRIX_OP_TRANSLATE: case COGL_MATRIX_OP_ROTATE: - case COGL_MATRIX_OP_ROTATE_QUATERNION: case COGL_MATRIX_OP_ROTATE_EULER: case COGL_MATRIX_OP_SCALE: break; @@ -495,7 +479,6 @@ initialized: case COGL_MATRIX_OP_LOAD_IDENTITY: case COGL_MATRIX_OP_TRANSLATE: case COGL_MATRIX_OP_ROTATE: - case COGL_MATRIX_OP_ROTATE_QUATERNION: case COGL_MATRIX_OP_ROTATE_EULER: case COGL_MATRIX_OP_SCALE: case COGL_MATRIX_OP_MULTIPLY: @@ -581,15 +564,6 @@ initialized: &rotate->euler); continue; } - case COGL_MATRIX_OP_ROTATE_QUATERNION: - { - CoglMatrixEntryRotateQuaternion *rotate = - (CoglMatrixEntryRotateQuaternion *)children[i]; - CoglQuaternion quaternion; - cogl_quaternion_init_from_array (&quaternion, rotate->values); - cogl_matrix_rotate_quaternion (matrix, &quaternion); - continue; - } case COGL_MATRIX_OP_SCALE: { CoglMatrixEntryScale *scale = @@ -981,18 +955,6 @@ cogl_matrix_entry_equal (CoglMatrixEntry *entry0, return FALSE; } break; - case COGL_MATRIX_OP_ROTATE_QUATERNION: - { - CoglMatrixEntryRotateQuaternion *rotate0 = - (CoglMatrixEntryRotateQuaternion *)entry0; - CoglMatrixEntryRotateQuaternion *rotate1 = - (CoglMatrixEntryRotateQuaternion *)entry1; - int i; - for (i = 0; i < 4; i++) - if (rotate0->values[i] != rotate1->values[i]) - return FALSE; - } - break; case COGL_MATRIX_OP_ROTATE_EULER: { CoglMatrixEntryRotateEuler *rotate0 = @@ -1092,17 +1054,6 @@ cogl_debug_matrix_entry_print (CoglMatrixEntry *entry) rotate->z); continue; } - case COGL_MATRIX_OP_ROTATE_QUATERNION: - { - CoglMatrixEntryRotateQuaternion *rotate = - (CoglMatrixEntryRotateQuaternion *)entry; - g_print (" ROTATE QUATERNION w=%f x=%f y=%f z=%f\n", - rotate->values[0], - rotate->values[1], - rotate->values[2], - rotate->values[3]); - continue; - } case COGL_MATRIX_OP_ROTATE_EULER: { CoglMatrixEntryRotateEuler *rotate = diff --git a/cogl/cogl/cogl-matrix-stack.h b/cogl/cogl/cogl-matrix-stack.h index 9ab4aa733..5a2c7d138 100644 --- a/cogl/cogl/cogl-matrix-stack.h +++ b/cogl/cogl/cogl-matrix-stack.h @@ -307,18 +307,6 @@ cogl_matrix_stack_rotate (CoglMatrixStack *stack, 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 diff --git a/cogl/cogl/cogl-matrix.c b/cogl/cogl/cogl-matrix.c index 21fffe42f..185ded57a 100644 --- a/cogl/cogl/cogl-matrix.c +++ b/cogl/cogl/cogl-matrix.c @@ -73,11 +73,9 @@ #include #include -#include -#include #include #include -#include +#include #include #include @@ -1358,16 +1356,6 @@ cogl_matrix_rotate (CoglMatrix *matrix, _COGL_MATRIX_DEBUG_PRINT (matrix); } -void -cogl_matrix_rotate_quaternion (CoglMatrix *matrix, - const CoglQuaternion *quaternion) -{ - CoglMatrix rotation_transform; - - cogl_matrix_init_from_quaternion (&rotation_transform, quaternion); - cogl_matrix_multiply (matrix, matrix, &rotation_transform); -} - void cogl_matrix_rotate_euler (CoglMatrix *matrix, const graphene_euler_t *euler) @@ -1735,48 +1723,6 @@ _cogl_matrix_init_from_matrix_without_inverse (CoglMatrix *matrix, matrix->flags = src->flags | MAT_DIRTY_INVERSE; } -static void -_cogl_matrix_init_from_quaternion (CoglMatrix *matrix, - const CoglQuaternion *quaternion) -{ - float qnorm = _COGL_QUATERNION_NORM (quaternion); - float s = (qnorm > 0.0f) ? (2.0f / qnorm) : 0.0f; - float xs = quaternion->x * s; - float ys = quaternion->y * s; - float zs = quaternion->z * s; - float wx = quaternion->w * xs; - float wy = quaternion->w * ys; - float wz = quaternion->w * zs; - float xx = quaternion->x * xs; - float xy = quaternion->x * ys; - float xz = quaternion->x * zs; - float yy = quaternion->y * ys; - float yz = quaternion->y * zs; - float zz = quaternion->z * zs; - - matrix->xx = 1.0f - (yy + zz); - matrix->yx = xy + wz; - matrix->zx = xz - wy; - matrix->xy = xy - wz; - matrix->yy = 1.0f - (xx + zz); - matrix->zy = yz + wx; - matrix->xz = xz + wy; - matrix->yz = yz - wx; - matrix->zz = 1.0f - (xx + yy); - matrix->xw = matrix->yw = matrix->zw = 0.0f; - matrix->wx = matrix->wy = matrix->wz = 0.0f; - matrix->ww = 1.0f; - - matrix->flags = (MAT_FLAG_GENERAL | MAT_DIRTY_ALL); -} - -void -cogl_matrix_init_from_quaternion (CoglMatrix *matrix, - const CoglQuaternion *quaternion) -{ - _cogl_matrix_init_from_quaternion (matrix, quaternion); -} - void cogl_matrix_init_from_euler (CoglMatrix *matrix, const graphene_euler_t *euler) diff --git a/cogl/cogl/cogl-matrix.h b/cogl/cogl/cogl-matrix.h index 30af4ac7d..7779b4ae7 100644 --- a/cogl/cogl/cogl-matrix.h +++ b/cogl/cogl/cogl-matrix.h @@ -41,7 +41,6 @@ #include #include -#include #include #include @@ -198,20 +197,6 @@ cogl_matrix_rotate (CoglMatrix *matrix, float y, float z); -/** - * cogl_matrix_rotate_quaternion: - * @matrix: A 4x4 transformation matrix - * @quaternion: A quaternion describing a rotation - * - * Multiplies @matrix with a rotation transformation described by the - * given #CoglQuaternion. - * - * Since: 2.0 - */ -void -cogl_matrix_rotate_quaternion (CoglMatrix *matrix, - const CoglQuaternion *quaternion); - /** * cogl_matrix_rotate_euler: * @matrix: A 4x4 transformation matrix @@ -517,17 +502,6 @@ cogl_matrix_init_from_array (CoglMatrix *matrix, const float * cogl_matrix_get_array (const CoglMatrix *matrix); -/** - * cogl_matrix_init_from_quaternion: - * @matrix: A 4x4 transformation matrix - * @quaternion: A #CoglQuaternion - * - * Initializes @matrix from a #CoglQuaternion rotation. - */ -void -cogl_matrix_init_from_quaternion (CoglMatrix *matrix, - const CoglQuaternion *quaternion); - /** * cogl_matrix_init_from_euler: * @matrix: A 4x4 transformation matrix diff --git a/cogl/cogl/cogl-quaternion-private.h b/cogl/cogl/cogl-quaternion-private.h deleted file mode 100644 index eda672ea8..000000000 --- a/cogl/cogl/cogl-quaternion-private.h +++ /dev/null @@ -1,44 +0,0 @@ -/* - * Cogl - * - * A Low Level GPU Graphics and Utilities API - * - * Copyright (C) 2008,2009 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: - * Robert Bragg - */ - -#ifndef __COGL_QUATERNION_PRIVATE_H__ -#define __COGL_QUATERNION_PRIVATE_H__ - -#include - -/* squared length */ -#define _COGL_QUATERNION_NORM(Q) \ - ((Q)->x*(Q)->x + (Q)->y*(Q)->y + (Q)->z*(Q)->z + (Q)->w*(Q)->w) - -#define _COGL_QUATERNION_DEGREES_TO_RADIANS (G_PI / 180.0f) -#define _COGL_QUATERNION_RADIANS_TO_DEGREES (180.0f / G_PI) - -#endif /* __COGL_QUATERNION_PRIVATE_H__ */ diff --git a/cogl/cogl/cogl-quaternion.c b/cogl/cogl/cogl-quaternion.c deleted file mode 100644 index a8f43a7d4..000000000 --- a/cogl/cogl/cogl-quaternion.c +++ /dev/null @@ -1,670 +0,0 @@ -/* - * Cogl - * - * A Low Level GPU Graphics and Utilities API - * - * Copyright (C) 2010 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: - * Robert Bragg - * - * Various references relating to quaternions: - * - * http://www.cs.caltech.edu/courses/cs171/quatut.pdf - * http://mathworld.wolfram.com/Quaternion.html - * http://www.gamedev.net/reference/articles/article1095.asp - * http://www.cprogramming.com/tutorial/3d/quaternions.html - * http://www.isner.com/tutorials/quatSpells/quaternion_spells_12.htm - * http://www.j3d.org/matrix_faq/matrfaq_latest.html#Q56 - * 3D Maths Primer for Graphics and Game Development ISBN-10: 1556229119 - */ - -#include "cogl-config.h" - -#include -#include -#include -#include -#include -#include "cogl-gtype-private.h" - -#include -#include - -#define FLOAT_EPSILON 1e-03 - -COGL_GTYPE_DEFINE_BOXED (Quaternion, quaternion, - cogl_quaternion_copy, - cogl_quaternion_free); - -static CoglQuaternion zero_quaternion = -{ - 0.0, 0.0, 0.0, 0.0, -}; - -static CoglQuaternion identity_quaternion = -{ - 1.0, 0.0, 0.0, 0.0, -}; - -/* This function is just here to be called from GDB so we don't really - want to put a declaration in a header and we just add it here to - avoid a warning */ -void -_cogl_quaternion_print (CoglQuaternion *quarternion); - -void -_cogl_quaternion_print (CoglQuaternion *quaternion) -{ - g_print ("[ %6.4f (%6.4f, %6.4f, %6.4f)]\n", - quaternion->w, - quaternion->x, - quaternion->y, - quaternion->z); -} - -void -cogl_quaternion_init (CoglQuaternion *quaternion, - float angle, - float x, - float y, - float z) -{ - float axis[3] = { x, y, z}; - cogl_quaternion_init_from_angle_vector (quaternion, angle, axis); -} - -void -cogl_quaternion_init_from_angle_vector (CoglQuaternion *quaternion, - float angle, - const float *axis3f_in) -{ - /* NB: We are using quaternions to represent an axis (a), angle (πœƒ) pair - * in this form: - * [w=cos(πœƒ/2) ( x=sin(πœƒ/2)*a.x, y=sin(πœƒ/2)*a.y, z=sin(πœƒ/2)*a.x )] - */ - float axis[3]; - float half_angle; - float sin_half_angle; - - /* XXX: Should we make cogl_vector3_normalize have separate in and - * out args? */ - axis[0] = axis3f_in[0]; - axis[1] = axis3f_in[1]; - axis[2] = axis3f_in[2]; - cogl_vector3_normalize (axis); - - half_angle = angle * _COGL_QUATERNION_DEGREES_TO_RADIANS * 0.5f; - sin_half_angle = sinf (half_angle); - - quaternion->w = cosf (half_angle); - - quaternion->x = axis[0] * sin_half_angle; - quaternion->y = axis[1] * sin_half_angle; - quaternion->z = axis[2] * sin_half_angle; - - cogl_quaternion_normalize (quaternion); -} - -void -cogl_quaternion_init_identity (CoglQuaternion *quaternion) -{ - quaternion->w = 1.0; - - quaternion->x = 0.0; - quaternion->y = 0.0; - quaternion->z = 0.0; -} - -void -cogl_quaternion_init_from_array (CoglQuaternion *quaternion, - const float *array) -{ - quaternion->w = array[0]; - quaternion->x = array[1]; - quaternion->y = array[2]; - quaternion->z = array[3]; -} - -void -cogl_quaternion_init_from_x_rotation (CoglQuaternion *quaternion, - float angle) -{ - /* NB: We are using quaternions to represent an axis (a), angle (πœƒ) pair - * in this form: - * [w=cos(πœƒ/2) ( x=sin(πœƒ/2)*a.x, y=sin(πœƒ/2)*a.y, z=sin(πœƒ/2)*a.x )] - */ - float half_angle = angle * _COGL_QUATERNION_DEGREES_TO_RADIANS * 0.5f; - - quaternion->w = cosf (half_angle); - - quaternion->x = sinf (half_angle); - quaternion->y = 0.0f; - quaternion->z = 0.0f; -} - -void -cogl_quaternion_init_from_y_rotation (CoglQuaternion *quaternion, - float angle) -{ - /* NB: We are using quaternions to represent an axis (a), angle (πœƒ) pair - * in this form: - * [w=cos(πœƒ/2) ( x=sin(πœƒ/2)*a.x, y=sin(πœƒ/2)*a.y, z=sin(πœƒ/2)*a.x )] - */ - float half_angle = angle * _COGL_QUATERNION_DEGREES_TO_RADIANS * 0.5f; - - quaternion->w = cosf (half_angle); - - quaternion->x = 0.0f; - quaternion->y = sinf (half_angle); - quaternion->z = 0.0f; -} - -void -cogl_quaternion_init_from_z_rotation (CoglQuaternion *quaternion, - float angle) -{ - /* NB: We are using quaternions to represent an axis (a), angle (πœƒ) pair - * in this form: - * [w=cos(πœƒ/2) ( x=sin(πœƒ/2)*a.x, y=sin(πœƒ/2)*a.y, z=sin(πœƒ/2)*a.x )] - */ - float half_angle = angle * _COGL_QUATERNION_DEGREES_TO_RADIANS * 0.5f; - - quaternion->w = cosf (half_angle); - - quaternion->x = 0.0f; - quaternion->y = 0.0f; - quaternion->z = sinf (half_angle); -} - -void -cogl_quaternion_init_from_euler (CoglQuaternion *quaternion, - const graphene_euler_t *euler) -{ - /* NB: We are using quaternions to represent an axis (a), angle (πœƒ) pair - * in this form: - * [w=cos(πœƒ/2) ( x=sin(πœƒ/2)*a.x, y=sin(πœƒ/2)*a.y, z=sin(πœƒ/2)*a.x )] - */ - float sin_heading = - sinf (graphene_euler_get_y (euler) * _COGL_QUATERNION_DEGREES_TO_RADIANS * 0.5f); - float sin_pitch = - sinf (graphene_euler_get_x (euler) * _COGL_QUATERNION_DEGREES_TO_RADIANS * 0.5f); - float sin_roll = - sinf (graphene_euler_get_z (euler) * _COGL_QUATERNION_DEGREES_TO_RADIANS * 0.5f); - float cos_heading = - cosf (graphene_euler_get_y (euler) * _COGL_QUATERNION_DEGREES_TO_RADIANS * 0.5f); - float cos_pitch = - cosf (graphene_euler_get_x (euler) * _COGL_QUATERNION_DEGREES_TO_RADIANS * 0.5f); - float cos_roll = - cosf (graphene_euler_get_z (euler) * _COGL_QUATERNION_DEGREES_TO_RADIANS * 0.5f); - - quaternion->w = - cos_heading * cos_pitch * cos_roll + - sin_heading * sin_pitch * sin_roll; - - quaternion->x = - cos_heading * sin_pitch * cos_roll + - sin_heading * cos_pitch * sin_roll; - quaternion->y = - sin_heading * cos_pitch * cos_roll - - cos_heading * sin_pitch * sin_roll; - quaternion->z = - cos_heading * cos_pitch * sin_roll - - sin_heading * sin_pitch * cos_roll; -} - -void -cogl_quaternion_init_from_quaternion (CoglQuaternion *quaternion, - CoglQuaternion *src) -{ - memcpy (quaternion, src, sizeof (float) * 4); -} - -/* XXX: it could be nice to make something like this public... */ -/* - * COGL_MATRIX_READ: - * @MATRIX: A 4x4 transformation matrix - * @ROW: The row of the value you want to read - * @COLUMN: The column of the value you want to read - * - * Reads a value from the given matrix using integers to index - * into the matrix. - */ -#define COGL_MATRIX_READ(MATRIX, ROW, COLUMN) \ - (((const float *)matrix)[COLUMN * 4 + ROW]) - -void -cogl_quaternion_init_from_matrix (CoglQuaternion *quaternion, - const CoglMatrix *matrix) -{ - /* Algorithm devised by Ken Shoemake, Ref: - * http://campar.in.tum.de/twiki/pub/Chair/DwarfTutorial/quatut.pdf - */ - - /* 3D maths literature refers to the diagonal of a matrix as the - * "trace" of a matrix... */ - float trace = matrix->xx + matrix->yy + matrix->zz; - float root; - - if (trace > 0.0f) - { - root = sqrtf (trace + 1); - quaternion->w = root * 0.5f; - root = 0.5f / root; - quaternion->x = (matrix->zy - matrix->yz) * root; - quaternion->y = (matrix->xz - matrix->zx) * root; - quaternion->z = (matrix->yx - matrix->xy) * root; - } - else - { -#define X 0 -#define Y 1 -#define Z 2 -#define W 3 - int h = X; - if (matrix->yy > matrix->xx) - h = Y; - if (matrix->zz > COGL_MATRIX_READ (matrix, h, h)) - h = Z; - switch (h) - { -#define CASE_MACRO(i, j, k, I, J, K) \ - case I: \ - root = sqrtf ((COGL_MATRIX_READ (matrix, I, I) - \ - (COGL_MATRIX_READ (matrix, J, J) + \ - COGL_MATRIX_READ (matrix, K, K))) + \ - COGL_MATRIX_READ (matrix, W, W)); \ - quaternion->i = root * 0.5f;\ - root = 0.5f / root;\ - quaternion->j = (COGL_MATRIX_READ (matrix, I, J) + \ - COGL_MATRIX_READ (matrix, J, I)) * root; \ - quaternion->k = (COGL_MATRIX_READ (matrix, K, I) + \ - COGL_MATRIX_READ (matrix, I, K)) * root; \ - quaternion->w = (COGL_MATRIX_READ (matrix, K, J) - \ - COGL_MATRIX_READ (matrix, J, K)) * root;\ - break - CASE_MACRO (x, y, z, X, Y, Z); - CASE_MACRO (y, z, x, Y, Z, X); - CASE_MACRO (z, x, y, Z, X, Y); -#undef CASE_MACRO -#undef X -#undef Y -#undef Z - } - } - - if (matrix->ww != 1.0f) - { - float s = 1.0 / sqrtf (matrix->ww); - quaternion->w *= s; - quaternion->x *= s; - quaternion->y *= s; - quaternion->z *= s; - } -} - -gboolean -cogl_quaternion_equal (const void *v1, const void *v2) -{ - const CoglQuaternion *a = v1; - const CoglQuaternion *b = v2; - - g_return_val_if_fail (v1 != NULL, FALSE); - g_return_val_if_fail (v2 != NULL, FALSE); - - if (v1 == v2) - return TRUE; - - return (a->w == b->w && - a->x == b->x && - a->y == b->y && - a->z == b->z); -} - -CoglQuaternion * -cogl_quaternion_copy (const CoglQuaternion *src) -{ - if (G_LIKELY (src)) - { - CoglQuaternion *new = g_slice_new (CoglQuaternion); - memcpy (new, src, sizeof (float) * 4); - return new; - } - else - return NULL; -} - -void -cogl_quaternion_free (CoglQuaternion *quaternion) -{ - g_slice_free (CoglQuaternion, quaternion); -} - -float -cogl_quaternion_get_rotation_angle (const CoglQuaternion *quaternion) -{ - /* NB: We are using quaternions to represent an axis (a), angle (πœƒ) pair - * in this form: - * [w=cos(πœƒ/2) ( x=sin(πœƒ/2)*a.x, y=sin(πœƒ/2)*a.y, z=sin(πœƒ/2)*a.x )] - */ - - /* FIXME: clamp [-1, 1] */ - return 2.0f * acosf (quaternion->w) * _COGL_QUATERNION_RADIANS_TO_DEGREES; -} - -void -cogl_quaternion_get_rotation_axis (const CoglQuaternion *quaternion, - float *vector3) -{ - float sin_half_angle_sqr; - float one_over_sin_angle_over_2; - - /* NB: We are using quaternions to represent an axis (a), angle (πœƒ) pair - * in this form: - * [w=cos(πœƒ/2) ( x=sin(πœƒ/2)*a.x, y=sin(πœƒ/2)*a.y, z=sin(πœƒ/2)*a.x )] - */ - - /* NB: sinΒ²(πœƒ) + cosΒ²(πœƒ) = 1 */ - - sin_half_angle_sqr = 1.0f - quaternion->w * quaternion->w; - - if (sin_half_angle_sqr <= 0.0f) - { - /* Either an identity quaternion or numerical imprecision. - * Either way we return an arbitrary vector. */ - vector3[0] = 1; - vector3[1] = 0; - vector3[2] = 0; - return; - } - - /* Calculate 1 / sin(πœƒ/2) */ - one_over_sin_angle_over_2 = 1.0f / sqrtf (sin_half_angle_sqr); - - vector3[0] = quaternion->x * one_over_sin_angle_over_2; - vector3[1] = quaternion->y * one_over_sin_angle_over_2; - vector3[2] = quaternion->z * one_over_sin_angle_over_2; -} - -void -cogl_quaternion_normalize (CoglQuaternion *quaternion) -{ - float slen = _COGL_QUATERNION_NORM (quaternion); - float factor = 1.0f / sqrtf (slen); - - quaternion->x *= factor; - quaternion->y *= factor; - quaternion->z *= factor; - - quaternion->w *= factor; - - return; -} - -float -cogl_quaternion_dot_product (const CoglQuaternion *a, - const CoglQuaternion *b) -{ - return a->w * b->w + a->x * b->x + a->y * b->y + a->z * b->z; -} - -void -cogl_quaternion_invert (CoglQuaternion *quaternion) -{ - quaternion->x = -quaternion->x; - quaternion->y = -quaternion->y; - quaternion->z = -quaternion->z; -} - -void -cogl_quaternion_multiply (CoglQuaternion *result, - const CoglQuaternion *a, - const CoglQuaternion *b) -{ - float w = a->w; - float x = a->x; - float y = a->y; - float z = a->z; - - g_return_if_fail (b != result); - - result->w = w * b->w - x * b->x - y * b->y - z * b->z; - - result->x = w * b->x + x * b->w + y * b->z - z * b->y; - result->y = w * b->y + y * b->w + z * b->x - x * b->z; - result->z = w * b->z + z * b->w + x * b->y - y * b->x; -} - -void -cogl_quaternion_pow (CoglQuaternion *quaternion, float exponent) -{ - float half_angle; - float new_half_angle; - float factor; - - /* Try and identify and nop identity quaternions to avoid - * dividing by zero */ - if (fabs (quaternion->w) > 0.9999f) - return; - - /* NB: We are using quaternions to represent an axis (a), angle (πœƒ) pair - * in this form: - * [w=cos(πœƒ/2) ( x=sin(πœƒ/2)*a.x, y=sin(πœƒ/2)*a.y, z=sin(πœƒ/2)*a.x )] - */ - - /* FIXME: clamp [-1, 1] */ - /* Extract πœƒ/2 from w */ - half_angle = acosf (quaternion->w); - - /* Compute the new πœƒ/2 */ - new_half_angle = half_angle * exponent; - - /* Compute the new w value */ - quaternion->w = cosf (new_half_angle); - - /* And new xyz values */ - factor = sinf (new_half_angle) / sinf (half_angle); - quaternion->x *= factor; - quaternion->y *= factor; - quaternion->z *= factor; -} - -void -cogl_quaternion_slerp (CoglQuaternion *result, - const CoglQuaternion *a, - const CoglQuaternion *b, - float t) -{ - float cos_difference; - float qb_w; - float qb_x; - float qb_y; - float qb_z; - float fa; - float fb; - - g_return_if_fail (t >=0 && t <= 1.0f); - - if (t == 0) - { - *result = *a; - return; - } - else if (t == 1) - { - *result = *b; - return; - } - - /* compute the cosine of the angle between the two given quaternions */ - cos_difference = cogl_quaternion_dot_product (a, b); - - /* If negative, use -b. Two quaternions q and -q represent the same angle but - * may produce a different slerp. We choose b or -b to rotate using the acute - * angle. - */ - if (cos_difference < 0.0f) - { - qb_w = -b->w; - qb_x = -b->x; - qb_y = -b->y; - qb_z = -b->z; - cos_difference = -cos_difference; - } - else - { - qb_w = b->w; - qb_x = b->x; - qb_y = b->y; - qb_z = b->z; - } - - /* If we have two unit quaternions the dot should be <= 1.0 */ - g_assert (cos_difference < 1.1f); - - - /* Determine the interpolation factors for each quaternion, simply using - * linear interpolation for quaternions that are nearly exactly the same. - * (this will avoid divisions by zero) - */ - - if (cos_difference > 0.9999f) - { - fa = 1.0f - t; - fb = t; - - /* XXX: should we also normalize() at the end in this case? */ - } - else - { - /* Calculate the sin of the angle between the two quaternions using the - * trig identity: sinΒ²(πœƒ) + cosΒ²(πœƒ) = 1 - */ - float sin_difference = sqrtf (1.0f - cos_difference * cos_difference); - - float difference = atan2f (sin_difference, cos_difference); - float one_over_sin_difference = 1.0f / sin_difference; - fa = sinf ((1.0f - t) * difference) * one_over_sin_difference; - fb = sinf (t * difference) * one_over_sin_difference; - } - - /* Finally interpolate the two quaternions */ - - result->x = fa * a->x + fb * qb_x; - result->y = fa * a->y + fb * qb_y; - result->z = fa * a->z + fb * qb_z; - result->w = fa * a->w + fb * qb_w; -} - -void -cogl_quaternion_nlerp (CoglQuaternion *result, - const CoglQuaternion *a, - const CoglQuaternion *b, - float t) -{ - float cos_difference; - float qb_w; - float qb_x; - float qb_y; - float qb_z; - float fa; - float fb; - - g_return_if_fail (t >=0 && t <= 1.0f); - - if (t == 0) - { - *result = *a; - return; - } - else if (t == 1) - { - *result = *b; - return; - } - - /* compute the cosine of the angle between the two given quaternions */ - cos_difference = cogl_quaternion_dot_product (a, b); - - /* If negative, use -b. Two quaternions q and -q represent the same angle but - * may produce a different slerp. We choose b or -b to rotate using the acute - * angle. - */ - if (cos_difference < 0.0f) - { - qb_w = -b->w; - qb_x = -b->x; - qb_y = -b->y; - qb_z = -b->z; - cos_difference = -cos_difference; - } - else - { - qb_w = b->w; - qb_x = b->x; - qb_y = b->y; - qb_z = b->z; - } - - /* If we have two unit quaternions the dot should be <= 1.0 */ - g_assert (cos_difference < 1.1f); - - fa = 1.0f - t; - fb = t; - - result->x = fa * a->x + fb * qb_x; - result->y = fa * a->y + fb * qb_y; - result->z = fa * a->z + fb * qb_z; - result->w = fa * a->w + fb * qb_w; - - cogl_quaternion_normalize (result); -} - -void -cogl_quaternion_squad (CoglQuaternion *result, - const CoglQuaternion *prev, - const CoglQuaternion *a, - const CoglQuaternion *b, - const CoglQuaternion *next, - float t) -{ - CoglQuaternion slerp0; - CoglQuaternion slerp1; - - cogl_quaternion_slerp (&slerp0, a, b, t); - cogl_quaternion_slerp (&slerp1, prev, next, t); - cogl_quaternion_slerp (result, &slerp0, &slerp1, 2.0f * t * (1.0f - t)); -} - -const CoglQuaternion * -cogl_get_static_identity_quaternion (void) -{ - return &identity_quaternion; -} - -const CoglQuaternion * -cogl_get_static_zero_quaternion (void) -{ - return &zero_quaternion; -} - diff --git a/cogl/cogl/cogl-quaternion.h b/cogl/cogl/cogl-quaternion.h deleted file mode 100644 index c6c6d504e..000000000 --- a/cogl/cogl/cogl-quaternion.h +++ /dev/null @@ -1,561 +0,0 @@ -/* - * Cogl - * - * A Low Level GPU Graphics and Utilities API - * - * Copyright (C) 2010 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: - * Robert Bragg - */ - -#if !defined(__COGL_H_INSIDE__) && !defined(COGL_COMPILATION) -#error "Only can be included directly." -#endif - -#ifndef __COGL_QUATERNION_H__ -#define __COGL_QUATERNION_H__ - -#include - -#include -#include - -G_BEGIN_DECLS - -/** - * SECTION:cogl-quaternion - * @short_description: Functions for initializing and manipulating - * quaternions. - * - * Quaternions have become a standard form for representing 3D - * rotations and have some nice properties when compared with other - * representation such as (roll,pitch,yaw) Euler angles. They can be - * used to interpolate between different rotations and they don't - * suffer from a problem called - * "Gimbal lock" - * where two of the axis of rotation may become aligned and you loose a - * degree of freedom. - * . - */ -#include - -#include - -/** - * CoglQuaternion: - * @w: based on the angle of rotation it is cos(πœƒ/2) - * @x: based on the angle of rotation and x component of the axis of - * rotation it is sin(πœƒ/2)*axis.x - * @y: based on the angle of rotation and y component of the axis of - * rotation it is sin(πœƒ/2)*axis.y - * @z: based on the angle of rotation and z component of the axis of - * rotation it is sin(πœƒ/2)*axis.z - * - * A quaternion is comprised of a scalar component and a 3D vector - * component. The scalar component is normally referred to as w and the - * vector might either be referred to as v or a (for axis) or expanded - * with the individual components: (x, y, z) A full quaternion would - * then be written as [w (x, y, z)]. - * - * Quaternions can be considered to represent an axis and angle - * pair although sadly these numbers are buried somewhat under some - * maths... - * - * For the curious you can see here that a given axis (a) and angle (πœƒ) - * pair are represented in a quaternion as follows: - * |[ - * [w=cos(πœƒ/2) ( x=sin(πœƒ/2)*a.x, y=sin(πœƒ/2)*a.y, z=sin(πœƒ/2)*a.x )] - * ]| - * - * Unit Quaternions: - * When using Quaternions to represent spatial orientations for 3D - * graphics it's always assumed you have a unit quaternion. The - * magnitude of a quaternion is defined as: - * |[ - * sqrt (wΒ² + xΒ² + yΒ² + zΒ²) - * ]| - * and a unit quaternion satisfies this equation: - * |[ - * wΒ² + xΒ² + yΒ² + zΒ² = 1 - * ]| - * - * Thankfully most of the time we don't actually have to worry about - * the maths that goes on behind the scenes but if you are curious to - * learn more here are some external references: - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * 3D Maths Primer for Graphics and Game Development ISBN-10: 1556229119 - * - * - * - * - * - * - * - * - * - */ -struct _CoglQuaternion -{ - /*< public >*/ - float w; - - float x; - float y; - float z; - - /*< private >*/ - float padding0; - float padding1; - float padding2; - float padding3; -}; -COGL_STRUCT_SIZE_ASSERT (CoglQuaternion, 32); - -/** - * cogl_quaternion_get_gtype: - * - * Returns: a #GType that can be used with the GLib type system. - */ -GType cogl_quaternion_get_gtype (void); - -/** - * cogl_quaternion_init: - * @quaternion: An uninitialized #CoglQuaternion - * @angle: The angle you want to rotate around the given axis - * @x: The x component of your axis vector about which you want to - * rotate. - * @y: The y component of your axis vector about which you want to - * rotate. - * @z: The z component of your axis vector about which you want to - * rotate. - * - * Initializes a quaternion that rotates @angle degrees around the - * axis vector (@x, @y, @z). The axis vector does not need to be - * normalized. - * - * Returns: A normalized, unit quaternion representing an orientation - * rotated @angle degrees around the axis vector (@x, @y, @z) - * - * Since: 2.0 - */ -void -cogl_quaternion_init (CoglQuaternion *quaternion, - float angle, - float x, - float y, - float z); - -/** - * cogl_quaternion_init_from_angle_vector: - * @quaternion: An uninitialized #CoglQuaternion - * @angle: The angle to rotate around @axis3f - * @axis3f: your 3 component axis vector about which you want to rotate. - * - * Initializes a quaternion that rotates @angle degrees around the - * given @axis vector. The axis vector does not need to be - * normalized. - * - * Returns: A normalized, unit quaternion representing an orientation - * rotated @angle degrees around the given @axis vector. - * - * Since: 2.0 - */ -void -cogl_quaternion_init_from_angle_vector (CoglQuaternion *quaternion, - float angle, - const float *axis3f); - -/** - * cogl_quaternion_init_identity: - * @quaternion: An uninitialized #CoglQuaternion - * - * Initializes the quaternion with the canonical quaternion identity - * [1 (0, 0, 0)] which represents no rotation. Multiplying a - * quaternion with this identity leaves the quaternion unchanged. - * - * You might also want to consider using - * cogl_get_static_identity_quaternion(). - * - * Since: 2.0 - */ -void -cogl_quaternion_init_identity (CoglQuaternion *quaternion); - -/** - * cogl_quaternion_init_from_array: - * @quaternion: A #CoglQuaternion - * @array: An array of 4 floats w,(x,y,z) - * - * Initializes a [w (x, y,z)] quaternion directly from an array of 4 - * floats: [w,x,y,z]. - * - * Since: 2.0 - */ -void -cogl_quaternion_init_from_array (CoglQuaternion *quaternion, - const float *array); - -/** - * cogl_quaternion_init_from_x_rotation: - * @quaternion: An uninitialized #CoglQuaternion - * @angle: The angle to rotate around the x axis - * - * XXX: check which direction this rotates - * - * Since: 2.0 - */ -void -cogl_quaternion_init_from_x_rotation (CoglQuaternion *quaternion, - float angle); - -/** - * cogl_quaternion_init_from_y_rotation: - * @quaternion: An uninitialized #CoglQuaternion - * @angle: The angle to rotate around the y axis - * - * - * Since: 2.0 - */ -void -cogl_quaternion_init_from_y_rotation (CoglQuaternion *quaternion, - float angle); - -/** - * cogl_quaternion_init_from_z_rotation: - * @quaternion: An uninitialized #CoglQuaternion - * @angle: The angle to rotate around the z axis - * - * - * Since: 2.0 - */ -void -cogl_quaternion_init_from_z_rotation (CoglQuaternion *quaternion, - float angle); - -/** - * cogl_quaternion_init_from_euler: - * @quaternion: A #CoglQuaternion - * @euler: A #graphene_euler_t with which to initialize the quaternion - * - * Since: 2.0 - */ -void -cogl_quaternion_init_from_euler (CoglQuaternion *quaternion, - const graphene_euler_t *euler); - -/** - * cogl_quaternion_init_from_quaternion: - * @quaternion: A #CoglQuaternion - * @src: A #CoglQuaternion with which to initialize @quaternion - * - * Since: 2.0 - */ -void -cogl_quaternion_init_from_quaternion (CoglQuaternion *quaternion, - CoglQuaternion *src); - -/** - * cogl_quaternion_init_from_matrix: - * @quaternion: A Cogl Quaternion - * @matrix: A rotation matrix with which to initialize the quaternion - * - * Initializes a quaternion from a rotation matrix. - * - * Since: 1.10 - * Stability: unstable - */ -void -cogl_quaternion_init_from_matrix (CoglQuaternion *quaternion, - const CoglMatrix *matrix); - -/** - * cogl_quaternion_equal: - * @v1: A #CoglQuaternion - * @v2: A #CoglQuaternion - * - * Compares that all the components of quaternions @a and @b are - * equal. - * - * An epsilon value is not used to compare the float components, but - * the == operator is at least used so that 0 and -0 are considered - * equal. - * - * Returns: %TRUE if the quaternions are equal else %FALSE. - * - * Since: 2.0 - */ -gboolean -cogl_quaternion_equal (const void *v1, const void *v2); - -/** - * cogl_quaternion_copy: - * @src: A #CoglQuaternion - * - * Allocates a new #CoglQuaternion on the stack and initializes it with - * the same values as @src. - * - * Returns: A newly allocated #CoglQuaternion which should be freed - * using cogl_quaternion_free() - * - * Since: 2.0 - */ -CoglQuaternion * -cogl_quaternion_copy (const CoglQuaternion *src); - -/** - * cogl_quaternion_free: - * @quaternion: A #CoglQuaternion - * - * Frees a #CoglQuaternion that was previously allocated via - * cogl_quaternion_copy(). - * - * Since: 2.0 - */ -void -cogl_quaternion_free (CoglQuaternion *quaternion); - -/** - * cogl_quaternion_get_rotation_angle: - * @quaternion: A #CoglQuaternion - * - * - * Since: 2.0 - */ -float -cogl_quaternion_get_rotation_angle (const CoglQuaternion *quaternion); - -/** - * cogl_quaternion_get_rotation_axis: - * @quaternion: A #CoglQuaternion - * @vector3: (out): an allocated 3-float array - * - * Since: 2.0 - */ -void -cogl_quaternion_get_rotation_axis (const CoglQuaternion *quaternion, - float *vector3); - -/** - * cogl_quaternion_normalize: - * @quaternion: A #CoglQuaternion - * - * - * Since: 2.0 - */ -void -cogl_quaternion_normalize (CoglQuaternion *quaternion); - -/** - * cogl_quaternion_dot_product: - * @a: A #CoglQuaternion - * @b: A #CoglQuaternion - * - * Since: 2.0 - */ -float -cogl_quaternion_dot_product (const CoglQuaternion *a, - const CoglQuaternion *b); - -/** - * cogl_quaternion_invert: - * @quaternion: A #CoglQuaternion - * - * - * Since: 2.0 - */ -void -cogl_quaternion_invert (CoglQuaternion *quaternion); - -/** - * cogl_quaternion_multiply: - * @result: The destination #CoglQuaternion - * @left: The second #CoglQuaternion rotation to apply - * @right: The first #CoglQuaternion rotation to apply - * - * This combines the rotations of two quaternions into @result. The - * operation is not commutative so the order is important because AxB - * != BxA. Cogl follows the standard convention for quaternions here - * so the rotations are applied @right to @left. This is similar to the - * combining of matrices. - * - * It is possible to multiply the @a quaternion in-place, so - * @result can be equal to @a but can't be equal to @b. - * - * Since: 2.0 - */ -void -cogl_quaternion_multiply (CoglQuaternion *result, - const CoglQuaternion *left, - const CoglQuaternion *right); - -/** - * cogl_quaternion_pow: - * @quaternion: A #CoglQuaternion - * @exponent: the exponent - * - * - * Since: 2.0 - */ -void -cogl_quaternion_pow (CoglQuaternion *quaternion, float exponent); - -/** - * cogl_quaternion_slerp: - * @result: The destination #CoglQuaternion - * @a: The first #CoglQuaternion - * @b: The second #CoglQuaternion - * @t: The factor in the range [0,1] used to interpolate between - * quaternion @a and @b. - * - * Performs a spherical linear interpolation between two quaternions. - * - * Noteable properties: - * - * - * commutative: No - * - * - * constant velocity: Yes - * - * - * torque minimal (travels along the surface of the 4-sphere): Yes - * - * - * more expensive than cogl_quaternion_nlerp() - * - * - */ -void -cogl_quaternion_slerp (CoglQuaternion *result, - const CoglQuaternion *a, - const CoglQuaternion *b, - float t); - -/** - * cogl_quaternion_nlerp: - * @result: The destination #CoglQuaternion - * @a: The first #CoglQuaternion - * @b: The second #CoglQuaternion - * @t: The factor in the range [0,1] used to interpolate between - * quaterion @a and @b. - * - * Performs a normalized linear interpolation between two quaternions. - * That is it does a linear interpolation of the quaternion components - * and then normalizes the result. This will follow the shortest arc - * between the two orientations (just like the slerp() function) but - * will not progress at a constant speed. Unlike slerp() nlerp is - * commutative which is useful if you are blending animations - * together. (I.e. nlerp (tmp, a, b) followed by nlerp (result, tmp, - * d) is the same as nlerp (tmp, a, d) followed by nlerp (result, tmp, - * b)). Finally nlerp is cheaper than slerp so it can be a good choice - * if you don't need the constant speed property of the slerp() function. - * - * Notable properties: - * - * - * commutative: Yes - * - * - * constant velocity: No - * - * - * torque minimal (travels along the surface of the 4-sphere): Yes - * - * - * faster than cogl_quaternion_slerp() - * - * - */ -void -cogl_quaternion_nlerp (CoglQuaternion *result, - const CoglQuaternion *a, - const CoglQuaternion *b, - float t); -/** - * cogl_quaternion_squad: - * @result: The destination #CoglQuaternion - * @prev: A #CoglQuaternion used before @a - * @a: The first #CoglQuaternion - * @b: The second #CoglQuaternion - * @next: A #CoglQuaternion that will be used after @b - * @t: The factor in the range [0,1] used to interpolate between - * quaternion @a and @b. - * - * - * Since: 2.0 - */ -void -cogl_quaternion_squad (CoglQuaternion *result, - const CoglQuaternion *prev, - const CoglQuaternion *a, - const CoglQuaternion *b, - const CoglQuaternion *next, - float t); - -/** - * cogl_get_static_identity_quaternion: - * - * Returns a pointer to a singleton quaternion constant describing the - * canonical identity [1 (0, 0, 0)] which represents no rotation. - * - * If you multiply a quaternion with the identity quaternion you will - * get back the same value as the original quaternion. - * - * Returns: A pointer to an identity quaternion - * - * Since: 2.0 - */ -const CoglQuaternion * -cogl_get_static_identity_quaternion (void); - -/** - * cogl_get_static_zero_quaternion: - * - * Returns: a pointer to a singleton quaternion constant describing a - * rotation of 180 degrees around a degenerate axis: - * [0 (0, 0, 0)] - * - * Since: 2.0 - */ -const CoglQuaternion * -cogl_get_static_zero_quaternion (void); - -G_END_DECLS - -#endif /* __COGL_QUATERNION_H__ */ - diff --git a/cogl/cogl/cogl-types.h b/cogl/cogl/cogl-types.h index f7b9b38ba..7906287e4 100644 --- a/cogl/cogl/cogl-types.h +++ b/cogl/cogl/cogl-types.h @@ -88,10 +88,6 @@ cogl_handle_get_type (void) G_GNUC_CONST; * between cogl-matrix.h and cogl-quaterion.h */ typedef struct _CoglMatrix CoglMatrix; -/* Same as above we forward declared CoglQuaternion to avoid - * circular dependencies. */ -typedef struct _CoglQuaternion CoglQuaternion; - /** * CoglAngle: * diff --git a/cogl/cogl/cogl.h b/cogl/cogl/cogl.h index aeda0d3b4..e0c93c873 100644 --- a/cogl/cogl/cogl.h +++ b/cogl/cogl/cogl.h @@ -102,7 +102,6 @@ #include #include #include -#include #include #include #include diff --git a/cogl/cogl/cogl.symbols b/cogl/cogl/cogl.symbols index 996fd775b..e0a9b57d8 100644 --- a/cogl/cogl/cogl.symbols +++ b/cogl/cogl/cogl.symbols @@ -266,7 +266,6 @@ cogl_framebuffer_rotate #ifdef COGL_ENABLE_EXPERIMENTAL_API cogl_framebuffer_rotate_euler -cogl_framebuffer_rotate_quaternion #endif cogl_framebuffer_scale @@ -309,8 +308,6 @@ cogl_get_proc_address cogl_get_projection_matrix cogl_get_rectangle_indices cogl_get_source -cogl_get_static_identity_quaternion -cogl_get_static_zero_quaternion cogl_get_viewport #ifdef COGL_HAS_GLIB_SUPPORT @@ -458,7 +455,6 @@ cogl_matrix_init_from_array cogl_matrix_init_translation cogl_matrix_is_identity cogl_matrix_init_from_euler -cogl_matrix_init_from_quaternion cogl_matrix_init_identity cogl_matrix_look_at cogl_matrix_multiply @@ -472,7 +468,6 @@ cogl_matrix_rotate #ifdef COGL_ENABLE_EXPERIMENTAL_API cogl_matrix_rotate_euler -cogl_matrix_rotate_quaternion #endif cogl_matrix_scale @@ -492,7 +487,6 @@ cogl_matrix_stack_pop cogl_matrix_stack_push cogl_matrix_stack_rotate cogl_matrix_stack_rotate_euler -cogl_matrix_stack_rotate_quaternion cogl_matrix_stack_scale cogl_matrix_stack_set cogl_matrix_stack_translate @@ -721,31 +715,6 @@ cogl_push_framebuffer cogl_push_matrix cogl_push_source -cogl_quaternion_copy -cogl_quaternion_dot_product -cogl_quaternion_equal -cogl_quaternion_free -#ifdef COGL_HAS_GTYPE_SUPPORT -cogl_quaternion_get_gtype -#endif -cogl_quaternion_get_rotation_angle -cogl_quaternion_get_rotation_axis -cogl_quaternion_init -cogl_quaternion_init_from_angle_vector -cogl_quaternion_init_from_array -cogl_quaternion_init_from_euler -cogl_quaternion_init_from_x_rotation -cogl_quaternion_init_from_y_rotation -cogl_quaternion_init_from_z_rotation -cogl_quaternion_init_identity -cogl_quaternion_invert -cogl_quaternion_multiply -cogl_quaternion_nlerp -cogl_quaternion_normalize -cogl_quaternion_pow -cogl_quaternion_slerp -cogl_quaternion_squad - cogl_read_pixels cogl_read_pixels_flags_get_type diff --git a/cogl/cogl/meson.build b/cogl/cogl/meson.build index 6da28e254..ed20e46a6 100644 --- a/cogl/cogl/meson.build +++ b/cogl/cogl/meson.build @@ -114,7 +114,6 @@ cogl_nonintrospected_headers = [ 'cogl-frame-info.h', 'cogl-vector.h', 'cogl-output.h', - 'cogl-quaternion.h', 'cogl-matrix-stack.h', 'cogl-poll.h', 'cogl-texture-2d-gl.h', @@ -266,8 +265,6 @@ cogl_sources = [ 'cogl-primitive.c', 'cogl-matrix.c', 'cogl-vector.c', - 'cogl-quaternion-private.h', - 'cogl-quaternion.c', 'cogl-matrix-private.h', 'cogl-matrix-stack.c', 'cogl-matrix-stack-private.h', diff --git a/cogl/tests/conform/meson.build b/cogl/tests/conform/meson.build index d5dcdc0aa..b8c3c0749 100644 --- a/cogl/tests/conform/meson.build +++ b/cogl/tests/conform/meson.build @@ -25,7 +25,7 @@ cogl_test_conformance_sources = [ 'test-point-sprite.c', 'test-no-gl-header.c', 'test-version.c', - 'test-euler-quaternion.c', + 'test-euler.c', 'test-layer-remove.c', 'test-alpha-test.c', 'test-map-buffer-range.c', diff --git a/cogl/tests/conform/test-conform-main.c b/cogl/tests/conform/test-conform-main.c index 2b70d3543..a01026d43 100644 --- a/cogl/tests/conform/test-conform-main.c +++ b/cogl/tests/conform/test-conform-main.c @@ -127,7 +127,7 @@ main (int argc, char **argv) UNPORTED_TEST (test_viewport); - ADD_TEST (test_euler_quaternion, 0, 0); + ADD_TEST (test_euler, 0, 0); ADD_TEST (test_color_hsl, 0, 0); ADD_TEST (test_fence, TEST_REQUIREMENT_FENCE, 0); diff --git a/cogl/tests/conform/test-declarations.h b/cogl/tests/conform/test-declarations.h index 531111962..850d59f0f 100644 --- a/cogl/tests/conform/test-declarations.h +++ b/cogl/tests/conform/test-declarations.h @@ -44,7 +44,7 @@ void test_pipeline_shader_state (void); void test_gles2_context (void); void test_gles2_context_fbo (void); void test_gles2_context_copy_tex_image (void); -void test_euler_quaternion (void); +void test_euler (void); void test_color_hsl (void); void test_fence (void); void test_texture_no_allocate (void); diff --git a/cogl/tests/conform/test-euler-quaternion.c b/cogl/tests/conform/test-euler.c similarity index 78% rename from cogl/tests/conform/test-euler-quaternion.c rename to cogl/tests/conform/test-euler.c index 8aa413a19..c911a1a13 100644 --- a/cogl/tests/conform/test-euler-quaternion.c +++ b/cogl/tests/conform/test-euler.c @@ -36,10 +36,9 @@ } while (0) void -test_euler_quaternion (void) +test_euler (void) { graphene_euler_t euler; - CoglQuaternion quaternion; CoglMatrix matrix_a, matrix_b; /* Try doing the rotation with three separate rotations */ @@ -49,18 +48,12 @@ test_euler_quaternion (void) cogl_matrix_rotate (&matrix_a, 50.0f, 0.0f, 0.0f, 1.0f); /* And try the same rotation with a euler */ - graphene_euler_init_with_order (&euler, 40, -30, 50, GRAPHENE_EULER_ORDER_YXZ); + graphene_euler_init_with_order (&euler, 40, -30, 50, GRAPHENE_EULER_ORDER_RYXZ); cogl_matrix_init_from_euler (&matrix_b, &euler); /* Verify that the matrices are approximately the same */ COMPARE_MATRICES (&matrix_a, &matrix_b); - /* Try converting the euler to a matrix via a quaternion */ - cogl_quaternion_init_from_euler (&quaternion, &euler); - memset (&matrix_b, 0, sizeof (matrix_b)); - cogl_matrix_init_from_quaternion (&matrix_b, &quaternion); - COMPARE_MATRICES (&matrix_a, &matrix_b); - /* Try applying the rotation from a euler to a framebuffer */ cogl_framebuffer_identity_matrix (test_fb); cogl_framebuffer_rotate_euler (test_fb, &euler); @@ -68,13 +61,6 @@ test_euler_quaternion (void) cogl_framebuffer_get_modelview_matrix (test_fb, &matrix_b); COMPARE_MATRICES (&matrix_a, &matrix_b); - /* And again with a quaternion */ - cogl_framebuffer_identity_matrix (test_fb); - cogl_framebuffer_rotate_quaternion (test_fb, &quaternion); - memset (&matrix_b, 0, sizeof (matrix_b)); - cogl_framebuffer_get_modelview_matrix (test_fb, &matrix_b); - COMPARE_MATRICES (&matrix_a, &matrix_b); - /* FIXME: This needs a lot more tests! */ if (cogl_test_verbose ())