From 4c872238d9edc9bbf7a6aeddffc1c9f5f9aaa2e2 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Sun, 31 Mar 2024 04:22:42 +0300 Subject: [PATCH 01/29] dont use I macro defined in standard --- docs/source/vec2.rst | 12 +++++------ docs/source/vec3.rst | 22 ++++++++++---------- docs/source/vec4.rst | 14 ++++++------- include/cglm/call/vec2.h | 4 ++-- include/cglm/call/vec3.h | 6 +++--- include/cglm/call/vec4.h | 4 ++-- include/cglm/struct/vec2.h | 16 +++++++-------- include/cglm/struct/vec3.h | 10 ++++----- include/cglm/struct/vec4.h | 20 +++++++++--------- include/cglm/vec2.h | 26 +++++++++++------------ include/cglm/vec3.h | 42 +++++++++++++++++++------------------- include/cglm/vec4.h | 26 +++++++++++------------ src/vec2.c | 8 ++++---- src/vec3.c | 12 +++++------ src/vec4.c | 8 ++++---- 15 files changed, 115 insertions(+), 115 deletions(-) diff --git a/docs/source/vec2.rst b/docs/source/vec2.rst index 95615d1..e9e38ca 100644 --- a/docs/source/vec2.rst +++ b/docs/source/vec2.rst @@ -397,16 +397,16 @@ Functions documentation | *[in]* **src** pointer to an array of floats | *[out]* **dest** destination vector -.. c:function:: void glm_vec2_reflect(vec2 I, vec2 N, vec2 dest) +.. c:function:: void glm_vec2_reflect(vec2 v, vec2 n, vec2 dest) Reflection vector using an incident ray and a surface normal Parameters: - | *[in]* **I** incident vector - | *[in]* **N** *❗️ normalized ❗️* normal vector + | *[in]* **v** incident vector + | *[in]* **n** *❗️ normalized ❗️* normal vector | *[out]* **dest** destination: reflection result -.. c:function:: bool glm_vec2_refract(vec2 I, vec2 N, float eta, vec2 dest) +.. c:function:: bool glm_vec2_refract(vec2 v, vec2 n, float eta, vec2 dest) Computes refraction vector for an incident vector and a surface normal. @@ -415,8 +415,8 @@ Functions documentation Otherwise, computes refraction vector, stores it in dest, and returns true. Parameters: - | *[in]* **I** *❗️ normalized ❗️* incident vector - | *[in]* **N** *❗️ normalized ❗️* normal vector + | *[in]* **v** *❗️ normalized ❗️* incident vector + | *[in]* **n** *❗️ normalized ❗️* normal vector | *[in]* **eta** ratio of indices of refraction (incident/transmitted) | *[out]* **dest** refraction vector if refraction occurs; zero vector otherwise diff --git a/docs/source/vec3.rst b/docs/source/vec3.rst index 91c16b9..0b989b8 100644 --- a/docs/source/vec3.rst +++ b/docs/source/vec3.rst @@ -516,26 +516,26 @@ Functions documentation | *[in]* **src** pointer to an array of floats | *[out]* **dest** destination vector -.. c:function:: void glm_vec3_faceforward(vec3 N, vec3 I, vec3 Nref, vec3 dest) +.. c:function:: void glm_vec3_faceforward(vec3 n, vec3 v, vec3 nref, vec3 dest) A vector pointing in the same direction as another Parameters: - | *[in]* **N** vector to orient - | *[in]* **I** incident vector - | *[in]* **Nref** reference vector + | *[in]* **n** vector to orient + | *[in]* **v** incident vector + | *[in]* **nref** reference vector | *[out]* **dest** destination: oriented vector, pointing away from the surface. -.. c:function:: void glm_vec3_reflect(vec3 I, vec3 N, vec3 dest) +.. c:function:: void glm_vec3_reflect(vec3 v, vec3 n, vec3 dest) Reflection vector using an incident ray and a surface normal Parameters: - | *[in]* **I** incident vector - | *[in]* **N** *❗️ normalized ❗️* normal vector + | *[in]* **v** incident vector + | *[in]* **n** *❗️ normalized ❗️* normal vector | *[out]* **dest** destination: reflection result -.. c:function:: bool glm_vec3_refract(vec3 I, vec3 N, float eta, vec3 dest) +.. c:function:: bool glm_vec3_refract(vec3 v, vec3 n, float eta, vec3 dest) Computes refraction vector for an incident vector and a surface normal. @@ -545,10 +545,10 @@ Functions documentation Otherwise, computes refraction vector, stores it in dest, and returns true. Parameters: - | *[in]* **I** *❗️ normalized ❗️* incident vector - | *[in]* **N** *❗️ normalized ❗️* normal vector + | *[in]* **v** *❗️ normalized ❗️* incident vector + | *[in]* **n** *❗️ normalized ❗️* normal vector | *[in]* **eta** ratio of indices of refraction (incident/transmitted) | *[out]* **dest** refraction vector if refraction occurs; zero vector otherwise Returns: - returns true if refraction occurs; false if total internal reflection occurs. \ No newline at end of file + returns true if refraction occurs; false if total internal reflection occurs. diff --git a/docs/source/vec4.rst b/docs/source/vec4.rst index 04c3a82..9035a3d 100644 --- a/docs/source/vec4.rst +++ b/docs/source/vec4.rst @@ -427,16 +427,16 @@ Functions documentation | *[in]* **src** pointer to an array of floats | *[out]* **dest** destination vector -.. c:function:: bool glm_vec4_reflect(vec4 I, vec4 N, vec4 dest) +.. c:function:: bool glm_vec4_reflect(vec4 v, vec4 n, vec4 dest) Reflection vector using an incident ray and a surface normal Parameters: - | *[in]* **I** incident vector - | *[in]* **N** *❗️ normalized ❗️* normal vector + | *[in]* **v** incident vector + | *[in]* **n** *❗️ normalized ❗️* normal vector | *[out]* **dest** destination: reflection result -.. c:function:: bool glm_vec4_refract(vec4 I, vec4 N, float eta, vec4 dest) +.. c:function:: bool glm_vec4_refract(vec4 v, vec4 n, float eta, vec4 dest) computes refraction vector for an incident vector and a surface normal. @@ -449,10 +449,10 @@ Functions documentation the 'w' component should manually adjust 'dest' after calling this function. Parameters: - | *[in]* **I** *❗️ normalized ❗️* incident vector - | *[in]* **N** *❗️ normalized ❗️* normal vector + | *[in]* **v** *❗️ normalized ❗️* incident vector + | *[in]* **n** *❗️ normalized ❗️* normal vector | *[in]* **eta** ratio of indices of refraction (incident/transmitted) | *[out]* **dest** refraction vector if refraction occurs; zero vector otherwise Returns: - returns true if refraction occurs; false if total internal reflection occurs. \ No newline at end of file + returns true if refraction occurs; false if total internal reflection occurs. diff --git a/include/cglm/call/vec2.h b/include/cglm/call/vec2.h index 2343d14..507f042 100644 --- a/include/cglm/call/vec2.h +++ b/include/cglm/call/vec2.h @@ -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 } diff --git a/include/cglm/call/vec3.h b/include/cglm/call/vec3.h index 2bde3ba..bb5a5d7 100644 --- a/include/cglm/call/vec3.h +++ b/include/cglm/call/vec3.h @@ -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 } diff --git a/include/cglm/call/vec4.h b/include/cglm/call/vec4.h index d121bea..a976e94 100644 --- a/include/cglm/call/vec4.h +++ b/include/cglm/call/vec4.h @@ -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 } diff --git a/include/cglm/struct/vec2.h b/include/cglm/struct/vec2.h index 3540d32..e1190e2 100644 --- a/include/cglm/struct/vec2.h +++ b/include/cglm/struct/vec2.h @@ -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 */ diff --git a/include/cglm/struct/vec3.h b/include/cglm/struct/vec3.h index e1e0a29..b7ce133 100644 --- a/include/cglm/struct/vec3.h +++ b/include/cglm/struct/vec3.h @@ -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); @@ -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; } diff --git a/include/cglm/struct/vec4.h b/include/cglm/struct/vec4.h index 4431460..8b2ef00 100644 --- a/include/cglm/struct/vec4.h +++ b/include/cglm/struct/vec4.h @@ -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 */ diff --git a/include/cglm/vec2.h b/include/cglm/vec2.h index aeb9e91..a6d1603 100644 --- a/include/cglm/vec2.h +++ b/include/cglm/vec2.h @@ -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 v, 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; } diff --git a/include/cglm/vec3.h b/include/cglm/vec3.h index 72bd371..be4029b 100644 --- a/include/cglm/vec3.h +++ b/include/cglm/vec3.h @@ -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; } diff --git a/include/cglm/vec4.h b/include/cglm/vec4.h index 4053b9f..a53746e 100644 --- a/include/cglm/vec4.h +++ b/include/cglm/vec4.h @@ -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,7 +1357,7 @@ glm_vec4_refract(vec4 I, vec4 N, float eta, vec4 dest) { return false; } - glm_vec4_scale(I, eta, dest); + glm_vec4_scale(v, eta, dest); glm_vec4_mulsubs(N, eni + sqrtf(k), dest); return true; } diff --git a/src/vec2.c b/src/vec2.c index 4f638a1..b124f86 100644 --- a/src/vec2.c +++ b/src/vec2.c @@ -305,12 +305,12 @@ glmc_vec2_make(const float * __restrict src, vec2 dest) { CGLM_EXPORT void -glmc_vec2_reflect(vec2 I, vec2 N, vec2 dest) { - glm_vec2_reflect(I, N, dest); +glmc_vec2_reflect(vec2 v, vec2 n, vec2 dest) { + glm_vec2_reflect(v, n, dest); } CGLM_EXPORT bool -glmc_vec2_refract(vec2 I, vec2 N, float eta, vec2 dest) { - return glm_vec2_refract(I, N, eta, dest); +glmc_vec2_refract(vec2 v, vec2 n, float eta, vec2 dest) { + return glm_vec2_refract(v, n, eta, dest); } diff --git a/src/vec3.c b/src/vec3.c index a31ce3f..c1316dc 100644 --- a/src/vec3.c +++ b/src/vec3.c @@ -462,18 +462,18 @@ glmc_vec3_make(const float * __restrict src, vec3 dest) { CGLM_EXPORT void -glmc_vec3_faceforward(vec3 N, vec3 I, vec3 Nref, vec3 dest) { - glm_vec3_faceforward(N, I, Nref, dest); +glmc_vec3_faceforward(vec3 n, vec3 v, vec3 nref, vec3 dest) { + glm_vec3_faceforward(n, v, nref, dest); } CGLM_EXPORT void -glmc_vec3_reflect(vec3 I, vec3 N, vec3 dest) { - glm_vec3_reflect(I, N, dest); +glmc_vec3_reflect(vec3 v, vec3 n, vec3 dest) { + glm_vec3_reflect(v, n, dest); } CGLM_EXPORT bool -glmc_vec3_refract(vec3 I, vec3 N, float eta, vec3 dest) { - return glm_vec3_refract(I, N, eta, dest); +glmc_vec3_refract(vec3 v, vec3 n, float eta, vec3 dest) { + return glm_vec3_refract(v, n, eta, dest); } diff --git a/src/vec4.c b/src/vec4.c index de23462..cac6606 100644 --- a/src/vec4.c +++ b/src/vec4.c @@ -426,12 +426,12 @@ glmc_vec4_make(const float * __restrict src, vec4 dest) { CGLM_EXPORT void -glmc_vec4_reflect(vec4 I, vec4 N, vec4 dest) { - glm_vec4_reflect(I, N, dest); +glmc_vec4_reflect(vec4 v, vec4 n, vec4 dest) { + glm_vec4_reflect(v, n, dest); } CGLM_EXPORT bool -glmc_vec4_refract(vec4 I, vec4 N, float eta, vec4 dest) { - return glm_vec4_refract(I, N, eta, dest); +glmc_vec4_refract(vec4 v, vec4 n, float eta, vec4 dest) { + return glm_vec4_refract(v, n, eta, dest); } From f388df7f3ed597c12bcfd4aee9c0077380c86b10 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Sun, 31 Mar 2024 04:40:42 +0300 Subject: [PATCH 02/29] fix typos --- include/cglm/vec2.h | 2 +- include/cglm/vec4.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/include/cglm/vec2.h b/include/cglm/vec2.h index a6d1603..aaac759 100644 --- a/include/cglm/vec2.h +++ b/include/cglm/vec2.h @@ -744,7 +744,7 @@ glm_vec2_reflect(vec2 v, vec2 n, vec2 dest) { */ CGLM_INLINE bool -glm_vec2_refract(vec2 v, vec2 v, float eta, vec2 dest) { +glm_vec2_refract(vec2 v, vec2 n, float eta, vec2 dest) { float ndi, eni, k; ndi = glm_vec2_dot(n, v); diff --git a/include/cglm/vec4.h b/include/cglm/vec4.h index a53746e..e24675f 100644 --- a/include/cglm/vec4.h +++ b/include/cglm/vec4.h @@ -1358,7 +1358,7 @@ glm_vec4_refract(vec4 v, vec4 n, float eta, vec4 dest) { } glm_vec4_scale(v, eta, dest); - glm_vec4_mulsubs(N, eni + sqrtf(k), dest); + glm_vec4_mulsubs(n, eni + sqrtf(k), dest); return true; } From 050bc95264e193f5031906e510a44df3d3783c68 Mon Sep 17 00:00:00 2001 From: Vincent Davis Jr Date: Fri, 29 Mar 2024 23:14:11 -0400 Subject: [PATCH 03/29] mat2x3: fix multiplication functions Signed-off-by: Vincent Davis Jr --- include/cglm/call/mat2x3.h | 4 ++-- include/cglm/mat2x3.h | 35 ++++++++++++++++++++++------------- include/cglm/struct/mat2x3.h | 14 +++++++------- src/mat2x3.c | 4 ++-- test/src/test_mat2x3.h | 24 ++++++++++++------------ 5 files changed, 45 insertions(+), 36 deletions(-) diff --git a/include/cglm/call/mat2x3.h b/include/cglm/call/mat2x3.h index 90ff606..59c9ee3 100644 --- a/include/cglm/call/mat2x3.h +++ b/include/cglm/call/mat2x3.h @@ -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 diff --git a/include/cglm/mat2x3.h b/include/cglm/mat2x3.h index 06fec14..3d5cedc 100644 --- a/include/cglm/mat2x3.h +++ b/include/cglm/mat2x3.h @@ -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,14 @@ 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, v1; - 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; + v0 = v[0]; v1 = v[1]; + + 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; } /*! diff --git a/include/cglm/struct/mat2x3.h b/include/cglm/struct/mat2x3.h index 77084a7..3798893 100644 --- a/include/cglm/struct/mat2x3.h +++ b/include/cglm/struct/mat2x3.h @@ -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; } diff --git a/src/mat2x3.c b/src/mat2x3.c index dc5fd30..3397bf2 100644 --- a/src/mat2x3.c +++ b/src/mat2x3.c @@ -28,13 +28,13 @@ 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) { glm_mat2x3_mul(m1, m2, dest); } CGLM_EXPORT void -glmc_mat2x3_mulv(mat2x3 m, vec3 v, vec2 dest) { +glmc_mat2x3_mulv(mat2x3 m, vec2 v, vec3 dest) { glm_mat2x3_mulv(m, v, dest); } diff --git a/test/src/test_mat2x3.h b/test/src/test_mat2x3.h index 7d615e4..8eb8144 100644 --- a/test/src/test_mat2x3.h +++ b/test/src/test_mat2x3.h @@ -83,42 +83,42 @@ TEST_IMPL(GLM_PREFIX, mat2x3_mul) { mat2x3 m1 = GLM_MAT2X3_ZERO_INIT; mat3x2 m2 = GLM_MAT3X2_ZERO_INIT; - mat2 m3 = GLM_MAT2_ZERO_INIT; - mat2 m4 = GLM_MAT2_ZERO_INIT; + mat3 m3 = GLM_MAT3_ZERO_INIT; + mat3 m4 = GLM_MAT3_ZERO_INIT; - int i, j, k; + int c, r, k; /* test random matrices */ /* random matrices */ test_rand_mat2x3(m1); test_rand_mat3x2(m2); - for (i = 0; i < 2; i++) { - for (j = 0; j < 2; j++) { - for (k = 0; k < 3; k++) { - m4[i][j] += m1[i][k] * m2[k][j]; + for (r = 0; r < 3; r++) { + for (c = 0; c < 3; c++) { + for (k = 0; k < 2; k++) { + m4[c][r] += m1[k][r] * m2[c][k]; } } } GLM(mat2x3_mul)(m1, m2, m3); - ASSERTIFY(test_assert_mat2_eq(m3, m4)) + ASSERTIFY(test_assert_mat3_eq(m3, m4)) TEST_SUCCESS } TEST_IMPL(GLM_PREFIX, mat2x3_mulv) { mat2x3 mat = A_MATRIX2X3; - vec3 v = {11.0f, 21.0f, 31.0f}; + vec2 v = {11.0f, 21.0f}; int i; - vec2 dest; + vec3 dest; float res = 0.0; GLM(mat2x3_mulv)(mat, v, dest); - for (i = 0; i < 2; i++) { - res = mat[i][0] * v[0] + mat[i][1] * v[1] + mat[i][2] * v[2]; + for (i = 0; i < 3; i++) { + res = mat[0][i] * v[0] + mat[1][i] * v[1]; ASSERT(test_eq(dest[i], res)) } From c5dcb93c92c0eb9d3825414d4ff058b446a4614a Mon Sep 17 00:00:00 2001 From: Vincent Davis Jr Date: Sat, 30 Mar 2024 14:22:23 -0400 Subject: [PATCH 04/29] docs: mat2x3 account for latest mulitplication changes This also includes tables to explain how mat2x3, column vectors and row vectors are represented. Also includes how resulting matrix or vector is formed. Signed-off-by: Vincent Davis Jr --- docs/source/mat2x3.rst | 60 ++++++++++++++++++++++++++++++++++++++---- 1 file changed, 55 insertions(+), 5 deletions(-) diff --git a/docs/source/mat2x3.rst b/docs/source/mat2x3.rst index 433c637..06780d6 100644 --- a/docs/source/mat2x3.rst +++ b/docs/source/mat2x3.rst @@ -23,6 +23,16 @@ Functions: #. :c:func:`glm_mat2x3_transpose` #. :c:func:`glm_mat2x3_scale` +Represented +~~~~~~~~~~~ + +.. csv-table:: mat2x3 + :header: "", "column 1", "column 2" + + "row 1", "m00", "m10" + "row 2", "m01", "m11" + "row 3", "m02", "m12" + Functions documentation ~~~~~~~~~~~~~~~~~~~~~~~ @@ -51,28 +61,68 @@ Functions documentation | *[in]* **src** pointer to an array of floats | *[out]* **dest** destination matrix2x3 -.. c:function:: void glm_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat2 dest) +.. c:function:: void glm_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat3 dest) multiply m1 and m2 to dest .. code-block:: c - glm_mat2x3_mul(mat2x3, mat3x2, mat2); + glm_mat2x3_mul(mat2x3, mat3x2, mat3); Parameters: | *[in]* **m1** left matrix (mat2x3) | *[in]* **m2** right matrix (mat3x2) - | *[out]* **dest** destination matrix (mat2) + | *[out]* **dest** destination matrix (mat3) -.. c:function:: void glm_mat2x3_mulv(mat2x3 m, vec3 v, vec2 dest) + .. csv-table:: mat2x3 + :header: "", "column 1", "column 2" - multiply mat2x3 with vec3 (column vector) and store in dest vector + "row 1", "a00", "a10" + "row 2", "a01", "a11" + "row 3", "a02", "a12" + + .. csv-table:: mat3x2 + :header: "", "column 1", "column 2", "column 3" + + "row 1", "b00", "b10", "b20" + "row 2", "b01", "b11", "b21" + + .. csv-table:: mat3x3 + :header: "", "column 1", "column 2", "column 3" + + "row 1", "a00 * b00 + a10 * b01", "a00 * b10 + a10 * b11", "a00 * b20 + a10 * b21" + "row 2", "a01 * b00 + a11 * b01", "a01 * b10 + a11 * b11", "a01 * b20 + a11 * b21" + "row 3", "a02 * b00 + a12 * b01", "a02 * b10 + a12 * b11", "a02 * b20 + a12 * b21" + +.. c:function:: void glm_mat2x3_mulv(mat2x3 m, vec2 v, vec3 dest) + + multiply mat2x3 with vec2 (column vector) and store in dest column vector Parameters: | *[in]* **m** mat2x3 (left) | *[in]* **v** vec3 (right, column vector) | *[out]* **dest** destination (result, column vector) + .. csv-table:: mat2x3 + :header: "", "column 1", "column 2" + + "row 1", "m00", "m10" + "row 2", "m01", "m11" + "row 3", "m02", "m12" + + .. csv-table:: column vec2 (1x2) + :header: "", "column 1" + + "row 1", "v0" + "row 2", "v1" + + .. csv-table:: column vec3 (1x3) + :header: "", "column 1" + + "row 1", "m00 * v0 + m10 * v1" + "row 2", "m01 * v0 + m11 * v1" + "row 3", "m02 * v0 + m12 * v1" + .. c:function:: void glm_mat2x3_transpose(mat2x3 m, mat3x2 dest) transpose matrix and store in dest From 46864ba2f7aca5a0d2c130736415ebe4f3bd66f8 Mon Sep 17 00:00:00 2001 From: Vincent Davis Jr Date: Sat, 30 Mar 2024 17:44:28 -0400 Subject: [PATCH 05/29] mat2x4: fix multiplication functions Signed-off-by: Vincent Davis Jr --- include/cglm/call/mat2x4.h | 4 ++-- include/cglm/mat2x4.h | 46 +++++++++++++++++++++++++----------- include/cglm/struct/mat2x4.h | 14 +++++------ src/mat2x4.c | 4 ++-- test/src/test_mat2x4.h | 24 +++++++++---------- test/tests.h | 14 +++++------ 6 files changed, 62 insertions(+), 44 deletions(-) diff --git a/include/cglm/call/mat2x4.h b/include/cglm/call/mat2x4.h index b11fd0e..84e805b 100644 --- a/include/cglm/call/mat2x4.h +++ b/include/cglm/call/mat2x4.h @@ -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 diff --git a/include/cglm/mat2x4.h b/include/cglm/mat2x4.h index 9b1bd48..2fdda24 100644 --- a/include/cglm/mat2x4.h +++ b/include/cglm/mat2x4.h @@ -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,15 @@ 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, v1; - 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; + v0 = v[0], v1 = v[1]; + + 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; } /*! diff --git a/include/cglm/struct/mat2x4.h b/include/cglm/struct/mat2x4.h index fbb63e0..afeedc1 100644 --- a/include/cglm/struct/mat2x4.h +++ b/include/cglm/struct/mat2x4.h @@ -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; } diff --git a/src/mat2x4.c b/src/mat2x4.c index 73db032..a221ed3 100644 --- a/src/mat2x4.c +++ b/src/mat2x4.c @@ -28,13 +28,13 @@ 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) { glm_mat2x4_mul(m1, m2, dest); } CGLM_EXPORT void -glmc_mat2x4_mulv(mat2x4 m, vec4 v, vec2 dest) { +glmc_mat2x4_mulv(mat2x4 m, vec2 v, vec4 dest) { glm_mat2x4_mulv(m, v, dest); } diff --git a/test/src/test_mat2x4.h b/test/src/test_mat2x4.h index ea594d1..17ee35f 100644 --- a/test/src/test_mat2x4.h +++ b/test/src/test_mat2x4.h @@ -86,42 +86,42 @@ TEST_IMPL(GLM_PREFIX, mat2x4_mul) { mat2x4 m1 = GLM_MAT2X4_ZERO_INIT; mat4x2 m2 = GLM_MAT4X2_ZERO_INIT; - mat2 m3 = GLM_MAT2_ZERO_INIT; - mat2 m4 = GLM_MAT2_ZERO_INIT; + mat4 m3 = GLM_MAT4_ZERO_INIT; + mat4 m4 = GLM_MAT4_ZERO_INIT; - int i, j, k; + int c, r, k; /* test random matrices */ /* random matrices */ test_rand_mat2x4(m1); test_rand_mat4x2(m2); - for (i = 0; i < 2; i++) { - for (j = 0; j < 2; j++) { - for (k = 0; k < 4; k++) { - m4[i][j] += m1[i][k] * m2[k][j]; + for (r = 0; r < 4; r++) { + for (c = 0; c < 4; c++) { + for (k = 0; k < 2; k++) { + m4[c][r] += m1[k][r] * m2[c][k]; } } } GLM(mat2x4_mul)(m1, m2, m3); - ASSERTIFY(test_assert_mat2_eq(m3, m4)) + ASSERTIFY(test_assert_mat4_eq(m3, m4)) TEST_SUCCESS } TEST_IMPL(GLM_PREFIX, mat2x4_mulv) { mat2x4 mat = A_MATRIX2X4; - vec4 v = {11.0f, 21.0f, 31.0f, 41.0f}; + vec2 v = {11.0f, 21.0f}; int i; - vec2 dest; + vec4 dest; float res = 0.0; GLM(mat2x4_mulv)(mat, v, dest); - for (i = 0; i < 2; i++) { - res = mat[i][0] * v[0] + mat[i][1] * v[1] + mat[i][2] * v[2] + mat[i][3] * v[3]; + for (i = 0; i < 4; i++) { + res = mat[0][i] * v[0] + mat[1][i] * v[1]; ASSERT(test_eq(dest[i], res)) } diff --git a/test/tests.h b/test/tests.h index d85a155..bcb2fda 100644 --- a/test/tests.h +++ b/test/tests.h @@ -1494,13 +1494,13 @@ TEST_LIST { TEST_ENTRY(glm_mat2x4_transpose) TEST_ENTRY(glm_mat2x4_scale) - TEST_ENTRY(glm_mat2x4_copy) - TEST_ENTRY(glm_mat2x4_zero) - TEST_ENTRY(glm_mat2x4_make) - TEST_ENTRY(glm_mat2x4_mul) - TEST_ENTRY(glm_mat2x4_mulv) - TEST_ENTRY(glm_mat2x4_transpose) - TEST_ENTRY(glm_mat2x4_scale) + TEST_ENTRY(glmc_mat2x4_copy) + TEST_ENTRY(glmc_mat2x4_zero) + TEST_ENTRY(glmc_mat2x4_make) + TEST_ENTRY(glmc_mat2x4_mul) + TEST_ENTRY(glmc_mat2x4_mulv) + TEST_ENTRY(glmc_mat2x4_transpose) + TEST_ENTRY(glmc_mat2x4_scale) /* camera (incl [LR]H cross [NZ]O) */ TEST_ENTRY(glm_perspective_lh_zo) From 2283c708c6a0f2938a980bae5bff6489ae7efd9b Mon Sep 17 00:00:00 2001 From: Vincent Davis Jr Date: Sat, 30 Mar 2024 21:10:10 -0400 Subject: [PATCH 06/29] mat3x2: fix multiplication functions Signed-off-by: Vincent Davis Jr --- include/cglm/call/mat3x2.h | 4 ++-- include/cglm/mat3x2.h | 37 ++++++++++++++++-------------------- include/cglm/struct/mat3x2.h | 14 +++++++------- src/mat3x2.c | 4 ++-- test/src/test_mat3x2.h | 24 +++++++++++------------ 5 files changed, 39 insertions(+), 44 deletions(-) diff --git a/include/cglm/call/mat3x2.h b/include/cglm/call/mat3x2.h index 302ae93..3c0daed 100644 --- a/include/cglm/call/mat3x2.h +++ b/include/cglm/call/mat3x2.h @@ -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 diff --git a/include/cglm/mat3x2.h b/include/cglm/mat3x2.h index 0ed466f..6369131 100644 --- a/include/cglm/mat3x2.h +++ b/include/cglm/mat3x2.h @@ -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,13 @@ 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, v1, v2; - 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; + v0 = v[0], v1 = v[1], v2 = v[2]; + + 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; } /*! diff --git a/include/cglm/struct/mat3x2.h b/include/cglm/struct/mat3x2.h index e9d077b..a95d5e1 100644 --- a/include/cglm/struct/mat3x2.h +++ b/include/cglm/struct/mat3x2.h @@ -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; } diff --git a/src/mat3x2.c b/src/mat3x2.c index 8517a9e..5ade303 100644 --- a/src/mat3x2.c +++ b/src/mat3x2.c @@ -28,13 +28,13 @@ 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) { glm_mat3x2_mul(m1, m2, dest); } CGLM_EXPORT void -glmc_mat3x2_mulv(mat3x2 m, vec2 v, vec3 dest) { +glmc_mat3x2_mulv(mat3x2 m, vec3 v, vec2 dest) { glm_mat3x2_mulv(m, v, dest); } diff --git a/test/src/test_mat3x2.h b/test/src/test_mat3x2.h index a825a2b..397879b 100644 --- a/test/src/test_mat3x2.h +++ b/test/src/test_mat3x2.h @@ -84,40 +84,40 @@ TEST_IMPL(GLM_PREFIX, mat3x2_mul) { mat3x2 m1 = GLM_MAT3X2_ZERO_INIT; mat2x3 m2 = GLM_MAT2X3_ZERO_INIT; - mat3 m3 = GLM_MAT3_ZERO_INIT; - mat3 m4 = GLM_MAT3_ZERO_INIT; + mat2 m3 = GLM_MAT2_ZERO_INIT; + mat2 m4 = GLM_MAT2_ZERO_INIT; - int i, j, k; + int c, r, k; test_rand_mat3x2(m1); test_rand_mat2x3(m2); - for (i = 0; i < 3; i++) { - for (j = 0; j < 3; j++) { - for (k = 0; k < 2; k++) { - m4[i][j] += m1[i][k] * m2[k][j]; + for (r = 0; r < 2; r++) { + for (c = 0; c < 2; c++) { + for (k = 0; k < 3; k++) { + m4[c][r] += m1[k][r] * m2[c][k]; } } } GLM(mat3x2_mul)(m1, m2, m3); - ASSERTIFY(test_assert_mat3_eq(m3, m4)) + ASSERTIFY(test_assert_mat2_eq(m3, m4)) TEST_SUCCESS } TEST_IMPL(GLM_PREFIX, mat3x2_mulv) { mat3x2 mat = A_MATRIX3X2; - vec2 v = {11.0f, 21.0f}; + vec3 v = {11.0f, 21.0f, 31.0f}; int i; - vec3 dest; + vec2 dest; float res = 0.0; GLM(mat3x2_mulv)(mat, v, dest); - for (i = 0; i < 3; i++) { - res = mat[i][0] * v[0] + mat[i][1] * v[1]; + for (i = 0; i < 2; i++) { + res = mat[0][i] * v[0] + mat[1][i] * v[1] + mat[2][i] * v[2]; ASSERT(test_eq(dest[i], res)) } From 088c66029d198939c7c13433bd6050d5dae0ba12 Mon Sep 17 00:00:00 2001 From: Vincent Davis Jr Date: Sun, 31 Mar 2024 00:39:27 -0400 Subject: [PATCH 07/29] docs: mat3x2 account for latest mulitplication changes This also includes tables to explain how mat3x2, column vectors, and row vectors are represented. Also includes how resulting matrix or vector is formed. Signed-off-by: Vincent Davis Jr --- docs/source/mat3x2.rst | 57 ++++++++++++++++++++++++++++++++++++++---- 1 file changed, 52 insertions(+), 5 deletions(-) diff --git a/docs/source/mat3x2.rst b/docs/source/mat3x2.rst index 7290153..7604728 100644 --- a/docs/source/mat3x2.rst +++ b/docs/source/mat3x2.rst @@ -23,6 +23,15 @@ Functions: #. :c:func:`glm_mat3x2_transpose` #. :c:func:`glm_mat3x2_scale` +Represented +~~~~~~~~~~~ + +.. csv-table:: mat3x2 + :header: "", "column 1", "column 2", "column 3" + + "row 1", "m00", "m10", "m20" + "row 2", "m01", "m11", "m21" + Functions documentation ~~~~~~~~~~~~~~~~~~~~~~~ @@ -51,28 +60,66 @@ Functions documentation | *[in]* **src** pointer to an array of floats | *[out]* **dest** destination matrix3x2 -.. c:function:: void glm_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat3 dest) +.. c:function:: void glm_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat2 dest) multiply m1 and m2 to dest .. code-block:: c - glm_mat3x2_mul(mat3x2, mat2x3, mat3); + glm_mat3x2_mul(mat3x2, mat2x3, mat2); Parameters: | *[in]* **m1** left matrix (mat3x2) | *[in]* **m2** right matrix (mat2x3) - | *[out]* **dest** destination matrix (mat3) + | *[out]* **dest** destination matrix (mat2) -.. c:function:: void glm_mat3x2_mulv(mat3x2 m, vec2 v, vec3 dest) + .. csv-table:: mat3x2 + :header: "", "column 1", "column 2", "column 3" - multiply mat3x2 with vec2 (column vector) and store in dest vector + "row 1", "a00", "a10", "a20" + "row 2", "a01", "a11", "a21" + + .. csv-table:: mat2x3 + :header: "", "column 1", "column 2" + + "row 1", "b00", "b10" + "row 2", "b01", "b11" + "row 3", "b02", "b12" + + .. csv-table:: mat2x2 + :header: "", "column 1", "column 2" + + "row 1", "a00 * b00 + a10 * b01 + a20 * b02", "a00 * b10 + a10 * b11 + a20 * b12" + "row 2", "a01 * b00 + a11 * b01 + a21 * b02", "a01 * b10 + a11 * b11 + a21 * b12" + +.. c:function:: void glm_mat3x2_mulv(mat3x2 m, vec3 v, vec2 dest) + + multiply mat3x2 with vec3 (column vector) and store in dest vector Parameters: | *[in]* **m** mat3x2 (left) | *[in]* **v** vec3 (right, column vector) | *[out]* **dest** destination (result, column vector) + .. csv-table:: mat3x2 + :header: "", "column 1", "column 2", "column 3" + + "row 1", "m00", "m10", "m20" + "row 2", "m01", "m11", "m21" + + .. csv-table:: column vec3 (1x3) + :header: "", "column 1" + + "row 1", "v0" + "row 2", "v1" + "row 3", "v2" + + .. csv-table:: column vec2 (1x2) + :header: "", "column 1" + + "row 1", "m00 * v0 + m10 * v1 + m20 * v2" + "row 2", "m01 * v0 + m11 * v1 + m21 * v2" + .. c:function:: void glm_mat3x2_transpose(mat3x2 m, mat2x3 dest) transpose matrix and store in dest From 54dfbc5a286af0bf8296111e22b378daa40176fe Mon Sep 17 00:00:00 2001 From: Vincent Davis Jr Date: Sat, 30 Mar 2024 18:29:03 -0400 Subject: [PATCH 08/29] docs: mat2x4 account for latest mulitplication changes This also includes tables to explain how mat2x4, column vectors, and row vectors are represented. Also includes how resulting matrix or vector is formed. Signed-off-by: Vincent Davis Jr --- docs/source/mat2x4.rst | 67 ++++++++++++++++++++++++++++++++++++++---- 1 file changed, 61 insertions(+), 6 deletions(-) diff --git a/docs/source/mat2x4.rst b/docs/source/mat2x4.rst index 9a0445f..0acc643 100644 --- a/docs/source/mat2x4.rst +++ b/docs/source/mat2x4.rst @@ -23,6 +23,17 @@ Functions: #. :c:func:`glm_mat2x4_transpose` #. :c:func:`glm_mat2x4_scale` +Represented +~~~~~~~~~~~ + +.. csv-table:: mat2x4 + :header: "", "column 1", "column 2" + + "row 1", "m00", "m10" + "row 2", "m01", "m11" + "row 3", "m02", "m12" + "row 4", "m03", "m13" + Functions documentation ~~~~~~~~~~~~~~~~~~~~~~~ @@ -51,28 +62,72 @@ Functions documentation | *[in]* **src** pointer to an array of floats | *[out]* **dest** destination matrix2x4 -.. c:function:: void glm_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat2 dest) +.. c:function:: void glm_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat4 dest) multiply m1 and m2 to dest .. code-block:: c - glm_mat2x4_mul(mat2x4, mat4x2, mat2); + glm_mat2x4_mul(mat2x4, mat4x2, mat4); Parameters: | *[in]* **m1** left matrix (mat2x4) | *[in]* **m2** right matrix (mat4x2) - | *[out]* **dest** destination matrix (mat2) + | *[out]* **dest** destination matrix (mat4) -.. c:function:: void glm_mat2x4_mulv(mat2x4 m, vec4 v, vec2 dest) + .. csv-table:: mat2x4 + :header: "", "column 1", "column 2" - multiply mat2x4 with vec4 (column vector) and store in dest vector + "row 1", "a00", "a10" + "row 2", "a01", "a11" + "row 3", "a02", "a12" + "row 4", "a03", "a13" + + .. csv-table:: mat4x2 + :header: "", "column 1", "column 2", "column 3", "column 4" + + "row 1", "b00", "b10", "b20", "b30" + "row 2", "b01", "b11", "b21", "b31" + + .. csv-table:: mat4x4 + :header: "", "column 1", "column 2", "column 3", "column 4" + + "row 1", "a00 * b00 + a10 * b01", "a00 * b10 + a10 * b11", "a00 * b20 + a10 * b21", "a00 * b30 + a10 * b31" + "row 2", "a01 * b00 + a11 * b01", "a01 * b10 + a11 * b11", "a01 * b20 + a11 * b21", "a01 * b30 + a11 * b31" + "row 3", "a02 * b00 + a12 * b01", "a02 * b10 + a12 * b11", "a02 * b20 + a12 * b21", "a02 * b30 + a12 * b31" + "row 4", "a03 * b00 + a13 * b01", "a03 * b10 + a13 * b11", "a03 * b20 + a13 * b21", "a03 * b30 + a13 * b31" + +.. c:function:: void glm_mat2x4_mulv(mat2x4 m, vec2 v, vec4 dest) + + multiply mat2x4 with vec2 (column vector) and store in dest column vector Parameters: | *[in]* **m** mat2x4 (left) - | *[in]* **v** vec4 (right, column vector) + | *[in]* **v** vec2 (right, column vector) | *[out]* **dest** destination (result, column vector) + .. csv-table:: mat2x4 + :header: "", "column 1", "column 2" + + "row 1", "m00", "m10" + "row 2", "m01", "m11" + "row 3", "m02", "m12" + "row 4", "m03", "m13" + + .. csv-table:: column vec2 (1x2) + :header: "", "column 1" + + "row 1", "v0" + "row 2", "v1" + + .. csv-table:: column vec4 (1x4) + :header: "", "column 1" + + "row 1", "m00 * v0 + m10 * v1" + "row 2", "m01 * v0 + m11 * v1" + "row 3", "m02 * v0 + m12 * v1" + "row 4", "m03 * v0 + m13 * v1" + .. c:function:: void glm_mat2x4_transpose(mat2x4 m, mat4x2 dest) transpose matrix and store in dest From bf4c5b4e266e342f2831a10c815449a546863dc6 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Sun, 31 Mar 2024 13:24:50 +0300 Subject: [PATCH 09/29] dont use I macro defined in standard --- include/cglm/struct/vec3.h | 18 +++++++++--------- test/src/test_vec2.h | 14 +++++++------- test/src/test_vec3.h | 20 ++++++++++---------- test/src/test_vec4.h | 14 +++++++------- 4 files changed, 33 insertions(+), 33 deletions(-) diff --git a/include/cglm/struct/vec3.h b/include/cglm/struct/vec3.h index b7ce133..536af03 100644 --- a/include/cglm/struct/vec3.h +++ b/include/cglm/struct/vec3.h @@ -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; } @@ -1126,8 +1126,8 @@ glms_vec3_(reflect)(vec3s v, 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 v, 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 */ diff --git a/test/src/test_vec2.h b/test/src/test_vec2.h index d45962d..8fd16b5 100644 --- a/test/src/test_vec2.h +++ b/test/src/test_vec2.h @@ -781,15 +781,15 @@ TEST_IMPL(GLM_PREFIX, vec2_reflect) { } TEST_IMPL(GLM_PREFIX, vec2_refract) { - vec2 I = {sqrtf(0.5f), -sqrtf(0.5f)}; /* Incoming vector at 45 degrees to normal */ - vec2 N = {0.0f, 1.0f}; /* Surface normal */ - vec2 dest; + vec2 v = {sqrtf(0.5f), -sqrtf(0.5f)}; /* Incoming vector at 45 degrees to normal */ + vec2 N = {0.0f, 1.0f}; /* Surface normal */ + vec2 dest; float eta; float r; /* Water to Air (eta = 1.33/1.0) */ eta = 1.33f / 1.0f; - r = GLM(vec2_refract)(I, N, eta, dest); + r = GLM(vec2_refract)(v, N, eta, dest); // In 2D, we expect a similar bending behavior as in 3D, so we check dest[1] if (!(dest[0] == 0.0f && dest[1] == 0.0f)) { ASSERT(dest[1] < -sqrtf(0.5f)); // Refracted ray bends away from the normal @@ -801,17 +801,17 @@ TEST_IMPL(GLM_PREFIX, vec2_refract) { /* Air to Glass (eta = 1.0 / 1.5) */ eta = 1.0f / 1.5f; - r = GLM(vec2_refract)(I, N, eta, dest); + r = GLM(vec2_refract)(v, N, eta, dest); ASSERT(dest[1] < -sqrtf(0.5f)); // Expect bending towards the normal /* Glass to Water (eta = 1.5 / 1.33) */ eta = 1.5f / 1.33f; - r = GLM(vec2_refract)(I, N, eta, dest); + r = GLM(vec2_refract)(v, N, eta, dest); ASSERT(dest[1] < -sqrtf(0.5f)); // Expect bending towards the normal, less bending than air to glass /* Diamond to Air (eta = 2.42 / 1.0) */ eta = 2.42f / 1.0f; - r = GLM(vec2_refract)(I, N, eta, dest); + r = GLM(vec2_refract)(v, N, eta, dest); if (!(dest[0] == 0.0f && dest[1] == 0.0f)) { /* High potential for total internal reflection, but if it occurs, expect significant bending */ ASSERT(dest[1] < -sqrtf(0.5f)); diff --git a/test/src/test_vec3.h b/test/src/test_vec3.h index 33f746b..2fffecd 100644 --- a/test/src/test_vec3.h +++ b/test/src/test_vec3.h @@ -1843,12 +1843,12 @@ TEST_IMPL(GLM_PREFIX, vec3_make) { TEST_IMPL(GLM_PREFIX, vec3_faceforward) { vec3 N = {0.0f, 1.0f, 0.0f}; - vec3 I = {1.0f, -1.0f, 0.0f}; + vec3 v = {1.0f, -1.0f, 0.0f}; vec3 Nref = {0.0f, -1.0f, 0.0f}; vec3 dest; - GLM(vec3_faceforward)(N, I, Nref, dest); - ASSERT(dest[0] == 0.0f + GLM(vec3_faceforward)(N, v, Nref, dest); + ASSERT(dest[0] == 0.0f && dest[1] == -1.0f && dest[2] == 0.0f); /* Expect N flipped */ @@ -1886,15 +1886,15 @@ TEST_IMPL(GLM_PREFIX, vec3_reflect) { } TEST_IMPL(GLM_PREFIX, vec3_refract) { - vec3 I = {sqrtf(0.5f), -sqrtf(0.5f), 0.0f}; /* Incoming vector at 45 degrees to normal */ - vec3 N = {0.0f, 1.0f, 0.0f}; /* Surface normal */ - vec3 dest; + vec3 v = {sqrtf(0.5f), -sqrtf(0.5f), 0.0f}; /* Incoming vector at 45 degrees to normal */ + vec3 N = {0.0f, 1.0f, 0.0f}; /* Surface normal */ + vec3 dest; float eta; bool r; /* Water to Air (eta = 1.33/1.0) */ eta = 1.33f / 1.0f; - r = GLM(vec3_refract)(I, N, eta, dest); + r = GLM(vec3_refract)(v, N, eta, dest); if (!(dest[0] == 0.0f && dest[1] == 0.0f && dest[2] == 0.0f)) { ASSERT(dest[1] < -sqrtf(0.5f)); ASSERT(r == true); @@ -1905,21 +1905,21 @@ TEST_IMPL(GLM_PREFIX, vec3_refract) { /* Air to Glass (eta = 1.0 / 1.5) */ eta = 1.0f / 1.5f; - r = GLM(vec3_refract)(I, N, eta, dest); + r = GLM(vec3_refract)(v, N, eta, dest); /* Expect bending towards the normal */ ASSERT(dest[1] < -sqrtf(0.5f)); /* Glass to Water (eta = 1.5 / 1.33) */ eta = 1.5f / 1.33f; - r = GLM(vec3_refract)(I, N, eta, dest); + r = GLM(vec3_refract)(v, N, eta, dest); /* Expect bending towards the normal, less bending than air to glass */ ASSERT(dest[1] < -sqrtf(0.5f)); /* Diamond to Air (eta = 2.42 / 1.0) */ eta = 2.42f / 1.0f; - r = GLM(vec3_refract)(I, N, eta, dest); + r = GLM(vec3_refract)(v, N, eta, dest); if (!(dest[0] == 0.0f && dest[1] == 0.0f && dest[2] == 0.0f)) { /* High potential for total internal reflection, but if it occurs, expect significant bending */ ASSERT(dest[1] < -sqrtf(0.5f)); diff --git a/test/src/test_vec4.h b/test/src/test_vec4.h index 3523420..d95815a 100644 --- a/test/src/test_vec4.h +++ b/test/src/test_vec4.h @@ -1571,15 +1571,15 @@ TEST_IMPL(GLM_PREFIX, vec4_reflect) { } TEST_IMPL(GLM_PREFIX, vec4_refract) { - vec4 I = {sqrtf(0.5f), -sqrtf(0.5f), 0.0f, 0.0f}; /* Incoming vector */ - vec4 N = {0.0f, 1.0f, 0.0f, 0.0f}; /* Surface normal */ - vec4 dest; + vec4 v = {sqrtf(0.5f), -sqrtf(0.5f), 0.0f, 0.0f}; /* Incoming vector */ + vec4 N = {0.0f, 1.0f, 0.0f, 0.0f}; /* Surface normal */ + vec4 dest; float eta; float r; /* Water to Air (eta = 1.33/1.0) */ eta = 1.33f / 1.0f; - r = GLM(vec4_refract)(I, N, eta, dest); + r = GLM(vec4_refract)(v, N, eta, dest); if (!(dest[0] == 0.0f && dest[1] == 0.0f && dest[2] == 0.0f && dest[3] == 0.0f)) { ASSERT(dest[1] < -sqrtf(0.5f)); ASSERT(r == true); @@ -1590,17 +1590,17 @@ TEST_IMPL(GLM_PREFIX, vec4_refract) { /* Air to Glass (eta = 1.0 / 1.5) */ eta = 1.0f / 1.5f; - r = GLM(vec4_refract)(I, N, eta, dest); + r = GLM(vec4_refract)(v, N, eta, dest); ASSERT(dest[1] < -sqrtf(0.5f)); // Expect bending towards the normal /* Glass to Water (eta = 1.5 / 1.33) */ eta = 1.5f / 1.33f; - r = GLM(vec4_refract)(I, N, eta, dest); + r = GLM(vec4_refract)(v, N, eta, dest); ASSERT(dest[1] < -sqrtf(0.5f)); // Expect bending towards the normal, less bending than air to glass /* Diamond to Air (eta = 2.42 / 1.0) */ eta = 2.42f / 1.0f; - r = GLM(vec4_refract)(I, N, eta, dest); + r = GLM(vec4_refract)(v, N, eta, dest); if (!(dest[0] == 0.0f && dest[1] == 0.0f && dest[2] == 0.0f && dest[3] == 0.0f)) { /* High potential for total internal reflection, but if it occurs, expect significant bending */ ASSERT(dest[1] < -sqrtf(0.5f)); From d2642eb206e8a4d8207f7d9b2eea5195035851aa Mon Sep 17 00:00:00 2001 From: Vincent Davis Jr Date: Sun, 31 Mar 2024 12:20:02 -0400 Subject: [PATCH 10/29] docs: expand wy-nav-content width to edge of screen RTD theme's default is 800px as max width for the content, but we have tables with tons of columns, which need the full width of the view-port. Comment from yocto project theme_overrides.css Signed-off-by: Vincent Davis Jr --- docs/source/conf.py | 6 +++++- docs/source/sphinx-static/theme_overrides.css | 12 ++++++++++++ 2 files changed, 17 insertions(+), 1 deletion(-) create mode 100644 docs/source/sphinx-static/theme_overrides.css diff --git a/docs/source/conf.py b/docs/source/conf.py index bf1251e..f0bc903 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -91,6 +91,7 @@ todo_include_todos = False # a list of builtin themes. # html_theme = 'sphinx_rtd_theme' +pygments_style = 'monokai' # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the @@ -111,8 +112,11 @@ html_theme_options = { # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". -# html_static_path = ['_static'] +html_static_path = ['sphinx-static'] +# Add customm CSS and JS files +html_css_files = ['theme_overrides.css'] +html_js_files = [] # -- Options for HTMLHelp output ------------------------------------------ diff --git a/docs/source/sphinx-static/theme_overrides.css b/docs/source/sphinx-static/theme_overrides.css new file mode 100644 index 0000000..0952e2c --- /dev/null +++ b/docs/source/sphinx-static/theme_overrides.css @@ -0,0 +1,12 @@ +@media screen { + /* content column + * + * RTD theme's default is 800px as max width for the content, but we have + * tables with tons of columns, which need the full width of the view-port. + * + * Comment from yocto project theme_overrides.css + */ + + .wy-nav-content{ max-width: none; } + +} From 3445f93fbcefe90282d3e5e7e0ae760d9c5a51e7 Mon Sep 17 00:00:00 2001 From: Vincent Davis Jr Date: Sun, 31 Mar 2024 13:09:02 -0400 Subject: [PATCH 11/29] mat4x2: fix multiplication functions Signed-off-by: Vincent Davis Jr --- include/cglm/call/mat4x2.h | 4 ++-- include/cglm/mat4x2.h | 44 ++++++++++++------------------------ include/cglm/struct/mat4x2.h | 20 ++++++++-------- src/mat4x2.c | 4 ++-- test/src/test_mat4x2.h | 24 ++++++++++---------- 5 files changed, 40 insertions(+), 56 deletions(-) diff --git a/include/cglm/call/mat4x2.h b/include/cglm/call/mat4x2.h index b60125d..2989124 100644 --- a/include/cglm/call/mat4x2.h +++ b/include/cglm/call/mat4x2.h @@ -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 diff --git a/include/cglm/mat4x2.h b/include/cglm/mat4x2.h index b1784d4..d3f0ad5 100644 --- a/include/cglm/mat4x2.h +++ b/include/cglm/mat4x2.h @@ -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; } /*! diff --git a/include/cglm/struct/mat4x2.h b/include/cglm/struct/mat4x2.h index 3a0db6f..17589bc 100644 --- a/include/cglm/struct/mat4x2.h +++ b/include/cglm/struct/mat4x2.h @@ -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; } diff --git a/src/mat4x2.c b/src/mat4x2.c index 2edd2e0..32015f2 100644 --- a/src/mat4x2.c +++ b/src/mat4x2.c @@ -28,13 +28,13 @@ 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) { glm_mat4x2_mul(m1, m2, dest); } CGLM_EXPORT void -glmc_mat4x2_mulv(mat4x2 m, vec2 v, vec4 dest) { +glmc_mat4x2_mulv(mat4x2 m, vec4 v, vec2 dest) { glm_mat4x2_mulv(m, v, dest); } diff --git a/test/src/test_mat4x2.h b/test/src/test_mat4x2.h index fd1ac48..b58d974 100644 --- a/test/src/test_mat4x2.h +++ b/test/src/test_mat4x2.h @@ -87,40 +87,40 @@ TEST_IMPL(GLM_PREFIX, mat4x2_mul) { mat4x2 m1 = GLM_MAT4X2_ZERO_INIT; mat2x4 m2 = GLM_MAT2X4_ZERO_INIT; - mat4 m3 = GLM_MAT4_ZERO_INIT; - mat4 m4 = GLM_MAT4_ZERO_INIT; + mat2 m3 = GLM_MAT2_ZERO_INIT; + mat2 m4 = GLM_MAT2_ZERO_INIT; - int i, j, k; + int c, r, k; test_rand_mat4x2(m1); test_rand_mat2x4(m2); - for (i = 0; i < 4; i++) { - for (j = 0; j < 4; j++) { - for (k = 0; k < 2; k++) { - m4[i][j] += m1[i][k] * m2[k][j]; + for (r = 0; r < 2; r++) { + for (c = 0; c < 2; c++) { + for (k = 0; k < 4; k++) { + m4[c][r] += m1[k][r] * m2[c][k]; } } } GLM(mat4x2_mul)(m1, m2, m3); - ASSERTIFY(test_assert_mat4_eq(m3, m4)) + ASSERTIFY(test_assert_mat2_eq(m3, m4)) TEST_SUCCESS } TEST_IMPL(GLM_PREFIX, mat4x2_mulv) { mat4x2 mat = A_MATRIX4X2; - vec2 v = {11.0f, 21.0f}; + vec4 v = {11.0f, 21.0f, 31.0f, 41.0f}; int i; - vec4 dest; + vec2 dest; float res = 0.0; GLM(mat4x2_mulv)(mat, v, dest); - for (i = 0; i < 4; i++) { - res = mat[i][0] * v[0] + mat[i][1] * v[1]; + for (i = 0; i < 2; i++) { + res = mat[0][i] * v[0] + mat[1][i] * v[1] + mat[2][i] * v[2] + mat[3][i] * v[3]; ASSERT(test_eq(dest[i], res)) } From 85165dd3e3c286336c9cef15720626424e68fd06 Mon Sep 17 00:00:00 2001 From: Vincent Davis Jr Date: Sun, 31 Mar 2024 13:33:33 -0400 Subject: [PATCH 12/29] docs: mat4x2 account for latest mulitplication changes This also includes tables to explain how mat4x2, column vectors, and row vectors are represented. Also includes how resulting matrix or vector is formed. Signed-off-by: Vincent Davis Jr --- docs/source/mat4x2.rst | 63 ++++++++++++++++++++++++++++++++++++++---- 1 file changed, 57 insertions(+), 6 deletions(-) diff --git a/docs/source/mat4x2.rst b/docs/source/mat4x2.rst index 4b7f291..35ab2b8 100644 --- a/docs/source/mat4x2.rst +++ b/docs/source/mat4x2.rst @@ -23,6 +23,15 @@ Functions: #. :c:func:`glm_mat4x2_transpose` #. :c:func:`glm_mat4x2_scale` +Represented +~~~~~~~~~~~ + +.. csv-table:: mat4x2 + :header: "", "column 1", "column 2", "column 3", "column4" + + "row 1", "m00", "m10", "m20", "m30" + "row 2", "m01", "m11", "m21", "m31" + Functions documentation ~~~~~~~~~~~~~~~~~~~~~~~ @@ -51,28 +60,70 @@ Functions documentation | *[in]* **src** pointer to an array of floats | *[out]* **dest** destination matrix4x2 -.. c:function:: void glm_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat4 dest) +.. c:function:: void glm_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat2 dest) multiply m1 and m2 to dest .. code-block:: c - glm_mat4x2_mul(mat4x2, mat2x4, mat4); + glm_mat4x2_mul(mat4x2, mat2x4, mat2); Parameters: | *[in]* **m1** left matrix (mat4x2) | *[in]* **m2** right matrix (mat2x4) - | *[out]* **dest** destination matrix (mat4) + | *[out]* **dest** destination matrix (mat2) -.. c:function:: void glm_mat4x2_mulv(mat4x2 m, vec2 v, vec4 dest) + .. csv-table:: mat4x2 + :header: "", "column 1", "column 2", "column 3", "column 4" - multiply mat4x2 with vec2 (column vector) and store in dest vector + "row 1", "a00", "a10", "a20", "a30" + "row 2", "a01", "a11", "a21", "a31" + + .. csv-table:: mat2x4 + :header: "", "column 1", "column 2" + + "row 1", "b00", "b10" + "row 2", "b01", "b11" + "row 3", "b02", "b12" + "row 4", "b03", "b13" + + .. csv-table:: mat2x2 + :header: "", "column 1", "column 2" + + "row 1", "a00 * b00 + a10 * b01 + a20 * b02 + a30 * b03", "a00 * b10 + a10 * b11 + a20 * b12 + a30 * b13" + "row 2", "a01 * b00 + a11 * b01 + a21 * b02 + a31 * b03", "a01 * b10 + a11 * b11 + a21 * b12 + a31 * b13" + +.. c:function:: void glm_mat4x2_mulv(mat4x2 m, vec4 v, vec2 dest) + + multiply mat4x2 with vec4 (column vector) and store in dest vector Parameters: | *[in]* **m** mat4x2 (left) - | *[in]* **v** vec2 (right, column vector) + | *[in]* **v** vec4 (right, column vector) | *[out]* **dest** destination (result, column vector) + .. csv-table:: mat4x2 + :header: "", "column 1", "column 2", "column 3" + + "row 1", "m00", "m10", "m20" + "row 2", "m01", "m11", "m21" + "row 3", "m02", "m12", "m22" + "row 4", "m03", "m13", "m23" + + .. csv-table:: column vec4 (1x4) + :header: "", "column 1" + + "row 1", "v0" + "row 2", "v1" + "row 3", "v2" + "row 4", "v3" + + .. csv-table:: column vec2 (1x2) + :header: "", "column 1" + + "row 1", "m00 * v0 + m10 * v1 + m20 * v2 + m30 * v3" + "row 2", "m01 * v0 + m11 * v1 + m21 * v2 + m31 * v3" + .. c:function:: void glm_mat4x2_transpose(mat4x2 m, mat2x4 dest) transpose matrix and store in dest From 1340b5d512fb3667c676080ba17070f203f79f51 Mon Sep 17 00:00:00 2001 From: Vincent Davis Jr Date: Sun, 31 Mar 2024 01:48:50 -0400 Subject: [PATCH 13/29] mat3x4: fix multiplication functions Signed-off-by: Vincent Davis Jr --- include/cglm/call/mat3x4.h | 4 +-- include/cglm/mat3x4.h | 56 ++++++++++++++++++++---------------- include/cglm/struct/mat3x4.h | 20 ++++++------- src/mat3x4.c | 4 +-- test/src/test_mat3x4.h | 24 ++++++++-------- 5 files changed, 58 insertions(+), 50 deletions(-) diff --git a/include/cglm/call/mat3x4.h b/include/cglm/call/mat3x4.h index 5339e16..ff23b4c 100644 --- a/include/cglm/call/mat3x4.h +++ b/include/cglm/call/mat3x4.h @@ -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 diff --git a/include/cglm/mat3x4.h b/include/cglm/mat3x4.h index aec4295..8d14523 100644 --- a/include/cglm/mat3x4.h +++ b/include/cglm/mat3x4.h @@ -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 diff --git a/include/cglm/struct/mat3x4.h b/include/cglm/struct/mat3x4.h index 29dd870..ee688f0 100644 --- a/include/cglm/struct/mat3x4.h +++ b/include/cglm/struct/mat3x4.h @@ -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; } diff --git a/src/mat3x4.c b/src/mat3x4.c index efc9062..75963c9 100644 --- a/src/mat3x4.c +++ b/src/mat3x4.c @@ -28,13 +28,13 @@ 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) { glm_mat3x4_mul(m1, m2, dest); } CGLM_EXPORT void -glmc_mat3x4_mulv(mat3x4 m, vec4 v, vec3 dest) { +glmc_mat3x4_mulv(mat3x4 m, vec3 v, vec4 dest) { glm_mat3x4_mulv(m, v, dest); } diff --git a/test/src/test_mat3x4.h b/test/src/test_mat3x4.h index c7d704c..16520ac 100644 --- a/test/src/test_mat3x4.h +++ b/test/src/test_mat3x4.h @@ -90,40 +90,40 @@ TEST_IMPL(GLM_PREFIX, mat3x4_mul) { mat3x4 m1 = GLM_MAT3X4_ZERO_INIT; mat4x3 m2 = GLM_MAT4X3_ZERO_INIT; - mat3 m3 = GLM_MAT3_ZERO_INIT; - mat3 m4 = GLM_MAT3_ZERO_INIT; + mat4 m3 = GLM_MAT4_ZERO_INIT; + mat4 m4 = GLM_MAT4_ZERO_INIT; - int i, j, k; + int c, r, k; test_rand_mat3x4(m1); test_rand_mat4x3(m2); - for (i = 0; i < 3; i++) { - for (j = 0; j < 3; j++) { - for (k = 0; k < 4; k++) { - m4[i][j] += m1[i][k] * m2[k][j]; + for (r = 0; r < 4; r++) { + for (c = 0; c < 4; c++) { + for (k = 0; k < 3; k++) { + m4[c][r] += m1[k][r] * m2[c][k]; } } } GLM(mat3x4_mul)(m1, m2, m3); - ASSERTIFY(test_assert_mat3_eq(m3, m4)) + ASSERTIFY(test_assert_mat4_eq(m3, m4)) TEST_SUCCESS } TEST_IMPL(GLM_PREFIX, mat3x4_mulv) { mat3x4 mat = A_MATRIX3X4; - vec4 v = {11.0f, 21.0f, 31.0f, 41.0f}; + vec4 v = {11.0f, 21.0f, 31.0f}; int i; - vec3 dest; + vec4 dest; float res = 0.0; GLM(mat3x4_mulv)(mat, v, dest); - for (i = 0; i < 3; i++) { - res = mat[i][0] * v[0] + mat[i][1] * v[1] + mat[i][2] * v[2]; + for (i = 0; i < 4; i++) { + res = mat[0][i] * v[0] + mat[1][i] * v[1] + mat[2][i] * v[2]; ASSERT(test_eq(dest[i], res)) } From fc7f0e13fd71e3e978fcab3eb56764e3ffebddf4 Mon Sep 17 00:00:00 2001 From: Vincent Davis Jr Date: Sun, 31 Mar 2024 02:07:21 -0400 Subject: [PATCH 14/29] docs: mat3x4 account for latest mulitplication changes This also includes tables to explain how mat3x4, column vectors, and row vectors are represented. Also includes how resulting matrix or vector is formed. Signed-off-by: Vincent Davis Jr --- docs/source/mat3x4.rst | 69 ++++++++++++++++++++++++++++++++++++++---- 1 file changed, 63 insertions(+), 6 deletions(-) diff --git a/docs/source/mat3x4.rst b/docs/source/mat3x4.rst index 9c23d06..cddce47 100644 --- a/docs/source/mat3x4.rst +++ b/docs/source/mat3x4.rst @@ -23,6 +23,17 @@ Functions: #. :c:func:`glm_mat3x4_transpose` #. :c:func:`glm_mat3x4_scale` +Represented +~~~~~~~~~~~ + +.. csv-table:: mat3x4 + :header: "", "column 1", "column 2", "column 3" + + "row 1", "m00", "m10", "m20" + "row 2", "m01", "m11", "m21" + "row 3", "m02", "m12", "m22" + "row 4", "m03", "m13", "m23" + Functions documentation ~~~~~~~~~~~~~~~~~~~~~~~ @@ -51,28 +62,74 @@ Functions documentation | *[in]* **src** pointer to an array of floats | *[out]* **dest** destination matrix3x4 -.. c:function:: void glm_mat3x4_mul(mat3x4 m1, mat4x3 m2, mat3 dest) +.. c:function:: void glm_mat3x4_mul(mat3x4 m1, mat4x3 m2, mat4 dest) multiply m1 and m2 to dest .. code-block:: c - glm_mat3x4_mul(mat3x4, mat4x3, mat3); + glm_mat3x4_mul(mat3x4, mat4x3, mat4); Parameters: | *[in]* **m1** left matrix (mat3x4) | *[in]* **m2** right matrix (mat4x3) - | *[out]* **dest** destination matrix (mat3) + | *[out]* **dest** destination matrix (mat4) -.. c:function:: void glm_mat3x4_mulv(mat3x4 m, vec4 v, vec3 dest) + .. csv-table:: mat3x4 + :header: "", "column 1", "column 2", "column 3" - multiply mat3x4 with vec4 (column vector) and store in dest vector + "row 1", "a00", "a10", "a20" + "row 2", "a01", "a11", "a21" + "row 3", "a02", "a12", "a22" + "row 4", "a03", "a13", "a23" + + .. csv-table:: mat4x3 + :header: "", "column 1", "column 2", "column 3", "column 4" + + "row 1", "b00", "b10", "b20", "b30" + "row 2", "b01", "b11", "b21", "b31" + "row 3", "b02", "b12", "b22", "b32" + + .. csv-table:: mat4x4 + :header: "", "column 1", "column 2", "column 3", "column 4" + + "row 1", "a00 * b00 + a10 * b01 + a20 * b02", "a00 * b10 + a10 * b11 + a20 * b12", "a00 * b20 + a10 * b21 + a20 * b22", "a00 * b30 + a10 * b31 + a20 * b32" + "row 2", "a01 * b00 + a11 * b01 + a21 * b02", "a01 * b10 + a11 * b11 + a21 * b12", "a01 * b20 + a11 * b21 + a21 * b22", "a01 * b30 + a11 * b31 + a21 * b32" + "row 3", "a02 * b00 + a12 * b01 + a22 * b02", "a02 * b10 + a12 * b11 + a22 * b12", "a02 * b20 + a12 * b21 + a22 * b22", "a02 * b30 + a12 * b31 + a22 * b32" + "row 4", "a03 * b00 + a13 * b01 + a23 * b02", "a03 * b10 + a13 * b11 + a23 * b12", "a03 * b20 + a13 * b21 + a23 * b22", "a03 * b30 + a13 * b31 + a23 * b32" + +.. c:function:: void glm_mat3x4_mulv(mat3x4 m, vec3 v, vec4 dest) + + multiply mat3x4 with vec3 (column vector) and store in dest vector Parameters: | *[in]* **m** mat3x4 (left) - | *[in]* **v** vec4 (right, column vector) + | *[in]* **v** vec3 (right, column vector) | *[out]* **dest** destination (result, column vector) + .. csv-table:: mat3x4 + :header: "", "column 1", "column 2", "column 3" + + "row 1", "m00", "m10", "m20" + "row 2", "m01", "m11", "m21" + "row 3", "m02", "m12", "m22" + "row 4", "m03", "m13", "m23" + + .. csv-table:: column vec3 (1x3) + :header: "", "column 1" + + "row 1", "v0" + "row 2", "v1" + "row 3", "v2" + + .. csv-table:: column vec4 (1x4) + :header: "", "column 1" + + "row 1", "m00 * v0 + m10 * v1 + m20 * v2" + "row 2", "m01 * v0 + m11 * v1 + m21 * v2" + "row 3", "m02 * v0 + m12 * v1 + m22 * v2" + "row 4", "m03 * v0 + m13 * v1 + m23 * v2" + .. c:function:: void glm_mat3x4_transpose(mat3x4 m, mat4x3 dest) transpose matrix and store in dest From a0e3d3766fe191eef43115f3acf58af4e95d1041 Mon Sep 17 00:00:00 2001 From: Vincent Davis Jr Date: Sun, 31 Mar 2024 14:14:35 -0400 Subject: [PATCH 15/29] mat4x3: fix multiplication functions Signed-off-by: Vincent Davis Jr --- include/cglm/call/mat4x3.h | 4 +-- include/cglm/mat4x3.h | 49 +++++++++++++++--------------------- include/cglm/struct/mat4x3.h | 18 ++++++------- src/mat4x3.c | 4 +-- test/src/test_mat4x3.h | 24 +++++++++--------- 5 files changed, 45 insertions(+), 54 deletions(-) diff --git a/include/cglm/call/mat4x3.h b/include/cglm/call/mat4x3.h index 131cf51..bb5c0a8 100644 --- a/include/cglm/call/mat4x3.h +++ b/include/cglm/call/mat4x3.h @@ -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 diff --git a/include/cglm/mat4x3.h b/include/cglm/mat4x3.h index 4266278..2ef05c1 100644 --- a/include/cglm/mat4x3.h +++ b/include/cglm/mat4x3.h @@ -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; } /*! diff --git a/include/cglm/struct/mat4x3.h b/include/cglm/struct/mat4x3.h index f2cc7bb..37a68e1 100644 --- a/include/cglm/struct/mat4x3.h +++ b/include/cglm/struct/mat4x3.h @@ -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; } diff --git a/src/mat4x3.c b/src/mat4x3.c index a50b983..8285424 100644 --- a/src/mat4x3.c +++ b/src/mat4x3.c @@ -28,13 +28,13 @@ 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) { glm_mat4x3_mul(m1, m2, dest); } CGLM_EXPORT void -glmc_mat4x3_mulv(mat4x3 m, vec3 v, vec4 dest) { +glmc_mat4x3_mulv(mat4x3 m, vec4 v, vec3 dest) { glm_mat4x3_mulv(m, v, dest); } diff --git a/test/src/test_mat4x3.h b/test/src/test_mat4x3.h index b760405..dc7c28e 100644 --- a/test/src/test_mat4x3.h +++ b/test/src/test_mat4x3.h @@ -91,40 +91,40 @@ TEST_IMPL(GLM_PREFIX, mat4x3_mul) { mat4x3 m1 = GLM_MAT4X3_ZERO_INIT; mat3x4 m2 = GLM_MAT3X4_ZERO_INIT; - mat4 m3 = GLM_MAT4_ZERO_INIT; - mat4 m4 = GLM_MAT4_ZERO_INIT; + mat3 m3 = GLM_MAT3_ZERO_INIT; + mat3 m4 = GLM_MAT3_ZERO_INIT; - int i, j, k; + int c, r, k; test_rand_mat4x3(m1); test_rand_mat3x4(m2); - for (i = 0; i < 4; i++) { - for (j = 0; j < 4; j++) { - for (k = 0; k < 3; k++) { - m4[i][j] += m1[i][k] * m2[k][j]; + for (r = 0; r < 3; r++) { + for (c = 0; c < 3; c++) { + for (k = 0; k < 4; k++) { + m4[c][r] += m1[k][r] * m2[c][k]; } } } GLM(mat4x3_mul)(m1, m2, m3); - ASSERTIFY(test_assert_mat4_eq(m3, m4)) + ASSERTIFY(test_assert_mat3_eq(m3, m4)) TEST_SUCCESS } TEST_IMPL(GLM_PREFIX, mat4x3_mulv) { mat4x3 mat = A_MATRIX4X3; - vec3 v = {11.0f, 21.0f, 31.0f}; + vec4 v = {11.0f, 21.0f, 31.0f, 41.0f}; int i; - vec4 dest; + vec3 dest; float res = 0.0; GLM(mat4x3_mulv)(mat, v, dest); - for (i = 0; i < 4; i++) { - res = mat[i][0] * v[0] + mat[i][1] * v[1] + mat[i][2] * v[2]; + for (i = 0; i < 3; i++) { + res = mat[0][i] * v[0] + mat[1][i] * v[1] + mat[2][i] * v[2] + mat[3][i] * v[3]; ASSERT(test_eq(dest[i], res)) } From 013ac5dd07f7c5aa851d4a0d8f7c0c49ac30c9ce Mon Sep 17 00:00:00 2001 From: Vincent Davis Jr Date: Sun, 31 Mar 2024 14:36:38 -0400 Subject: [PATCH 16/29] docs: mat4x3 account for latest mulitplication changes This also includes tables to explain how mat4x3, column vectors, and row vectors are represented. Also includes how resulting matrix or vector is formed. Signed-off-by: Vincent Davis Jr --- docs/source/mat4x3.rst | 66 ++++++++++++++++++++++++++++++++++++++---- 1 file changed, 60 insertions(+), 6 deletions(-) diff --git a/docs/source/mat4x3.rst b/docs/source/mat4x3.rst index 574c09a..5136e88 100644 --- a/docs/source/mat4x3.rst +++ b/docs/source/mat4x3.rst @@ -23,6 +23,16 @@ Functions: #. :c:func:`glm_mat4x3_transpose` #. :c:func:`glm_mat4x3_scale` +Represented +~~~~~~~~~~~ + +.. csv-table:: mat4x3 + :header: "", "column 1", "column 2", "column 3", "column4" + + "row 1", "m00", "m10", "m20", "m30" + "row 2", "m01", "m11", "m21", "m31" + "row 3", "m02", "m12", "m22", "m32" + Functions documentation ~~~~~~~~~~~~~~~~~~~~~~~ @@ -51,28 +61,72 @@ Functions documentation | *[in]* **src** pointer to an array of floats | *[out]* **dest** destination matrix4x3 -.. c:function:: void glm_mat4x3_mul(mat4x3 m1, mat3x4 m2, mat4 dest) +.. c:function:: void glm_mat4x3_mul(mat4x3 m1, mat3x4 m2, mat3 dest) multiply m1 and m2 to dest .. code-block:: c - glm_mat4x3_mul(mat4x3, mat3x4, mat4); + glm_mat4x3_mul(mat4x3, mat3x4, mat3); Parameters: | *[in]* **m1** left matrix (mat4x3) | *[in]* **m2** right matrix (mat3x4) - | *[out]* **dest** destination matrix (mat4) + | *[out]* **dest** destination matrix (mat3) -.. c:function:: void glm_mat4x3_mulv(mat4x3 m, vec3 v, vec4 dest) + .. csv-table:: mat4x3 + :header: "", "column 1", "column 2", "column 3", "column 4" - multiply mat4x3 with vec3 (column vector) and store in dest vector + "row 1", "a00", "a10", "a20", "a30" + "row 2", "a01", "a11", "a21", "a31" + "row 3", "a02", "a12", "a22", "a32" + + .. csv-table:: mat3x4 + :header: "", "column 1", "column 2", "column 3" + + "row 1", "b00", "b10", "b20" + "row 2", "b01", "b11", "b21" + "row 3", "b02", "b12", "b22" + "row 4", "b03", "b13", "b23" + + .. csv-table:: mat3x3 + :header: "", "column 1", "column 2", "column 3" + + "row 1", "a00 * b00 + a10 * b01 + a20 * b02 + a30 * b03", "a00 * b10 + a10 * b11 + a20 * b12 + a30 * b13", "a00 * b20 + a10 * b21 + a20 * b22 + a30 * b23" + "row 2", "a01 * b00 + a11 * b01 + a21 * b02 + a31 * b03", "a01 * b10 + a11 * b11 + a21 * b12 + a31 * b13", "a01 * b20 + a11 * b21 + a21 * b22 + a31 * b23" + "row 3", "a02 * b00 + a12 * b01 + a22 * b02 + a32 * b03", "a02 * b10 + a12 * b11 + a22 * b12 + a32 * b13", "a02 * b20 + a12 * b21 + a22 * b22 + a32 * b23" + +.. c:function:: void glm_mat4x3_mulv(mat4x3 m, vec4 v, vec3 dest) + + multiply mat4x3 with vec4 (column vector) and store in dest column vector Parameters: | *[in]* **m** mat4x3 (left) - | *[in]* **v** vec3 (right, column vector) + | *[in]* **v** vec4 (right, column vector) | *[out]* **dest** destination (result, column vector) + .. csv-table:: mat4x3 + :header: "", "column 1", "column 2", "column 3", "column 4" + + "row 1", "m00", "m10", "m20", "m30" + "row 2", "m01", "m11", "m21", "m31" + "row 3", "m02", "m12", "m22", "m32" + + .. csv-table:: column vec4 (1x4) + :header: "", "column 1" + + "row 1", "v0" + "row 2", "v1" + "row 3", "v2" + "row 4", "v3" + + .. csv-table:: column vec3 (1x3) + :header: "", "column 1" + + "row 1", "m00 * v0 + m10 * v1 + m20 * v2 + m30 * v3" + "row 2", "m01 * v0 + m11 * v1 + m21 * v2 + m31 * v3" + "row 3", "m02 * v0 + m12 * v1 + m22 * v2 + m32 * v3" + .. c:function:: void glm_mat4x3_transpose(mat4x3 m, mat3x4 dest) transpose matrix and store in dest From 8396bbf0b38444cfdc597ca089e6dd50213690d2 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Sun, 31 Mar 2024 23:06:30 +0300 Subject: [PATCH 17/29] coding style --- include/cglm/mat2x3.h | 4 +--- include/cglm/mat2x4.h | 4 +--- include/cglm/mat3x2.h | 4 +--- 3 files changed, 3 insertions(+), 9 deletions(-) diff --git a/include/cglm/mat2x3.h b/include/cglm/mat2x3.h index 3d5cedc..f5e25ef 100644 --- a/include/cglm/mat2x3.h +++ b/include/cglm/mat2x3.h @@ -122,9 +122,7 @@ glm_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat3 dest) { CGLM_INLINE void glm_mat2x3_mulv(mat2x3 m, vec2 v, vec3 dest) { - float v0, v1; - - v0 = v[0]; v1 = v[1]; + float v0 = v[0]; v1 = v[1]; dest[0] = m[0][0] * v0 + m[1][0] * v1; dest[1] = m[0][1] * v0 + m[1][1] * v1; diff --git a/include/cglm/mat2x4.h b/include/cglm/mat2x4.h index 2fdda24..e5c1281 100644 --- a/include/cglm/mat2x4.h +++ b/include/cglm/mat2x4.h @@ -129,9 +129,7 @@ glm_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat4 dest) { CGLM_INLINE void glm_mat2x4_mulv(mat2x4 m, vec2 v, vec4 dest) { - float v0, v1; - - v0 = v[0], v1 = v[1]; + float v0 = v[0], v1 = v[1]; dest[0] = m[0][0] * v0 + m[1][0] * v1; dest[1] = m[0][1] * v0 + m[1][1] * v1; diff --git a/include/cglm/mat3x2.h b/include/cglm/mat3x2.h index 6369131..75ed9c2 100644 --- a/include/cglm/mat3x2.h +++ b/include/cglm/mat3x2.h @@ -118,9 +118,7 @@ glm_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat2 dest) { CGLM_INLINE void glm_mat3x2_mulv(mat3x2 m, vec3 v, vec2 dest) { - float v0, v1, v2; - - v0 = v[0], v1 = v[1], v2 = v[2]; + float v0 = v[0], v1 = v[1], v2 = v[2]; 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; From e3ed9834a111e7c9a36aec4c6a143cd5398edb96 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Sun, 31 Mar 2024 23:06:50 +0300 Subject: [PATCH 18/29] Update mat2x3.h --- include/cglm/mat2x3.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/cglm/mat2x3.h b/include/cglm/mat2x3.h index f5e25ef..811baaf 100644 --- a/include/cglm/mat2x3.h +++ b/include/cglm/mat2x3.h @@ -122,7 +122,7 @@ glm_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat3 dest) { CGLM_INLINE void glm_mat2x3_mulv(mat2x3 m, vec2 v, vec3 dest) { - float v0 = v[0]; v1 = v[1]; + float v0 = v[0], v1 = v[1]; dest[0] = m[0][0] * v0 + m[1][0] * v1; dest[1] = m[0][1] * v0 + m[1][1] * v1; From 32a477ef07141ef9cd1055615960a11c449b0716 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Sun, 31 Mar 2024 23:35:15 +0300 Subject: [PATCH 19/29] separate SSE and SSE2 --- include/cglm/simd/intrin.h | 14 ++++++++++++-- include/cglm/simd/x86.h | 23 +++++++++++++++++------ 2 files changed, 29 insertions(+), 8 deletions(-) diff --git a/include/cglm/simd/intrin.h b/include/cglm/simd/intrin.h index 137df65..11c46e5 100644 --- a/include/cglm/simd/intrin.h +++ b/include/cglm/simd/intrin.h @@ -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 -# include # define CGLM_SSE_FP 1 # ifndef CGLM_SIMD_x86 # define CGLM_SIMD_x86 # endif #endif +#if defined(__SSE2__) +# include +# define CGLM_SSE2_FP 1 +# ifndef CGLM_SIMD_x86 +# define CGLM_SIMD_x86 +# endif +#endif + #if defined(__SSE3__) # include # ifndef CGLM_SIMD_x86 diff --git a/include/cglm/simd/x86.h b/include/cglm/simd/x86.h index 8fd5a72..eb227e7 100644 --- a/include/cglm/simd/x86.h +++ b/include/cglm/simd/x86.h @@ -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))) @@ -56,16 +56,27 @@ /* Note that `0x80000000` corresponds to `INT_MIN` for a 32-bit int. */ #define GLMM_NEGZEROf ((int)0x80000000) /* 0x80000000 ---> -0.0f */ +#define GLMM_POSZEROf ((int)0x00000000) /* 0x00000000 ---> +0.0f */ -#define GLMM__SIGNMASKf(X, Y, Z, W) \ +#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 From 35a12ed033d4de03c12a5fe6a5c8862663d4d144 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Mon, 1 Apr 2024 00:52:59 +0300 Subject: [PATCH 20/29] make SSE2-only features not available in SSE --- include/cglm/simd/x86.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/include/cglm/simd/x86.h b/include/cglm/simd/x86.h index eb227e7..071a272 100644 --- a/include/cglm/simd/x86.h +++ b/include/cglm/simd/x86.h @@ -218,6 +218,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]) { @@ -236,6 +237,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 From 00d2e8a4cf261e6bf7090b8f3549d097fb3c306c Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Mon, 1 Apr 2024 01:46:25 +0300 Subject: [PATCH 21/29] suppress warnings --- test/src/test_vec2.h | 2 ++ test/src/test_vec3.h | 2 ++ test/src/test_vec4.h | 2 ++ 3 files changed, 6 insertions(+) diff --git a/test/src/test_vec2.h b/test/src/test_vec2.h index 8fd16b5..e7bfe88 100644 --- a/test/src/test_vec2.h +++ b/test/src/test_vec2.h @@ -802,11 +802,13 @@ TEST_IMPL(GLM_PREFIX, vec2_refract) { /* Air to Glass (eta = 1.0 / 1.5) */ eta = 1.0f / 1.5f; r = GLM(vec2_refract)(v, N, eta, dest); + ASSERT(r == true); ASSERT(dest[1] < -sqrtf(0.5f)); // Expect bending towards the normal /* Glass to Water (eta = 1.5 / 1.33) */ eta = 1.5f / 1.33f; r = GLM(vec2_refract)(v, N, eta, dest); + ASSERT(r == true); ASSERT(dest[1] < -sqrtf(0.5f)); // Expect bending towards the normal, less bending than air to glass /* Diamond to Air (eta = 2.42 / 1.0) */ diff --git a/test/src/test_vec3.h b/test/src/test_vec3.h index 2fffecd..6165fdb 100644 --- a/test/src/test_vec3.h +++ b/test/src/test_vec3.h @@ -1908,6 +1908,7 @@ TEST_IMPL(GLM_PREFIX, vec3_refract) { r = GLM(vec3_refract)(v, N, eta, dest); /* Expect bending towards the normal */ + ASSERT(r == true); ASSERT(dest[1] < -sqrtf(0.5f)); /* Glass to Water (eta = 1.5 / 1.33) */ @@ -1915,6 +1916,7 @@ TEST_IMPL(GLM_PREFIX, vec3_refract) { r = GLM(vec3_refract)(v, N, eta, dest); /* Expect bending towards the normal, less bending than air to glass */ + ASSERT(r == true); ASSERT(dest[1] < -sqrtf(0.5f)); /* Diamond to Air (eta = 2.42 / 1.0) */ diff --git a/test/src/test_vec4.h b/test/src/test_vec4.h index d95815a..e61bef2 100644 --- a/test/src/test_vec4.h +++ b/test/src/test_vec4.h @@ -1591,11 +1591,13 @@ TEST_IMPL(GLM_PREFIX, vec4_refract) { /* Air to Glass (eta = 1.0 / 1.5) */ eta = 1.0f / 1.5f; r = GLM(vec4_refract)(v, N, eta, dest); + ASSERT(r == true); ASSERT(dest[1] < -sqrtf(0.5f)); // Expect bending towards the normal /* Glass to Water (eta = 1.5 / 1.33) */ eta = 1.5f / 1.33f; r = GLM(vec4_refract)(v, N, eta, dest); + ASSERT(r == true); ASSERT(dest[1] < -sqrtf(0.5f)); // Expect bending towards the normal, less bending than air to glass /* Diamond to Air (eta = 2.42 / 1.0) */ From 9ce0a3b6258fad775bebe1951042f2a4f5f74ce3 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Mon, 1 Apr 2024 13:22:51 +0300 Subject: [PATCH 22/29] tests: disable isnan check for min/max which may not work correctly especially in fast-math environment --- test/src/test_vec3.h | 16 ++++++++-------- test/src/test_vec4.h | 16 ++++++++-------- 2 files changed, 16 insertions(+), 16 deletions(-) diff --git a/test/src/test_vec3.h b/test/src/test_vec3.h index 6165fdb..df6a659 100644 --- a/test/src/test_vec3.h +++ b/test/src/test_vec3.h @@ -1673,14 +1673,14 @@ TEST_IMPL(GLM_PREFIX, vec3_eqv_eps) { TEST_IMPL(GLM_PREFIX, vec3_max) { vec3 v1 = {2.104f, -3.012f, -4.10f}, v2 = {-12.35f, -31.140f, -43.502f}; - vec3 v3 = {INFINITY, 0.0f, 0.0f}, v4 = {NAN, INFINITY, 2.0f}; - vec3 v5 = {NAN, -1.0f, -1.0f}, v6 = {-1.0f, -11.0f, 11.0f}; + vec3 v3 = {INFINITY, 0.0f, 0.0f}/*, v4 = {NAN, INFINITY, 2.0f}*/; + vec3 /*v5 = {NAN, -1.0f, -1.0f}, */v6 = {-1.0f, -11.0f, 11.0f}; ASSERT(test_eq(GLM(vec3_max)(v1), 2.104f)) ASSERT(test_eq(GLM(vec3_max)(v2), -12.35f)) ASSERT(isinf(GLM(vec3_max)(v3))) - ASSERT(isnan(GLM(vec3_max)(v4))) - ASSERT(isnan(GLM(vec3_max)(v5))) +// ASSERT(isnan(GLM(vec3_max)(v4))) +// ASSERT(isnan(GLM(vec3_max)(v5))) ASSERT(test_eq(GLM(vec3_max)(v6), 11.0f)) TEST_SUCCESS @@ -1688,14 +1688,14 @@ TEST_IMPL(GLM_PREFIX, vec3_max) { TEST_IMPL(GLM_PREFIX, vec3_min) { vec3 v1 = {2.104f, -3.012f, -4.10f}, v2 = {-12.35f, -31.140f, -43.502f}; - vec3 v3 = {INFINITY, 0.0f, 0.0f}, v4 = {NAN, INFINITY, 2.0f}; - vec3 v5 = {NAN, -1.0f, -1.0f}, v6 = {-1.0f, -11.0f, 11.0f}; + vec3 v3 = {INFINITY, 0.0f, 0.0f}/*, v4 = {NAN, INFINITY, 2.0f}*/; + vec3 /*v5 = {NAN, -1.0f, -1.0f},*/ v6 = {-1.0f, -11.0f, 11.0f}; ASSERT(test_eq(GLM(vec3_min)(v1), -4.10f)) ASSERT(test_eq(GLM(vec3_min)(v2), -43.502f)) ASSERT(test_eq(GLM(vec3_min)(v3), 0.0f)) - ASSERT(isnan(GLM(vec3_min)(v4))) - ASSERT(isnan(GLM(vec3_min)(v5))) +// ASSERT(isnan(GLM(vec3_min)(v4))) +// ASSERT(isnan(GLM(vec3_min)(v5))) ASSERT(test_eq(GLM(vec3_min)(v6), -11.0f)) TEST_SUCCESS diff --git a/test/src/test_vec4.h b/test/src/test_vec4.h index e61bef2..77e7555 100644 --- a/test/src/test_vec4.h +++ b/test/src/test_vec4.h @@ -1345,15 +1345,15 @@ TEST_IMPL(GLM_PREFIX, vec4_max) { vec4 v1 = {2.104f, -3.012f, -4.10f, -4.10f}; vec4 v2 = {-12.35f, -31.140f, -43.502f, -43.502f}; vec4 v3 = {INFINITY, 0.0f, 0.0f, 0.0f}; - vec4 v4 = {NAN, INFINITY, 2.0f, 2.0f}; - vec4 v5 = {NAN, -1.0f, -1.0f, -1.0f}; +// vec4 v4 = {NAN, INFINITY, 2.0f, 2.0f}; +// vec4 v5 = {NAN, -1.0f, -1.0f, -1.0f}; vec4 v6 = {-1.0f, -11.0f, 11.0f, 11.0f}; ASSERT(test_eq(GLM(vec4_max)(v1), 2.104f)) ASSERT(test_eq(GLM(vec4_max)(v2), -12.35f)) ASSERT(isinf(GLM(vec4_max)(v3))) - ASSERT(isnan(GLM(vec4_max)(v4))) - ASSERT(isnan(GLM(vec4_max)(v5))) +// ASSERT(isnan(GLM(vec4_max)(v4))) +// ASSERT(isnan(GLM(vec4_max)(v5))) ASSERT(test_eq(GLM(vec4_max)(v6), 11.0f)) TEST_SUCCESS @@ -1363,15 +1363,15 @@ TEST_IMPL(GLM_PREFIX, vec4_min) { vec4 v1 = {2.104f, -3.012f, -4.10f, -4.10f}; vec4 v2 = {-12.35f, -31.140f, -43.502f, -43.502f}; vec4 v3 = {INFINITY, 0.0f, 0.0f, 0.0f}; - vec4 v4 = {NAN, INFINITY, 2.0f, 2.0f}; - vec4 v5 = {NAN, -1.0f, -1.0f, -1.0f}; +// vec4 v4 = {NAN, INFINITY, 2.0f, 2.0f}; +// vec4 v5 = {NAN, -1.0f, -1.0f, -1.0f}; vec4 v6 = {-1.0f, -11.0f, 11.0f, 11.0f}; ASSERT(test_eq(GLM(vec4_min)(v1), -4.10f)) ASSERT(test_eq(GLM(vec4_min)(v2), -43.502f)) ASSERT(test_eq(GLM(vec4_min)(v3), 0.0f)) - ASSERT(isnan(GLM(vec4_min)(v4))) - ASSERT(isnan(GLM(vec4_min)(v5))) +// ASSERT(isnan(GLM(vec4_min)(v4))) +// ASSERT(isnan(GLM(vec4_min)(v5))) ASSERT(test_eq(GLM(vec4_min)(v6), -11.0f)) TEST_SUCCESS From 8b15fd51ba51dd9bb1a8b8352c6d49f0cff02019 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Mon, 1 Apr 2024 13:23:17 +0300 Subject: [PATCH 23/29] common way to identify CGLM_FAST_MATH --- include/cglm/common.h | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/include/cglm/common.h b/include/cglm/common.h index d3c3484..af1116f 100644 --- a/include/cglm/common.h +++ b/include/cglm/common.h @@ -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)) From d8e933b5b1776245a980886f61109142a2132a26 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Mon, 1 Apr 2024 13:23:22 +0300 Subject: [PATCH 24/29] Update test_project.h --- test/src/test_project.h | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/test/src/test_project.h b/test/src/test_project.h index 41bdecd..54fdb91 100644 --- a/test/src/test_project.h +++ b/test/src/test_project.h @@ -26,9 +26,15 @@ TEST_IMPL(GLM_PREFIX, unprojecti) { /* unprojected of projected vector must be same as original one */ /* we used 0.01 because of projection floating point errors */ +#ifndef CGLM_FAST_MATH ASSERT(fabsf(pos[0] - unprojected[0]) < 0.01) ASSERT(fabsf(pos[1] - unprojected[1]) < 0.01) ASSERT(fabsf(pos[2] - unprojected[2]) < 0.01) +#else + ASSERT(fabsf(pos[0] - unprojected[0]) < 0.1) + ASSERT(fabsf(pos[1] - unprojected[1]) < 0.1) + ASSERT(fabsf(pos[2] - unprojected[2]) < 0.1) +#endif TEST_SUCCESS } @@ -50,9 +56,16 @@ TEST_IMPL(GLM_PREFIX, unproject) { /* unprojected of projected vector must be same as original one */ /* we used 0.01 because of projection floating point errors */ + +#ifndef CGLM_FAST_MATH ASSERT(fabsf(pos[0] - unprojected[0]) < 0.01) ASSERT(fabsf(pos[1] - unprojected[1]) < 0.01) ASSERT(fabsf(pos[2] - unprojected[2]) < 0.01) +#else + ASSERT(fabsf(pos[0] - unprojected[0]) < 0.1) + ASSERT(fabsf(pos[1] - unprojected[1]) < 0.1) + ASSERT(fabsf(pos[2] - unprojected[2]) < 0.1) +#endif TEST_SUCCESS } @@ -74,9 +87,16 @@ TEST_IMPL(GLM_PREFIX, project) { /* unprojected of projected vector must be same as original one */ /* we used 0.01 because of projection floating point errors */ + +#ifndef CGLM_FAST_MATH ASSERT(fabsf(pos[0] - unprojected[0]) < 0.01) ASSERT(fabsf(pos[1] - unprojected[1]) < 0.01) ASSERT(fabsf(pos[2] - unprojected[2]) < 0.01) +#else + ASSERT(fabsf(pos[0] - unprojected[0]) < 0.1) + ASSERT(fabsf(pos[1] - unprojected[1]) < 0.1) + ASSERT(fabsf(pos[2] - unprojected[2]) < 0.1) +#endif /* test with no projection */ glm_mat4_identity(mvp); From 1d09c41e18e75bd51bc463106f7a168a47a247fc Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Mon, 1 Apr 2024 13:23:52 +0300 Subject: [PATCH 25/29] make xor enable in SSEonly + fast math --- include/cglm/simd/x86.h | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/include/cglm/simd/x86.h b/include/cglm/simd/x86.h index 071a272..b107a36 100644 --- a/include/cglm/simd/x86.h +++ b/include/cglm/simd/x86.h @@ -55,8 +55,20 @@ #endif /* Note that `0x80000000` corresponds to `INT_MIN` for a 32-bit int. */ -#define GLMM_NEGZEROf ((int)0x80000000) /* 0x80000000 ---> -0.0f */ -#define GLMM_POSZEROf ((int)0x00000000) /* 0x00000000 ---> +0.0f */ + +#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 = 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) \ From 4e929a81c2d69903d28ca2b52c860c78510cdf7c Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Mon, 1 Apr 2024 13:26:08 +0300 Subject: [PATCH 26/29] Update x86.h --- include/cglm/simd/x86.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/cglm/simd/x86.h b/include/cglm/simd/x86.h index b107a36..81081dc 100644 --- a/include/cglm/simd/x86.h +++ b/include/cglm/simd/x86.h @@ -61,7 +61,7 @@ # define GLMM_POSZEROf ((int)0x00000000) /* 0x00000000 ---> +0.0f */ #else # ifdef CGLM_FAST_MATH - union { int i; float f; } static GLMM_NEGZEROf_TU = { .i = 0x80000000 }; + 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 From c9c7941a720d0850a04fd9ee1efce03e3b8c0010 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Mon, 1 Apr 2024 14:10:38 +0300 Subject: [PATCH 27/29] tests: dont test isnan on fast math --- test/src/test_vec3.h | 9 ++++++--- test/src/test_vec4.h | 9 ++++++--- 2 files changed, 12 insertions(+), 6 deletions(-) diff --git a/test/src/test_vec3.h b/test/src/test_vec3.h index df6a659..f23c784 100644 --- a/test/src/test_vec3.h +++ b/test/src/test_vec3.h @@ -1702,6 +1702,7 @@ TEST_IMPL(GLM_PREFIX, vec3_min) { } TEST_IMPL(GLM_PREFIX, vec3_isnan) { +#ifndef CGLM_FAST_MATH vec3 v1 = {2.104f, -3.012f, -4.10f}, v2 = {-12.35f, -31.140f, -43.502f}; vec3 v3 = {INFINITY, 0.0f, 0.0f}, v4 = {NAN, INFINITY, 2.0f}; vec3 v5 = {NAN, -1.0f, -1.0f}, v6 = {-1.0f, -1.0f, 11.0f}; @@ -1712,11 +1713,12 @@ TEST_IMPL(GLM_PREFIX, vec3_isnan) { ASSERT(GLM(vec3_isnan)(v4)) ASSERT(GLM(vec3_isnan)(v5)) ASSERT(!GLM(vec3_isnan)(v6)) - +#endif TEST_SUCCESS } TEST_IMPL(GLM_PREFIX, vec3_isinf) { +#ifndef CGLM_FAST_MATH vec3 v1 = {2.104f, -3.012f, -4.10f}, v2 = {-12.35f, -31.140f, -43.502f}; vec3 v3 = {INFINITY, 0.0f, 0.0f}, v4 = {NAN, INFINITY, 2.0f}; vec3 v5 = {NAN, -1.0f, -1.0f}, v6 = {-1.0f, -1.0f, 11.0f}; @@ -1727,11 +1729,12 @@ TEST_IMPL(GLM_PREFIX, vec3_isinf) { ASSERT(GLM(vec3_isinf)(v4)) ASSERT(!GLM(vec3_isinf)(v5)) ASSERT(!GLM(vec3_isinf)(v6)) - +#endif TEST_SUCCESS } TEST_IMPL(GLM_PREFIX, vec3_isvalid) { +#ifndef CGLM_FAST_MATH vec3 v1 = {2.104f, -3.012f, -4.10f}, v2 = {-12.35f, -31.140f, -43.502f}; vec3 v3 = {INFINITY, 0.0f, 0.0f}, v4 = {NAN, INFINITY, 2.0f}; vec3 v5 = {NAN, -1.0f, -1.0f}, v6 = {-1.0f, -1.0f, 11.0f}; @@ -1742,7 +1745,7 @@ TEST_IMPL(GLM_PREFIX, vec3_isvalid) { ASSERT(!GLM(vec3_isvalid)(v4)) ASSERT(!GLM(vec3_isvalid)(v5)) ASSERT(GLM(vec3_isvalid)(v6)) - +#endif TEST_SUCCESS } diff --git a/test/src/test_vec4.h b/test/src/test_vec4.h index 77e7555..8d814e2 100644 --- a/test/src/test_vec4.h +++ b/test/src/test_vec4.h @@ -1378,6 +1378,7 @@ TEST_IMPL(GLM_PREFIX, vec4_min) { } TEST_IMPL(GLM_PREFIX, vec4_isnan) { +#ifndef CGLM_FAST_MATH vec4 v1 = {2.104f, -3.012f, -4.10f, -4.10f}; vec4 v2 = {-12.35f, -31.140f, -43.502f, -43.502f}; vec4 v3 = {INFINITY, 0.0f, 0.0f, 0.0f}; @@ -1391,11 +1392,12 @@ TEST_IMPL(GLM_PREFIX, vec4_isnan) { ASSERT(GLM(vec4_isnan)(v4)) ASSERT(GLM(vec4_isnan)(v5)) ASSERT(!GLM(vec4_isnan)(v6)) - +#endif TEST_SUCCESS } TEST_IMPL(GLM_PREFIX, vec4_isinf) { +#ifndef CGLM_FAST_MATH vec4 v1 = {2.104f, -3.012f, -4.10f, -4.10f}; vec4 v2 = {-12.35f, -31.140f, -43.502f, -43.502f}; vec4 v3 = {INFINITY, 0.0f, 0.0f, 0.0f}; @@ -1409,11 +1411,12 @@ TEST_IMPL(GLM_PREFIX, vec4_isinf) { ASSERT(GLM(vec4_isinf)(v4)) ASSERT(!GLM(vec4_isinf)(v5)) ASSERT(!GLM(vec4_isinf)(v6)) - +#endif TEST_SUCCESS } TEST_IMPL(GLM_PREFIX, vec4_isvalid) { +#ifndef CGLM_FAST_MATH vec4 v1 = {2.104f, -3.012f, -4.10f, -4.10f}; vec4 v2 = {-12.35f, -31.140f, -43.502f, -43.502f}; vec4 v3 = {INFINITY, 0.0f, 0.0f, 0.0f}; @@ -1427,7 +1430,7 @@ TEST_IMPL(GLM_PREFIX, vec4_isvalid) { ASSERT(!GLM(vec4_isvalid)(v4)) ASSERT(!GLM(vec4_isvalid)(v5)) ASSERT(GLM(vec4_isvalid)(v6)) - +#endif TEST_SUCCESS } From 568634a79e8f2996822616bfd387a9262779e06f Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Mon, 1 Apr 2024 16:48:58 +0300 Subject: [PATCH 28/29] tests: dont test isinf == true on fast math --- test/src/test_vec3.h | 2 ++ test/src/test_vec4.h | 2 ++ 2 files changed, 4 insertions(+) diff --git a/test/src/test_vec3.h b/test/src/test_vec3.h index f23c784..7c057f3 100644 --- a/test/src/test_vec3.h +++ b/test/src/test_vec3.h @@ -1678,7 +1678,9 @@ TEST_IMPL(GLM_PREFIX, vec3_max) { ASSERT(test_eq(GLM(vec3_max)(v1), 2.104f)) ASSERT(test_eq(GLM(vec3_max)(v2), -12.35f)) +#ifndef CGLM_FAST_MATH ASSERT(isinf(GLM(vec3_max)(v3))) +#endif // ASSERT(isnan(GLM(vec3_max)(v4))) // ASSERT(isnan(GLM(vec3_max)(v5))) ASSERT(test_eq(GLM(vec3_max)(v6), 11.0f)) diff --git a/test/src/test_vec4.h b/test/src/test_vec4.h index 8d814e2..435c700 100644 --- a/test/src/test_vec4.h +++ b/test/src/test_vec4.h @@ -1351,7 +1351,9 @@ TEST_IMPL(GLM_PREFIX, vec4_max) { ASSERT(test_eq(GLM(vec4_max)(v1), 2.104f)) ASSERT(test_eq(GLM(vec4_max)(v2), -12.35f)) +#ifndef CGLM_FAST_MATH ASSERT(isinf(GLM(vec4_max)(v3))) +#endif // ASSERT(isnan(GLM(vec4_max)(v4))) // ASSERT(isnan(GLM(vec4_max)(v5))) ASSERT(test_eq(GLM(vec4_max)(v6), 11.0f)) From da4224ba32f47472900a00ce9eb1d6b7c1003fa4 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Tue, 2 Apr 2024 00:52:54 +0300 Subject: [PATCH 29/29] now working on v0.9.5 --- CMakeLists.txt | 2 +- cglm.podspec | 2 +- configure.ac | 2 +- docs/source/conf.py | 4 ++-- include/cglm/version.h | 2 +- meson.build | 2 +- 6 files changed, 7 insertions(+), 7 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 0e10b2c..169296d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,6 +1,6 @@ cmake_minimum_required(VERSION 3.8.2) project(cglm - VERSION 0.9.4 + VERSION 0.9.5 HOMEPAGE_URL https://github.com/recp/cglm DESCRIPTION "OpenGL Mathematics (glm) for C" LANGUAGES C diff --git a/cglm.podspec b/cglm.podspec index 52d6122..85603b7 100644 --- a/cglm.podspec +++ b/cglm.podspec @@ -2,7 +2,7 @@ Pod::Spec.new do |s| # Description s.name = "cglm" - s.version = "0.9.3" + s.version = "0.9.4" s.summary = "📽 Highly Optimized Graphics Math (glm) for C" s.description = <<-DESC cglm is math library for graphics programming for C. See the documentation or README for all features. diff --git a/configure.ac b/configure.ac index 399aadb..e3daae9 100644 --- a/configure.ac +++ b/configure.ac @@ -7,7 +7,7 @@ #***************************************************************************** AC_PREREQ([2.69]) -AC_INIT([cglm], [0.9.4], [info@recp.me]) +AC_INIT([cglm], [0.9.5], [info@recp.me]) AM_INIT_AUTOMAKE([-Wall foreign subdir-objects serial-tests]) # Don't use the default cflags (-O2 -g), we set ours manually in Makefile.am. diff --git a/docs/source/conf.py b/docs/source/conf.py index f0bc903..0f5df86 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -62,9 +62,9 @@ author = u'Recep Aslantas' # built documents. # # The short X.Y version. -version = u'0.9.4' +version = u'0.9.5' # The full version, including alpha/beta/rc tags. -release = u'0.9.4' +release = u'0.9.5' # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. diff --git a/include/cglm/version.h b/include/cglm/version.h index d8a1111..704fea0 100644 --- a/include/cglm/version.h +++ b/include/cglm/version.h @@ -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 */ diff --git a/meson.build b/meson.build index 29ec0c0..3afdc4f 100644 --- a/meson.build +++ b/meson.build @@ -1,5 +1,5 @@ project('cglm', 'c', - version : '0.9.4', + version : '0.9.5', license : 'mit', default_options : [ 'c_std=c11',