diff --git a/README.md b/README.md index ff1b4df..9567960 100644 --- a/README.md +++ b/README.md @@ -16,7 +16,7 @@ Complete documentation: http://cglm.readthedocs.io #### Note for previous versions: -- _dup (duplicate) is changed to _copy. For instance `glm_vec_dup -> glm_vec_copy` +- _dup (duplicate) is changed to _copy. For instance `glm_vec_dup -> glm_vec3_copy` - OpenGL related functions are dropped to make this lib platform/third-party independent - make sure you have latest version and feel free to report bugs, troubles - **[bugfix]** euler angles was implemented in reverse order (extrinsic) it was fixed, now they are intrinsic. Make sure that @@ -201,15 +201,15 @@ If you want to use inline versions of funcstions then; include main header ``` the header will include all headers. Then call func you want e.g. rotate vector by axis: ```C -glm_vec_rotate(v1, glm_rad(45), (vec3){1.0f, 0.0f, 0.0f}); +glm_vec3_rotate(v1, glm_rad(45), (vec3){1.0f, 0.0f, 0.0f}); ``` some functions are overloaded :) e.g you can normalize vector: ```C -glm_vec_normalize(vec); +glm_vec3_normalize(vec); ``` this will normalize vec and store normalized vector into `vec` but if you will store normalized vector into another vector do this: ```C -glm_vec_normalize_to(vec, result); +glm_vec3_normalize_to(vec, result); ``` like this function you may see `_to` postfix, this functions store results to another variables and save temp memory @@ -220,7 +220,7 @@ to call pre-compiled versions include header with `c` postfix, c means call. Pre ``` this header will include all headers with c postfix. You need to call functions with c posfix: ```C -glmc_vec_normalize(vec); +glmc_vec3_normalize(vec); ``` Function usage and parameters are documented inside related headers. You may see same parameter passed twice in some examples like this: diff --git a/include/cglm/affine-mat.h b/include/cglm/affine-mat.h index d26857b..0dcb447 100644 --- a/include/cglm/affine-mat.h +++ b/include/cglm/affine-mat.h @@ -160,8 +160,8 @@ glm_inv_tr(mat4 mat) { /* translate */ glm_mat3_mulv(r, mat[3], t); - glm_vec_negate(t); - glm_vec_copy(t, mat[3]); + glm_vec3_negate(t); + glm_vec3_copy(t, mat[3]); #endif } diff --git a/include/cglm/affine.h b/include/cglm/affine.h index 4c0e1e9..364ed20 100644 --- a/include/cglm/affine.h +++ b/include/cglm/affine.h @@ -170,7 +170,7 @@ CGLM_INLINE void glm_translate_make(mat4 m, vec3 v) { glm_mat4_identity(m); - glm_vec_copy(v, m[3]); + glm_vec3_copy(v, m[3]); } /*! @@ -325,13 +325,13 @@ glm_rotate_make(mat4 m, float angle, vec3 axis) { c = cosf(angle); - glm_vec_normalize_to(axis, axisn); - glm_vec_scale(axisn, 1.0f - c, v); - glm_vec_scale(axisn, sinf(angle), vs); + glm_vec3_normalize_to(axis, axisn); + glm_vec3_scale(axisn, 1.0f - c, v); + glm_vec3_scale(axisn, sinf(angle), vs); - glm_vec_scale(axisn, v[0], m[0]); - glm_vec_scale(axisn, v[1], m[1]); - glm_vec_scale(axisn, v[2], m[2]); + glm_vec3_scale(axisn, v[0], m[0]); + glm_vec3_scale(axisn, v[1], m[1]); + glm_vec3_scale(axisn, v[2], m[2]); m[0][0] += c; m[1][0] -= vs[2]; m[2][0] += vs[1]; m[0][1] += vs[2]; m[1][1] += c; m[2][1] -= vs[0]; @@ -370,7 +370,7 @@ void glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis) { CGLM_ALIGN(8) vec3 pivotInv; - glm_vec_negate_to(pivot, pivotInv); + glm_vec3_negate_to(pivot, pivotInv); glm_translate(m, pivot); glm_rotate(m, angle, axis); @@ -395,7 +395,7 @@ void glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis) { CGLM_ALIGN(8) vec3 pivotInv; - glm_vec_negate_to(pivot, pivotInv); + glm_vec3_negate_to(pivot, pivotInv); glm_translate_make(m, pivot); glm_rotate(m, angle, axis); @@ -411,9 +411,9 @@ glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis) { CGLM_INLINE void glm_decompose_scalev(mat4 m, vec3 s) { - s[0] = glm_vec_norm(m[0]); - s[1] = glm_vec_norm(m[1]); - s[2] = glm_vec_norm(m[2]); + s[0] = glm_vec3_norm(m[0]); + s[1] = glm_vec3_norm(m[1]); + s[2] = glm_vec3_norm(m[2]); } /*! @@ -429,7 +429,7 @@ bool glm_uniscaled(mat4 m) { CGLM_ALIGN(8) vec3 s; glm_decompose_scalev(m, s); - return glm_vec_eq_all(s); + return glm_vec3_eq_all(s); } /*! @@ -451,9 +451,9 @@ glm_decompose_rs(mat4 m, mat4 r, vec3 s) { glm_vec4_copy(m[2], r[2]); glm_vec4_copy(t, r[3]); - s[0] = glm_vec_norm(m[0]); - s[1] = glm_vec_norm(m[1]); - s[2] = glm_vec_norm(m[2]); + s[0] = glm_vec3_norm(m[0]); + s[1] = glm_vec3_norm(m[1]); + s[2] = glm_vec3_norm(m[2]); glm_vec4_scale(r[0], 1.0f/s[0], r[0]); glm_vec4_scale(r[1], 1.0f/s[1], r[1]); @@ -462,12 +462,12 @@ glm_decompose_rs(mat4 m, mat4 r, vec3 s) { /* Note from Apple Open Source (asume that the matrix is orthonormal): check for a coordinate system flip. If the determinant is -1, then negate the matrix and the scaling factors. */ - glm_vec_cross(m[0], m[1], v); - if (glm_vec_dot(v, m[2]) < 0.0f) { + glm_vec3_cross(m[0], m[1], v); + if (glm_vec3_dot(v, m[2]) < 0.0f) { glm_vec4_flipsign(r[0]); glm_vec4_flipsign(r[1]); glm_vec4_flipsign(r[2]); - glm_vec_negate(s); + glm_vec3_negate(s); } } diff --git a/include/cglm/box.h b/include/cglm/box.h index 3708107..0fec3ee 100644 --- a/include/cglm/box.h +++ b/include/cglm/box.h @@ -25,33 +25,33 @@ void glm_aabb_transform(vec3 box[2], mat4 m, vec3 dest[2]) { vec3 v[2], xa, xb, ya, yb, za, zb, tmp; - glm_vec_scale(m[0], box[0][0], xa); - glm_vec_scale(m[0], box[1][0], xb); + glm_vec3_scale(m[0], box[0][0], xa); + glm_vec3_scale(m[0], box[1][0], xb); - glm_vec_scale(m[1], box[0][1], ya); - glm_vec_scale(m[1], box[1][1], yb); + glm_vec3_scale(m[1], box[0][1], ya); + glm_vec3_scale(m[1], box[1][1], yb); - glm_vec_scale(m[2], box[0][2], za); - glm_vec_scale(m[2], box[1][2], zb); + glm_vec3_scale(m[2], box[0][2], za); + glm_vec3_scale(m[2], box[1][2], zb); /* min(xa, xb) + min(ya, yb) + min(za, zb) + translation */ - glm_vec_minv(xa, xb, v[0]); - glm_vec_minv(ya, yb, tmp); - glm_vec_add(v[0], tmp, v[0]); - glm_vec_minv(za, zb, tmp); - glm_vec_add(v[0], tmp, v[0]); - glm_vec_add(v[0], m[3], v[0]); + glm_vec3_minv(xa, xb, v[0]); + glm_vec3_minv(ya, yb, tmp); + glm_vec3_add(v[0], tmp, v[0]); + glm_vec3_minv(za, zb, tmp); + glm_vec3_add(v[0], tmp, v[0]); + glm_vec3_add(v[0], m[3], v[0]); /* max(xa, xb) + max(ya, yb) + max(za, zb) + translation */ - glm_vec_maxv(xa, xb, v[1]); - glm_vec_maxv(ya, yb, tmp); - glm_vec_add(v[1], tmp, v[1]); - glm_vec_maxv(za, zb, tmp); - glm_vec_add(v[1], tmp, v[1]); - glm_vec_add(v[1], m[3], v[1]); + glm_vec3_maxv(xa, xb, v[1]); + glm_vec3_maxv(ya, yb, tmp); + glm_vec3_add(v[1], tmp, v[1]); + glm_vec3_maxv(za, zb, tmp); + glm_vec3_add(v[1], tmp, v[1]); + glm_vec3_add(v[1], m[3], v[1]); - glm_vec_copy(v[0], dest[0]); - glm_vec_copy(v[1], dest[1]); + glm_vec3_copy(v[0], dest[0]); + glm_vec3_copy(v[1], dest[1]); } /*! @@ -162,8 +162,8 @@ glm_aabb_frustum(vec3 box[2], vec4 planes[6]) { CGLM_INLINE void glm_aabb_invalidate(vec3 box[2]) { - glm_vec_broadcast(FLT_MAX, box[0]); - glm_vec_broadcast(-FLT_MAX, box[1]); + glm_vec3_broadcast(FLT_MAX, box[0]); + glm_vec3_broadcast(-FLT_MAX, box[1]); } /*! @@ -174,8 +174,8 @@ glm_aabb_invalidate(vec3 box[2]) { CGLM_INLINE bool glm_aabb_isvalid(vec3 box[2]) { - return glm_vec_max(box[0]) != FLT_MAX - && glm_vec_min(box[1]) != -FLT_MAX; + return glm_vec3_max(box[0]) != FLT_MAX + && glm_vec3_min(box[1]) != -FLT_MAX; } /*! @@ -186,7 +186,7 @@ glm_aabb_isvalid(vec3 box[2]) { CGLM_INLINE float glm_aabb_size(vec3 box[2]) { - return glm_vec_distance(box[0], box[1]); + return glm_vec3_distance(box[0], box[1]); } /*! @@ -209,7 +209,7 @@ glm_aabb_radius(vec3 box[2]) { CGLM_INLINE void glm_aabb_center(vec3 box[2], vec3 dest) { - glm_vec_center(box[0], box[1], dest); + glm_vec3_center(box[0], box[1], dest); } /*! diff --git a/include/cglm/call/vec3.h b/include/cglm/call/vec3.h index d96de98..1cd2e08 100644 --- a/include/cglm/call/vec3.h +++ b/include/cglm/call/vec3.h @@ -13,234 +13,231 @@ extern "C" { #include "../cglm.h" -/* DEPRECATED! use _copy, _ucopy versions */ -#define glmc_vec_dup(v, dest) glmc_vec_copy(v, dest) - CGLM_EXPORT void glmc_vec3(vec4 v4, vec3 dest); CGLM_EXPORT void -glmc_vec_copy(vec3 a, vec3 dest); +glmc_vec3_copy(vec3 a, vec3 dest); CGLM_EXPORT void -glmc_vec_zero(vec3 v); +glmc_vec3_zero(vec3 v); CGLM_EXPORT void -glmc_vec_one(vec3 v); +glmc_vec3_one(vec3 v); CGLM_EXPORT float -glmc_vec_dot(vec3 a, vec3 b); +glmc_vec3_dot(vec3 a, vec3 b); CGLM_EXPORT void -glmc_vec_cross(vec3 a, vec3 b, vec3 d); +glmc_vec3_cross(vec3 a, vec3 b, vec3 d); CGLM_EXPORT float -glmc_vec_norm(vec3 vec); +glmc_vec3_norm(vec3 vec); CGLM_EXPORT float -glmc_vec_norm2(vec3 vec); +glmc_vec3_norm2(vec3 vec); CGLM_EXPORT void -glmc_vec_normalize_to(vec3 vec, vec3 dest); +glmc_vec3_normalize_to(vec3 vec, vec3 dest); CGLM_EXPORT void -glmc_vec_normalize(vec3 v); +glmc_vec3_normalize(vec3 v); CGLM_EXPORT void -glmc_vec_add(vec3 v1, vec3 v2, vec3 dest); +glmc_vec3_add(vec3 v1, vec3 v2, vec3 dest); CGLM_EXPORT void -glmc_vec_adds(vec3 v, float s, vec3 dest); +glmc_vec3_adds(vec3 v, float s, vec3 dest); CGLM_EXPORT void -glmc_vec_sub(vec3 a, vec3 b, vec3 dest); +glmc_vec3_sub(vec3 a, vec3 b, vec3 dest); CGLM_EXPORT void -glmc_vec_subs(vec3 v, float s, vec3 dest); +glmc_vec3_subs(vec3 v, float s, vec3 dest); CGLM_EXPORT void -glmc_vec_mul(vec3 a, vec3 b, vec3 d); +glmc_vec3_mul(vec3 a, vec3 b, vec3 d); CGLM_EXPORT void -glmc_vec_scale(vec3 v, float s, vec3 dest); +glmc_vec3_scale(vec3 v, float s, vec3 dest); CGLM_EXPORT void -glmc_vec_scale_as(vec3 v, float s, vec3 dest); +glmc_vec3_scale_as(vec3 v, float s, vec3 dest); CGLM_EXPORT void -glmc_vec_div(vec3 a, vec3 b, vec3 dest); +glmc_vec3_div(vec3 a, vec3 b, vec3 dest); CGLM_EXPORT void -glmc_vec_divs(vec3 a, float s, vec3 dest); +glmc_vec3_divs(vec3 a, float s, vec3 dest); CGLM_EXPORT void -glmc_vec_addadd(vec3 a, vec3 b, vec3 dest); +glmc_vec3_addadd(vec3 a, vec3 b, vec3 dest); CGLM_EXPORT void -glmc_vec_subadd(vec3 a, vec3 b, vec3 dest); +glmc_vec3_subadd(vec3 a, vec3 b, vec3 dest); CGLM_EXPORT void -glmc_vec_muladd(vec3 a, vec3 b, vec3 dest); +glmc_vec3_muladd(vec3 a, vec3 b, vec3 dest); CGLM_EXPORT void -glmc_vec_muladds(vec3 a, float s, vec3 dest); +glmc_vec3_muladds(vec3 a, float s, vec3 dest); CGLM_EXPORT void -glmc_vec_flipsign(vec3 v); +glmc_vec3_flipsign(vec3 v); CGLM_EXPORT void -glmc_vec_flipsign_to(vec3 v, vec3 dest); +glmc_vec3_flipsign_to(vec3 v, vec3 dest); CGLM_EXPORT void -glmc_vec_negate(vec3 v); +glmc_vec3_negate(vec3 v); CGLM_EXPORT void -glmc_vec_negate_to(vec3 v, vec3 dest); +glmc_vec3_negate_to(vec3 v, vec3 dest); CGLM_EXPORT void -glmc_vec_inv(vec3 v); +glmc_vec3_inv(vec3 v); CGLM_EXPORT void -glmc_vec_inv_to(vec3 v, vec3 dest); +glmc_vec3_inv_to(vec3 v, vec3 dest); CGLM_EXPORT float -glmc_vec_angle(vec3 v1, vec3 v2); +glmc_vec3_angle(vec3 v1, vec3 v2); CGLM_EXPORT void -glmc_vec_rotate(vec3 v, float angle, vec3 axis); +glmc_vec3_rotate(vec3 v, float angle, vec3 axis); CGLM_EXPORT void -glmc_vec_rotate_m4(mat4 m, vec3 v, vec3 dest); +glmc_vec3_rotate_m4(mat4 m, vec3 v, vec3 dest); CGLM_EXPORT void -glmc_vec_rotate_m3(mat3 m, vec3 v, vec3 dest); +glmc_vec3_rotate_m3(mat3 m, vec3 v, vec3 dest); CGLM_EXPORT void -glmc_vec_proj(vec3 a, vec3 b, vec3 dest); +glmc_vec3_proj(vec3 a, vec3 b, vec3 dest); CGLM_EXPORT void -glmc_vec_center(vec3 v1, vec3 v2, vec3 dest); +glmc_vec3_center(vec3 v1, vec3 v2, vec3 dest); CGLM_EXPORT float -glmc_vec_distance2(vec3 v1, vec3 v2); +glmc_vec3_distance2(vec3 v1, vec3 v2); CGLM_EXPORT float -glmc_vec_distance(vec3 v1, vec3 v2); +glmc_vec3_distance(vec3 v1, vec3 v2); CGLM_EXPORT void -glmc_vec_maxv(vec3 v1, vec3 v2, vec3 dest); +glmc_vec3_maxv(vec3 v1, vec3 v2, vec3 dest); CGLM_EXPORT void -glmc_vec_minv(vec3 v1, vec3 v2, vec3 dest); +glmc_vec3_minv(vec3 v1, vec3 v2, vec3 dest); CGLM_EXPORT void -glmc_vec_clamp(vec3 v, float minVal, float maxVal); +glmc_vec3_clamp(vec3 v, float minVal, float maxVal); CGLM_EXPORT void -glmc_vec_ortho(vec3 v, vec3 dest); +glmc_vec3_ortho(vec3 v, vec3 dest); CGLM_EXPORT void -glmc_vec_lerp(vec3 from, vec3 to, float t, vec3 dest); +glmc_vec3_lerp(vec3 from, vec3 to, float t, vec3 dest); /* ext */ CGLM_EXPORT void -glmc_vec_mulv(vec3 a, vec3 b, vec3 d); +glmc_vec3_mulv(vec3 a, vec3 b, vec3 d); CGLM_EXPORT void -glmc_vec_broadcast(float val, vec3 d); +glmc_vec3_broadcast(float val, vec3 d); CGLM_EXPORT bool -glmc_vec_eq(vec3 v, float val); +glmc_vec3_eq(vec3 v, float val); CGLM_EXPORT bool -glmc_vec_eq_eps(vec3 v, float val); +glmc_vec3_eq_eps(vec3 v, float val); CGLM_EXPORT bool -glmc_vec_eq_all(vec3 v); +glmc_vec3_eq_all(vec3 v); CGLM_EXPORT bool -glmc_vec_eqv(vec3 v1, vec3 v2); +glmc_vec3_eqv(vec3 v1, vec3 v2); CGLM_EXPORT bool -glmc_vec_eqv_eps(vec3 v1, vec3 v2); +glmc_vec3_eqv_eps(vec3 v1, vec3 v2); CGLM_EXPORT float -glmc_vec_max(vec3 v); +glmc_vec3_max(vec3 v); CGLM_EXPORT float -glmc_vec_min(vec3 v); +glmc_vec3_min(vec3 v); CGLM_EXPORT bool -glmc_vec_isnan(vec3 v); +glmc_vec3_isnan(vec3 v); CGLM_EXPORT bool -glmc_vec_isinf(vec3 v); +glmc_vec3_isinf(vec3 v); CGLM_EXPORT bool -glmc_vec_isvalid(vec3 v); +glmc_vec3_isvalid(vec3 v); CGLM_EXPORT void -glmc_vec_sign(vec3 v, vec3 dest); +glmc_vec3_sign(vec3 v, vec3 dest); CGLM_EXPORT void -glmc_vec_sqrt(vec3 v, vec3 dest); +glmc_vec3_sqrt(vec3 v, vec3 dest); #ifdef __cplusplus } diff --git a/include/cglm/cam.h b/include/cglm/cam.h index 284ae82..acfa970 100644 --- a/include/cglm/cam.h +++ b/include/cglm/cam.h @@ -320,13 +320,13 @@ glm_lookat(vec3 eye, mat4 dest) { CGLM_ALIGN(8) vec3 f, u, s; - glm_vec_sub(center, eye, f); - glm_vec_normalize(f); + glm_vec3_sub(center, eye, f); + glm_vec3_normalize(f); - glm_vec_cross(f, up, s); - glm_vec_normalize(s); + glm_vec3_cross(f, up, s); + glm_vec3_normalize(s); - glm_vec_cross(s, f, u); + glm_vec3_cross(s, f, u); dest[0][0] = s[0]; dest[0][1] = u[0]; @@ -337,9 +337,9 @@ glm_lookat(vec3 eye, dest[2][0] = s[2]; dest[2][1] = u[2]; dest[2][2] =-f[2]; - dest[3][0] =-glm_vec_dot(s, eye); - dest[3][1] =-glm_vec_dot(u, eye); - dest[3][2] = glm_vec_dot(f, eye); + dest[3][0] =-glm_vec3_dot(s, eye); + dest[3][1] =-glm_vec3_dot(u, eye); + dest[3][2] = glm_vec3_dot(f, eye); dest[0][3] = dest[1][3] = dest[2][3] = 0.0f; dest[3][3] = 1.0f; } @@ -362,7 +362,7 @@ CGLM_INLINE void glm_look(vec3 eye, vec3 dir, vec3 up, mat4 dest) { CGLM_ALIGN(8) vec3 target; - glm_vec_add(eye, dir, target); + glm_vec3_add(eye, dir, target); glm_lookat(eye, target, up, dest); } @@ -380,7 +380,7 @@ CGLM_INLINE void glm_look_anyup(vec3 eye, vec3 dir, mat4 dest) { CGLM_ALIGN(8) vec3 up; - glm_vec_ortho(dir, up); + glm_vec3_ortho(dir, up); glm_look(eye, dir, up, dest); } diff --git a/include/cglm/frustum.h b/include/cglm/frustum.h index d4e8d47..78b39d2 100644 --- a/include/cglm/frustum.h +++ b/include/cglm/frustum.h @@ -106,7 +106,7 @@ glm_frustum_planes(mat4 m, vec4 dest[6]) { * * Find center coordinates: * for (j = 0; j < 4; j++) { - * glm_vec_center(corners[i], corners[i + 4], centerCorners[i]); + * glm_vec3_center(corners[i], corners[i + 4], centerCorners[i]); * } * * @param[in] invMat matrix (see brief) @@ -187,8 +187,8 @@ glm_frustum_box(vec4 corners[8], mat4 m, vec3 box[2]) { vec3 min, max; int i; - glm_vec_broadcast(FLT_MAX, min); - glm_vec_broadcast(-FLT_MAX, max); + glm_vec3_broadcast(FLT_MAX, min); + glm_vec3_broadcast(-FLT_MAX, max); for (i = 0; i < 8; i++) { glm_mat4_mulv(m, corners[i], v); @@ -202,8 +202,8 @@ glm_frustum_box(vec4 corners[8], mat4 m, vec3 box[2]) { max[2] = glm_max(max[2], v[2]); } - glm_vec_copy(min, box[0]); - glm_vec_copy(max, box[1]); + glm_vec3_copy(min, box[0]); + glm_vec3_copy(max, box[1]); } /*! @@ -228,7 +228,7 @@ glm_frustum_corners_at(vec4 corners[8], float dist, sc; /* because distance and scale is same for all */ - dist = glm_vec_distance(corners[GLM_RTF], corners[GLM_RTN]); + dist = glm_vec3_distance(corners[GLM_RTF], corners[GLM_RTN]); sc = dist * (splitDist / farDist); /* left bottom */ diff --git a/include/cglm/mat3.h b/include/cglm/mat3.h index 5d0d6ac..2d6523c 100644 --- a/include/cglm/mat3.h +++ b/include/cglm/mat3.h @@ -330,9 +330,9 @@ CGLM_INLINE void glm_mat3_swap_col(mat3 mat, int col1, int col2) { vec3 tmp; - glm_vec_copy(mat[col1], tmp); - glm_vec_copy(mat[col2], mat[col1]); - glm_vec_copy(tmp, mat[col2]); + glm_vec3_copy(mat[col1], tmp); + glm_vec3_copy(mat[col2], mat[col1]); + glm_vec3_copy(tmp, mat[col2]); } /*! diff --git a/include/cglm/plane.h b/include/cglm/plane.h index e0faed5..48fe879 100644 --- a/include/cglm/plane.h +++ b/include/cglm/plane.h @@ -30,7 +30,7 @@ CGLM_INLINE void glm_plane_normalize(vec4 plane) { - glm_vec4_scale(plane, 1.0f / glm_vec_norm(plane), plane); + glm_vec4_scale(plane, 1.0f / glm_vec3_norm(plane), plane); } #endif /* cglm_plane_h */ diff --git a/include/cglm/quat.h b/include/cglm/quat.h index b4283b6..37aba8d 100644 --- a/include/cglm/quat.h +++ b/include/cglm/quat.h @@ -361,7 +361,7 @@ glm_quat_imagn(versor q, vec3 dest) { CGLM_INLINE float glm_quat_imaglen(versor q) { - return glm_vec_norm(q); + return glm_vec3_norm(q); } /*! @@ -670,7 +670,7 @@ glm_quat_look(vec3 eye, versor ori, mat4 dest) { /* translate */ glm_mat4_mulv3(dest, eye, 1.0f, dest[3]); - glm_vec_negate(dest[3]); + glm_vec3_negate(dest[3]); } /*! @@ -687,7 +687,7 @@ glm_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest) { CGLM_ALIGN(8) vec3 axis; float dot, angle; - dot = glm_vec_dot(dir, fwd); + dot = glm_vec3_dot(dir, fwd); if (fabsf(dot + 1.0f) < 0.000001f) { glm_quat_init(dest, up[0], up[1], up[2], GLM_PIf); return; @@ -719,7 +719,7 @@ CGLM_INLINE void glm_quat_forp(vec3 from, vec3 to, vec3 fwd, vec3 up, versor dest) { CGLM_ALIGN(8) vec3 dir; - glm_vec_sub(to, from, dir); + glm_vec3_sub(to, from, dir); glm_quat_for(dir, fwd, up, dest); } @@ -741,14 +741,14 @@ glm_quat_rotatev(versor q, vec3 v, vec3 dest) { glm_quat_imag(p, u); s = glm_quat_real(p); - glm_vec_scale(u, 2.0f * glm_vec_dot(u, v), v1); - glm_vec_scale(v, s * s - glm_vec_dot(u, u), v2); - glm_vec_add(v1, v2, v1); + glm_vec3_scale(u, 2.0f * glm_vec3_dot(u, v), v1); + glm_vec3_scale(v, s * s - glm_vec3_dot(u, u), v2); + glm_vec3_add(v1, v2, v1); - glm_vec_cross(u, v, v2); - glm_vec_scale(v2, 2.0f * s, v2); + glm_vec3_cross(u, v, v2); + glm_vec3_scale(v2, 2.0f * s, v2); - glm_vec_add(v1, v2, dest); + glm_vec3_add(v1, v2, dest); } /*! @@ -778,7 +778,7 @@ void glm_quat_rotate_at(mat4 m, versor q, vec3 pivot) { CGLM_ALIGN(8) vec3 pivotInv; - glm_vec_negate_to(pivot, pivotInv); + glm_vec3_negate_to(pivot, pivotInv); glm_translate(m, pivot); glm_quat_rotate(m, q, m); @@ -802,7 +802,7 @@ void glm_quat_rotate_atm(mat4 m, versor q, vec3 pivot) { CGLM_ALIGN(8) vec3 pivotInv; - glm_vec_negate_to(pivot, pivotInv); + glm_vec3_negate_to(pivot, pivotInv); glm_translate_make(m, pivot); glm_quat_rotate(m, q, m); diff --git a/include/cglm/sphere.h b/include/cglm/sphere.h index a7501b9..334b83a 100644 --- a/include/cglm/sphere.h +++ b/include/cglm/sphere.h @@ -60,13 +60,13 @@ void glm_sphere_merge(vec4 s1, vec4 s2, vec4 dest) { float dist, radii; - dist = glm_vec_distance(s1, s2); + dist = glm_vec3_distance(s1, s2); radii = dist + s1[3] + s2[3]; radii = glm_max(radii, s1[3]); radii = glm_max(radii, s2[3]); - glm_vec_center(s1, s2, dest); + glm_vec3_center(s1, s2, dest); dest[3] = radii; } @@ -79,7 +79,7 @@ glm_sphere_merge(vec4 s1, vec4 s2, vec4 dest) { CGLM_INLINE bool glm_sphere_sphere(vec4 s1, vec4 s2) { - return glm_vec_distance2(s1, s2) <= glm_pow2(s1[3] + s2[3]); + return glm_vec3_distance2(s1, s2) <= glm_pow2(s1[3] + s2[3]); } /*! @@ -93,7 +93,7 @@ bool glm_sphere_point(vec4 s, vec3 point) { float rr; rr = s[3] * s[3]; - return glm_vec_distance2(point, s) <= rr; + return glm_vec3_distance2(point, s) <= rr; } #endif /* cglm_sphere_h */ diff --git a/include/cglm/vec3-ext.h b/include/cglm/vec3-ext.h index e12c133..34166f4 100644 --- a/include/cglm/vec3-ext.h +++ b/include/cglm/vec3-ext.h @@ -11,15 +11,20 @@ /* Functions: - CGLM_INLINE void glm_vec_mulv(vec3 a, vec3 b, vec3 d); - CGLM_INLINE void glm_vec_broadcast(float val, vec3 d); - CGLM_INLINE bool glm_vec_eq(vec3 v, float val); - CGLM_INLINE bool glm_vec_eq_eps(vec3 v, float val); - CGLM_INLINE bool glm_vec_eq_all(vec3 v); - CGLM_INLINE bool glm_vec_eqv(vec3 v1, vec3 v2); - CGLM_INLINE bool glm_vec_eqv_eps(vec3 v1, vec3 v2); - CGLM_INLINE float glm_vec_max(vec3 v); - CGLM_INLINE float glm_vec_min(vec3 v); + CGLM_INLINE void glm_vec3_mulv(vec3 a, vec3 b, vec3 d); + CGLM_INLINE void glm_vec3_broadcast(float val, vec3 d); + CGLM_INLINE bool glm_vec3_eq(vec3 v, float val); + CGLM_INLINE bool glm_vec3_eq_eps(vec3 v, float val); + CGLM_INLINE bool glm_vec3_eq_all(vec3 v); + CGLM_INLINE bool glm_vec3_eqv(vec3 v1, vec3 v2); + CGLM_INLINE bool glm_vec3_eqv_eps(vec3 v1, vec3 v2); + CGLM_INLINE float glm_vec3_max(vec3 v); + CGLM_INLINE float glm_vec3_min(vec3 v); + CGLM_INLINE bool glm_vec3_isnan(vec3 v); + CGLM_INLINE bool glm_vec3_isinf(vec3 v); + CGLM_INLINE bool glm_vec3_isvalid(vec3 v); + CGLM_INLINE void glm_vec3_sign(vec3 v, vec3 dest); + CGLM_INLINE void glm_vec3_sqrt(vec3 v, vec3 dest); */ #ifndef cglm_vec3_ext_h @@ -32,7 +37,7 @@ #include /*! - * @brief DEPRECATED! use glm_vec_mul + * @brief DEPRECATED! use glm_vec3_mul * * @param[in] a vec1 * @param[in] b vec2 @@ -40,7 +45,7 @@ */ CGLM_INLINE void -glm_vec_mulv(vec3 a, vec3 b, vec3 d) { +glm_vec3_mulv(vec3 a, vec3 b, vec3 d) { d[0] = a[0] * b[0]; d[1] = a[1] * b[1]; d[2] = a[2] * b[2]; @@ -54,7 +59,7 @@ glm_vec_mulv(vec3 a, vec3 b, vec3 d) { */ CGLM_INLINE void -glm_vec_broadcast(float val, vec3 d) { +glm_vec3_broadcast(float val, vec3 d) { d[0] = d[1] = d[2] = val; } @@ -66,7 +71,7 @@ glm_vec_broadcast(float val, vec3 d) { */ CGLM_INLINE bool -glm_vec_eq(vec3 v, float val) { +glm_vec3_eq(vec3 v, float val) { return v[0] == val && v[0] == v[1] && v[0] == v[2]; } @@ -78,7 +83,7 @@ glm_vec_eq(vec3 v, float val) { */ CGLM_INLINE bool -glm_vec_eq_eps(vec3 v, float val) { +glm_vec3_eq_eps(vec3 v, float val) { return fabsf(v[0] - val) <= FLT_EPSILON && fabsf(v[1] - val) <= FLT_EPSILON && fabsf(v[2] - val) <= FLT_EPSILON; @@ -91,7 +96,7 @@ glm_vec_eq_eps(vec3 v, float val) { */ CGLM_INLINE bool -glm_vec_eq_all(vec3 v) { +glm_vec3_eq_all(vec3 v) { return v[0] == v[1] && v[0] == v[2]; } @@ -103,10 +108,10 @@ glm_vec_eq_all(vec3 v) { */ CGLM_INLINE bool -glm_vec_eqv(vec3 v1, vec3 v2) { +glm_vec3_eqv(vec3 v1, vec3 v2) { return v1[0] == v2[0] - && v1[1] == v2[1] - && v1[2] == v2[2]; + && v1[1] == v2[1] + && v1[2] == v2[2]; } /*! @@ -117,7 +122,7 @@ glm_vec_eqv(vec3 v1, vec3 v2) { */ CGLM_INLINE bool -glm_vec_eqv_eps(vec3 v1, vec3 v2) { +glm_vec3_eqv_eps(vec3 v1, vec3 v2) { return fabsf(v1[0] - v2[0]) <= FLT_EPSILON && fabsf(v1[1] - v2[1]) <= FLT_EPSILON && fabsf(v1[2] - v2[2]) <= FLT_EPSILON; @@ -130,7 +135,7 @@ glm_vec_eqv_eps(vec3 v1, vec3 v2) { */ CGLM_INLINE float -glm_vec_max(vec3 v) { +glm_vec3_max(vec3 v) { float max; max = v[0]; @@ -149,7 +154,7 @@ glm_vec_max(vec3 v) { */ CGLM_INLINE float -glm_vec_min(vec3 v) { +glm_vec3_min(vec3 v) { float min; min = v[0]; @@ -169,7 +174,7 @@ glm_vec_min(vec3 v) { */ CGLM_INLINE bool -glm_vec_isnan(vec3 v) { +glm_vec3_isnan(vec3 v) { return isnan(v[0]) || isnan(v[1]) || isnan(v[2]); } @@ -181,7 +186,7 @@ glm_vec_isnan(vec3 v) { */ CGLM_INLINE bool -glm_vec_isinf(vec3 v) { +glm_vec3_isinf(vec3 v) { return isinf(v[0]) || isinf(v[1]) || isinf(v[2]); } @@ -193,8 +198,8 @@ glm_vec_isinf(vec3 v) { */ CGLM_INLINE bool -glm_vec_isvalid(vec3 v) { - return !glm_vec_isnan(v) && !glm_vec_isinf(v); +glm_vec3_isvalid(vec3 v) { + return !glm_vec3_isnan(v) && !glm_vec3_isinf(v); } /*! @@ -206,7 +211,7 @@ glm_vec_isvalid(vec3 v) { */ CGLM_INLINE void -glm_vec_sign(vec3 v, vec3 dest) { +glm_vec3_sign(vec3 v, vec3 dest) { dest[0] = glm_signf(v[0]); dest[1] = glm_signf(v[1]); dest[2] = glm_signf(v[2]); @@ -220,7 +225,7 @@ glm_vec_sign(vec3 v, vec3 dest) { */ CGLM_INLINE void -glm_vec_sqrt(vec3 v, vec3 dest) { +glm_vec3_sqrt(vec3 v, vec3 dest) { dest[0] = sqrtf(v[0]); dest[1] = sqrtf(v[1]); dest[2] = sqrtf(v[2]); diff --git a/include/cglm/vec3.h b/include/cglm/vec3.h index 5dfe612..eb64c80 100644 --- a/include/cglm/vec3.h +++ b/include/cglm/vec3.h @@ -5,11 +5,6 @@ * Full license can be found in the LICENSE file */ -/*! - * vec3 functions dont have suffix e.g glm_vec_dot (not glm_vec3_dot) - * all functions without suffix are vec3 functions - */ - /* Macros: glm_vec_dup(v, dest) @@ -23,47 +18,47 @@ Functions: CGLM_INLINE void glm_vec3(vec4 v4, vec3 dest); - CGLM_INLINE void glm_vec_copy(vec3 a, vec3 dest); - CGLM_INLINE void glm_vec_zero(vec3 v); - CGLM_INLINE void glm_vec_one(vec3 v); - CGLM_INLINE float glm_vec_dot(vec3 a, vec3 b); - CGLM_INLINE void glm_vec_cross(vec3 a, vec3 b, vec3 d); - CGLM_INLINE float glm_vec_norm2(vec3 v); - CGLM_INLINE float glm_vec_norm(vec3 vec); - CGLM_INLINE void glm_vec_add(vec3 a, vec3 b, vec3 dest); - CGLM_INLINE void glm_vec_adds(vec3 a, float s, vec3 dest); - CGLM_INLINE void glm_vec_sub(vec3 a, vec3 b, vec3 dest); - CGLM_INLINE void glm_vec_subs(vec3 a, float s, vec3 dest); - CGLM_INLINE void glm_vec_mul(vec3 a, vec3 b, vec3 dest); - CGLM_INLINE void glm_vec_scale(vec3 v, float s, vec3 dest); - CGLM_INLINE void glm_vec_scale_as(vec3 v, float s, vec3 dest); - CGLM_INLINE void glm_vec_div(vec3 a, vec3 b, vec3 dest); - CGLM_INLINE void glm_vec_divs(vec3 a, float s, vec3 dest); - CGLM_INLINE void glm_vec_addadd(vec3 a, vec3 b, vec3 dest); - CGLM_INLINE void glm_vec_subadd(vec3 a, vec3 b, vec3 dest); - CGLM_INLINE void glm_vec_muladd(vec3 a, vec3 b, vec3 dest); - CGLM_INLINE void glm_vec_muladds(vec3 a, float s, vec3 dest); - CGLM_INLINE void glm_vec_flipsign(vec3 v); - CGLM_INLINE void glm_vec_flipsign_to(vec3 v, vec3 dest); - CGLM_INLINE void glm_vec_negate_to(vec3 v, vec3 dest); - CGLM_INLINE void glm_vec_negate(vec3 v); - CGLM_INLINE void glm_vec_inv(vec3 v); - CGLM_INLINE void glm_vec_inv_to(vec3 v, vec3 dest); - CGLM_INLINE void glm_vec_normalize(vec3 v); - CGLM_INLINE void glm_vec_normalize_to(vec3 vec, vec3 dest); - CGLM_INLINE float glm_vec_distance(vec3 v1, vec3 v2); - CGLM_INLINE float glm_vec_angle(vec3 v1, vec3 v2); - CGLM_INLINE void glm_vec_rotate(vec3 v, float angle, vec3 axis); - CGLM_INLINE void glm_vec_rotate_m4(mat4 m, vec3 v, vec3 dest); - CGLM_INLINE void glm_vec_rotate_m4(mat3 m, vec3 v, vec3 dest); - CGLM_INLINE void glm_vec_proj(vec3 a, vec3 b, vec3 dest); - CGLM_INLINE void glm_vec_center(vec3 v1, vec3 v2, vec3 dest); - CGLM_INLINE float glm_vec_distance2(vec3 v1, vec3 v2); - CGLM_INLINE void glm_vec_maxv(vec3 v1, vec3 v2, vec3 dest); - CGLM_INLINE void glm_vec_minv(vec3 v1, vec3 v2, vec3 dest); - CGLM_INLINE void glm_vec_ortho(vec3 v, vec3 dest); - CGLM_INLINE void glm_vec_clamp(vec3 v, float minVal, float maxVal); - CGLM_INLINE void glm_vec_lerp(vec3 from, vec3 to, float t, vec3 dest); + CGLM_INLINE void glm_vec3_copy(vec3 a, vec3 dest); + CGLM_INLINE void glm_vec3_zero(vec3 v); + CGLM_INLINE void glm_vec3_one(vec3 v); + CGLM_INLINE float glm_vec3_dot(vec3 a, vec3 b); + CGLM_INLINE void glm_vec3_cross(vec3 a, vec3 b, vec3 d); + CGLM_INLINE float glm_vec3_norm2(vec3 v); + CGLM_INLINE float glm_vec3_norm(vec3 vec); + CGLM_INLINE void glm_vec3_add(vec3 a, vec3 b, vec3 dest); + CGLM_INLINE void glm_vec3_adds(vec3 a, float s, vec3 dest); + CGLM_INLINE void glm_vec3_sub(vec3 a, vec3 b, vec3 dest); + CGLM_INLINE void glm_vec3_subs(vec3 a, float s, vec3 dest); + CGLM_INLINE void glm_vec3_mul(vec3 a, vec3 b, vec3 dest); + CGLM_INLINE void glm_vec3_scale(vec3 v, float s, vec3 dest); + CGLM_INLINE void glm_vec3_scale_as(vec3 v, float s, vec3 dest); + CGLM_INLINE void glm_vec3_div(vec3 a, vec3 b, vec3 dest); + CGLM_INLINE void glm_vec3_divs(vec3 a, float s, vec3 dest); + CGLM_INLINE void glm_vec3_addadd(vec3 a, vec3 b, vec3 dest); + CGLM_INLINE void glm_vec3_subadd(vec3 a, vec3 b, vec3 dest); + CGLM_INLINE void glm_vec3_muladd(vec3 a, vec3 b, vec3 dest); + CGLM_INLINE void glm_vec3_muladds(vec3 a, float s, vec3 dest); + CGLM_INLINE void glm_vec3_flipsign(vec3 v); + CGLM_INLINE void glm_vec3_flipsign_to(vec3 v, vec3 dest); + CGLM_INLINE void glm_vec3_negate_to(vec3 v, vec3 dest); + CGLM_INLINE void glm_vec3_negate(vec3 v); + CGLM_INLINE void glm_vec3_inv(vec3 v); + CGLM_INLINE void glm_vec3_inv_to(vec3 v, vec3 dest); + CGLM_INLINE void glm_vec3_normalize(vec3 v); + CGLM_INLINE void glm_vec3_normalize_to(vec3 vec, vec3 dest); + CGLM_INLINE float glm_vec3_distance(vec3 v1, vec3 v2); + CGLM_INLINE float glm_vec3_angle(vec3 v1, vec3 v2); + CGLM_INLINE void glm_vec3_rotate(vec3 v, float angle, vec3 axis); + CGLM_INLINE void glm_vec3_rotate_m4(mat4 m, vec3 v, vec3 dest); + CGLM_INLINE void glm_vec3_rotate_m3(mat3 m, vec3 v, vec3 dest); + CGLM_INLINE void glm_vec3_proj(vec3 a, vec3 b, vec3 dest); + CGLM_INLINE void glm_vec3_center(vec3 v1, vec3 v2, vec3 dest); + CGLM_INLINE float glm_vec3_distance2(vec3 v1, vec3 v2); + CGLM_INLINE void glm_vec3_maxv(vec3 v1, vec3 v2, vec3 dest); + CGLM_INLINE void glm_vec3_minv(vec3 v1, vec3 v2, vec3 dest); + CGLM_INLINE void glm_vec3_ortho(vec3 v, vec3 dest); + CGLM_INLINE void glm_vec3_clamp(vec3 v, float minVal, float maxVal); + CGLM_INLINE void glm_vec3_lerp(vec3 from, vec3 to, float t, vec3 dest); Convenient: CGLM_INLINE void glm_cross(vec3 a, vec3 b, vec3 d); @@ -73,8 +68,8 @@ DEPRECATED: glm_vec_dup - glm_vec_flipsign - glm_vec_flipsign_to + glm_vec3_flipsign + glm_vec3_flipsign_to */ #ifndef cglm_vec3_h @@ -86,7 +81,7 @@ #include "util.h" /* DEPRECATED! use _copy, _ucopy versions */ -#define glm_vec_dup(v, dest) glm_vec_copy(v, dest) +#define glm_vec_dup(v, dest) glm_vec3_copy(v, dest) #define GLM_VEC3_ONE_INIT {1.0f, 1.0f, 1.0f} #define GLM_VEC3_ZERO_INIT {0.0f, 0.0f, 0.0f} @@ -120,7 +115,7 @@ glm_vec3(vec4 v4, vec3 dest) { */ CGLM_INLINE void -glm_vec_copy(vec3 a, vec3 dest) { +glm_vec3_copy(vec3 a, vec3 dest) { dest[0] = a[0]; dest[1] = a[1]; dest[2] = a[2]; @@ -133,7 +128,7 @@ glm_vec_copy(vec3 a, vec3 dest) { */ CGLM_INLINE void -glm_vec_zero(vec3 v) { +glm_vec3_zero(vec3 v) { v[0] = v[1] = v[2] = 0.0f; } @@ -144,7 +139,7 @@ glm_vec_zero(vec3 v) { */ CGLM_INLINE void -glm_vec_one(vec3 v) { +glm_vec3_one(vec3 v) { v[0] = v[1] = v[2] = 1.0f; } @@ -158,7 +153,7 @@ glm_vec_one(vec3 v) { */ CGLM_INLINE float -glm_vec_dot(vec3 a, vec3 b) { +glm_vec3_dot(vec3 a, vec3 b) { return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; } @@ -171,7 +166,7 @@ glm_vec_dot(vec3 a, vec3 b) { */ CGLM_INLINE void -glm_vec_cross(vec3 a, vec3 b, vec3 d) { +glm_vec3_cross(vec3 a, vec3 b, vec3 d) { /* (u2.v3 - u3.v2, u3.v1 - u1.v3, u1.v2 - u2.v1) */ d[0] = a[1] * b[2] - a[2] * b[1]; d[1] = a[2] * b[0] - a[0] * b[2]; @@ -191,8 +186,8 @@ glm_vec_cross(vec3 a, vec3 b, vec3 d) { */ CGLM_INLINE float -glm_vec_norm2(vec3 v) { - return glm_vec_dot(v, v); +glm_vec3_norm2(vec3 v) { + return glm_vec3_dot(v, v); } /*! @@ -204,8 +199,8 @@ glm_vec_norm2(vec3 v) { */ CGLM_INLINE float -glm_vec_norm(vec3 vec) { - return sqrtf(glm_vec_norm2(vec)); +glm_vec3_norm(vec3 vec) { + return sqrtf(glm_vec3_norm2(vec)); } /*! @@ -217,7 +212,7 @@ glm_vec_norm(vec3 vec) { */ CGLM_INLINE void -glm_vec_add(vec3 a, vec3 b, vec3 dest) { +glm_vec3_add(vec3 a, vec3 b, vec3 dest) { dest[0] = a[0] + b[0]; dest[1] = a[1] + b[1]; dest[2] = a[2] + b[2]; @@ -232,7 +227,7 @@ glm_vec_add(vec3 a, vec3 b, vec3 dest) { */ CGLM_INLINE void -glm_vec_adds(vec3 v, float s, vec3 dest) { +glm_vec3_adds(vec3 v, float s, vec3 dest) { dest[0] = v[0] + s; dest[1] = v[1] + s; dest[2] = v[2] + s; @@ -247,7 +242,7 @@ glm_vec_adds(vec3 v, float s, vec3 dest) { */ CGLM_INLINE void -glm_vec_sub(vec3 a, vec3 b, vec3 dest) { +glm_vec3_sub(vec3 a, vec3 b, vec3 dest) { dest[0] = a[0] - b[0]; dest[1] = a[1] - b[1]; dest[2] = a[2] - b[2]; @@ -262,7 +257,7 @@ glm_vec_sub(vec3 a, vec3 b, vec3 dest) { */ CGLM_INLINE void -glm_vec_subs(vec3 v, float s, vec3 dest) { +glm_vec3_subs(vec3 v, float s, vec3 dest) { dest[0] = v[0] - s; dest[1] = v[1] - s; dest[2] = v[2] - s; @@ -277,7 +272,7 @@ glm_vec_subs(vec3 v, float s, vec3 dest) { */ CGLM_INLINE void -glm_vec_mul(vec3 a, vec3 b, vec3 d) { +glm_vec3_mul(vec3 a, vec3 b, vec3 d) { d[0] = a[0] * b[0]; d[1] = a[1] * b[1]; d[2] = a[2] * b[2]; @@ -292,7 +287,7 @@ glm_vec_mul(vec3 a, vec3 b, vec3 d) { */ CGLM_INLINE void -glm_vec_scale(vec3 v, float s, vec3 dest) { +glm_vec3_scale(vec3 v, float s, vec3 dest) { dest[0] = v[0] * s; dest[1] = v[1] * s; dest[2] = v[2] * s; @@ -307,16 +302,16 @@ glm_vec_scale(vec3 v, float s, vec3 dest) { */ CGLM_INLINE void -glm_vec_scale_as(vec3 v, float s, vec3 dest) { +glm_vec3_scale_as(vec3 v, float s, vec3 dest) { float norm; - norm = glm_vec_norm(v); + norm = glm_vec3_norm(v); if (norm == 0.0f) { - glm_vec_zero(dest); + glm_vec3_zero(dest); return; } - glm_vec_scale(v, s / norm, dest); + glm_vec3_scale(v, s / norm, dest); } /*! @@ -328,7 +323,7 @@ glm_vec_scale_as(vec3 v, float s, vec3 dest) { */ CGLM_INLINE void -glm_vec_div(vec3 a, vec3 b, vec3 dest) { +glm_vec3_div(vec3 a, vec3 b, vec3 dest) { dest[0] = a[0] / b[0]; dest[1] = a[1] / b[1]; dest[2] = a[2] / b[2]; @@ -343,7 +338,7 @@ glm_vec_div(vec3 a, vec3 b, vec3 dest) { */ CGLM_INLINE void -glm_vec_divs(vec3 v, float s, vec3 dest) { +glm_vec3_divs(vec3 v, float s, vec3 dest) { dest[0] = v[0] / s; dest[1] = v[1] / s; dest[2] = v[2] / s; @@ -360,7 +355,7 @@ glm_vec_divs(vec3 v, float s, vec3 dest) { */ CGLM_INLINE void -glm_vec_addadd(vec3 a, vec3 b, vec3 dest) { +glm_vec3_addadd(vec3 a, vec3 b, vec3 dest) { dest[0] += a[0] + b[0]; dest[1] += a[1] + b[1]; dest[2] += a[2] + b[2]; @@ -377,7 +372,7 @@ glm_vec_addadd(vec3 a, vec3 b, vec3 dest) { */ CGLM_INLINE void -glm_vec_subadd(vec3 a, vec3 b, vec3 dest) { +glm_vec3_subadd(vec3 a, vec3 b, vec3 dest) { dest[0] += a[0] - b[0]; dest[1] += a[1] - b[1]; dest[2] += a[2] - b[2]; @@ -394,7 +389,7 @@ glm_vec_subadd(vec3 a, vec3 b, vec3 dest) { */ CGLM_INLINE void -glm_vec_muladd(vec3 a, vec3 b, vec3 dest) { +glm_vec3_muladd(vec3 a, vec3 b, vec3 dest) { dest[0] += a[0] * b[0]; dest[1] += a[1] * b[1]; dest[2] += a[2] * b[2]; @@ -411,14 +406,14 @@ glm_vec_muladd(vec3 a, vec3 b, vec3 dest) { */ CGLM_INLINE void -glm_vec_muladds(vec3 a, float s, vec3 dest) { +glm_vec3_muladds(vec3 a, float s, vec3 dest) { dest[0] += a[0] * s; dest[1] += a[1] * s; dest[2] += a[2] * s; } /*! - * DEPRECATED! use glm_vec_negate and friends + * DEPRECATED! use glm_vec3_negate and friends * * @brief negate vector components * @@ -426,14 +421,14 @@ glm_vec_muladds(vec3 a, float s, vec3 dest) { */ CGLM_INLINE void -glm_vec_flipsign(vec3 v) { +glm_vec3_flipsign(vec3 v) { v[0] = -v[0]; v[1] = -v[1]; v[2] = -v[2]; } /*! - * DEPRECATED! use glm_vec_negate and friends + * DEPRECATED! use glm_vec3_negate and friends * * @brief negate vector components and store result in dest * @@ -442,7 +437,7 @@ glm_vec_flipsign(vec3 v) { */ CGLM_INLINE void -glm_vec_flipsign_to(vec3 v, vec3 dest) { +glm_vec3_flipsign_to(vec3 v, vec3 dest) { dest[0] = -v[0]; dest[1] = -v[1]; dest[2] = -v[2]; @@ -456,7 +451,7 @@ glm_vec_flipsign_to(vec3 v, vec3 dest) { */ CGLM_INLINE void -glm_vec_negate_to(vec3 v, vec3 dest) { +glm_vec3_negate_to(vec3 v, vec3 dest) { dest[0] = -v[0]; dest[1] = -v[1]; dest[2] = -v[2]; @@ -469,8 +464,8 @@ glm_vec_negate_to(vec3 v, vec3 dest) { */ CGLM_INLINE void -glm_vec_negate(vec3 v) { - glm_vec_negate_to(v, v); +glm_vec3_negate(vec3 v) { + glm_vec3_negate_to(v, v); } /*! @@ -480,8 +475,8 @@ glm_vec_negate(vec3 v) { */ CGLM_INLINE void -glm_vec_inv(vec3 v) { - glm_vec_negate(v); +glm_vec3_inv(vec3 v) { + glm_vec3_negate(v); } /*! @@ -492,8 +487,8 @@ glm_vec_inv(vec3 v) { */ CGLM_INLINE void -glm_vec_inv_to(vec3 v, vec3 dest) { - glm_vec_negate_to(v, dest); +glm_vec3_inv_to(vec3 v, vec3 dest) { + glm_vec3_negate_to(v, dest); } /*! @@ -503,17 +498,17 @@ glm_vec_inv_to(vec3 v, vec3 dest) { */ CGLM_INLINE void -glm_vec_normalize(vec3 v) { +glm_vec3_normalize(vec3 v) { float norm; - norm = glm_vec_norm(v); + norm = glm_vec3_norm(v); if (norm == 0.0f) { v[0] = v[1] = v[2] = 0.0f; return; } - glm_vec_scale(v, 1.0f / norm, v); + glm_vec3_scale(v, 1.0f / norm, v); } /*! @@ -524,17 +519,17 @@ glm_vec_normalize(vec3 v) { */ CGLM_INLINE void -glm_vec_normalize_to(vec3 vec, vec3 dest) { +glm_vec3_normalize_to(vec3 vec, vec3 dest) { float norm; - norm = glm_vec_norm(vec); + norm = glm_vec3_norm(vec); if (norm == 0.0f) { - glm_vec_zero(dest); + glm_vec3_zero(dest); return; } - glm_vec_scale(vec, 1.0f / norm, dest); + glm_vec3_scale(vec, 1.0f / norm, dest); } /*! @@ -547,12 +542,12 @@ glm_vec_normalize_to(vec3 vec, vec3 dest) { */ CGLM_INLINE float -glm_vec_angle(vec3 v1, vec3 v2) { +glm_vec3_angle(vec3 v1, vec3 v2) { float norm, dot; /* maybe compiler generate approximation instruction (rcp) */ - norm = 1.0f / (glm_vec_norm(v1) * glm_vec_norm(v2)); - dot = glm_vec_dot(v1, v2) * norm; + norm = 1.0f / (glm_vec3_norm(v1) * glm_vec3_norm(v2)); + dot = glm_vec3_dot(v1, v2) * norm; if (dot > 1.0f) return 0.0f; @@ -571,27 +566,27 @@ glm_vec_angle(vec3 v1, vec3 v2) { */ CGLM_INLINE void -glm_vec_rotate(vec3 v, float angle, vec3 axis) { +glm_vec3_rotate(vec3 v, float angle, vec3 axis) { vec3 v1, v2, k; float c, s; c = cosf(angle); s = sinf(angle); - glm_vec_normalize_to(axis, k); + glm_vec3_normalize_to(axis, k); /* Right Hand, Rodrigues' rotation formula: v = v*cos(t) + (kxv)sin(t) + k*(k.v)(1 - cos(t)) */ - glm_vec_scale(v, c, v1); + glm_vec3_scale(v, c, v1); - glm_vec_cross(k, v, v2); - glm_vec_scale(v2, s, v2); + glm_vec3_cross(k, v, v2); + glm_vec3_scale(v2, s, v2); - glm_vec_add(v1, v2, v1); + glm_vec3_add(v1, v2, v1); - glm_vec_scale(k, glm_vec_dot(k, v) * (1.0f - c), v2); - glm_vec_add(v1, v2, v); + glm_vec3_scale(k, glm_vec3_dot(k, v) * (1.0f - c), v2); + glm_vec3_add(v1, v2, v); } /*! @@ -609,7 +604,7 @@ glm_vec_rotate(vec3 v, float angle, vec3 axis) { */ CGLM_INLINE void -glm_vec_rotate_m4(mat4 m, vec3 v, vec3 dest) { +glm_vec3_rotate_m4(mat4 m, vec3 v, vec3 dest) { vec4 x, y, z, res; glm_vec4_normalize_to(m[0], x); @@ -632,7 +627,7 @@ glm_vec_rotate_m4(mat4 m, vec3 v, vec3 dest) { */ CGLM_INLINE void -glm_vec_rotate_m3(mat3 m, vec3 v, vec3 dest) { +glm_vec3_rotate_m3(mat3 m, vec3 v, vec3 dest) { vec4 res, x, y, z; glm_vec4(m[0], 0.0f, x); @@ -659,10 +654,10 @@ glm_vec_rotate_m3(mat3 m, vec3 v, vec3 dest) { */ CGLM_INLINE void -glm_vec_proj(vec3 a, vec3 b, vec3 dest) { - glm_vec_scale(b, - glm_vec_dot(a, b) / glm_vec_norm2(b), - dest); +glm_vec3_proj(vec3 a, vec3 b, vec3 dest) { + glm_vec3_scale(b, + glm_vec3_dot(a, b) / glm_vec3_norm2(b), + dest); } /** @@ -674,9 +669,9 @@ glm_vec_proj(vec3 a, vec3 b, vec3 dest) { */ CGLM_INLINE void -glm_vec_center(vec3 v1, vec3 v2, vec3 dest) { - glm_vec_add(v1, v2, dest); - glm_vec_scale(dest, 0.5f, dest); +glm_vec3_center(vec3 v1, vec3 v2, vec3 dest) { + glm_vec3_add(v1, v2, dest); + glm_vec3_scale(dest, 0.5f, dest); } /** @@ -688,7 +683,7 @@ glm_vec_center(vec3 v1, vec3 v2, vec3 dest) { */ CGLM_INLINE float -glm_vec_distance2(vec3 v1, vec3 v2) { +glm_vec3_distance2(vec3 v1, vec3 v2) { return glm_pow2(v2[0] - v1[0]) + glm_pow2(v2[1] - v1[1]) + glm_pow2(v2[2] - v1[2]); @@ -703,8 +698,8 @@ glm_vec_distance2(vec3 v1, vec3 v2) { */ CGLM_INLINE float -glm_vec_distance(vec3 v1, vec3 v2) { - return sqrtf(glm_vec_distance2(v1, v2)); +glm_vec3_distance(vec3 v1, vec3 v2) { + return sqrtf(glm_vec3_distance2(v1, v2)); } /*! @@ -716,7 +711,7 @@ glm_vec_distance(vec3 v1, vec3 v2) { */ CGLM_INLINE void -glm_vec_maxv(vec3 v1, vec3 v2, vec3 dest) { +glm_vec3_maxv(vec3 v1, vec3 v2, vec3 dest) { dest[0] = glm_max(v1[0], v2[0]); dest[1] = glm_max(v1[1], v2[1]); dest[2] = glm_max(v1[2], v2[2]); @@ -731,7 +726,7 @@ glm_vec_maxv(vec3 v1, vec3 v2, vec3 dest) { */ CGLM_INLINE void -glm_vec_minv(vec3 v1, vec3 v2, vec3 dest) { +glm_vec3_minv(vec3 v1, vec3 v2, vec3 dest) { dest[0] = glm_min(v1[0], v2[0]); dest[1] = glm_min(v1[1], v2[1]); dest[2] = glm_min(v1[2], v2[2]); @@ -745,7 +740,7 @@ glm_vec_minv(vec3 v1, vec3 v2, vec3 dest) { */ CGLM_INLINE void -glm_vec_ortho(vec3 v, vec3 dest) { +glm_vec3_ortho(vec3 v, vec3 dest) { dest[0] = v[1] - v[2]; dest[1] = v[2] - v[0]; dest[2] = v[0] - v[1]; @@ -760,7 +755,7 @@ glm_vec_ortho(vec3 v, vec3 dest) { */ CGLM_INLINE void -glm_vec_clamp(vec3 v, float minVal, float maxVal) { +glm_vec3_clamp(vec3 v, float minVal, float maxVal) { v[0] = glm_clamp(v[0], minVal, maxVal); v[1] = glm_clamp(v[1], minVal, maxVal); v[2] = glm_clamp(v[2], minVal, maxVal); @@ -778,14 +773,14 @@ glm_vec_clamp(vec3 v, float minVal, float maxVal) { */ CGLM_INLINE void -glm_vec_lerp(vec3 from, vec3 to, float t, vec3 dest) { +glm_vec3_lerp(vec3 from, vec3 to, float t, vec3 dest) { vec3 s, v; /* from + s * (to - from) */ - glm_vec_broadcast(glm_clamp_zo(t), s); - glm_vec_sub(to, from, v); - glm_vec_mulv(s, v, v); - glm_vec_add(from, v, dest); + glm_vec3_broadcast(glm_clamp_zo(t), s); + glm_vec3_sub(to, from, v); + glm_vec3_mulv(s, v, v); + glm_vec3_add(from, v, dest); } /*! @@ -800,7 +795,7 @@ glm_vec_lerp(vec3 from, vec3 to, float t, vec3 dest) { CGLM_INLINE void glm_cross(vec3 a, vec3 b, vec3 d) { - glm_vec_cross(a, b, d); + glm_vec3_cross(a, b, d); } /*! @@ -816,7 +811,7 @@ glm_cross(vec3 a, vec3 b, vec3 d) { CGLM_INLINE float glm_dot(vec3 a, vec3 b) { - return glm_vec_dot(a, b); + return glm_vec3_dot(a, b); } /*! @@ -829,7 +824,7 @@ glm_dot(vec3 a, vec3 b) { CGLM_INLINE void glm_normalize(vec3 v) { - glm_vec_normalize(v); + glm_vec3_normalize(v); } /*! @@ -843,7 +838,7 @@ glm_normalize(vec3 v) { CGLM_INLINE void glm_normalize_to(vec3 v, vec3 dest) { - glm_vec_normalize_to(v, dest); + glm_vec3_normalize_to(v, dest); } #endif /* cglm_vec3_h */ diff --git a/include/cglm/vec4-ext.h b/include/cglm/vec4-ext.h index b7902b6..e45ef85 100644 --- a/include/cglm/vec4-ext.h +++ b/include/cglm/vec4-ext.h @@ -11,15 +11,20 @@ /* Functions: - CGLM_INLINE void glm_vec4_mulv(vec4 a, vec4 b, vec4 d); - CGLM_INLINE void glm_vec4_broadcast(float val, vec4 d); - CGLM_INLINE bool glm_vec4_eq(vec4 v, float val); - CGLM_INLINE bool glm_vec4_eq_eps(vec4 v, float val); - CGLM_INLINE bool glm_vec4_eq_all(vec4 v); - CGLM_INLINE bool glm_vec4_eqv(vec4 v1, vec4 v2); - CGLM_INLINE bool glm_vec4_eqv_eps(vec4 v1, vec4 v2); + CGLM_INLINE void glm_vec4_mulv(vec4 a, vec4 b, vec4 d); + CGLM_INLINE void glm_vec4_broadcast(float val, vec4 d); + CGLM_INLINE bool glm_vec4_eq(vec4 v, float val); + CGLM_INLINE bool glm_vec4_eq_eps(vec4 v, float val); + CGLM_INLINE bool glm_vec4_eq_all(vec4 v); + CGLM_INLINE bool glm_vec4_eqv(vec4 v1, vec4 v2); + CGLM_INLINE bool glm_vec4_eqv_eps(vec4 v1, vec4 v2); CGLM_INLINE float glm_vec4_max(vec4 v); CGLM_INLINE float glm_vec4_min(vec4 v); + CGLM_INLINE bool glm_vec4_isnan(vec4 v); + CGLM_INLINE bool glm_vec4_isinf(vec4 v); + CGLM_INLINE bool glm_vec4_isvalid(vec4 v); + CGLM_INLINE void glm_vec4_sign(vec4 v, vec4 dest); + CGLM_INLINE void glm_vec4_sqrt(vec4 v, vec4 dest); */ #ifndef cglm_vec4_ext_h @@ -150,7 +155,7 @@ float glm_vec4_max(vec4 v) { float max; - max = glm_vec_max(v); + max = glm_vec3_max(v); if (v[3] > max) max = v[3]; @@ -167,7 +172,7 @@ float glm_vec4_min(vec4 v) { float min; - min = glm_vec_min(v); + min = glm_vec3_min(v); if (v[3] < min) min = v[3]; diff --git a/include/cglm/vec4.h b/include/cglm/vec4.h index d0221d4..ec14ce3 100644 --- a/include/cglm/vec4.h +++ b/include/cglm/vec4.h @@ -5,11 +5,6 @@ * Full license can be found in the LICENSE file */ -/*! - * vec3 functions dont have suffix e.g glm_vec_dot (not glm_vec3_dot) - * all functions without suffix are vec3 functions - */ - /* Macros: glm_vec4_dup3(v, dest) diff --git a/src/vec3.c b/src/vec3.c index 541dd13..5f743b3 100644 --- a/src/vec3.c +++ b/src/vec3.c @@ -16,332 +16,332 @@ glmc_vec3(vec4 v4, vec3 dest) { CGLM_EXPORT void -glmc_vec_copy(vec3 a, vec3 dest) { - glm_vec_copy(a, dest); +glmc_vec3_copy(vec3 a, vec3 dest) { + glm_vec3_copy(a, dest); } CGLM_EXPORT void -glmc_vec_zero(vec3 v) { - glm_vec_zero(v); +glmc_vec3_zero(vec3 v) { + glm_vec3_zero(v); } CGLM_EXPORT void -glmc_vec_one(vec3 v) { - glm_vec_one(v); +glmc_vec3_one(vec3 v) { + glm_vec3_one(v); } CGLM_EXPORT float -glmc_vec_dot(vec3 a, vec3 b) { - return glm_vec_dot(a, b); +glmc_vec3_dot(vec3 a, vec3 b) { + return glm_vec3_dot(a, b); } CGLM_EXPORT void -glmc_vec_cross(vec3 a, vec3 b, vec3 d) { - glm_vec_cross(a, b, d); +glmc_vec3_cross(vec3 a, vec3 b, vec3 d) { + glm_vec3_cross(a, b, d); } CGLM_EXPORT float -glmc_vec_norm(vec3 vec) { - return glm_vec_norm(vec); +glmc_vec3_norm(vec3 vec) { + return glm_vec3_norm(vec); } CGLM_EXPORT void -glmc_vec_normalize_to(vec3 vec, vec3 dest) { - glm_vec_normalize_to(vec, dest); +glmc_vec3_normalize_to(vec3 vec, vec3 dest) { + glm_vec3_normalize_to(vec, dest); } CGLM_EXPORT void -glmc_vec_normalize(vec3 v) { - glm_vec_normalize(v); +glmc_vec3_normalize(vec3 v) { + glm_vec3_normalize(v); } CGLM_EXPORT float -glmc_vec_norm2(vec3 vec) { - return glm_vec_norm2(vec); +glmc_vec3_norm2(vec3 vec) { + return glm_vec3_norm2(vec); } CGLM_EXPORT void -glmc_vec_add(vec3 v1, vec3 v2, vec3 dest) { - glm_vec_add(v1, v2, dest); +glmc_vec3_add(vec3 v1, vec3 v2, vec3 dest) { + glm_vec3_add(v1, v2, dest); } CGLM_EXPORT void -glmc_vec_adds(vec3 v, float s, vec3 dest) { - glm_vec_adds(v, s, dest); +glmc_vec3_adds(vec3 v, float s, vec3 dest) { + glm_vec3_adds(v, s, dest); } CGLM_EXPORT void -glmc_vec_sub(vec3 a, vec3 b, vec3 dest) { - glm_vec_sub(a, b, dest); +glmc_vec3_sub(vec3 a, vec3 b, vec3 dest) { + glm_vec3_sub(a, b, dest); } CGLM_EXPORT void -glmc_vec_subs(vec3 v, float s, vec3 dest) { - glm_vec_subs(v, s, dest); +glmc_vec3_subs(vec3 v, float s, vec3 dest) { + glm_vec3_subs(v, s, dest); } CGLM_EXPORT void -glmc_vec_mul(vec3 a, vec3 b, vec3 d) { - glm_vec_mul(a, b, d); +glmc_vec3_mul(vec3 a, vec3 b, vec3 d) { + glm_vec3_mul(a, b, d); } CGLM_EXPORT void -glmc_vec_scale(vec3 v, float s, vec3 dest) { - glm_vec_scale(v, s, dest); +glmc_vec3_scale(vec3 v, float s, vec3 dest) { + glm_vec3_scale(v, s, dest); } CGLM_EXPORT void -glmc_vec_scale_as(vec3 v, float s, vec3 dest) { - glm_vec_scale_as(v, s, dest); +glmc_vec3_scale_as(vec3 v, float s, vec3 dest) { + glm_vec3_scale_as(v, s, dest); } CGLM_EXPORT void -glmc_vec_div(vec3 a, vec3 b, vec3 dest) { - glm_vec_div(a, b, dest); +glmc_vec3_div(vec3 a, vec3 b, vec3 dest) { + glm_vec3_div(a, b, dest); } CGLM_EXPORT void -glmc_vec_divs(vec3 a, float s, vec3 dest) { - glm_vec_divs(a, s, dest); +glmc_vec3_divs(vec3 a, float s, vec3 dest) { + glm_vec3_divs(a, s, dest); } CGLM_EXPORT void -glmc_vec_addadd(vec3 a, vec3 b, vec3 dest) { - glm_vec_addadd(a, b, dest); +glmc_vec3_addadd(vec3 a, vec3 b, vec3 dest) { + glm_vec3_addadd(a, b, dest); } CGLM_EXPORT void -glmc_vec_subadd(vec3 a, vec3 b, vec3 dest) { - glm_vec_subadd(a, b, dest); +glmc_vec3_subadd(vec3 a, vec3 b, vec3 dest) { + glm_vec3_subadd(a, b, dest); } CGLM_EXPORT void -glmc_vec_muladd(vec3 a, vec3 b, vec3 dest) { - glm_vec_muladd(a, b, dest); +glmc_vec3_muladd(vec3 a, vec3 b, vec3 dest) { + glm_vec3_muladd(a, b, dest); } CGLM_EXPORT void -glmc_vec_muladds(vec3 a, float s, vec3 dest) { - glm_vec_muladds(a, s, dest); +glmc_vec3_muladds(vec3 a, float s, vec3 dest) { + glm_vec3_muladds(a, s, dest); } CGLM_EXPORT void -glmc_vec_flipsign(vec3 v) { - glm_vec_flipsign(v); +glmc_vec3_flipsign(vec3 v) { + glm_vec3_flipsign(v); } CGLM_EXPORT void -glmc_vec_flipsign_to(vec3 v, vec3 dest) { - glm_vec_flipsign_to(v, dest); +glmc_vec3_flipsign_to(vec3 v, vec3 dest) { + glm_vec3_flipsign_to(v, dest); } CGLM_EXPORT void -glmc_vec_negate(vec3 v) { - glm_vec_negate(v); +glmc_vec3_negate(vec3 v) { + glm_vec3_negate(v); } CGLM_EXPORT void -glmc_vec_negate_to(vec3 v, vec3 dest) { - glm_vec_negate_to(v, dest); +glmc_vec3_negate_to(vec3 v, vec3 dest) { + glm_vec3_negate_to(v, dest); } CGLM_EXPORT void -glmc_vec_inv(vec3 v) { - glm_vec_inv(v); +glmc_vec3_inv(vec3 v) { + glm_vec3_inv(v); } CGLM_EXPORT void -glmc_vec_inv_to(vec3 v, vec3 dest) { - glm_vec_inv_to(v, dest); +glmc_vec3_inv_to(vec3 v, vec3 dest) { + glm_vec3_inv_to(v, dest); } CGLM_EXPORT float -glmc_vec_angle(vec3 v1, vec3 v2) { - return glm_vec_angle(v1, v2); +glmc_vec3_angle(vec3 v1, vec3 v2) { + return glm_vec3_angle(v1, v2); } CGLM_EXPORT void -glmc_vec_rotate(vec3 v, float angle, vec3 axis) { - glm_vec_rotate(v, angle, axis); +glmc_vec3_rotate(vec3 v, float angle, vec3 axis) { + glm_vec3_rotate(v, angle, axis); } CGLM_EXPORT void -glmc_vec_rotate_m4(mat4 m, vec3 v, vec3 dest) { - glm_vec_rotate_m4(m, v, dest); +glmc_vec3_rotate_m4(mat4 m, vec3 v, vec3 dest) { + glm_vec3_rotate_m4(m, v, dest); } CGLM_EXPORT void -glmc_vec_rotate_m3(mat3 m, vec3 v, vec3 dest) { - glm_vec_rotate_m3(m, v, dest); +glmc_vec3_rotate_m3(mat3 m, vec3 v, vec3 dest) { + glm_vec3_rotate_m3(m, v, dest); } CGLM_EXPORT void -glmc_vec_proj(vec3 a, vec3 b, vec3 dest) { - glm_vec_proj(a, b, dest); +glmc_vec3_proj(vec3 a, vec3 b, vec3 dest) { + glm_vec3_proj(a, b, dest); } CGLM_EXPORT void -glmc_vec_center(vec3 v1, vec3 v2, vec3 dest) { - glm_vec_center(v1, v2, dest); +glmc_vec3_center(vec3 v1, vec3 v2, vec3 dest) { + glm_vec3_center(v1, v2, dest); } CGLM_EXPORT float -glmc_vec_distance2(vec3 v1, vec3 v2) { - return glm_vec_distance2(v1, v2); +glmc_vec3_distance2(vec3 v1, vec3 v2) { + return glm_vec3_distance2(v1, v2); } CGLM_EXPORT float -glmc_vec_distance(vec3 v1, vec3 v2) { - return glm_vec_distance(v1, v2); +glmc_vec3_distance(vec3 v1, vec3 v2) { + return glm_vec3_distance(v1, v2); } CGLM_EXPORT void -glmc_vec_maxv(vec3 v1, vec3 v2, vec3 dest) { - glm_vec_minv(v1, v2, dest); +glmc_vec3_maxv(vec3 v1, vec3 v2, vec3 dest) { + glm_vec3_minv(v1, v2, dest); } CGLM_EXPORT void -glmc_vec_minv(vec3 v1, vec3 v2, vec3 dest) { - glm_vec_maxv(v1, v2, dest); +glmc_vec3_minv(vec3 v1, vec3 v2, vec3 dest) { + glm_vec3_maxv(v1, v2, dest); } CGLM_EXPORT void -glmc_vec_clamp(vec3 v, float minVal, float maxVal) { - glm_vec_clamp(v, minVal, maxVal); +glmc_vec3_clamp(vec3 v, float minVal, float maxVal) { + glm_vec3_clamp(v, minVal, maxVal); } CGLM_EXPORT void -glmc_vec_ortho(vec3 v, vec3 dest) { - glm_vec_ortho(v, dest); +glmc_vec3_ortho(vec3 v, vec3 dest) { + glm_vec3_ortho(v, dest); } CGLM_EXPORT void -glmc_vec_lerp(vec3 from, vec3 to, float t, vec3 dest) { - glm_vec_lerp(from, to, t, dest); +glmc_vec3_lerp(vec3 from, vec3 to, float t, vec3 dest) { + glm_vec3_lerp(from, to, t, dest); } /* ext */ CGLM_EXPORT void -glmc_vec_mulv(vec3 a, vec3 b, vec3 d) { - glm_vec_mulv(a, b, d); +glmc_vec3_mulv(vec3 a, vec3 b, vec3 d) { + glm_vec3_mulv(a, b, d); } CGLM_EXPORT void -glmc_vec_broadcast(float val, vec3 d) { - glm_vec_broadcast(val, d); +glmc_vec3_broadcast(float val, vec3 d) { + glm_vec3_broadcast(val, d); } CGLM_EXPORT bool -glmc_vec_eq(vec3 v, float val) { - return glm_vec_eq(v, val); +glmc_vec3_eq(vec3 v, float val) { + return glm_vec3_eq(v, val); } CGLM_EXPORT bool -glmc_vec_eq_eps(vec3 v, float val) { - return glm_vec_eq_eps(v, val); +glmc_vec3_eq_eps(vec3 v, float val) { + return glm_vec3_eq_eps(v, val); } CGLM_EXPORT bool -glmc_vec_eq_all(vec3 v) { - return glm_vec_eq_all(v); +glmc_vec3_eq_all(vec3 v) { + return glm_vec3_eq_all(v); } CGLM_EXPORT bool -glmc_vec_eqv(vec3 v1, vec3 v2) { - return glm_vec_eqv(v1, v2); +glmc_vec3_eqv(vec3 v1, vec3 v2) { + return glm_vec3_eqv(v1, v2); } CGLM_EXPORT bool -glmc_vec_eqv_eps(vec3 v1, vec3 v2) { - return glm_vec_eqv_eps(v1, v2); +glmc_vec3_eqv_eps(vec3 v1, vec3 v2) { + return glm_vec3_eqv_eps(v1, v2); } CGLM_EXPORT float -glmc_vec_max(vec3 v) { - return glm_vec_max(v); +glmc_vec3_max(vec3 v) { + return glm_vec3_max(v); } CGLM_EXPORT float -glmc_vec_min(vec3 v) { - return glm_vec_min(v); +glmc_vec3_min(vec3 v) { + return glm_vec3_min(v); } CGLM_EXPORT bool -glmc_vec_isnan(vec3 v) { - return glm_vec_isnan(v); +glmc_vec3_isnan(vec3 v) { + return glm_vec3_isnan(v); } CGLM_EXPORT bool -glmc_vec_isinf(vec3 v) { - return glm_vec_isinf(v); +glmc_vec3_isinf(vec3 v) { + return glm_vec3_isinf(v); } CGLM_EXPORT bool -glmc_vec_isvalid(vec3 v) { - return glm_vec_isvalid(v); +glmc_vec3_isvalid(vec3 v) { + return glm_vec3_isvalid(v); } CGLM_EXPORT void -glmc_vec_sign(vec3 v, vec3 dest) { - glm_vec_sign(v, dest); +glmc_vec3_sign(vec3 v, vec3 dest) { + glm_vec3_sign(v, dest); } CGLM_EXPORT void -glmc_vec_sqrt(vec3 v, vec3 dest) { - glm_vec_sqrt(v, dest); +glmc_vec3_sqrt(vec3 v, vec3 dest) { + glm_vec3_sqrt(v, dest); } diff --git a/test/src/test_cam.c b/test/src/test_cam.c index f54c984..c1f31e1 100644 --- a/test/src/test_cam.c +++ b/test/src/test_cam.c @@ -16,7 +16,7 @@ test_camera_lookat(void **state) { up = {0.0f, 1.0f, 0.0f} ; - glm_vec_add(eye, dir, center); + glm_vec3_add(eye, dir, center); glm_lookat(eye, center, up, view1); glm_look(eye, dir, up, view2); diff --git a/test/src/test_clamp.c b/test/src/test_clamp.c index ee98958..70d684b 100644 --- a/test/src/test_clamp.c +++ b/test/src/test_clamp.c @@ -16,7 +16,7 @@ test_clamp(void **state) { assert_true(glm_clamp(-1.6f, 0.0f, 1.0f) == 0.0f); assert_true(glm_clamp(0.6f, 0.0f, 1.0f) == 0.6f); - glm_vec_clamp(v3, 0.0, 1.0); + glm_vec3_clamp(v3, 0.0, 1.0); glm_vec4_clamp(v4, 1.5, 3.0); assert_true(v3[0] == 1.0f); diff --git a/test/src/test_quat.c b/test/src/test_quat.c index 74d12b5..62e2306 100644 --- a/test/src/test_quat.c +++ b/test/src/test_quat.c @@ -128,7 +128,7 @@ test_quat(void **state) { axis[1] = sinf(glm_rad(-90.0f) * 0.5f) * 1.0f; axis[2] = 0.0f; - assert_true(glm_vec_eqv_eps(imag, axis)); + assert_true(glm_vec3_eqv_eps(imag, axis)); /* 9.2 axis */ glm_quat_axis(q4, axis); @@ -143,7 +143,7 @@ test_quat(void **state) { v1[0] = 0.0f; v1[1] = 0.0f; v1[2] = -1.0f; v2[0] = 0.0f; v2[1] = 0.0f; v2[2] = -1.0f; - glm_vec_rotate(v1, glm_rad(90.0f), (vec3){1.0f, 0.0f, 0.0f}); + glm_vec3_rotate(v1, glm_rad(90.0f), (vec3){1.0f, 0.0f, 0.0f}); glm_quatv(q3, glm_rad(90.0f), (vec3){1.0f, 0.0f, 0.0f}); glm_vec4_scale(q3, 1.5, q3); diff --git a/test/src/test_vec3.c b/test/src/test_vec3.c index dd0c55d..6cfc593 100644 --- a/test/src/test_vec3.c +++ b/test/src/test_vec3.c @@ -14,64 +14,64 @@ test_vec3(void **state) { vec3 v, v1, v2; /* test zero */ - glm_vec_zero(v); + glm_vec3_zero(v); test_assert_vec3_eq(GLM_VEC3_ZERO, v); /* test one */ - glm_vec_one(v); + glm_vec3_one(v); test_assert_vec3_eq(GLM_VEC3_ONE, v); /* adds, subs, div, divs, mul */ - glm_vec_add(v, GLM_VEC3_ONE, v); - assert_true(glmc_vec_eq_eps(v, 2)); + glm_vec3_add(v, GLM_VEC3_ONE, v); + assert_true(glmc_vec3_eq_eps(v, 2)); - glm_vec_adds(v, 10, v); - assert_true(glmc_vec_eq_eps(v, 12)); + glm_vec3_adds(v, 10, v); + assert_true(glmc_vec3_eq_eps(v, 12)); - glm_vec_sub(v, GLM_VEC3_ONE, v); - assert_true(glmc_vec_eq_eps(v, 11)); + glm_vec3_sub(v, GLM_VEC3_ONE, v); + assert_true(glmc_vec3_eq_eps(v, 11)); - glm_vec_subs(v, 1, v); - assert_true(glmc_vec_eq_eps(v, 10)); + glm_vec3_subs(v, 1, v); + assert_true(glmc_vec3_eq_eps(v, 10)); - glm_vec_broadcast(2, v1); - glm_vec_div(v, v1, v); - assert_true(glmc_vec_eq_eps(v, 5)); + glm_vec3_broadcast(2, v1); + glm_vec3_div(v, v1, v); + assert_true(glmc_vec3_eq_eps(v, 5)); - glm_vec_divs(v, 0.5, v); - assert_true(glmc_vec_eq_eps(v, 10)); + glm_vec3_divs(v, 0.5, v); + assert_true(glmc_vec3_eq_eps(v, 10)); - glm_vec_mul(v, v1, v); - assert_true(glmc_vec_eq_eps(v, 20)); + glm_vec3_mul(v, v1, v); + assert_true(glmc_vec3_eq_eps(v, 20)); - glm_vec_scale(v, 0.5, v); - assert_true(glmc_vec_eq_eps(v, 10)); + glm_vec3_scale(v, 0.5, v); + assert_true(glmc_vec3_eq_eps(v, 10)); - glm_vec_normalize_to(v, v1); - glm_vec_scale(v1, 0.8, v1); - glm_vec_scale_as(v, 0.8, v); + glm_vec3_normalize_to(v, v1); + glm_vec3_scale(v1, 0.8, v1); + glm_vec3_scale_as(v, 0.8, v); test_assert_vec3_eq(v1, v); /* addadd, subadd, muladd */ - glm_vec_one(v); + glm_vec3_one(v); - glm_vec_addadd(GLM_VEC3_ONE, GLM_VEC3_ONE, v); - assert_true(glmc_vec_eq_eps(v, 3)); + glm_vec3_addadd(GLM_VEC3_ONE, GLM_VEC3_ONE, v); + assert_true(glmc_vec3_eq_eps(v, 3)); - glm_vec_subadd(GLM_VEC3_ONE, GLM_VEC3_ZERO, v); - assert_true(glmc_vec_eq_eps(v, 4)); + glm_vec3_subadd(GLM_VEC3_ONE, GLM_VEC3_ZERO, v); + assert_true(glmc_vec3_eq_eps(v, 4)); - glm_vec_broadcast(2, v1); - glm_vec_broadcast(3, v2); - glm_vec_muladd(v1, v2, v); - assert_true(glmc_vec_eq_eps(v, 10)); + glm_vec3_broadcast(2, v1); + glm_vec3_broadcast(3, v2); + glm_vec3_muladd(v1, v2, v); + assert_true(glmc_vec3_eq_eps(v, 10)); /* rotate */ - glm_vec_copy(GLM_YUP, v); + glm_vec3_copy(GLM_YUP, v); glm_rotate_make(rot1, glm_rad(90), GLM_XUP); - glm_vec_rotate_m4(rot1, v, v1); + glm_vec3_rotate_m4(rot1, v, v1); glm_mat4_pick3(rot1, rot1m3); - glm_vec_rotate_m3(rot1m3, v, v2); + glm_vec3_rotate_m3(rot1m3, v, v2); test_assert_vec3_eq(v1, v2); test_assert_vec3_eq(v1, GLM_ZUP);