From fd3b0634d273929dc4dc64ad4f7617e9f3910708 Mon Sep 17 00:00:00 2001 From: acoto87 Date: Mon, 20 May 2019 17:11:10 -0500 Subject: [PATCH] Change for function that output multiple values - Now the functions that output mutliple values, such as glms_decompose_rs and glms_decompose receive pointers. - Added missing comments to struct/vec3 and struct/vec4 files. --- include/cglm/structs/affine.h | 16 +- include/cglm/structs/box.h | 45 ++-- include/cglm/structs/vec3-ext.h | 98 ++++++++ include/cglm/structs/vec3.h | 422 +++++++++++++++++++++++++++++++- include/cglm/structs/vec4-ext.h | 98 ++++++++ include/cglm/structs/vec4.h | 321 +++++++++++++++++++++++- 6 files changed, 947 insertions(+), 53 deletions(-) diff --git a/include/cglm/structs/affine.h b/include/cglm/structs/affine.h index 72cab13..481aaa3 100644 --- a/include/cglm/structs/affine.h +++ b/include/cglm/structs/affine.h @@ -25,8 +25,8 @@ CGLM_INLINE mat4s glms_rotate_atm(mat4s m, vec3s pivot, float angle, vec3s axis); CGLM_INLINE vec3s glms_decompose_scalev(mat4s m); CGLM_INLINE bool glms_uniscaled(mat4s m); - CGLM_INLINE void glms_decompose_rs(mat4s m, mat4s r, vec3s s); - CGLM_INLINE void glms_decompose(mat4s m, vec4s t, mat4s r, vec3s s); + CGLM_INLINE void glms_decompose_rs(mat4s m, mat4s * r, vec3s * s); + CGLM_INLINE void glms_decompose(mat4s m, vec4s t, mat4s * r, vec3s * s); */ #ifndef cglm_affines_h @@ -315,10 +315,8 @@ glms_uniscaled(mat4s m) { */ CGLM_INLINE void -glms_decompose_rs(mat4s m, mat4s r, vec3s s) { - // FIX: Modify param - // - glm_decompose_rs(m.raw, r.raw, s.raw); +glms_decompose_rs(mat4s m, mat4s * __restrict r, vec3s * __restrict s) { + glm_decompose_rs(m.raw, r->raw, s->raw); } /*! @@ -332,10 +330,8 @@ glms_decompose_rs(mat4s m, mat4s r, vec3s s) { */ CGLM_INLINE void -glms_decompose(mat4s m, vec4s t, mat4s r, vec3s s) { - // FIX: Modify param - // - glm_decompose(m.raw, t.raw, r.raw, s.raw); +glms_decompose(mat4s m, vec4s * __restrict t, mat4s * __restrict r, vec3s * __restrict s) { + glm_decompose(m.raw, t->raw, r->raw, s->raw); } #endif /* cglm_affines_h */ diff --git a/include/cglm/structs/box.h b/include/cglm/structs/box.h index ca7c3a6..4251bd7 100644 --- a/include/cglm/structs/box.h +++ b/include/cglm/structs/box.h @@ -162,7 +162,7 @@ glms_aabb_isvalid(vec3s box[2]) { CGLM_INLINE float glms_aabb_size(vec3s box[2]) { - return glms_vec3_distance(box[0], box[1]); + return glm_vec3_distance(box[0].raw, box[1].raw); } /*! @@ -197,9 +197,12 @@ glms_aabb_center(vec3s box[2]) { CGLM_INLINE bool glms_aabb_aabb(vec3s box[2], vec3s other[2]) { - return (box[0].x <= other[1].x && box[1].x >= other[0].x) - && (box[0].y <= other[1].y && box[1].y >= other[0].y) - && (box[0].z <= other[1].z && box[1].z >= other[0].z); + vec3 rawBox[2]; + vec3 rawOther[2]; + + glms_vec3_unpack(rawBox, box, 2); + glms_vec3_unpack(rawOther, other, 2); + return glm_aabb_aabb(rawBox, rawOther); } /*! @@ -213,19 +216,11 @@ glms_aabb_aabb(vec3s box[2], vec3s other[2]) { */ CGLM_INLINE bool -glms_aabb_sphere(vec3s box[2], vec4 s) { - float dmin; - int a, b, c; - - a = s[0] >= box[0].x; - b = s[1] >= box[0].y; - c = s[2] >= box[0].z; - - dmin = glm_pow2(s[0] - box[a].x) - + glm_pow2(s[1] - box[b].y) - + glm_pow2(s[2] - box[c].z); - - return dmin <= glm_pow2(s[3]); +glms_aabb_sphere(vec3s box[2], vec4s s) { + vec3 rawBox[2]; + + glms_vec3_unpack(rawBox, box, 2); + return glm_aabb_sphere(rawBox, s.raw); } /*! @@ -237,9 +232,10 @@ glms_aabb_sphere(vec3s box[2], vec4 s) { CGLM_INLINE bool glms_aabb_point(vec3s box[2], vec3s point) { - return (point.x >= box[0].x && point.x <= box[1].x) - && (point.y >= box[0].y && point.y <= box[1].y) - && (point.z >= box[0].z && point.z <= box[1].z); + vec3 rawBox[2]; + + glms_vec3_unpack(rawBox, box, 2); + return glm_aabb_point(rawBox, point.raw); } /*! @@ -251,9 +247,12 @@ glms_aabb_point(vec3s box[2], vec3s point) { CGLM_INLINE bool glms_aabb_contains(vec3s box[2], vec3s other[2]) { - return (box[0].x <= other[0].x && box[1].x >= other[1].x) - && (box[0].y <= other[0].y && box[1].y >= other[1].y) - && (box[0].z <= other[0].z && box[1].z >= other[1].z); + vec3 rawBox[2]; + vec3 rawOther[2]; + + glms_vec3_unpack(rawBox, box, 2); + glms_vec3_unpack(rawOther, other, 2); + return glm_aabb_contains(rawBox, rawOther); } #endif /* cglm_boxs_h */ diff --git a/include/cglm/structs/vec3-ext.h b/include/cglm/structs/vec3-ext.h index 0449b3d..2e5e729 100644 --- a/include/cglm/structs/vec3-ext.h +++ b/include/cglm/structs/vec3-ext.h @@ -5,6 +5,27 @@ * Full license can be found in the LICENSE file */ +/*! + * @brief SIMD like functions + */ + +/* + Functions: + CGLM_INLINE vec3s glms_vec3_broadcast(float val); + CGLM_INLINE bool glms_vec3_eq(vec3s v, float val); + CGLM_INLINE bool glms_vec3_eq_eps(vec3s v, float val); + CGLM_INLINE bool glms_vec3_eq_all(vec3s v); + CGLM_INLINE bool glms_vec3_eqv(vec3s a, vec3s b); + CGLM_INLINE bool glms_vec3_eqv_eps(vec3s a, vec3s b); + CGLM_INLINE float glms_vec3_max(vec3s v); + CGLM_INLINE float glms_vec3_min(vec3s v); + CGLM_INLINE bool glms_vec3_isnan(vec3s v); + CGLM_INLINE bool glms_vec3_isinf(vec3s v); + CGLM_INLINE bool glms_vec3_isvalid(vec3s v); + CGLM_INLINE vec3s glms_vec3_sign(vec3s v); + CGLM_INLINE vec3s glms_vec3_sqrt(vec3s v); + */ + #ifndef cglm_vec3s_ext_h #define cglm_vec3s_ext_h @@ -13,6 +34,12 @@ #include "../util.h" #include "../vec3-ext.h" +/*! + * @brief fill a vector with specified value + * + * @param[in] val value + * @returns dest + */ CGLM_INLINE vec3s glms_vec3_broadcast(float val) { @@ -21,66 +48,131 @@ glms_vec3_broadcast(float val) { return r; } +/*! + * @brief check if vector is equal to value (without epsilon) + * + * @param[in] v vector + * @param[in] val value + */ CGLM_INLINE bool glms_vec3_eq(vec3s v, float val) { return glm_vec3_eq(v.raw, val); } +/*! + * @brief check if vector is equal to value (with epsilon) + * + * @param[in] v vector + * @param[in] val value + */ CGLM_INLINE bool glms_vec3_eq_eps(vec3s v, float val) { return glm_vec3_eq_eps(v.raw, val); } +/*! + * @brief check if vectors members are equal (without epsilon) + * + * @param[in] v vector + */ CGLM_INLINE bool glms_vec3_eq_all(vec3s v) { return glm_vec3_eq_all(v.raw); } +/*! + * @brief check if vector is equal to another (without epsilon) + * + * @param[in] a vector + * @param[in] b vector + */ CGLM_INLINE bool glms_vec3_eqv(vec3s a, vec3s b) { return glm_vec3_eqv(a.raw, b.raw); } +/*! + * @brief check if vector is equal to another (with epsilon) + * + * @param[in] a vector + * @param[in] b vector + */ CGLM_INLINE bool glms_vec3_eqv_eps(vec3s a, vec3s b) { return glm_vec3_eqv_eps(a.raw, b.raw); } +/*! + * @brief max value of vector + * + * @param[in] v vector + */ CGLM_INLINE float glms_vec3_max(vec3s v) { return glm_vec3_max(v.raw); } +/*! + * @brief min value of vector + * + * @param[in] v vector + */ CGLM_INLINE float glms_vec3_min(vec3s v) { return glm_vec3_min(v.raw); } +/*! + * @brief check if all items are NaN (not a number) + * you should only use this in DEBUG mode or very critical asserts + * + * @param[in] v vector + */ CGLM_INLINE bool glms_vec3_isnan(vec3s v) { return glm_vec3_isnan(v.raw); } +/*! + * @brief check if all items are INFINITY + * you should only use this in DEBUG mode or very critical asserts + * + * @param[in] v vector + */ CGLM_INLINE bool glms_vec3_isinf(vec3s v) { return glm_vec3_isinf(v.raw); } +/*! + * @brief check if all items are valid number + * you should only use this in DEBUG mode or very critical asserts + * + * @param[in] v vector + */ CGLM_INLINE bool glms_vec3_isvalid(vec3s v) { return glm_vec3_isvalid(v.raw); } +/*! + * @brief get sign of 32 bit float as +1, -1, 0 + * + * Important: It returns 0 for zero/NaN input + * + * @param v vector + * @returns sign vector + */ CGLM_INLINE vec3s glms_vec3_sign(vec3s v) { @@ -89,6 +181,12 @@ glms_vec3_sign(vec3s v) { return r; } +/*! + * @brief square root of each vector item + * + * @param[in] v vector + * @returns destination vector + */ CGLM_INLINE vec3s glms_vec3_sqrt(vec3s v) { diff --git a/include/cglm/structs/vec3.h b/include/cglm/structs/vec3.h index 312d59a..766742b 100644 --- a/include/cglm/structs/vec3.h +++ b/include/cglm/structs/vec3.h @@ -5,6 +5,67 @@ * Full license can be found in the LICENSE file */ +/* + Macros: + GLMS_VEC3_ONE_INIT + GLMS_VEC3_ZERO_INIT + GLMS_VEC3_ONE + GLMS_VEC3_ZERO + GLMS_YUP + GLMS_ZUP + GLMS_XUP + + Functions: + CGLM_INLINE vec3s glms_vec3(vec4s v4); + CGLM_INLINE vec3s glms_vec3_copy(vec3s v); + CGLM_INLINE void glms_vec3_pack(vec3s dst[], vec3 src[], size_t len); + CGLM_INLINE void glms_vec3_unpack(vec3 dst[], vec3s src[], size_t len); + CGLM_INLINE vec3s glms_vec3_zero(); + CGLM_INLINE vec3s glms_vec3_one(); + CGLM_INLINE float glms_vec3_dot(vec3s a, vec3s b); + CGLM_INLINE float glms_vec3_norm2(vec3s v); + CGLM_INLINE float glms_vec3_norm(vec3s v); + CGLM_INLINE vec3s glms_vec3_add(vec3s a, vec3s b); + CGLM_INLINE vec3s glms_vec3_adds(vec3s a, float s); + CGLM_INLINE vec3s glms_vec3_sub(vec3s a, vec3s b); + CGLM_INLINE vec3s glms_vec3_subs(vec3s a, float s); + CGLM_INLINE vec3s glms_vec3_mul(vec3s a, vec3s b); + CGLM_INLINE vec3s glms_vec3_scale(vec3s v, float s); + CGLM_INLINE vec3s glms_vec3_scale_as(vec3s v, float s); + CGLM_INLINE vec3s glms_vec3_div(vec3s a, vec3s b); + CGLM_INLINE vec3s glms_vec3_divs(vec3s a, float s); + CGLM_INLINE vec3s glms_vec3_addadd(vec3s a, vec3s b, vec3s dest); + CGLM_INLINE vec3s glms_vec3_subadd(vec3s a, vec3s b, vec3s dest); + CGLM_INLINE vec3s glms_vec3_muladd(vec3s a, vec3s b, vec3s dest); + CGLM_INLINE vec3s glms_vec3_muladds(vec3s a, float s, vec3s dest); + CGLM_INLINE vec3s glms_vec3_maxadd(vec3s a, vec3s b, vec3s dest); + CGLM_INLINE vec3s glms_vec3_minadd(vec3s a, vec3s b, vec3s dest); + CGLM_INLINE vec3s glms_vec3_flipsign(vec3s v); + CGLM_INLINE vec3s glms_vec3_negate(vec3s v); + CGLM_INLINE vec3s glms_vec3_inv(vec3s v); + CGLM_INLINE vec3s glms_vec3_normalize(vec3s v); + CGLM_INLINE vec3s glms_vec3_cross(vec3s a, vec3s b); + CGLM_INLINE vec3s glms_vec3_crossn(vec3s a, vec3s b); + CGLM_INLINE float glms_vec3_distance(vec3s a, vec3s b); + CGLM_INLINE float glms_vec3_angle(vec3s a, vec3s b); + CGLM_INLINE vec3s glms_vec3_rotate(vec3s v, float angle, vec3s axis); + CGLM_INLINE vec3s glms_vec3_rotate_m4(mat4s m, vec3s v); + CGLM_INLINE vec3s glms_vec3_rotate_m3(mat3s m, vec3s v); + CGLM_INLINE vec3s glms_vec3_proj(vec3s a, vec3s b); + CGLM_INLINE vec3s glms_vec3_center(vec3s a, vec3s b); + CGLM_INLINE float glms_vec3_distance2(vec3s a, vec3s b); + CGLM_INLINE vec3s glms_vec3_maxv(vec3s a, vec3s b); + CGLM_INLINE vec3s glms_vec3_minv(vec3s a, vec3s b); + CGLM_INLINE vec3s glms_vec3_ortho(vec3s v); + CGLM_INLINE vec3s glms_vec3_clamp(vec3s v, float minVal, float maxVal); + CGLM_INLINE vec3s glms_vec3_lerp(vec3s from, vec3s to, float t); + + Convenient: + CGLM_INLINE vec3s glms_cross(vec3s a, vec3s b); + CGLM_INLINE float glms_dot(vec3s a, vec3s b); + CGLM_INLINE vec3s glms_normalize(vec3s v); + */ + #ifndef cglm_vec3s_h #define cglm_vec3s_h @@ -24,6 +85,12 @@ #define GLMS_ZUP ((vec3s){0.0f, 0.0f, 1.0f}) #define GLMS_XUP ((vec3s){1.0f, 0.0f, 0.0f}) +/*! + * @brief init vec3 using vec4 + * + * @param[in] v4 vector4 + * @returns destination + */ CGLM_INLINE vec3s glms_vec3(vec4s v4) { @@ -32,6 +99,12 @@ glms_vec3(vec4s v4) { return r; } +/*! + * @brief copy all members of [a] to [dest] + * + * @param[in] a source + * @returns destination + */ CGLM_INLINE vec3s glms_vec3_copy(vec3s v) { @@ -40,6 +113,13 @@ glms_vec3_copy(vec3s v) { return r; } +/*! + * @brief pack an array of vec3 into an array of vec3s + * + * @param[out] dst array of vec3 + * @param[in] src array of vec3s + * @param[in] len number of elements + */ CGLM_INLINE void glms_vec3_pack(vec3s dst[], vec3 src[], size_t len) { @@ -52,6 +132,13 @@ glms_vec3_pack(vec3s dst[], vec3 src[], size_t len) { } } +/*! + * @brief unpack an array of vec3s into an array of vec3 + * + * @param[out] dst array of vec3s + * @param[in] src array of vec3 + * @param[in] len number of elements + */ CGLM_INLINE void glms_vec3_unpack(vec3 dst[], vec3s src[], size_t len) { @@ -64,6 +151,12 @@ glms_vec3_unpack(vec3 dst[], vec3s src[], size_t len) { } } +/*! + * @brief make vector zero + * + * @param[in] v vector + * @returns zero vector + */ CGLM_INLINE vec3s glms_vec3_zero() { @@ -72,6 +165,12 @@ glms_vec3_zero() { return r; } +/*! + * @brief make vector one + * + * @param[in] v vector + * @returns one vector + */ CGLM_INLINE vec3s glms_vec3_one() { @@ -80,24 +179,57 @@ glms_vec3_one() { return r; } +/*! + * @brief vec3 dot product + * + * @param[in] a vector1 + * @param[in] b vector2 + * + * @return dot product + */ CGLM_INLINE float glms_vec3_dot(vec3s a, vec3s b) { return glm_vec3_dot(a.raw, b.raw); } +/*! + * @brief norm * norm (magnitude) of vec + * + * we can use this func instead of calling norm * norm, because it would call + * sqrtf fuction twice but with this func we can avoid func call, maybe this is + * not good name for this func + * + * @param[in] v vector + * + * @return norm * norm + */ CGLM_INLINE float glms_vec3_norm2(vec3s v) { return glm_vec3_norm2(v.raw); } +/*! + * @brief norm (magnitude) of vec3 + * + * @param[in] v vector + * + * @return norm + */ CGLM_INLINE float glms_vec3_norm(vec3s v) { return glm_vec3_norm(v.raw); } +/*! + * @brief add a vector to b vector store result in dest + * + * @param[in] a vector1 + * @param[in] b vector2 + * @returns destination vector + */ CGLM_INLINE vec3s glms_vec3_add(vec3s a, vec3s b) { @@ -106,6 +238,13 @@ glms_vec3_add(vec3s a, vec3s b) { return r; } +/*! + * @brief add scalar to v vector store result in dest (d = v + s) + * + * @param[in] v vector + * @param[in] s scalar + * @returns destination vector + */ CGLM_INLINE vec3s glms_vec3_adds(vec3s a, float s) { @@ -114,6 +253,13 @@ glms_vec3_adds(vec3s a, float s) { return r; } +/*! + * @brief subtract b vector from a vector store result in dest + * + * @param[in] a vector1 + * @param[in] b vector2 + * @returns destination vector + */ CGLM_INLINE vec3s glms_vec3_sub(vec3s a, vec3s b) { @@ -122,6 +268,13 @@ glms_vec3_sub(vec3s a, vec3s b) { return r; } +/*! + * @brief subtract scalar from v vector store result in dest (d = v - s) + * + * @param[in] v vector + * @param[in] s scalar + * @returns destination vector + */ CGLM_INLINE vec3s glms_vec3_subs(vec3s a, float s) { @@ -130,6 +283,13 @@ glms_vec3_subs(vec3s a, float s) { return r; } +/*! + * @brief multiply two vector (component-wise multiplication) + * + * @param a vector1 + * @param b vector2 + * @returns v3 = (a[0] * b[0], a[1] * b[1], a[2] * b[2]) + */ CGLM_INLINE vec3s glms_vec3_mul(vec3s a, vec3s b) { @@ -138,6 +298,13 @@ glms_vec3_mul(vec3s a, vec3s b) { return r; } +/*! + * @brief multiply/scale vec3 vector with scalar: result = v * s + * + * @param[in] v vector + * @param[in] s scalar + * @returns destination vector + */ CGLM_INLINE vec3s glms_vec3_scale(vec3s v, float s) { @@ -146,6 +313,13 @@ glms_vec3_scale(vec3s v, float s) { return r; } +/*! + * @brief make vec3 vector scale as specified: result = unit(v) * s + * + * @param[in] v vector + * @param[in] s scalar + * @returns destination vector + */ CGLM_INLINE vec3s glms_vec3_scale_as(vec3s v, float s) { @@ -154,6 +328,13 @@ glms_vec3_scale_as(vec3s v, float s) { return r; } +/*! + * @brief div vector with another component-wise division: d = a / b + * + * @param[in] a vector 1 + * @param[in] b vector 2 + * @returns result = (a[0]/b[0], a[1]/b[1], a[2]/b[2]) + */ CGLM_INLINE vec3s glms_vec3_div(vec3s a, vec3s b) { @@ -162,6 +343,13 @@ glms_vec3_div(vec3s a, vec3s b) { return r; } +/*! + * @brief div vector with scalar: d = v / s + * + * @param[in] v vector + * @param[in] s scalar + * @returns result = (a[0]/s, a[1]/s, a[2]/s) + */ CGLM_INLINE vec3s glms_vec3_divs(vec3s a, float s) { @@ -170,6 +358,15 @@ glms_vec3_divs(vec3s a, float s) { return r; } +/*! + * @brief add two vectors and add result to sum + * + * it applies += operator so dest must be initialized + * + * @param[in] a vector 1 + * @param[in] b vector 2 + * @returns dest += (a + b) + */ CGLM_INLINE vec3s glms_vec3_addadd(vec3s a, vec3s b, vec3s dest) { @@ -177,6 +374,15 @@ glms_vec3_addadd(vec3s a, vec3s b, vec3s dest) { return dest; } +/*! + * @brief sub two vectors and add result to dest + * + * it applies += operator so dest must be initialized + * + * @param[in] a vector 1 + * @param[in] b vector 2 + * @returns dest += (a + b) + */ CGLM_INLINE vec3s glms_vec3_subadd(vec3s a, vec3s b, vec3s dest) { @@ -184,6 +390,15 @@ glms_vec3_subadd(vec3s a, vec3s b, vec3s dest) { return dest; } +/*! + * @brief mul two vectors and add result to dest + * + * it applies += operator so dest must be initialized + * + * @param[in] a vector 1 + * @param[in] b vector 2 + * @returns dest += (a * b) + */ CGLM_INLINE vec3s glms_vec3_muladd(vec3s a, vec3s b, vec3s dest) { @@ -191,6 +406,15 @@ glms_vec3_muladd(vec3s a, vec3s b, vec3s dest) { return dest; } +/*! + * @brief mul vector with scalar and add result to sum + * + * it applies += operator so dest must be initialized + * + * @param[in] a vector + * @param[in] s scalar + * @returns dest += (a * b) + */ CGLM_INLINE vec3s glms_vec3_muladds(vec3s a, float s, vec3s dest) { @@ -198,6 +422,15 @@ glms_vec3_muladds(vec3s a, float s, vec3s dest) { return dest; } +/*! + * @brief add max of two vector to result/dest + * + * it applies += operator so dest must be initialized + * + * @param[in] a vector 1 + * @param[in] b vector 2 + * @returns dest += max(a, b) + */ CGLM_INLINE vec3s glms_vec3_maxadd(vec3s a, vec3s b, vec3s dest) { @@ -205,6 +438,15 @@ glms_vec3_maxadd(vec3s a, vec3s b, vec3s dest) { return dest; } +/*! + * @brief add min of two vector to result/dest + * + * it applies += operator so dest must be initialized + * + * @param[in] a vector 1 + * @param[in] b vector 2 + * @returns dest += min(a, b) + */ CGLM_INLINE vec3s glms_vec3_minadd(vec3s a, vec3s b, vec3s dest) { @@ -212,6 +454,12 @@ glms_vec3_minadd(vec3s a, vec3s b, vec3s dest) { return dest; } +/*! + * @brief negate vector components and store result in dest + * + * @param[in] v vector + * @returns result vector + */ CGLM_INLINE vec3s glms_vec3_flipsign(vec3s v) { @@ -219,6 +467,12 @@ glms_vec3_flipsign(vec3s v) { return v; } +/*! + * @brief negate vector components + * + * @param[in] v vector + * @returns negated vector + */ CGLM_INLINE vec3s glms_vec3_negate(vec3s v) { @@ -226,13 +480,12 @@ glms_vec3_negate(vec3s v) { return v; } -CGLM_INLINE -vec3s -glms_vec3_inv(vec3s v) { - glm_vec3_inv(v.raw); - return v; -} - +/*! + * @brief normalize vec3 and store result in same vec + * + * @param[in] v vector + * @returns normalized vector + */ CGLM_INLINE vec3s glms_vec3_normalize(vec3s v) { @@ -240,6 +493,13 @@ glms_vec3_normalize(vec3s v) { return v; } +/*! + * @brief cross product of two vector (RH) + * + * @param[in] a vector 1 + * @param[in] b vector 2 + * @returns destination + */ CGLM_INLINE vec3s glms_vec3_cross(vec3s a, vec3s b) { @@ -248,6 +508,13 @@ glms_vec3_cross(vec3s a, vec3s b) { return r; } +/*! + * @brief cross product of two vector (RH) and normalize the result + * + * @param[in] a vector 1 + * @param[in] b vector 2 + * @returns destination + */ CGLM_INLINE vec3s glms_vec3_crossn(vec3s a, vec3s b) { @@ -256,18 +523,28 @@ glms_vec3_crossn(vec3s a, vec3s b) { return r; } -CGLM_INLINE -float -glms_vec3_distance(vec3s a, vec3s b) { - return glm_vec3_distance(a.raw, b.raw); -} - +/*! + * @brief angle betwen two vector + * + * @param[in] a vector1 + * @param[in] b vector2 + * + * @return angle as radians + */ CGLM_INLINE float glms_vec3_angle(vec3s a, vec3s b) { return glm_vec3_angle(a.raw, b.raw); } +/*! + * @brief rotate vec3 around axis by angle using Rodrigues' rotation formula + * + * @param[in] v vector + * @param[in] axis axis vector (must be unit vector) + * @param[in] angle angle by radians + * @returns rotated vector + */ CGLM_INLINE vec3s glms_vec3_rotate(vec3s v, float angle, vec3s axis) { @@ -275,6 +552,19 @@ glms_vec3_rotate(vec3s v, float angle, vec3s axis) { return v; } +/*! + * @brief apply rotation matrix to vector + * + * matrix format should be (no perspective): + * a b c x + * e f g y + * i j k z + * 0 0 0 w + * + * @param[in] m affine matrix or rot matrix + * @param[in] v vector + * @returns rotated vector + */ CGLM_INLINE vec3s glms_vec3_rotate_m4(mat4s m, vec3s v) { @@ -283,6 +573,13 @@ glms_vec3_rotate_m4(mat4s m, vec3s v) { return r; } +/*! + * @brief apply rotation matrix to vector + * + * @param[in] m affine matrix or rot matrix + * @param[in] v vector + * @returns rotated vector + */ CGLM_INLINE vec3s glms_vec3_rotate_m3(mat3s m, vec3s v) { @@ -291,6 +588,13 @@ glms_vec3_rotate_m3(mat3s m, vec3s v) { return r; } +/*! + * @brief project a vector onto b vector + * + * @param[in] a vector1 + * @param[in] b vector2 + * @returns projected vector + */ CGLM_INLINE vec3s glms_vec3_proj(vec3s a, vec3s b) { @@ -299,6 +603,13 @@ glms_vec3_proj(vec3s a, vec3s b) { return r; } +/** + * @brief find center point of two vector + * + * @param[in] a vector1 + * @param[in] b vector2 + * @returns center point + */ CGLM_INLINE vec3s glms_vec3_center(vec3s a, vec3s b) { @@ -307,12 +618,39 @@ glms_vec3_center(vec3s a, vec3s b) { return r; } +/** + * @brief squared distance between two vectors + * + * @param[in] a vector1 + * @param[in] b vector2 + * @return squared distance (distance * distance) + */ CGLM_INLINE float glms_vec3_distance2(vec3s a, vec3s b) { return glm_vec3_distance2(a.raw, b.raw); } +/** + * @brief distance between two vectors + * + * @param[in] a vector1 + * @param[in] b vector2 + * @return distance + */ +CGLM_INLINE +float +glms_vec3_distance(vec3s a, vec3s b) { + return glm_vec3_distance(a.raw, b.raw); +} + +/*! + * @brief max values of vectors + * + * @param[in] a vector1 + * @param[in] b vector2 + * @returns destination + */ CGLM_INLINE vec3s glms_vec3_maxv(vec3s a, vec3s b) { @@ -321,6 +659,13 @@ glms_vec3_maxv(vec3s a, vec3s b) { return r; } +/*! + * @brief min values of vectors + * + * @param[in] a vector1 + * @param[in] b vector2 + * @returns destination + */ CGLM_INLINE vec3s glms_vec3_minv(vec3s a, vec3s b) { @@ -329,6 +674,12 @@ glms_vec3_minv(vec3s a, vec3s b) { return r; } +/*! + * @brief possible orthogonal/perpendicular vector + * + * @param[in] v vector + * @returns orthogonal/perpendicular vector + */ CGLM_INLINE vec3s glms_vec3_ortho(vec3s v) { @@ -337,6 +688,14 @@ glms_vec3_ortho(vec3s v) { return r; } +/*! + * @brief clamp vector's individual members between min and max values + * + * @param[in] v vector + * @param[in] minVal minimum value + * @param[in] maxVal maximum value + * @returns clamped vector + */ CGLM_INLINE vec3s glms_vec3_clamp(vec3s v, float minVal, float maxVal) { @@ -344,6 +703,16 @@ glms_vec3_clamp(vec3s v, float minVal, float maxVal) { return v; } +/*! + * @brief linear interpolation between two vector + * + * formula: from + s * (to - from) + * + * @param[in] from from value + * @param[in] to to value + * @param[in] t interpolant (amount) clamped between 0 and 1 + * @returns destination + */ CGLM_INLINE vec3s glms_vec3_lerp(vec3s from, vec3s to, float t) { @@ -352,6 +721,15 @@ glms_vec3_lerp(vec3s from, vec3s to, float t) { return r; } +/*! + * @brief vec3 cross product + * + * this is just convenient wrapper + * + * @param[in] a source 1 + * @param[in] b source 2 + * @returns destination + */ CGLM_INLINE vec3s glms_cross(vec3s a, vec3s b) { @@ -360,12 +738,30 @@ glms_cross(vec3s a, vec3s b) { return r; } +/*! + * @brief vec3 dot product + * + * this is just convenient wrapper + * + * @param[in] a vector1 + * @param[in] b vector2 + * + * @return dot product + */ CGLM_INLINE float glms_dot(vec3s a, vec3s b) { return glm_dot(a.raw, b.raw); } +/*! + * @brief normalize vec3 and store result in same vec + * + * this is just convenient wrapper + * + * @param[in] v vector + * @returns normalized vector + */ CGLM_INLINE vec3s glms_normalize(vec3s v) { diff --git a/include/cglm/structs/vec4-ext.h b/include/cglm/structs/vec4-ext.h index 4fbb2d3..0b81b49 100644 --- a/include/cglm/structs/vec4-ext.h +++ b/include/cglm/structs/vec4-ext.h @@ -5,6 +5,27 @@ * Full license can be found in the LICENSE file */ +/*! + * @brief SIMD like functions + */ + +/* + Functions: + CGLM_INLINE vec4s glms_vec4_broadcast(float val); + CGLM_INLINE bool glms_vec4_eq(vec4s v, float val); + CGLM_INLINE bool glms_vec4_eq_eps(vec4s v, float val); + CGLM_INLINE bool glms_vec4_eq_all(vec4s v); + CGLM_INLINE bool glms_vec4_eqv(vec4s a, vec4s b); + CGLM_INLINE bool glms_vec4_eqv_eps(vec4s a, vec4s b); + CGLM_INLINE float glms_vec4_max(vec4s v); + CGLM_INLINE float glms_vec4_min(vec4s v); + CGLM_INLINE bool glms_vec4_isnan(vec4s v); + CGLM_INLINE bool glms_vec4_isinf(vec4s v); + CGLM_INLINE bool glms_vec4_isvalid(vec4s v); + CGLM_INLINE vec4s glms_vec4_sign(vec4s v); + CGLM_INLINE vec4s glms_vec4_sqrt(vec4s v); + */ + #ifndef cglm_vec4s_ext_h #define cglm_vec4s_ext_h @@ -13,6 +34,12 @@ #include "../util.h" #include "../vec4-ext.h" +/*! + * @brief fill a vector with specified value + * + * @param val value + * @returns dest + */ CGLM_INLINE vec4s glms_vec4_broadcast(float val) { @@ -21,66 +48,131 @@ glms_vec4_broadcast(float val) { return r; } +/*! + * @brief check if vector is equal to value (without epsilon) + * + * @param v vector + * @param val value + */ CGLM_INLINE bool glms_vec4_eq(vec4s v, float val) { return glm_vec4_eq(v.raw, val); } +/*! + * @brief check if vector is equal to value (with epsilon) + * + * @param v vector + * @param val value + */ CGLM_INLINE bool glms_vec4_eq_eps(vec4s v, float val) { return glm_vec4_eq_eps(v.raw, val); } +/*! + * @brief check if vectors members are equal (without epsilon) + * + * @param v vector + */ CGLM_INLINE bool glms_vec4_eq_all(vec4s v) { return glm_vec4_eq_all(v.raw); } +/*! + * @brief check if vector is equal to another (without epsilon) + * + * @param a vector + * @param b vector + */ CGLM_INLINE bool glms_vec4_eqv(vec4s a, vec4s b) { return glm_vec4_eqv(a.raw, b.raw); } +/*! + * @brief check if vector is equal to another (with epsilon) + * + * @param a vector + * @param b vector + */ CGLM_INLINE bool glms_vec4_eqv_eps(vec4s a, vec4s b) { return glm_vec4_eqv_eps(a.raw, b.raw); } +/*! + * @brief max value of vector + * + * @param v vector + */ CGLM_INLINE float glms_vec4_max(vec4s v) { return glm_vec4_max(v.raw); } +/*! + * @brief min value of vector + * + * @param v vector + */ CGLM_INLINE float glms_vec4_min(vec4s v) { return glm_vec4_min(v.raw); } +/*! + * @brief check if one of items is NaN (not a number) + * you should only use this in DEBUG mode or very critical asserts + * + * @param[in] v vector + */ CGLM_INLINE bool glms_vec4_isnan(vec4s v) { return glm_vec4_isnan(v.raw); } +/*! + * @brief check if one of items is INFINITY + * you should only use this in DEBUG mode or very critical asserts + * + * @param[in] v vector + */ CGLM_INLINE bool glms_vec4_isinf(vec4s v) { return glm_vec4_isinf(v.raw); } +/*! + * @brief check if all items are valid number + * you should only use this in DEBUG mode or very critical asserts + * + * @param[in] v vector + */ CGLM_INLINE bool glms_vec4_isvalid(vec4s v) { return glm_vec4_isvalid(v.raw); } +/*! + * @brief get sign of 32 bit float as +1, -1, 0 + * + * Important: It returns 0 for zero/NaN input + * + * @param v vector + * @returns sign vector + */ CGLM_INLINE vec4s glms_vec4_sign(vec4s v) { @@ -89,6 +181,12 @@ glms_vec4_sign(vec4s v) { return r; } +/*! + * @brief square root of each vector item + * + * @param[in] v vector + * @returns destination vector + */ CGLM_INLINE vec4s glms_vec4_sqrt(vec4s v) { diff --git a/include/cglm/structs/vec4.h b/include/cglm/structs/vec4.h index 956fee1..2f950a7 100644 --- a/include/cglm/structs/vec4.h +++ b/include/cglm/structs/vec4.h @@ -5,6 +5,51 @@ * Full license can be found in the LICENSE file */ +/* + Macros: + GLM_VEC4_ONE_INIT + GLM_VEC4_BLACK_INIT + GLM_VEC4_ZERO_INIT + GLM_VEC4_ONE + GLM_VEC4_BLACK + GLM_VEC4_ZERO + + Functions: + CGLM_INLINE vec4s glms_vec4(vec3s v3, float last); + CGLM_INLINE vec3s glms_vec4_copy3(vec4s v); + CGLM_INLINE vec4s glms_vec4_copy(vec4s v); + CGLM_INLINE vec4s glms_vec4_ucopy(vec4s v); + CGLM_INLINE void glms_vec4_pack(vec4s dst[], vec4 src[], size_t len); + CGLM_INLINE void glms_vec4_unpack(vec4 dst[], vec4s src[], size_t len); + CGLM_INLINE float glms_vec4_dot(vec4s a, vec4s b); + CGLM_INLINE float glms_vec4_norm2(vec4s v); + CGLM_INLINE float glms_vec4_norm(vec4s v); + CGLM_INLINE vec4s glms_vec4_add(vec4s a, vec4s b); + CGLM_INLINE vec4s glms_vec4_adds(vec4s v, float s); + CGLM_INLINE vec4s glms_vec4_sub(vec4s a, vec4s b); + CGLM_INLINE vec4s glms_vec4_subs(vec4s v, float s); + CGLM_INLINE vec4s glms_vec4_mul(vec4s a, vec4s b); + CGLM_INLINE vec4s glms_vec4_scale(vec4s v, float s); + CGLM_INLINE vec4s glms_vec4_scale_as(vec4s v, float s); + CGLM_INLINE vec4s glms_vec4_div(vec4s a, vec4s b); + CGLM_INLINE vec4s glms_vec4_divs(vec4s v, float s); + CGLM_INLINE vec4s glms_vec4_addadd(vec4s a, vec4s b, vec4s dest); + CGLM_INLINE vec4s glms_vec4_subadd(vec4s a, vec4s b, vec4s dest); + CGLM_INLINE vec4s glms_vec4_muladd(vec4s a, vec4s b, vec4s dest); + CGLM_INLINE vec4s glms_vec4_muladds(vec4s a, float s, vec4s dest); + CGLM_INLINE vec4s glms_vec4_maxadd(vec4s a, vec4s b, vec4s dest); + CGLM_INLINE vec4s glms_vec4_minadd(vec4s a, vec4s b, vec4s dest); + CGLM_INLINE vec4s glms_vec4_negate(vec4s v); + CGLM_INLINE vec4s glms_vec4_inv(vec4s v); + CGLM_INLINE vec4s glms_vec4_normalize(vec4s v); + CGLM_INLINE float glms_vec4_distance(vec4s a, vec4s b); + CGLM_INLINE vec4s glms_vec4_maxv(vec4s a, vec4s b); + CGLM_INLINE vec4s glms_vec4_minv(vec4s a, vec4s b); + CGLM_INLINE vec4s glms_vec4_clamp(vec4s v, float minVal, float maxVal); + CGLM_INLINE vec4s glms_vec4_lerp(vec4s from, vec4s to, float t); + CGLM_INLINE vec4s glms_vec4_cubic(float s); + */ + #ifndef cglm_vec4s_h #define cglm_vec4s_h @@ -22,6 +67,13 @@ #define GLMS_VEC4_BLACK ((vec4s)GLM_VEC4_BLACK_INIT) #define GLMS_VEC4_ZERO ((vec4s)GLM_VEC4_ZERO_INIT) +/*! + * @brief init vec4 using vec3 + * + * @param[in] v3 vector3 + * @param[in] last last item + * @returns destination + */ CGLM_INLINE vec4s glms_vec4(vec3s v3, float last) { @@ -30,6 +82,12 @@ glms_vec4(vec3s v3, float last) { return r; } +/*! + * @brief copy first 3 members of [a] to [dest] + * + * @param[in] a source + * @returns destination + */ CGLM_INLINE vec3s glms_vec4_copy3(vec4s v) { @@ -38,6 +96,12 @@ glms_vec4_copy3(vec4s v) { return r; } +/*! + * @brief copy all members of [a] to [dest] + * + * @param[in] v source + * @returns destination + */ CGLM_INLINE vec4s glms_vec4_copy(vec4s v) { @@ -46,6 +110,14 @@ glms_vec4_copy(vec4s v) { return r; } +/*! + * @brief copy all members of [a] to [dest] + * + * alignment is not required + * + * @param[in] v source + * @returns destination + */ CGLM_INLINE vec4s glms_vec4_ucopy(vec4s v) { @@ -54,6 +126,13 @@ glms_vec4_ucopy(vec4s v) { return r; } +/*! + * @brief pack an array of vec4 into an array of vec4s + * + * @param[out] dst array of vec4 + * @param[in] src array of vec4s + * @param[in] len number of elements + */ CGLM_INLINE void glms_vec4_pack(vec4s dst[], vec4 src[], size_t len) { @@ -66,6 +145,13 @@ glms_vec4_pack(vec4s dst[], vec4 src[], size_t len) { } } +/*! + * @brief unpack an array of vec4s into an array of vec4 + * + * @param[out] dst array of vec4s + * @param[in] src array of vec4 + * @param[in] len number of elements + */ CGLM_INLINE void glms_vec4_unpack(vec4 dst[], vec4s src[], size_t len) { @@ -78,24 +164,85 @@ glms_vec4_unpack(vec4 dst[], vec4s src[], size_t len) { } } +/*! + * @brief make vector zero + * + * @param[in] v vector + * @returns zero vector + */ +CGLM_INLINE +vec4s +glms_vec4_zero() { + vec4s r; + glm_vec4_zero(r.raw); + return r; +} + +/*! + * @brief make vector one + * + * @param[in] v vector + * @returns one vector + */ +CGLM_INLINE +vec4s +glms_vec4_one() { + vec4s r; + glm_vec4_one(r.raw); + return r; +} + +/*! + * @brief vec4 dot product + * + * @param[in] a vector1 + * @param[in] b vector2 + * + * @return dot product + */ CGLM_INLINE float glms_vec4_dot(vec4s a, vec4s b) { return glm_vec4_dot(a.raw, b.raw); } +/*! + * @brief norm * norm (magnitude) of vec + * + * we can use this func instead of calling norm * norm, because it would call + * sqrtf fuction twice but with this func we can avoid func call, maybe this is + * not good name for this func + * + * @param[in] v vec4 + * + * @return norm * norm + */ CGLM_INLINE float glms_vec4_norm2(vec4s v) { return glm_vec4_norm2(v.raw); } +/*! + * @brief norm (magnitude) of vec4 + * + * @param[in] v vector + * + * @return norm + */ CGLM_INLINE float glms_vec4_norm(vec4s v) { return glm_vec4_norm(v.raw); } +/*! + * @brief add b vector to a vector store result in dest + * + * @param[in] a vector1 + * @param[in] b vector2 + * @returns destination vector + */ CGLM_INLINE vec4s glms_vec4_add(vec4s a, vec4s b) { @@ -104,6 +251,13 @@ glms_vec4_add(vec4s a, vec4s b) { return r; } +/*! + * @brief add scalar to v vector store result in dest (d = v + vec(s)) + * + * @param[in] v vector + * @param[in] s scalar + * @returns destination vector + */ CGLM_INLINE vec4s glms_vec4_adds(vec4s v, float s) { @@ -112,6 +266,13 @@ glms_vec4_adds(vec4s v, float s) { return r; } +/*! + * @brief subtract b vector from a vector store result in dest (d = a - b) + * + * @param[in] a vector1 + * @param[in] b vector2 + * @returns destination vector + */ CGLM_INLINE vec4s glms_vec4_sub(vec4s a, vec4s b) { @@ -120,6 +281,13 @@ glms_vec4_sub(vec4s a, vec4s b) { return r; } +/*! + * @brief subtract scalar from v vector store result in dest (d = v - vec(s)) + * + * @param[in] v vector + * @param[in] s scalar + * @returns destination vector + */ CGLM_INLINE vec4s glms_vec4_subs(vec4s v, float s) { @@ -128,6 +296,13 @@ glms_vec4_subs(vec4s v, float s) { return r; } +/*! + * @brief multiply two vector (component-wise multiplication) + * + * @param a vector1 + * @param b vector2 + * @returns dest = (a[0] * b[0], a[1] * b[1], a[2] * b[2], a[3] * b[3]) + */ CGLM_INLINE vec4s glms_vec4_mul(vec4s a, vec4s b) { @@ -136,6 +311,13 @@ glms_vec4_mul(vec4s a, vec4s b) { return r; } +/*! + * @brief multiply/scale vec4 vector with scalar: result = v * s + * + * @param[in] v vector + * @param[in] s scalar + * @returns destination vector + */ CGLM_INLINE vec4s glms_vec4_scale(vec4s v, float s) { @@ -144,6 +326,13 @@ glms_vec4_scale(vec4s v, float s) { return r; } +/*! + * @brief make vec4 vector scale as specified: result = unit(v) * s + * + * @param[in] v vector + * @param[in] s scalar + * @returns destination vector + */ CGLM_INLINE vec4s glms_vec4_scale_as(vec4s v, float s) { @@ -152,6 +341,13 @@ glms_vec4_scale_as(vec4s v, float s) { return r; } +/*! + * @brief div vector with another component-wise division: d = a / b + * + * @param[in] a vector 1 + * @param[in] b vector 2 + * @returns result = (a[0]/b[0], a[1]/b[1], a[2]/b[2], a[3]/b[3]) + */ CGLM_INLINE vec4s glms_vec4_div(vec4s a, vec4s b) { @@ -160,6 +356,13 @@ glms_vec4_div(vec4s a, vec4s b) { return r; } +/*! + * @brief div vec4 vector with scalar: d = v / s + * + * @param[in] v vector + * @param[in] s scalar + * @returns destination vector + */ CGLM_INLINE vec4s glms_vec4_divs(vec4s v, float s) { @@ -168,6 +371,15 @@ glms_vec4_divs(vec4s v, float s) { return r; } +/*! + * @brief add two vectors and add result to sum + * + * it applies += operator so dest must be initialized + * + * @param[in] a vector 1 + * @param[in] b vector 2 + * @returns dest += (a + b) + */ CGLM_INLINE vec4s glms_vec4_addadd(vec4s a, vec4s b, vec4s dest) { @@ -175,6 +387,15 @@ glms_vec4_addadd(vec4s a, vec4s b, vec4s dest) { return dest; } +/*! + * @brief sub two vectors and add result to dest + * + * it applies += operator so dest must be initialized + * + * @param[in] a vector 1 + * @param[in] b vector 2 + * @returns dest += (a - b) + */ CGLM_INLINE vec4s glms_vec4_subadd(vec4s a, vec4s b, vec4s dest) { @@ -182,6 +403,15 @@ glms_vec4_subadd(vec4s a, vec4s b, vec4s dest) { return dest; } +/*! + * @brief mul two vectors and add result to dest + * + * it applies += operator so dest must be initialized + * + * @param[in] a vector 1 + * @param[in] b vector 2 + * @returns dest += (a * b) + */ CGLM_INLINE vec4s glms_vec4_muladd(vec4s a, vec4s b, vec4s dest) { @@ -189,6 +419,15 @@ glms_vec4_muladd(vec4s a, vec4s b, vec4s dest) { return dest; } +/*! + * @brief mul vector with scalar and add result to sum + * + * it applies += operator so dest must be initialized + * + * @param[in] a vector + * @param[in] s scalar + * @returns dest += (a * b) + */ CGLM_INLINE vec4s glms_vec4_muladds(vec4s a, float s, vec4s dest) { @@ -196,6 +435,15 @@ glms_vec4_muladds(vec4s a, float s, vec4s dest) { return dest; } +/*! + * @brief add max of two vector to result/dest + * + * it applies += operator so dest must be initialized + * + * @param[in] a vector 1 + * @param[in] b vector 2 + * @returns dest += max(a, b) + */ CGLM_INLINE vec4s glms_vec4_maxadd(vec4s a, vec4s b, vec4s dest) { @@ -203,6 +451,15 @@ glms_vec4_maxadd(vec4s a, vec4s b, vec4s dest) { return dest; } +/*! + * @brief add min of two vector to result/dest + * + * it applies += operator so dest must be initialized + * + * @param[in] a vector 1 + * @param[in] b vector 2 + * @returns dest += min(a, b) + */ CGLM_INLINE vec4s glms_vec4_minadd(vec4s a, vec4s b, vec4s dest) { @@ -210,6 +467,12 @@ glms_vec4_minadd(vec4s a, vec4s b, vec4s dest) { return dest; } +/*! + * @brief negate vector components and store result in dest + * + * @param[in] v vector + * @returns result vector + */ CGLM_INLINE vec4s glms_vec4_negate(vec4s v) { @@ -217,13 +480,12 @@ glms_vec4_negate(vec4s v) { return v; } -CGLM_INLINE -vec4s -glms_vec4_inv(vec4s v) { - glm_vec4_inv(v.raw); - return v; -} - +/*! + * @brief normalize vec4 and store result in same vec + * + * @param[in] v vector + * @returns normalized vector + */ CGLM_INLINE vec4s glms_vec4_normalize(vec4s v) { @@ -231,12 +493,26 @@ glms_vec4_normalize(vec4s v) { return v; } +/** + * @brief distance between two vectors + * + * @param[in] a vector1 + * @param[in] b vector2 + * @return returns distance + */ CGLM_INLINE float glms_vec4_distance(vec4s a, vec4s b) { return glm_vec4_distance(a.raw, b.raw); } +/*! + * @brief max values of vectors + * + * @param[in] a vector1 + * @param[in] b vector2 + * @returns destination + */ CGLM_INLINE vec4s glms_vec4_maxv(vec4s a, vec4s b) { @@ -245,6 +521,13 @@ glms_vec4_maxv(vec4s a, vec4s b) { return r; } +/*! + * @brief min values of vectors + * + * @param[in] a vector1 + * @param[in] b vector2 + * @returns destination + */ CGLM_INLINE vec4s glms_vec4_minv(vec4s a, vec4s b) { @@ -253,6 +536,14 @@ glms_vec4_minv(vec4s a, vec4s b) { return r; } +/*! + * @brief clamp vector's individual members between min and max values + * + * @param[in] v vector + * @param[in] minVal minimum value + * @param[in] maxVal maximum value + * @returns clamped vector + */ CGLM_INLINE vec4s glms_vec4_clamp(vec4s v, float minVal, float maxVal) { @@ -260,6 +551,16 @@ glms_vec4_clamp(vec4s v, float minVal, float maxVal) { return v; } +/*! + * @brief linear interpolation between two vector + * + * formula: from + s * (to - from) + * + * @param[in] from from value + * @param[in] to to value + * @param[in] t interpolant (amount) clamped between 0 and 1 + * @returns destination + */ CGLM_INLINE vec4s glms_vec4_lerp(vec4s from, vec4s to, float t) { @@ -268,6 +569,12 @@ glms_vec4_lerp(vec4s from, vec4s to, float t) { return r; } +/*! + * @brief helper to fill vec4 as [S^3, S^2, S, 1] + * + * @param[in] s parameter + * @returns destination + */ CGLM_INLINE vec4s glms_vec4_cubic(float s) {