External/cglm
1
0
Fork 0
mirror of https://github.com/recp/cglm.git synced 2025-12-26 02:25:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into optimize-inv

Browse Source
This commit is contained in:
Recep Aslantas
2024-04-04 00:31:08 +03:00
parent 0ff0e8948f da4224ba32
commit a94f839d6d
66 changed files with 910 additions and 506 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
include/cglm/call/mat2x3.h
View File

@@ -27,11 +27,11 @@ glmc_mat2x3_make(const float * __restrict src, mat2x3 dest);
CGLM_EXPORT
void
glmc_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat2 dest);
glmc_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat3 dest);
CGLM_EXPORT
void
glmc_mat2x3_mulv(mat2x3 m, vec3 v, vec2 dest);
glmc_mat2x3_mulv(mat2x3 m, vec2 v, vec3 dest);
CGLM_EXPORT
void

4
include/cglm/call/mat2x4.h
View File

@@ -27,11 +27,11 @@ glmc_mat2x4_make(const float * __restrict src, mat2x4 dest);
CGLM_EXPORT
void
glmc_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat2 dest);
glmc_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat4 dest);
CGLM_EXPORT
void
glmc_mat2x4_mulv(mat2x4 m, vec4 v, vec2 dest);
glmc_mat2x4_mulv(mat2x4 m, vec2 v, vec4 dest);
CGLM_EXPORT
void

4
include/cglm/call/mat3x2.h
View File

@@ -27,11 +27,11 @@ glmc_mat3x2_make(const float * __restrict src, mat3x2 dest);
CGLM_EXPORT
void
glmc_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat3 dest);
glmc_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat2 dest);
CGLM_EXPORT
void
glmc_mat3x2_mulv(mat3x2 m, vec2 v, vec3 dest);
glmc_mat3x2_mulv(mat3x2 m, vec3 v, vec2 dest);
CGLM_EXPORT
void

4
include/cglm/call/mat3x4.h
View File

@@ -27,11 +27,11 @@ glmc_mat3x4_make(const float * __restrict src, mat3x4 dest);
CGLM_EXPORT
void
glmc_mat3x4_mul(mat3x4 m1, mat4x3 m2, mat3 dest);
glmc_mat3x4_mul(mat3x4 m1, mat4x3 m2, mat4 dest);
CGLM_EXPORT
void
glmc_mat3x4_mulv(mat3x4 m, vec4 v, vec3 dest);
glmc_mat3x4_mulv(mat3x4 m, vec3 v, vec4 dest);
CGLM_EXPORT
void

4
include/cglm/call/mat4x2.h
View File

@@ -27,11 +27,11 @@ glmc_mat4x2_make(const float * __restrict src, mat4x2 dest);
CGLM_EXPORT
void
glmc_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat4 dest);
glmc_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat2 dest);
CGLM_EXPORT
void
glmc_mat4x2_mulv(mat4x2 m, vec2 v, vec4 dest);
glmc_mat4x2_mulv(mat4x2 m, vec4 v, vec2 dest);
CGLM_EXPORT
void

4
include/cglm/call/mat4x3.h
View File

@@ -27,11 +27,11 @@ glmc_mat4x3_make(const float * __restrict src, mat4x3 dest);
CGLM_EXPORT
void
glmc_mat4x3_mul(mat4x3 m1, mat3x4 m2, mat4 dest);
glmc_mat4x3_mul(mat4x3 m1, mat3x4 m2, mat3 dest);
CGLM_EXPORT
void
glmc_mat4x3_mulv(mat4x3 m, vec3 v, vec4 dest);
glmc_mat4x3_mulv(mat4x3 m, vec4 v, vec3 dest);
CGLM_EXPORT
void

4
include/cglm/call/vec2.h
View File

@@ -199,11 +199,11 @@ glmc_vec2_make(const float * __restrict src, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_reflect(vec2 I, vec2 N, vec2 dest);
glmc_vec2_reflect(vec2 v, vec2 n, vec2 dest);
CGLM_EXPORT
bool
glmc_vec2_refract(vec2 I, vec2 N, float eta, vec2 dest);
glmc_vec2_refract(vec2 v, vec2 n, float eta, vec2 dest);
#ifdef __cplusplus
}

6
include/cglm/call/vec3.h
View File

@@ -336,15 +336,15 @@ glmc_vec3_make(const float * __restrict src, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_faceforward(vec3 N, vec3 I, vec3 Nref, vec3 dest);
glmc_vec3_faceforward(vec3 n, vec3 v, vec3 nref, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_reflect(vec3 I, vec3 N, vec3 dest);
glmc_vec3_reflect(vec3 v, vec3 n, vec3 dest);
CGLM_EXPORT
bool
glmc_vec3_refract(vec3 I, vec3 N, float eta, vec3 dest);
glmc_vec3_refract(vec3 v, vec3 n, float eta, vec3 dest);
#ifdef __cplusplus
}

4
include/cglm/call/vec4.h
View File

@@ -313,11 +313,11 @@ glmc_vec4_make(const float * __restrict src, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_reflect(vec4 I, vec4 N, vec4 dest);
glmc_vec4_reflect(vec4 v, vec4 n, vec4 dest);
CGLM_EXPORT
bool
glmc_vec4_refract(vec4 I, vec4 N, float eta, vec4 dest);
glmc_vec4_refract(vec4 v, vec4 n, float eta, vec4 dest);
#ifdef __cplusplus
}

4
include/cglm/common.h
View File

@@ -45,6 +45,10 @@
# define CGLM_LIKELY(expr) (expr)
#endif
#if defined(_M_FP_FAST) || defined(__FAST_MATH__)
# define CGLM_FAST_MATH
#endif
#define GLM_SHUFFLE4(z, y, x, w) (((z) << 6) | ((y) << 4) | ((x) << 2) | (w))
#define GLM_SHUFFLE3(z, y, x) (((z) << 4) | ((y) << 2) | (x))

33
include/cglm/mat2x3.h
View File

@@ -14,8 +14,8 @@
CGLM_INLINE void glm_mat2x3_copy(mat2x3 mat, mat2x3 dest);
CGLM_INLINE void glm_mat2x3_zero(mat2x3 mat);
CGLM_INLINE void glm_mat2x3_make(const float * __restrict src, mat2x3 dest);
CGLM_INLINE void glm_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat2 dest);
CGLM_INLINE void glm_mat2x3_mulv(mat2x3 m, vec3 v, vec2 dest);
CGLM_INLINE void glm_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat3 dest);
CGLM_INLINE void glm_mat2x3_mulv(mat2x3 m, vec2 v, vec3 dest);
CGLM_INLINE void glm_mat2x3_transpose(mat2x3 m, mat3x2 dest);
CGLM_INLINE void glm_mat2x3_scale(mat2x3 m, float s);
*/
@@ -82,7 +82,7 @@ glm_mat2x3_make(const float * __restrict src, mat2x3 dest) {
* @brief multiply m1 and m2 to dest
*
* @code
* glm_mat2x3_mul(mat2x3, mat3x2, mat2);
* glm_mat2x3_mul(mat2x3, mat3x2, mat3);
* @endcode
*
* @param[in] m1 left matrix (mat2x3)
@@ -91,19 +91,25 @@ glm_mat2x3_make(const float * __restrict src, mat2x3 dest) {
*/
CGLM_INLINE
void
glm_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat2 dest) {
float a00 = m1[0][0], a01 = m1[0][1], a02 = m1[0][2],
glm_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat3 dest) {
float a00 = m1[0][0], a01 = m1[0][1], a02 = m1[0][2],
a10 = m1[1][0], a11 = m1[1][1], a12 = m1[1][2],
b00 = m2[0][0], b01 = m2[0][1],
b10 = m2[1][0], b11 = m2[1][1],
b20 = m2[2][0], b21 = m2[2][1];
dest[0][0] = a00 * b00 + a01 * b10 + a02 * b20;
dest[0][1] = a00 * b01 + a01 * b11 + a02 * b21;
dest[0][0] = a00 * b00 + a10 * b01;
dest[0][1] = a01 * b00 + a11 * b01;
dest[0][2] = a02 * b00 + a12 * b01;
dest[1][0] = a10 * b00 + a11 * b10 + a12 * b20;
dest[1][1] = a10 * b01 + a11 * b11 + a12 * b21;
dest[1][0] = a00 * b10 + a10 * b11;
dest[1][1] = a01 * b10 + a11 * b11;
dest[1][2] = a02 * b10 + a12 * b11;
dest[2][0] = a00 * b20 + a10 * b21;
dest[2][1] = a01 * b20 + a11 * b21;
dest[2][2] = a02 * b20 + a12 * b21;
}
/*!
@@ -115,11 +121,12 @@ glm_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat2 dest) {
*/
CGLM_INLINE
void
glm_mat2x3_mulv(mat2x3 m, vec3 v, vec2 dest) {
float v0 = v[0], v1 = v[1], v2 = v[2];
glm_mat2x3_mulv(mat2x3 m, vec2 v, vec3 dest) {
float v0 = v[0], v1 = v[1];
dest[0] = m[0][0] * v0 + m[0][1] * v1 + m[0][2] * v2;
dest[1] = m[1][0] * v0 + m[1][1] * v1 + m[1][2] * v2;
dest[0] = m[0][0] * v0 + m[1][0] * v1;
dest[1] = m[0][1] * v0 + m[1][1] * v1;
dest[2] = m[0][2] * v0 + m[1][2] * v1;
}
/*!

44
include/cglm/mat2x4.h
View File

@@ -14,8 +14,8 @@
CGLM_INLINE void glm_mat2x4_copy(mat2x4 mat, mat2x4 dest);
CGLM_INLINE void glm_mat2x4_zero(mat2x4 mat);
CGLM_INLINE void glm_mat2x4_make(const float * __restrict src, mat2x4 dest);
CGLM_INLINE void glm_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat2 dest);
CGLM_INLINE void glm_mat2x4_mulv(mat2x4 m, vec4 v, vec2 dest);
CGLM_INLINE void glm_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat4 dest);
CGLM_INLINE void glm_mat2x4_mulv(mat2x4 m, vec2 v, vec4 dest);
CGLM_INLINE void glm_mat2x4_transpose(mat2x4 m, mat4x2 dest);
CGLM_INLINE void glm_mat2x4_scale(mat2x4 m, float s);
*/
@@ -80,16 +80,16 @@ glm_mat2x4_make(const float * __restrict src, mat2x4 dest) {
* @brief multiply m1 and m2 to dest
*
* @code
* glm_mat2x4_mul(mat2x4, mat4x2, mat2);
* glm_mat2x4_mul(mat2x4, mat4x2, mat4);
* @endcode
*
* @param[in] m1 left matrix (mat2x4)
* @param[in] m2 right matrix (mat4x2)
* @param[out] dest destination matrix (mat2)
* @param[out] dest destination matrix (mat4)
*/
CGLM_INLINE
void
glm_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat2 dest) {
glm_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat4 dest) {
float a00 = m1[0][0], a01 = m1[0][1], a02 = m1[0][2], a03 = m1[0][3],
a10 = m1[1][0], a11 = m1[1][1], a12 = m1[1][2], a13 = m1[1][3],
@@ -98,15 +98,29 @@ glm_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat2 dest) {
b20 = m2[2][0], b21 = m2[2][1],
b30 = m2[3][0], b31 = m2[3][1];
dest[0][0] = a00 * b00 + a01 * b10 + a02 * b20 + a03 * b30;
dest[0][1] = a00 * b01 + a01 * b11 + a02 * b21 + a03 * b31;
dest[0][0] = a00 * b00 + a10 * b01;
dest[0][1] = a01 * b00 + a11 * b01;
dest[0][2] = a02 * b00 + a12 * b01;
dest[0][3] = a03 * b00 + a13 * b01;
dest[1][0] = a10 * b00 + a11 * b10 + a12 * b20 + a13 * b30;
dest[1][1] = a10 * b01 + a11 * b11 + a12 * b21 + a13 * b31;
dest[1][0] = a00 * b10 + a10 * b11;
dest[1][1] = a01 * b10 + a11 * b11;
dest[1][2] = a02 * b10 + a12 * b11;
dest[1][3] = a03 * b10 + a13 * b11;
dest[2][0] = a00 * b20 + a10 * b21;
dest[2][1] = a01 * b20 + a11 * b21;
dest[2][2] = a02 * b20 + a12 * b21;
dest[2][3] = a03 * b20 + a13 * b21;
dest[3][0] = a00 * b30 + a10 * b31;
dest[3][1] = a01 * b30 + a11 * b31;
dest[3][2] = a02 * b30 + a12 * b31;
dest[3][3] = a03 * b30 + a13 * b31;
}
/*!
* @brief multiply matrix with column vector and store in dest vector
* @brief multiply matrix with column vector and store in dest column vector
*
* @param[in] m matrix (left)
* @param[in] v vector (right, column vector)
@@ -114,11 +128,13 @@ glm_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat2 dest) {
*/
CGLM_INLINE
void
glm_mat2x4_mulv(mat2x4 m, vec4 v, vec2 dest) {
float v0 = v[0], v1 = v[1], v2 = v[2], v3 = v[3];
glm_mat2x4_mulv(mat2x4 m, vec2 v, vec4 dest) {
float v0 = v[0], v1 = v[1];
dest[0] = m[0][0] * v0 + m[0][1] * v1 + m[0][2] * v2 + m[0][3] * v3;
dest[1] = m[1][0] * v0 + m[1][1] * v1 + m[1][2] * v2 + m[1][3] * v3;
dest[0] = m[0][0] * v0 + m[1][0] * v1;
dest[1] = m[0][1] * v0 + m[1][1] * v1;
dest[2] = m[0][2] * v0 + m[1][2] * v1;
dest[3] = m[0][3] * v0 + m[1][3] * v1;
}
/*!

35
include/cglm/mat3x2.h
View File

@@ -14,8 +14,8 @@
CGLM_INLINE void glm_mat3x2_copy(mat3x2 mat, mat3x2 dest);
CGLM_INLINE void glm_mat3x2_zero(mat3x2 mat);
CGLM_INLINE void glm_mat3x2_make(const float * __restrict src, mat3x2 dest);
CGLM_INLINE void glm_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat3 dest);
CGLM_INLINE void glm_mat3x2_mulv(mat3x2 m, vec2 v, vec3 dest);
CGLM_INLINE void glm_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat2 dest);
CGLM_INLINE void glm_mat3x2_mulv(mat3x2 m, vec3 v, vec2 dest);
CGLM_INLINE void glm_mat3x2_transpose(mat3x2 m, mat2x3 dest);
CGLM_INLINE void glm_mat3x2_scale(mat3x2 m, float s);
*/
@@ -84,16 +84,16 @@ glm_mat3x2_make(const float * __restrict src, mat3x2 dest) {
* @brief multiply m1 and m2 to dest
*
* @code
* glm_mat3x2_mul(mat3x2, mat2x3, mat3);
* glm_mat3x2_mul(mat3x2, mat2x3, mat2);
* @endcode
*
* @param[in] m1 left matrix (mat3x2)
* @param[in] m2 right matrix (mat2x3)
* @param[out] dest destination matrix (mat3)
* @param[out] dest destination matrix (mat2)
*/
CGLM_INLINE
void
glm_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat3 dest) {
glm_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat2 dest) {
float a00 = m1[0][0], a01 = m1[0][1],
a10 = m1[1][0], a11 = m1[1][1],
a20 = m1[2][0], a21 = m1[2][1],
@@ -101,21 +101,15 @@ glm_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat3 dest) {
b00 = m2[0][0], b01 = m2[0][1], b02 = m2[0][2],
b10 = m2[1][0], b11 = m2[1][1], b12 = m2[1][2];
dest[0][0] = a00 * b00 + a01 * b10;
dest[0][1] = a00 * b01 + a01 * b11;
dest[0][2] = a00 * b02 + a01 * b12;
dest[0][0] = a00 * b00 + a10 * b01 + a20 * b02;
dest[0][1] = a01 * b00 + a11 * b01 + a21 * b02;
dest[1][0] = a10 * b00 + a11 * b10;
dest[1][1] = a10 * b01 + a11 * b11;
dest[1][2] = a10 * b02 + a11 * b12;
dest[2][0] = a20 * b00 + a21 * b10;
dest[2][1] = a20 * b01 + a21 * b11;
dest[2][2] = a20 * b02 + a21 * b12;
dest[1][0] = a00 * b10 + a10 * b11 + a20 * b12;
dest[1][1] = a01 * b10 + a11 * b11 + a21 * b12;
}
/*!
* @brief multiply matrix with column vector and store in dest vector
* @brief multiply matrix with column vector and store in dest column vector
*
* @param[in] m matrix (left)
* @param[in] v vector (right, column vector)
@@ -123,12 +117,11 @@ glm_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat3 dest) {
*/
CGLM_INLINE
void
glm_mat3x2_mulv(mat3x2 m, vec2 v, vec3 dest) {
float v0 = v[0], v1 = v[1];
glm_mat3x2_mulv(mat3x2 m, vec3 v, vec2 dest) {
float v0 = v[0], v1 = v[1], v2 = v[2];
dest[0] = m[0][0] * v0 + m[0][1] * v1;
dest[1] = m[1][0] * v0 + m[1][1] * v1;
dest[2] = m[2][0] * v0 + m[2][1] * v1;
dest[0] = m[0][0] * v0 + m[1][0] * v1 + m[2][0] * v2;
dest[1] = m[0][1] * v0 + m[1][1] * v1 + m[2][1] * v2;
}
/*!

56
include/cglm/mat3x4.h
View File

@@ -14,8 +14,8 @@
CGLM_INLINE void glm_mat3x4_copy(mat3x4 mat, mat3x4 dest);
CGLM_INLINE void glm_mat3x4_zero(mat3x4 mat);
CGLM_INLINE void glm_mat3x4_make(const float * __restrict src, mat3x4 dest);
CGLM_INLINE void glm_mat3x4_mul(mat3x4 m1, mat4x3 m2, mat3 dest);
CGLM_INLINE void glm_mat3x4_mulv(mat3x4 m, vec4 v, vec3 dest);
CGLM_INLINE void glm_mat3x4_mul(mat3x4 m1, mat4x3 m2, mat4 dest);
CGLM_INLINE void glm_mat3x4_mulv(mat3x4 m, vec3 v, vec4 dest);
CGLM_INLINE void glm_mat3x4_transpose(mat3x4 m, mat4x3 dest);
CGLM_INLINE void glm_mat3x4_scale(mat3x4 m, float s);
*/
@@ -87,16 +87,16 @@ glm_mat3x4_make(const float * __restrict src, mat3x4 dest) {
* @brief multiply m1 and m2 to dest
*
* @code
* glm_mat3x4_mul(mat3x4, mat4x3, mat3);
* glm_mat3x4_mul(mat3x4, mat4x3, mat4);
* @endcode
*
* @param[in] m1 left matrix (mat3x4)
* @param[in] m2 right matrix (mat4x3)
* @param[out] dest destination matrix (mat3)
* @param[out] dest destination matrix (mat4)
*/
CGLM_INLINE
void
glm_mat3x4_mul(mat3x4 m1, mat4x3 m2, mat3 dest) {
glm_mat3x4_mul(mat3x4 m1, mat4x3 m2, mat4 dest) {
float a00 = m1[0][0], a01 = m1[0][1], a02 = m1[0][2], a03 = m1[0][3],
a10 = m1[1][0], a11 = m1[1][1], a12 = m1[1][2], a13 = m1[1][3],
a20 = m1[2][0], a21 = m1[2][1], a22 = m1[2][2], a23 = m1[2][3],
@@ -106,21 +106,29 @@ glm_mat3x4_mul(mat3x4 m1, mat4x3 m2, mat3 dest) {
b20 = m2[2][0], b21 = m2[2][1], b22 = m2[2][2],
b30 = m2[3][0], b31 = m2[3][1], b32 = m2[3][2];
dest[0][0] = a00 * b00 + a01 * b10 + a02 * b20 + a03 * b30;
dest[0][1] = a00 * b01 + a01 * b11 + a02 * b21 + a03 * b31;
dest[0][2] = a00 * b02 + a01 * b12 + a02 * b22 + a03 * b32;
dest[0][0] = a00 * b00 + a10 * b01 + a20 * b02;
dest[0][1] = a01 * b00 + a11 * b01 + a21 * b02;
dest[0][2] = a02 * b00 + a12 * b01 + a22 * b02;
dest[0][3] = a03 * b00 + a13 * b01 + a23 * b02;
dest[1][0] = a10 * b00 + a11 * b10 + a12 * b20 + a13 * b30;
dest[1][1] = a10 * b01 + a11 * b11 + a12 * b21 + a13 * b31;
dest[1][2] = a10 * b02 + a11 * b12 + a12 * b22 + a13 * b32;
dest[1][0] = a00 * b10 + a10 * b11 + a20 * b12;
dest[1][1] = a01 * b10 + a11 * b11 + a21 * b12;
dest[1][2] = a02 * b10 + a12 * b11 + a22 * b12;
dest[1][3] = a03 * b10 + a13 * b11 + a23 * b12;
dest[2][0] = a20 * b00 + a21 * b10 + a22 * b20 + a23 * b30;
dest[2][1] = a20 * b01 + a21 * b11 + a22 * b21 + a23 * b31;
dest[2][2] = a20 * b02 + a21 * b12 + a22 * b22 + a23 * b32;
dest[2][0] = a00 * b20 + a10 * b21 + a20 * b22;
dest[2][1] = a01 * b20 + a11 * b21 + a21 * b22;
dest[2][2] = a02 * b20 + a12 * b21 + a22 * b22;
dest[2][3] = a03 * b20 + a13 * b21 + a23 * b22;
dest[3][0] = a00 * b30 + a10 * b31 + a20 * b32;
dest[3][1] = a01 * b30 + a11 * b31 + a21 * b32;
dest[3][2] = a02 * b30 + a12 * b31 + a22 * b32;
dest[3][3] = a03 * b30 + a13 * b31 + a23 * b32;
}
/*!
* @brief multiply matrix with column vector and store in dest vector
* @brief multiply matrix with column vector and store in dest column vector
*
* @param[in] m matrix (left)
* @param[in] v vector (right, column vector)
@@ -128,12 +136,13 @@ glm_mat3x4_mul(mat3x4 m1, mat4x3 m2, mat3 dest) {
*/
CGLM_INLINE
void
glm_mat3x4_mulv(mat3x4 m, vec4 v, vec3 dest) {
float v0 = v[0], v1 = v[1], v2 = v[2], v3 = v[3];
glm_mat3x4_mulv(mat3x4 m, vec3 v, vec4 dest) {
float v0 = v[0], v1 = v[1], v2 = v[2];
dest[0] = m[0][0] * v0 + m[0][1] * v1 + m[0][2] * v2 + m[0][3] * v3;
dest[1] = m[1][0] * v0 + m[1][1] * v1 + m[1][2] * v2 + m[1][3] * v3;
dest[2] = m[2][0] * v0 + m[2][1] * v1 + m[2][2] * v2 + m[2][3] * v3;
dest[0] = m[0][0] * v0 + m[1][0] * v1 + m[2][0] * v2;
dest[1] = m[0][1] * v0 + m[1][1] * v1 + m[2][1] * v2;
dest[2] = m[0][2] * v0 + m[1][2] * v1 + m[2][2] * v2;
dest[3] = m[0][3] * v0 + m[1][3] * v1 + m[2][3] * v2;
}
/*!
@@ -162,10 +171,9 @@ glm_mat3x4_transpose(mat3x4 m, mat4x3 dest) {
CGLM_INLINE
void
glm_mat3x4_scale(mat3x4 m, float s) {
m[0][0] *= s; m[1][0] *= s; m[2][0] *= s;
m[0][1] *= s; m[1][1] *= s; m[2][1] *= s;
m[0][2] *= s; m[1][2] *= s; m[2][2] *= s;
m[0][3] *= s; m[1][3] *= s; m[2][3] *= s;
m[0][0] *= s; m[0][1] *= s; m[0][2] *= s; m[0][3] *= s;
m[1][0] *= s; m[1][1] *= s; m[1][2] *= s; m[1][3] *= s;
m[2][0] *= s; m[2][1] *= s; m[2][2] *= s; m[2][3] *= s;
}
#endif

44
include/cglm/mat4x2.h
View File

@@ -14,8 +14,8 @@
CGLM_INLINE void glm_mat4x2_copy(mat4x2 mat, mat4x2 dest);
CGLM_INLINE void glm_mat4x2_zero(mat4x2 mat);
CGLM_INLINE void glm_mat4x2_make(const float * __restrict src, mat4x2 dest);
CGLM_INLINE void glm_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat4 dest);
CGLM_INLINE void glm_mat4x2_mulv(mat4x2 m, vec2 v, vec4 dest);
CGLM_INLINE void glm_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat2 dest);
CGLM_INLINE void glm_mat4x2_mulv(mat4x2 m, vec4 v, vec2 dest);
CGLM_INLINE void glm_mat4x2_transpose(mat4x2 m, mat2x4 dest);
CGLM_INLINE void glm_mat4x2_scale(mat4x2 m, float s);
*/
@@ -90,16 +90,16 @@ glm_mat4x2_make(const float * __restrict src, mat4x2 dest) {
* @brief multiply m1 and m2 to dest
*
* @code
* glm_mat4x2_mul(mat4x2, mat2x4, mat4);
* glm_mat4x2_mul(mat4x2, mat2x4, mat2);
* @endcode
*
* @param[in] m1 left matrix (mat4x2)
* @param[in] m2 right matrix (mat2x4)
* @param[out] dest destination matrix (mat4)
* @param[out] dest destination matrix (mat2)
*/
CGLM_INLINE
void
glm_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat4 dest) {
glm_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat2 dest) {
float a00 = m1[0][0], a01 = m1[0][1],
a10 = m1[1][0], a11 = m1[1][1],
a20 = m1[2][0], a21 = m1[2][1],
@@ -108,29 +108,15 @@ glm_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat4 dest) {
b00 = m2[0][0], b01 = m2[0][1], b02 = m2[0][2], b03 = m2[0][3],
b10 = m2[1][0], b11 = m2[1][1], b12 = m2[1][2], b13 = m2[1][3];
dest[0][0] = a00 * b00 + a01 * b10;
dest[0][1] = a00 * b01 + a01 * b11;
dest[0][2] = a00 * b02 + a01 * b12;
dest[0][3] = a00 * b03 + a01 * b13;
dest[0][0] = a00 * b00 + a10 * b01 + a20 * b02 + a30 * b03;
dest[0][1] = a01 * b00 + a11 * b01 + a21 * b02 + a31 * b03;
dest[1][0] = a10 * b00 + a11 * b10;
dest[1][1] = a10 * b01 + a11 * b11;
dest[1][2] = a10 * b02 + a11 * b12;
dest[1][3] = a10 * b03 + a11 * b13;
dest[2][0] = a20 * b00 + a21 * b10;
dest[2][1] = a20 * b01 + a21 * b11;
dest[2][2] = a20 * b02 + a21 * b12;
dest[2][3] = a20 * b03 + a21 * b13;
dest[3][0] = a30 * b00 + a31 * b10;
dest[3][1] = a30 * b01 + a31 * b11;
dest[3][2] = a30 * b02 + a31 * b12;
dest[3][3] = a30 * b03 + a31 * b13;
dest[1][0] = a00 * b10 + a10 * b11 + a20 * b12 + a30 * b13;
dest[1][1] = a01 * b10 + a11 * b11 + a21 * b12 + a31 * b13;
}
/*!
* @brief multiply matrix with column vector and store in dest vector
* @brief multiply matrix with column vector and store in dest column vector
*
* @param[in] m matrix (left)
* @param[in] v vector (right, column vector)
@@ -138,13 +124,11 @@ glm_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat4 dest) {
*/
CGLM_INLINE
void
glm_mat4x2_mulv(mat4x2 m, vec2 v, vec4 dest) {
float v0 = v[0], v1 = v[1];
glm_mat4x2_mulv(mat4x2 m, vec4 v, vec2 dest) {
float v0 = v[0], v1 = v[1], v2 = v[2], v3 = v[3];
dest[0] = m[0][0] * v0 + m[0][1] * v1;
dest[1] = m[1][0] * v0 + m[1][1] * v1;
dest[2] = m[2][0] * v0 + m[2][1] * v1;
dest[3] = m[3][0] * v0 + m[3][1] * v1;
dest[0] = m[0][0] * v0 + m[1][0] * v1 + m[2][0] * v2 + m[3][0] * v3;
dest[1] = m[0][1] * v0 + m[1][1] * v1 + m[2][1] * v2 + m[3][1] * v3;
}
/*!

49
include/cglm/mat4x3.h
View File

@@ -14,8 +14,8 @@
CGLM_INLINE void glm_mat4x3_copy(mat4x3 mat, mat4x3 dest);
CGLM_INLINE void glm_mat4x3_zero(mat4x3 mat);
CGLM_INLINE void glm_mat4x3_make(const float * __restrict src, mat4x3 dest);
CGLM_INLINE void glm_mat4x3_mul(mat4x3 m1, mat3x4 m2, mat4 dest);
CGLM_INLINE void glm_mat4x3_mulv(mat4x3 m, vec3 v, vec4 dest);
CGLM_INLINE void glm_mat4x3_mul(mat4x3 m1, mat3x4 m2, mat3 dest);
CGLM_INLINE void glm_mat4x3_mulv(mat4x3 m, vec4 v, vec3 dest);
CGLM_INLINE void glm_mat4x3_transpose(mat4x3 m, mat3x4 dest);
CGLM_INLINE void glm_mat4x3_scale(mat4x3 m, float s);
*/
@@ -99,16 +99,16 @@ glm_mat4x3_make(const float * __restrict src, mat4x3 dest) {
* @brief multiply m1 and m2 to dest
*
* @code
* glm_mat4x3_mul(mat4x3, mat3x4, mat4);
* glm_mat4x3_mul(mat4x3, mat3x4, mat3);
* @endcode
*
* @param[in] m1 left matrix (mat4x3)
* @param[in] m2 right matrix (mat3x4)
* @param[out] dest destination matrix (mat4)
* @param[out] dest destination matrix (mat3)
*/
CGLM_INLINE
void
glm_mat4x3_mul(mat4x3 m1, mat3x4 m2, mat4 dest) {
glm_mat4x3_mul(mat4x3 m1, mat3x4 m2, mat3 dest) {
float a00 = m1[0][0], a01 = m1[0][1], a02 = m1[0][2],
a10 = m1[1][0], a11 = m1[1][1], a12 = m1[1][2],
a20 = m1[2][0], a21 = m1[2][1], a22 = m1[2][2],
@@ -118,29 +118,21 @@ glm_mat4x3_mul(mat4x3 m1, mat3x4 m2, mat4 dest) {
b10 = m2[1][0], b11 = m2[1][1], b12 = m2[1][2], b13 = m2[1][3],
b20 = m2[2][0], b21 = m2[2][1], b22 = m2[2][2], b23 = m2[2][3];
dest[0][0] = a00 * b00 + a01 * b10 + a02 * b20;
dest[0][1] = a00 * b01 + a01 * b11 + a02 * b21;
dest[0][2] = a00 * b02 + a01 * b12 + a02 * b22;
dest[0][3] = a00 * b03 + a01 * b13 + a02 * b23;
dest[0][0] = a00 * b00 + a10 * b01 + a20 * b02 + a30 * b03;
dest[0][1] = a01 * b00 + a11 * b01 + a21 * b02 + a31 * b03;
dest[0][2] = a02 * b00 + a12 * b01 + a22 * b02 + a32 * b03;
dest[1][0] = a10 * b00 + a11 * b10 + a12 * b20;
dest[1][1] = a10 * b01 + a11 * b11 + a12 * b21;
dest[1][2] = a10 * b02 + a11 * b12 + a12 * b22;
dest[1][3] = a10 * b03 + a11 * b13 + a12 * b23;
dest[1][0] = a00 * b10 + a10 * b11 + a20 * b12 + a30 * b13;
dest[1][1] = a01 * b10 + a11 * b11 + a21 * b12 + a31 * b13;
dest[1][2] = a02 * b10 + a12 * b11 + a22 * b12 + a32 * b13;
dest[2][0] = a20 * b00 + a21 * b10 + a22 * b20;
dest[2][1] = a20 * b01 + a21 * b11 + a22 * b21;
dest[2][2] = a20 * b02 + a21 * b12 + a22 * b22;
dest[2][3] = a20 * b03 + a21 * b13 + a22 * b23;
dest[3][0] = a30 * b00 + a31 * b10 + a32 * b20;
dest[3][1] = a30 * b01 + a31 * b11 + a32 * b21;
dest[3][2] = a30 * b02 + a31 * b12 + a32 * b22;
dest[3][3] = a30 * b03 + a31 * b13 + a32 * b23;
dest[2][0] = a00 * b20 + a10 * b21 + a20 * b22 + a30 * b23;
dest[2][1] = a01 * b20 + a11 * b21 + a21 * b22 + a31 * b23;
dest[2][2] = a02 * b20 + a12 * b21 + a22 * b22 + a32 * b23;
}
/*!
* @brief multiply matrix with column vector and store in dest vector
* @brief multiply matrix with column vector and store in dest column vector
*
* @param[in] m matrix (left)
* @param[in] v vector (right, column vector)
@@ -148,13 +140,12 @@ glm_mat4x3_mul(mat4x3 m1, mat3x4 m2, mat4 dest) {
*/
CGLM_INLINE
void
glm_mat4x3_mulv(mat4x3 m, vec3 v, vec4 dest) {
float v0 = v[0], v1 = v[1], v2 = v[2];
glm_mat4x3_mulv(mat4x3 m, vec4 v, vec3 dest) {
float v0 = v[0], v1 = v[1], v2 = v[2], v3 = v[3];
dest[0] = m[0][0] * v0 + m[0][1] * v1 + m[0][2] * v2;
dest[1] = m[1][0] * v0 + m[1][1] * v1 + m[1][2] * v2;
dest[2] = m[2][0] * v0 + m[2][1] * v1 + m[2][2] * v2;
dest[3] = m[3][0] * v0 + m[3][1] * v1 + m[3][2] * v2;
dest[0] = m[0][0] * v0 + m[1][0] * v1 + m[2][0] * v2 + m[3][0] * v3;
dest[1] = m[0][1] * v0 + m[1][1] * v1 + m[2][1] * v2 + m[3][1] * v3;
dest[2] = m[0][2] * v0 + m[1][2] * v1 + m[2][2] * v2 + m[3][2] * v3;
}
/*!

14
include/cglm/simd/intrin.h
View File

@@ -10,6 +10,9 @@
#if defined( _MSC_VER )
# if (defined(_M_AMD64) || defined(_M_X64)) || _M_IX86_FP == 2
# ifndef __SSE__
# define __SSE__
# endif
# ifndef __SSE2__
# define __SSE2__
# endif
@@ -24,15 +27,22 @@
# endif
#endif
#if defined( __SSE__ ) || defined( __SSE2__ )
#if defined(__SSE__)
# include <xmmintrin.h>
# include <emmintrin.h>
# define CGLM_SSE_FP 1
# ifndef CGLM_SIMD_x86
# define CGLM_SIMD_x86
# endif
#endif
#if defined(__SSE2__)
# include <emmintrin.h>
# define CGLM_SSE2_FP 1
# ifndef CGLM_SIMD_x86
# define CGLM_SIMD_x86
# endif
#endif
#if defined(__SSE3__)
# include <pmmintrin.h>
# ifndef CGLM_SIMD_x86

39
include/cglm/simd/x86.h
View File

@@ -21,7 +21,7 @@
#define glmm_set1(x) _mm_set1_ps(x)
#define glmm_128 __m128
#ifdef CGLM_USE_INT_DOMAIN
#if defined(CGLM_USE_INT_DOMAIN) && defined(__SSE2__)
# define glmm_shuff1(xmm, z, y, x, w) \
_mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(xmm), \
_MM_SHUFFLE(z, y, x, w)))
@@ -55,17 +55,40 @@
#endif
/* Note that `0x80000000` corresponds to `INT_MIN` for a 32-bit int. */
#define GLMM_NEGZEROf ((int)0x80000000) /* 0x80000000 ---> -0.0f */
#define GLMM__SIGNMASKf(X, Y, Z, W) \
#if defined(__SSE2__)
# define GLMM_NEGZEROf ((int)0x80000000) /* 0x80000000 ---> -0.0f */
# define GLMM_POSZEROf ((int)0x00000000) /* 0x00000000 ---> +0.0f */
#else
# ifdef CGLM_FAST_MATH
union { int i; float f; } static GLMM_NEGZEROf_TU = { .i = (int)0x80000000 };
# define GLMM_NEGZEROf GLMM_NEGZEROf_TU.f
# define GLMM_POSZEROf 0.0f
# else
# define GLMM_NEGZEROf -0.0f
# define GLMM_POSZEROf 0.0f
# endif
#endif
#if defined(__SSE2__)
# define GLMM__SIGNMASKf(X, Y, Z, W) \
_mm_castsi128_ps(_mm_set_epi32(X, Y, Z, W))
/* _mm_set_ps(X, Y, Z, W); */
#else
# define GLMM__SIGNMASKf(X, Y, Z, W) _mm_set_ps(X, Y, Z, W)
#endif
#define glmm_float32x4_SIGNMASK_PNPN GLMM__SIGNMASKf(0, GLMM_NEGZEROf, 0, GLMM_NEGZEROf)
#define glmm_float32x4_SIGNMASK_NPNP GLMM__SIGNMASKf(GLMM_NEGZEROf, 0, GLMM_NEGZEROf, 0)
#define glmm_float32x4_SIGNMASK_NPPN GLMM__SIGNMASKf(GLMM_NEGZEROf, 0, 0, GLMM_NEGZEROf)
#define glmm_float32x4_SIGNMASK_PNPN GLMM__SIGNMASKf(GLMM_POSZEROf, GLMM_NEGZEROf, GLMM_POSZEROf, GLMM_NEGZEROf)
#define glmm_float32x4_SIGNMASK_NPNP GLMM__SIGNMASKf(GLMM_NEGZEROf, GLMM_POSZEROf, GLMM_NEGZEROf, GLMM_POSZEROf)
#define glmm_float32x4_SIGNMASK_NPPN GLMM__SIGNMASKf(GLMM_NEGZEROf, GLMM_POSZEROf, GLMM_POSZEROf, GLMM_NEGZEROf)
/* fasth math prevents -0.0f to work */
#if defined(__SSE2__)
# define glmm_float32x4_SIGNMASK_NEG _mm_castsi128_ps(_mm_set1_epi32(GLMM_NEGZEROf)) /* _mm_set1_ps(-0.0f) */
#else
# define glmm_float32x4_SIGNMASK_NEG _mm_set1_ps(GLMM_NEGZEROf)
#endif
#define glmm_float32x4_SIGNMASK_NEG _mm_castsi128_ps(_mm_set1_epi32(GLMM_NEGZEROf)) /* _mm_set1_ps(-0.0f) */
#define glmm_float32x8_SIGNMASK_NEG _mm256_castsi256_ps(_mm256_set1_epi32(GLMM_NEGZEROf))
static inline
@@ -207,6 +230,7 @@ glmm_norm_inf(__m128 a) {
return _mm_cvtss_f32(glmm_vhmax(glmm_abs(a)));
}
#if defined(__SSE2__)
static inline
__m128
glmm_load3(float v[3]) {
@@ -225,6 +249,7 @@ glmm_store3(float v[3], __m128 vx) {
_mm_storel_pi(CGLM_CASTPTR_ASSUME_ALIGNED(v, __m64), vx);
_mm_store_ss(&v[2], glmm_shuff1(vx, 2, 2, 2, 2));
}
#endif
static inline
__m128

14
include/cglm/struct/mat2x3.h
View File

@@ -14,7 +14,7 @@
CGLM_INLINE mat2x3s glms_mat2x3_zero(void);
CGLM_INLINE mat2x3s glms_mat2x3_make(const float * __restrict src);
CGLM_INLINE mat2s glms_mat2x3_mul(mat2x3s m1, mat3x2s m2);
CGLM_INLINE vec2s glms_mat2x3_mulv(mat2x3s m, vec3s v);
CGLM_INLINE vec3s glms_mat2x3_mulv(mat2x3s m, vec2s v);
CGLM_INLINE mat3x2s glms_mat2x3_transpose(mat2x3s m);
CGLM_INLINE mat2x3s glms_mat2x3_scale(mat2x3s m, float s);
*/
@@ -73,9 +73,9 @@ glms_mat2x3_(make)(const float * __restrict src) {
* @returns destination matrix (mat2s)
*/
CGLM_INLINE
mat2s
mat3s
glms_mat2x3_(mul)(mat2x3s m1, mat3x2s m2) {
mat2s r;
mat3s r;
glm_mat2x3_mul(m1.raw, m2.raw, r.raw);
return r;
}
@@ -85,12 +85,12 @@ glms_mat2x3_(mul)(mat2x3s m1, mat3x2s m2) {
*
* @param[in] m matrix (left)
* @param[in] v vector (right, column vector)
* @param[out] dest result vector
* @returns destination vector (vec3s)
*/
CGLM_INLINE
vec2s
glms_mat2x3_(mulv)(mat2x3s m, vec3s v) {
vec2s r;
vec3s
glms_mat2x3_(mulv)(mat2x3s m, vec2s v) {
vec3s r;
glm_mat2x3_mulv(m.raw, v.raw, r.raw);
return r;
}

14
include/cglm/struct/mat2x4.h
View File

@@ -14,7 +14,7 @@
CGLM_INLINE mat2x4s glms_mat2x4_zero(void);
CGLM_INLINE mat2x4s glms_mat2x4_make(const float * __restrict src);
CGLM_INLINE mat2s glms_mat2x4_mul(mat2x4s m1, mat4x2s m2);
CGLM_INLINE vec2s glms_mat2x4_mulv(mat2x4s m, vec4s v);
CGLM_INLINE vec4s glms_mat2x4_mulv(mat2x4s m, vec2s v);
CGLM_INLINE mat4x2s glms_mat2x4_transpose(mat2x4s m);
CGLM_INLINE mat2x4s glms_mat2x4_scale(mat2x4s m, float s);
*/
@@ -73,24 +73,24 @@ glms_mat2x4_(make)(const float * __restrict src) {
* @returns destination matrix (mat2s)
*/
CGLM_INLINE
mat2s
mat4s
glms_mat2x4_(mul)(mat2x4s m1, mat4x2s m2) {
mat2s r;
mat4s r;
glm_mat2x4_mul(m1.raw, m2.raw, r.raw);
return r;
}
/*!
* @brief multiply matrix with column vector and store in dest vector
* @brief multiply matrix with column vector and store in dest column vector
*
* @param[in] m matrix (left)
* @param[in] v vector (right, column vector)
* @param[out] dest result vector
*/
CGLM_INLINE
vec2s
glms_mat2x4_(mulv)(mat2x4s m, vec4s v) {
vec2s r;
vec4s
glms_mat2x4_(mulv)(mat2x4s m, vec2s v) {
vec4s r;
glm_mat2x4_mulv(m.raw, v.raw, r.raw);
return r;
}

14
include/cglm/struct/mat3x2.h
View File

@@ -13,8 +13,8 @@
Functions:
CGLM_INLINE mat3x2s glms_mat3x2_zero(void);
CGLM_INLINE mat3x2s glms_mat3x2_make(const float * __restrict src);
CGLM_INLINE mat3s glms_mat3x2_mul(mat3x2s m1, mat2x3s m2);
CGLM_INLINE vec3s glms_mat3x2_mulv(mat3x2s m, vec2s v);
CGLM_INLINE mat2s glms_mat3x2_mul(mat3x2s m1, mat2x3s m2);
CGLM_INLINE vec2s glms_mat3x2_mulv(mat3x2s m, vec3s v);
CGLM_INLINE mat2x3s glms_mat3x2_transpose(mat3x2s m);
CGLM_INLINE mat3x2s glms_mat3x2_scale(mat3x2s m, float s);
*/
@@ -73,9 +73,9 @@ glms_mat3x2_(make)(const float * __restrict src) {
* @returns destination matrix (mat3s)
*/
CGLM_INLINE
mat3s
mat2s
glms_mat3x2_(mul)(mat3x2s m1, mat2x3s m2) {
mat3s r;
mat2s r;
glm_mat3x2_mul(m1.raw, m2.raw, r.raw);
return r;
}
@@ -88,9 +88,9 @@ glms_mat3x2_(mul)(mat3x2s m1, mat2x3s m2) {
* @param[out] dest result vector
*/
CGLM_INLINE
vec3s
glms_mat3x2_(mulv)(mat3x2s m, vec2s v) {
vec3s r;
vec2s
glms_mat3x2_(mulv)(mat3x2s m, vec3s v) {
vec2s r;
glm_mat3x2_mulv(m.raw, v.raw, r.raw);
return r;
}

20
include/cglm/struct/mat3x4.h
View File

@@ -13,8 +13,8 @@
Functions:
CGLM_INLINE mat3x4s glms_mat3x4_zero(void);
CGLM_INLINE mat3x4s glms_mat3x4_make(const float * __restrict src);
CGLM_INLINE mat3s glms_mat3x4_mul(mat3x4s m1, mat4x3s m2);
CGLM_INLINE vec3s glms_mat3x4_mulv(mat3x4s m, vec4s v);
CGLM_INLINE mat4s glms_mat3x4_mul(mat3x4s m1, mat4x3s m2);
CGLM_INLINE vec4s glms_mat3x4_mulv(mat3x4s m, vec3s v);
CGLM_INLINE mat4x3s glms_mat3x4_transpose(mat3x4s m);
CGLM_INLINE mat3x4s glms_mat3x4_scale(mat3x4s m, float s);
*/
@@ -70,27 +70,27 @@ glms_mat3x4_(make)(const float * __restrict src) {
*
* @param[in] m1 left matrix (mat3x4s)
* @param[in] m2 right matrix (mat4x3s)
* @returns destination matrix (mat3s)
* @returns destination matrix (mat4s)
*/
CGLM_INLINE
mat3s
mat4s
glms_mat3x4_(mul)(mat3x4s m1, mat4x3s m2) {
mat3s r;
mat4s r;
glm_mat3x4_mul(m1.raw, m2.raw, r.raw);
return r;
}
/*!
* @brief multiply matrix with column vector and store in dest vector
* @brief multiply matrix with column vector and store in dest column vector
*
* @param[in] m matrix (left)
* @param[in] v vector (right, column vector)
* @param[out] dest result vector
* @returns destination vector (vec4s)
*/
CGLM_INLINE
vec3s
glms_mat3x4_(mulv)(mat3x4s m, vec4s v) {
vec3s r;
vec4s
glms_mat3x4_(mulv)(mat3x4s m, vec3s v) {
vec4s r;
glm_mat3x4_mulv(m.raw, v.raw, r.raw);
return r;
}

20
include/cglm/struct/mat4x2.h
View File

@@ -13,8 +13,8 @@
Functions:
CGLM_INLINE mat4x2s glms_mat4x2_zero(void);
CGLM_INLINE mat4x2s glms_mat4x2_make(const float * __restrict src);
CGLM_INLINE mat4s glms_mat4x2_mul(mat4x2s m1, mat2x4s m2);
CGLM_INLINE vec4s glms_mat4x2_mulv(mat4x2s m, vec2s v);
CGLM_INLINE mat2s glms_mat4x2_mul(mat4x2s m1, mat2x4s m2);
CGLM_INLINE vec2s glms_mat4x2_mulv(mat4x2s m, vec4s v);
CGLM_INLINE mat2x4s glms_mat4x2_transpose(mat4x2s m);
CGLM_INLINE mat4x2s glms_mat4x2_scale(mat4x2s m, float s);
*/
@@ -71,27 +71,27 @@ glms_mat4x2_(make)(const float * __restrict src) {
*
* @param[in] m1 left matrix (mat4x2s)
* @param[in] m2 right matrix (mat2x4s)
* @returns destination matrix (mat4s)
* @returns destination matrix (mat2s)
*/
CGLM_INLINE
mat4s
mat2s
glms_mat4x2_(mul)(mat4x2s m1, mat2x4s m2) {
mat4s r;
mat2s r;
glm_mat4x2_mul(m1.raw, m2.raw, r.raw);
return r;
}
/*!
* @brief multiply matrix with column vector and store in dest vector
* @brief multiply matrix with column vector and store in dest column vector
*
* @param[in] m matrix (left)
* @param[in] v vector (right, column vector)
* @param[out] dest result vector
* @returns destination vector (vec2s)
*/
CGLM_INLINE
vec4s
glms_mat4x2_(mulv)(mat4x2s m, vec2s v) {
vec4s r;
vec2s
glms_mat4x2_(mulv)(mat4x2s m, vec4s v) {
vec2s r;
glm_mat4x2_mulv(m.raw, v.raw, r.raw);
return r;
}

18
include/cglm/struct/mat4x3.h
View File

@@ -13,8 +13,8 @@
Functions:
CGLM_INLINE mat4x3s glms_mat4x3_zero(void);
CGLM_INLINE mat4x3s glms_mat4x3_make(const float * __restrict src);
CGLM_INLINE mat4s glms_mat4x3_mul(mat4x3s m1, mat3x4s m2);
CGLM_INLINE vec4s glms_mat4x3_mulv(mat4x3s m, vec3s v);
CGLM_INLINE mat3s glms_mat4x3_mul(mat4x3s m1, mat3x4s m2);
CGLM_INLINE vec3s glms_mat4x3_mulv(mat4x3s m, vec4s v);
CGLM_INLINE mat3x4s glms_mat4x3_transpose(mat4x3s m);
CGLM_INLINE mat4x3s glms_mat4x3_scale(mat4x3s m, float s);
*/
@@ -70,12 +70,12 @@ glms_mat4x3_(make)(const float * __restrict src) {
*
* @param[in] m1 left matrix (mat4x3s)
* @param[in] m2 right matrix (mat3x4s)
* @returns destination matrix (mat4s)
* @returns destination matrix (mat3s)
*/
CGLM_INLINE
mat4s
mat3s
glms_mat4x3_(mul)(mat4x3s m1, mat3x4s m2) {
mat4s r;
mat3s r;
glm_mat4x3_mul(m1.raw, m2.raw, r.raw);
return r;
}
@@ -85,12 +85,12 @@ glms_mat4x3_(mul)(mat4x3s m1, mat3x4s m2) {
*
* @param[in] m matrix (left)
* @param[in] v vector (right, column vector)
* @param[out] dest result vector
* @returns destination vector (vec3s)
*/
CGLM_INLINE
vec4s
glms_mat4x3_(mulv)(mat4x3s m, vec3s v) {
vec4s r;
vec3s
glms_mat4x3_(mulv)(mat4x3s m, vec4s v) {
vec3s r;
glm_mat4x3_mulv(m.raw, v.raw, r.raw);
return r;
}

16
include/cglm/struct/vec2.h
View File

@@ -54,8 +54,8 @@
CGLM_INLINE vec2s glms_vec2_clamp(vec2s v, float minVal, float maxVal)
CGLM_INLINE vec2s glms_vec2_lerp(vec2s from, vec2s to, float t)
CGLM_INLINE vec2s glms_vec2_make(float * restrict src)
CGLM_INLINE vec2s glms_vec2_reflect(vec2s I, vec2s N)
CGLM_INLINE bool glms_vec2_refract(vec2s I, vec2s N, float eta, vec2s *dest)
CGLM_INLINE vec2s glms_vec2_reflect(vec2s v, vec2s n)
CGLM_INLINE bool glms_vec2_refract(vec2s v, vec2s n, float eta, vec2s *dest)
*/
#ifndef cglms_vec2s_h
@@ -702,9 +702,9 @@ glms_vec2_(make)(const float * __restrict src) {
*/
CGLM_INLINE
vec2s
glms_vec2_(reflect)(vec2s I, vec2s N) {
glms_vec2_(reflect)(vec2s v, vec2s n) {
vec2s dest;
glm_vec2_reflect(I.raw, N.raw, dest.raw);
glm_vec2_reflect(v.raw, n.raw, dest.raw);
return dest;
}
@@ -715,8 +715,8 @@ glms_vec2_(reflect)(vec2s I, vec2s N) {
* occurs (angle too great given eta), dest is set to zero and returns false.
* Otherwise, computes refraction vector, stores it in dest, and returns true.
*
* @param[in] I normalized incident vector
* @param[in] N normalized normal vector
* @param[in] v normalized incident vector
* @param[in] n normalized normal vector
* @param[in] eta ratio of indices of refraction (incident/transmitted)
* @param[out] dest refraction vector if refraction occurs; zero vector otherwise
*
@@ -724,8 +724,8 @@ glms_vec2_(reflect)(vec2s I, vec2s N) {
*/
CGLM_INLINE
bool
glms_vec2_(refract)(vec2s I, vec2s N, float eta, vec2s * __restrict dest) {
return glm_vec2_refract(I.raw, N.raw, eta, dest->raw);
glms_vec2_(refract)(vec2s v, vec2s n, float eta, vec2s * __restrict dest) {
return glm_vec2_refract(v.raw, n.raw, eta, dest->raw);
}
#endif /* cglms_vec2s_h */

28
include/cglm/struct/vec3.h
View File

@@ -76,9 +76,9 @@
CGLM_INLINE vec3s glms_vec3_smoothinterpc(vec3s from, vec3s to, float t);
CGLM_INLINE vec3s glms_vec3_swizzle(vec3s v, int mask);
CGLM_INLINE vec3s glms_vec3_make(float * restrict src);
CGLM_INLINE vec3s glms_vec3_faceforward(vec3s N, vec3s I, vec3s Nref);
CGLM_INLINE vec3s glms_vec3_reflect(vec3s I, vec3s N);
CGLM_INLINE bool glms_vec3_refract(vec3s I, vec3s N, float eta, vec3s *dest)
CGLM_INLINE vec3s glms_vec3_faceforward(vec3s n, vec3s v, vec3s nref);
CGLM_INLINE vec3s glms_vec3_reflect(vec3s v, vec3s n);
CGLM_INLINE bool glms_vec3_refract(vec3s v, vec3s n, float eta, vec3s *dest)
Convenient:
CGLM_INLINE vec3s glms_cross(vec3s a, vec3s b);
@@ -1091,16 +1091,16 @@ glms_vec3_(make)(const float * __restrict src) {
*
* orients a vector to point away from a surface as defined by its normal
*
* @param[in] N vector to orient.
* @param[in] I incident vector
* @param[in] Nref reference vector
* @param[in] n vector to orient.
* @param[in] v incident vector
* @param[in] nref reference vector
* @returns oriented vector, pointing away from the surface.
*/
CGLM_INLINE
vec3s
glms_vec3_(faceforward)(vec3s N, vec3s I, vec3s Nref) {
glms_vec3_(faceforward)(vec3s n, vec3s v, vec3s nref) {
vec3s dest;
glm_vec3_faceforward(N.raw, I.raw, Nref.raw, dest.raw);
glm_vec3_faceforward(n.raw, v.raw, nref.raw, dest.raw);
return dest;
}
@@ -1113,9 +1113,9 @@ glms_vec3_(faceforward)(vec3s N, vec3s I, vec3s Nref) {
*/
CGLM_INLINE
vec3s
glms_vec3_(reflect)(vec3s I, vec3s N) {
glms_vec3_(reflect)(vec3s v, vec3s n) {
vec3s dest;
glm_vec3_reflect(I.raw, N.raw, dest.raw);
glm_vec3_reflect(v.raw, n.raw, dest.raw);
return dest;
}
@@ -1126,8 +1126,8 @@ glms_vec3_(reflect)(vec3s I, vec3s N) {
* occurs (angle too great given eta), dest is set to zero and returns false.
* Otherwise, computes refraction vector, stores it in dest, and returns true.
*
* @param[in] I normalized incident vector
* @param[in] N normalized normal vector
* @param[in] v normalized incident vector
* @param[in] n normalized normal vector
* @param[in] eta ratio of indices of refraction (incident/transmitted)
* @param[out] dest refraction vector if refraction occurs; zero vector otherwise
*
@@ -1135,8 +1135,8 @@ glms_vec3_(reflect)(vec3s I, vec3s N) {
*/
CGLM_INLINE
bool
glms_vec3_(refract)(vec3s I, vec3s N, float eta, vec3s * __restrict dest) {
return glm_vec3_refract(I.raw, N.raw, eta, dest->raw);
glms_vec3_(refract)(vec3s v, vec3s n, float eta, vec3s * __restrict dest) {
return glm_vec3_refract(v.raw, n.raw, eta, dest->raw);
}
#endif /* cglms_vec3s_h */

20
include/cglm/struct/vec4.h
View File

@@ -67,8 +67,8 @@
CGLM_INLINE vec4s glms_vec4_cubic(float s);
CGLM_INLINE vec4s glms_vec4_swizzle(vec4s v, int mask);
CGLM_INLINE vec4s glms_vec4_make(float * restrict src);
CGLM_INLINE vec4s glms_vec4_reflect(vec4s I, vec4s N);
CGLM_INLINE bool glms_vec4_refract(vec4s I, vec4s N, float eta, vec4s *dest)
CGLM_INLINE vec4s glms_vec4_reflect(vec4s v, vec4s n);
CGLM_INLINE bool glms_vec4_refract(vec4s v, vec4s n, float eta, vec4s *dest)
*/
#ifndef cglms_vec4s_h
@@ -932,15 +932,15 @@ glms_vec4_(make)(const float * __restrict src) {
/*!
* @brief reflection vector using an incident ray and a surface normal
*
* @param[in] I incident vector
* @param[in] N normalized normal vector
* @param[in] v incident vector
* @param[in] n normalized normal vector
* @returns reflection result
*/
CGLM_INLINE
vec4s
glms_vec4_(reflect)(vec4s I, vec4s N) {
glms_vec4_(reflect)(vec4s v, vec4s n) {
vec4s dest;
glm_vec4_reflect(I.raw, N.raw, dest.raw);
glm_vec4_reflect(v.raw, n.raw, dest.raw);
return dest;
}
@@ -955,8 +955,8 @@ glms_vec4_(reflect)(vec4s I, vec4s N) {
* incident vector 'I' in the output 'dest', users requiring the preservation of
* the 'w' component should manually adjust 'dest' after calling this function.
*
* @param[in] I normalized incident vector
* @param[in] N normalized normal vector
* @param[in] v normalized incident vector
* @param[in] n normalized normal vector
* @param[in] eta ratio of indices of refraction (incident/transmitted)
* @param[out] dest refraction vector if refraction occurs; zero vector otherwise
*
@@ -964,8 +964,8 @@ glms_vec4_(reflect)(vec4s I, vec4s N) {
*/
CGLM_INLINE
bool
glms_vec4_(refract)(vec4s I, vec4s N, float eta, vec4s * __restrict dest) {
return glm_vec4_refract(I.raw, N.raw, eta, dest->raw);
glms_vec4_(refract)(vec4s v, vec4s n, float eta, vec4s * __restrict dest) {
return glm_vec4_refract(v.raw, n.raw, eta, dest->raw);
}
#endif /* cglms_vec4s_h */

26
include/cglm/vec2.h
View File

@@ -55,8 +55,8 @@
CGLM_INLINE void glm_vec2_clamp(vec2 v, float minVal, float maxVal)
CGLM_INLINE void glm_vec2_lerp(vec2 from, vec2 to, float t, vec2 dest)
CGLM_INLINE void glm_vec2_make(float * restrict src, vec2 dest)
CGLM_INLINE void glm_vec2_reflect(vec2 I, vec2 N, vec2 dest)
CGLM_INLINE void glm_vec2_refract(vec2 I, vec2 N, float eta, vec2 dest)
CGLM_INLINE void glm_vec2_reflect(vec2 v, vec2 n, vec2 dest)
CGLM_INLINE void glm_vec2_refract(vec2 v, vec2 n, float eta, vec2 dest)
*/
#ifndef cglm_vec2_h
@@ -716,16 +716,16 @@ glm_vec2_make(const float * __restrict src, vec2 dest) {
/*!
* @brief reflection vector using an incident ray and a surface normal
*
* @param[in] I incident vector
* @param[in] N normalized normal vector
* @param[in] v incident vector
* @param[in] n normalized normal vector
* @param[out] dest destination vector for the reflection result
*/
CGLM_INLINE
void
glm_vec2_reflect(vec2 I, vec2 N, vec2 dest) {
glm_vec2_reflect(vec2 v, vec2 n, vec2 dest) {
vec2 temp;
glm_vec2_scale(N, 2.0f * glm_vec2_dot(I, N), temp);
glm_vec2_sub(I, temp, dest);
glm_vec2_scale(n, 2.0f * glm_vec2_dot(v, n), temp);
glm_vec2_sub(v, temp, dest);
}
/*!
@@ -735,8 +735,8 @@ glm_vec2_reflect(vec2 I, vec2 N, vec2 dest) {
* occurs (angle too great given eta), dest is set to zero and returns false.
* Otherwise, computes refraction vector, stores it in dest, and returns true.
*
* @param[in] I normalized incident vector
* @param[in] N normalized normal vector
* @param[in] v normalized incident vector
* @param[in] n normalized normal vector
* @param[in] eta ratio of indices of refraction (incident/transmitted)
* @param[out] dest refraction vector if refraction occurs; zero vector otherwise
*
@@ -744,10 +744,10 @@ glm_vec2_reflect(vec2 I, vec2 N, vec2 dest) {
*/
CGLM_INLINE
bool
glm_vec2_refract(vec2 I, vec2 N, float eta, vec2 dest) {
glm_vec2_refract(vec2 v, vec2 n, float eta, vec2 dest) {
float ndi, eni, k;
ndi = glm_vec2_dot(N, I);
ndi = glm_vec2_dot(n, v);
eni = eta * ndi;
k = 1.0f + eta * eta - eni * eni;
@@ -756,8 +756,8 @@ glm_vec2_refract(vec2 I, vec2 N, float eta, vec2 dest) {
return false;
}
glm_vec2_scale(I, eta, dest);
glm_vec2_mulsubs(N, eni + sqrtf(k), dest);
glm_vec2_scale(v, eta, dest);
glm_vec2_mulsubs(n, eni + sqrtf(k), dest);
return true;
}

42
include/cglm/vec3.h
View File

@@ -80,9 +80,9 @@
CGLM_INLINE void glm_vec3_smoothinterpc(vec3 from, vec3 to, float t, vec3 dest);
CGLM_INLINE void glm_vec3_swizzle(vec3 v, int mask, vec3 dest);
CGLM_INLINE void glm_vec3_make(float * restrict src, vec3 dest);
CGLM_INLINE void glm_vec3_faceforward(vec3 N, vec3 I, vec3 Nref, vec3 dest);
CGLM_INLINE void glm_vec3_reflect(vec3 I, vec3 N, vec3 dest);
CGLM_INLINE void glm_vec3_refract(vec3 I, vec3 N, float eta, vec3 dest);
CGLM_INLINE void glm_vec3_faceforward(vec3 n, vec3 v, vec3 nref, vec3 dest);
CGLM_INLINE void glm_vec3_reflect(vec3 v, vec3 n, vec3 dest);
CGLM_INLINE void glm_vec3_refract(vec3 v, vec3 n, float eta, vec3 dest);
Convenient:
CGLM_INLINE void glm_cross(vec3 a, vec3 b, vec3 d);
@@ -1210,36 +1210,36 @@ glm_vec3_make(const float * __restrict src, vec3 dest) {
*
* orients a vector to point away from a surface as defined by its normal
*
* @param[in] N vector to orient
* @param[in] I incident vector
* @param[in] Nref reference vector
* @param[in] n vector to orient
* @param[in] v incident vector
* @param[in] nref reference vector
* @param[out] dest oriented vector, pointing away from the surface
*/
CGLM_INLINE
void
glm_vec3_faceforward(vec3 N, vec3 I, vec3 Nref, vec3 dest) {
if (glm_vec3_dot(I, Nref) < 0.0f) {
glm_vec3_faceforward(vec3 n, vec3 v, vec3 nref, vec3 dest) {
if (glm_vec3_dot(v, nref) < 0.0f) {
/* N is facing away from I */
glm_vec3_copy(N, dest);
glm_vec3_copy(n, dest);
} else {
/* N is facing towards I, negate it */
glm_vec3_negate_to(N, dest);
glm_vec3_negate_to(n, dest);
}
}
/*!
* @brief reflection vector using an incident ray and a surface normal
*
* @param[in] I incident vector
* @param[in] N normalized normal vector
* @param[in] v incident vector
* @param[in] n normalized normal vector
* @param[out] dest reflection result
*/
CGLM_INLINE
void
glm_vec3_reflect(vec3 I, vec3 N, vec3 dest) {
glm_vec3_reflect(vec3 v, vec3 n, vec3 dest) {
vec3 temp;
glm_vec3_scale(N, 2.0f * glm_vec3_dot(I, N), temp);
glm_vec3_sub(I, temp, dest);
glm_vec3_scale(n, 2.0f * glm_vec3_dot(v, n), temp);
glm_vec3_sub(v, temp, dest);
}
/*!
@@ -1249,8 +1249,8 @@ glm_vec3_reflect(vec3 I, vec3 N, vec3 dest) {
* occurs (angle too great given eta), dest is set to zero and returns false.
* Otherwise, computes refraction vector, stores it in dest, and returns true.
*
* @param[in] I normalized incident vector
* @param[in] N normalized normal vector
* @param[in] v normalized incident vector
* @param[in] n normalized normal vector
* @param[in] eta ratio of indices of refraction (incident/transmitted)
* @param[out] dest refraction vector if refraction occurs; zero vector otherwise
*
@@ -1258,10 +1258,10 @@ glm_vec3_reflect(vec3 I, vec3 N, vec3 dest) {
*/
CGLM_INLINE
bool
glm_vec3_refract(vec3 I, vec3 N, float eta, vec3 dest) {
glm_vec3_refract(vec3 v, vec3 n, float eta, vec3 dest) {
float ndi, eni, k;
ndi = glm_vec3_dot(N, I);
ndi = glm_vec3_dot(n, v);
eni = eta * ndi;
k = 1.0f + eta * eta - eni * eni;
@@ -1270,8 +1270,8 @@ glm_vec3_refract(vec3 I, vec3 N, float eta, vec3 dest) {
return false;
}
glm_vec3_scale(I, eta, dest);
glm_vec3_mulsubs(N, eni + sqrtf(k), dest);
glm_vec3_scale(v, eta, dest);
glm_vec3_mulsubs(n, eni + sqrtf(k), dest);
return true;
}

28
include/cglm/vec4.h
View File

@@ -65,8 +65,8 @@
CGLM_INLINE void glm_vec4_smoothinterpc(vec4 from, vec4 to, float t, vec4 dest);
CGLM_INLINE void glm_vec4_swizzle(vec4 v, int mask, vec4 dest);
CGLM_INLINE void glm_vec4_make(float * restrict src, vec4 dest);
CGLM_INLINE void glm_vec4_reflect(vec4 I, vec4 N, vec4 dest);
CGLM_INLINE void glm_vec4_refract(vec4 I, vec4 N, float eta, vec4 dest);
CGLM_INLINE void glm_vec4_reflect(vec4 v, vec4 n, vec4 dest);
CGLM_INLINE void glm_vec4_refract(vec4 v, vec4 n, float eta, vec4 dest);
DEPRECATED:
glm_vec4_dup
@@ -1309,20 +1309,20 @@ glm_vec4_make(const float * __restrict src, vec4 dest) {
/*!
* @brief reflection vector using an incident ray and a surface normal
*
* @param[in] I incident vector
* @param[in] N normalized normal vector
* @param[in] v incident vector
* @param[in] n normalized normal vector
* @param[out] dest destination vector for the reflection result
*/
CGLM_INLINE
void
glm_vec4_reflect(vec4 I, vec4 N, vec4 dest) {
glm_vec4_reflect(vec4 v, vec4 n, vec4 dest) {
vec4 temp;
/* TODO: direct simd touch */
glm_vec4_scale(N, 2.0f * glm_vec4_dot(I, N), temp);
glm_vec4_sub(I, temp, dest);
glm_vec4_scale(n, 2.0f * glm_vec4_dot(v, n), temp);
glm_vec4_sub(v, temp, dest);
dest[3] = I[3];
dest[3] = v[3];
}
/*!
@@ -1336,8 +1336,8 @@ glm_vec4_reflect(vec4 I, vec4 N, vec4 dest) {
* incident vector 'I' in the output 'dest', users requiring the preservation of
* the 'w' component should manually adjust 'dest' after calling this function.
*
* @param[in] I normalized incident vector
* @param[in] N normalized normal vector
* @param[in] v normalized incident vector
* @param[in] n normalized normal vector
* @param[in] eta ratio of indices of refraction (incident/transmitted)
* @param[out] dest refraction vector if refraction occurs; zero vector otherwise
*
@@ -1345,10 +1345,10 @@ glm_vec4_reflect(vec4 I, vec4 N, vec4 dest) {
*/
CGLM_INLINE
bool
glm_vec4_refract(vec4 I, vec4 N, float eta, vec4 dest) {
glm_vec4_refract(vec4 v, vec4 n, float eta, vec4 dest) {
float ndi, eni, k;
ndi = glm_vec4_dot(N, I);
ndi = glm_vec4_dot(n, v);
eni = eta * ndi;
k = 1.0f + eta * eta - eni * eni;
@@ -1357,8 +1357,8 @@ glm_vec4_refract(vec4 I, vec4 N, float eta, vec4 dest) {
return false;
}
glm_vec4_scale(I, eta, dest);
glm_vec4_mulsubs(N, eni + sqrtf(k), dest);
glm_vec4_scale(v, eta, dest);
glm_vec4_mulsubs(n, eni + sqrtf(k), dest);
return true;
}

2
include/cglm/version.h
View File

@@ -10,6 +10,6 @@
#define CGLM_VERSION_MAJOR 0
#define CGLM_VERSION_MINOR 9
#define CGLM_VERSION_PATCH 4
#define CGLM_VERSION_PATCH 5
#endif /* cglm_version_h */