External/cglm
1
0
Fork 0
mirror of https://github.com/recp/cglm.git synced 2026-01-01 05:06:13 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #369 from telephone001/master

Browse Source 
euler to quat functions
This commit is contained in:
Recep Aslantas
2023-12-25 10:42:04 +03:00
committed by GitHub
parent 40cfbe9717 d820410435
commit 040926999a
8 changed files with 1026 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
include/cglm/call/euler.h
View File

@@ -49,6 +49,31 @@ CGLM_EXPORT
void
glmc_euler_by_order(vec3 angles, glm_euler_seq axis, mat4 dest);
CGLM_EXPORT
void
glmc_euler_xyz_quat(vec3 angles, versor dest);
CGLM_EXPORT
void
glmc_euler_xzy_quat(vec3 angles, versor dest);
CGLM_EXPORT
void
glmc_euler_yxz_quat(vec3 angles, versor dest);
CGLM_EXPORT
void
glmc_euler_yzx_quat(vec3 angles, versor dest);
CGLM_EXPORT
void
glmc_euler_zxy_quat(vec3 angles, versor dest);
CGLM_EXPORT
void
glmc_euler_zyx_quat(vec3 angles, versor dest);
#ifdef __cplusplus
}
#endif

113
include/cglm/euler.h
View File

@@ -30,6 +30,12 @@
CGLM_INLINE void glm_euler_by_order(vec3 angles,
glm_euler_seq ord,
mat4 dest);
CGLM_INLINE void glm_euler_xyz_quat(vec3 angles, versor dest);
CGLM_INLINE void glm_euler_xzy_quat(vec3 angles, versor dest);
CGLM_INLINE void glm_euler_yxz_quat(vec3 angles, versor dest);
CGLM_INLINE void glm_euler_yzx_quat(vec3 angles, versor dest);
CGLM_INLINE void glm_euler_zxy_quat(vec3 angles, versor dest);
CGLM_INLINE void glm_euler_zyx_quat(vec3 angles, versor dest);
*/
#ifndef cglm_euler_h
@@ -37,6 +43,8 @@
#include "common.h"
#include "handed/euler_to_quat_rh.h"
/*!
* if you have axis order like vec3 orderVec = [0, 1, 2] or [0, 2, 1]...
* vector then you can convert it to this enum by doing this:
@@ -188,7 +196,6 @@ glm_euler_xzy(vec3 angles, mat4 dest) {
dest[3][3] = 1.0f;
}
/*!
* @brief build rotation matrix from euler angles
*
@@ -448,4 +455,108 @@ glm_euler_by_order(vec3 angles, glm_euler_seq ord, mat4 dest) {
dest[3][3] = 1.0f;
}
/*!
* @brief creates NEW quaternion using rotation angles and does
* rotations in x y z order (roll pitch yaw)
*
* @param[out] q quaternion
* @param[in] angle angles x y z (radians)
*/
CGLM_INLINE
void
glm_euler_xyz_quat(vec3 angles, versor dest) {
#ifdef CGLM_FORCE_LEFT_HANDED
glm_euler_xyz_quat_lh(angles, dest);
#else
glm_euler_xyz_quat_rh(angles, dest);
#endif
}
/*!
* @brief creates NEW quaternion using rotation angles and does
* rotations in x z y order (roll yaw pitch)
*
* @param[out] q quaternion
* @param[in] angle angles x y z (radians)
*/
CGLM_INLINE
void
glm_euler_xzy_quat(vec3 angles, versor dest) {
#ifdef CGLM_FORCE_LEFT_HANDED
glm_euler_xzy_quat_lh(angles, dest);
#else
glm_euler_xzy_quat_rh(angles, dest);
#endif
}
/*!
* @brief creates NEW quaternion using rotation angles and does
* rotations in y x z order (pitch roll yaw)
*
* @param[out] q quaternion
* @param[in] angle angles x y z (radians)
*/
CGLM_INLINE
void
glm_euler_yxz_quat(vec3 angles, versor dest) {
#ifdef CGLM_FORCE_LEFT_HANDED
glm_euler_yxz_quat_lh(angles, dest);
#else
glm_euler_yxz_quat_rh(angles, dest);
#endif
}
/*!
* @brief creates NEW quaternion using rotation angles and does
* rotations in y z x order (pitch yaw roll)
*
* @param[out] q quaternion
* @param[in] angle angles x y z (radians)
*/
CGLM_INLINE
void
glm_euler_yzx_quat(vec3 angles, versor dest) {
#ifdef CGLM_FORCE_LEFT_HANDED
glm_euler_yzx_quat_lh(angles, dest);
#else
glm_euler_yzx_quat_rh(angles, dest);
#endif
}
/*!
* @brief creates NEW quaternion using rotation angles and does
* rotations in z x y order (yaw roll pitch)
*
* @param[out] q quaternion
* @param[in] angle angles x y z (radians)
*/
CGLM_INLINE
void
glm_euler_zxy_quat(vec3 angles, versor dest) {
#ifdef CGLM_FORCE_LEFT_HANDED
glm_euler_zxy_quat_lh(angles, dest);
#else
glm_euler_zxy_quat_rh(angles, dest);
#endif
}
/*!
* @brief creates NEW quaternion using rotation angles and does
* rotations in z y x order (yaw pitch roll)
*
* @param[out] q quaternion
* @param[in] angle angles x y z (radians)
*/
CGLM_INLINE
void
glm_euler_zyx_quat(vec3 angles, versor dest) {
#ifdef CGLM_FORCE_LEFT_HANDED
glm_euler_zyx_quat_lh(angles, dest);
#else
glm_euler_zyx_quat_rh(angles, dest);
#endif
}
#endif /* cglm_euler_h */

165
include/cglm/handed/euler_to_quat_rh.h Normal file
View File

@@ -0,0 +1,165 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
/*
Functions:
CGLM_INLINE void glm_euler_xyz_quat_rh(vec3 angles, versor dest);
CGLM_INLINE void glm_euler_xzy_quat_rh(vec3 angles, versor dest);
CGLM_INLINE void glm_euler_yxz_quat_rh(vec3 angles, versor dest);
CGLM_INLINE void glm_euler_yzx_quat_rh(vec3 angles, versor dest);
CGLM_INLINE void glm_euler_zxy_quat_rh(vec3 angles, versor dest);
CGLM_INLINE void glm_euler_zyx_quat_rh(vec3 angles, versor dest);
*/
#ifndef cglm_euler_to_quat_rh_h
#define cglm_euler_to_quat_rh_h
#include "../common.h"
/*!
* @brief creates NEW quaternion using rotation angles and does
* rotations in x y z order in right hand (roll pitch yaw)
*
* @param[out] q quaternion
* @param[in] angle angles x y z (radians)
*/
CGLM_INLINE
void
glm_euler_xyz_quat_rh(vec3 angles, versor dest) {
float xc, yc, zc,
xs, ys, zs;
xs = sinf(angles[0] * 0.5f); xc = cosf(angles[0] * 0.5f);
ys = sinf(angles[1] * 0.5f); yc = cosf(angles[1] * 0.5f);
zs = sinf(angles[2] * 0.5f); zc = cosf(angles[2] * 0.5f);
dest[0] = xc * ys * zs + xs * yc * zc;
dest[1] = xc * ys * zc - xs * yc * zs;
dest[2] = xc * yc * zs + xs * ys * zc;
dest[3] = xc * yc * zc - xs * ys * zs;
}
/*!
* @brief creates NEW quaternion using rotation angles and does
* rotations in x z y order in right hand (roll yaw pitch)
*
* @param[out] q quaternion
* @param[in] angle angles x y z (radians)
*/
CGLM_INLINE
void
glm_euler_xzy_quat_rh(vec3 angles, versor dest) {
float xc, yc, zc,
xs, ys, zs;
xs = sinf(angles[0] * 0.5f); xc = cosf(angles[0] * 0.5f);
ys = sinf(angles[1] * 0.5f); yc = cosf(angles[1] * 0.5f);
zs = sinf(angles[2] * 0.5f); zc = cosf(angles[2] * 0.5f);
dest[0] = -xc * zs * ys + xs * zc * yc;
dest[1] = xc * zc * ys - xs * zs * yc;
dest[2] = xc * zs * yc + xs * zc * ys;
dest[3] = xc * zc * yc + xs * zs * ys;
}
/*!
* @brief creates NEW quaternion using rotation angles and does
* rotations in y x z order in right hand (pitch roll yaw)
*
* @param[out] q quaternion
* @param[in] angle angles x y z (radians)
*/
CGLM_INLINE
void
glm_euler_yxz_quat_rh(vec3 angles, versor dest) {
float xc, yc, zc,
xs, ys, zs;
xs = sinf(angles[0] * 0.5f); xc = cosf(angles[0] * 0.5f);
ys = sinf(angles[1] * 0.5f); yc = cosf(angles[1] * 0.5f);
zs = sinf(angles[2] * 0.5f); zc = cosf(angles[2] * 0.5f);
dest[0] = yc * xs * zc + ys * xc * zs;
dest[1] = -yc * xs * zs + ys * xc * zc;
dest[2] = yc * xc * zs - ys * xs * zc;
dest[3] = yc * xc * zc + ys * xs * zs;
}
/*!
* @brief creates NEW quaternion using rotation angles and does
* rotations in y z x order in right hand (pitch yaw roll)
*
* @param[out] q quaternion
* @param[in] angle angles x y z (radians)
*/
CGLM_INLINE
void
glm_euler_yzx_quat_rh(vec3 angles, versor dest) {
float xc, yc, zc,
xs, ys, zs;
xs = sinf(angles[0] * 0.5f); xc = cosf(angles[0] * 0.5f);
ys = sinf(angles[1] * 0.5f); yc = cosf(angles[1] * 0.5f);
zs = sinf(angles[2] * 0.5f); zc = cosf(angles[2] * 0.5f);
dest[0] = yc * zc * xs + ys * zs * xc;
dest[1] = yc * zs * xs + ys * zc * xc;
dest[2] = yc * zs * xc - ys * zc * xs;
dest[3] = yc * zc * xc - ys * zs * xs;
}
/*!
* @brief creates NEW quaternion using rotation angles and does
* rotations in z x y order in right hand (yaw roll pitch)
*
* @param[out] q quaternion
* @param[in] angle angles x y z (radians)
*/
CGLM_INLINE
void
glm_euler_zxy_quat_rh(vec3 angles, versor dest) {
float xc, yc, zc,
xs, ys, zs;
xs = sinf(angles[0] * 0.5f); xc = cosf(angles[0] * 0.5f);
ys = sinf(angles[1] * 0.5f); yc = cosf(angles[1] * 0.5f);
zs = sinf(angles[2] * 0.5f); zc = cosf(angles[2] * 0.5f);
dest[0] = zc * xs * yc - zs * xc * ys;
dest[1] = zc * xc * ys + zs * xs * yc;
dest[2] = zc * xs * ys + zs * xc * yc;
dest[3] = zc * xc * yc - zs * xs * ys;
}
/*!
* @brief creates NEW quaternion using rotation angles and does
* rotations in z y x order in right hand (yaw pitch roll)
*
* @param[out] q quaternion
* @param[in] angle angles x y z (radians)
*/
CGLM_INLINE
void
glm_euler_zyx_quat_rh(vec3 angles, versor dest) {
float xc, yc, zc,
xs, ys, zs;
xs = sinf(angles[0] * 0.5f); xc = cosf(angles[0] * 0.5f);
ys = sinf(angles[1] * 0.5f); yc = cosf(angles[1] * 0.5f);
zs = sinf(angles[2] * 0.5f); zc = cosf(angles[2] * 0.5f);
dest[0] = zc * yc * xs - zs * ys * xc;
dest[1] = zc * ys * xc + zs * yc * xs;
dest[2] = -zc * ys * xs + zs * yc * xc;
dest[3] = zc * yc * xc + zs * ys * xs;
}
#endif /*cglm_euler_to_quat_rh_h*/

97
include/cglm/struct/euler.h
View File

@@ -26,6 +26,12 @@
CGLM_INLINE mat4s glms_euler_zxy(vec3s angles)
CGLM_INLINE mat4s glms_euler_zyx(vec3s angles)
CGLM_INLINE mat4s glms_euler_by_order(vec3s angles, glm_euler_seq ord)
CGLM_INLINE versors glms_euler_xyz_quat(vec3s angles)
CGLM_INLINE versors glms_euler_xzy_quat(vec3s angles)
CGLM_INLINE versors glms_euler_yxz_quat(vec3s angles)
CGLM_INLINE versors glms_euler_yzx_quat(vec3s angles)
CGLM_INLINE versors glms_euler_zxy_quat(vec3s angles)
CGLM_INLINE versors glms_euler_zyx_quat(vec3s angles)
*/
#ifndef cglms_euler_h
@@ -149,4 +155,95 @@ glms_euler_by_order(vec3s angles, glm_euler_seq ord) {
return dest;
}
/*!
* @brief creates NEW quaternion using rotation angles and does
* rotations in x y z order (roll pitch yaw)
*
* @param[out] q quaternion
* @param[in] angle angles x y z (radians)
*/
CGLM_INLINE
versors
glms_euler_xyz_quat(vec3s angles) {
versors dest;
glm_euler_xyz_quat(angles.raw, dest.raw);
return dest;
}
/*!
* @brief creates NEW quaternion using rotation angles and does
* rotations in x z y order (roll yaw pitch)
*
* @param[out] q quaternion
* @param[in] angle angles x y z (radians)
*/
CGLM_INLINE
versors
glms_euler_xzy_quat(vec3s angles) {
versors dest;
glm_euler_xzy_quat(angles.raw, dest.raw);
return dest;
}
/*!
* @brief creates NEW quaternion using rotation angles and does
* rotations in y x z order (pitch roll yaw)
*
* @param[out] q quaternion
* @param[in] angle angles x y z (radians)
*/
CGLM_INLINE
versors
glms_euler_yxz_quat(vec3s angles) {
versors dest;
glm_euler_yxz_quat(angles.raw, dest.raw);
return dest;
}
/*!
* @brief creates NEW quaternion using rotation angles and does
* rotations in y z x order (pitch yaw roll)
*
* @param[out] q quaternion
* @param[in] angle angles x y z (radians)
*/
CGLM_INLINE
versors
glms_euler_yzx_quat(vec3s angles) {
versors dest;
glm_euler_yzx_quat(angles.raw, dest.raw);
return dest;
}
/*!
* @brief creates NEW quaternion using rotation angles and does
* rotations in z x y order (yaw roll pitch)
*
* @param[out] q quaternion
* @param[in] angle angles x y z (radians)
*/
CGLM_INLINE
versors
glms_euler_zxy_quat(vec3s angles) {
versors dest;
glm_euler_zxy_quat(angles.raw, dest.raw);
return dest;
}
/*!
* @brief creates NEW quaternion using rotation angles and does
* rotations in z y x order (yaw pitch roll)
*
* @param[out] q quaternion
* @param[in] angle angles x y z (radians)
*/
CGLM_INLINE
versors
glms_euler_zyx_quat(vec3s angles) {
versors dest;
glm_euler_zyx_quat(angles.raw, dest.raw);
return dest;
}
#endif /* cglms_euler_h */