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

vec: rename glm_vec_ namespace to glm_vec3_

Browse Source
This commit is contained in:
Recep Aslantas
2018-11-28 23:22:30 +03:00
parent ef6134263e
commit 0b8c63a90e
20 changed files with 460 additions and 463 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
README.md
View File

@@ -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:

4
include/cglm/affine-mat.h
View File

@@ -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
}

38
include/cglm/affine.h
View File

@@ -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);
}
}

52
include/cglm/box.h
View File

@@ -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);
}
/*!

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

@@ -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
}

20
include/cglm/cam.h
View File

@@ -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);
}

12
include/cglm/frustum.h
View File

@@ -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 */

6
include/cglm/mat3.h
View File

@@ -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]);
}
/*!

2
include/cglm/plane.h
View File

@@ -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 */

24
include/cglm/quat.h
View File

@@ -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);

8
include/cglm/sphere.h
View File

@@ -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 */

59
include/cglm/vec3-ext.h
View File

@@ -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 <float.h>
/*!
* @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]);

251
include/cglm/vec3.h
View File

@@ -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 */

23
include/cglm/vec4-ext.h
View File

@@ -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];

5
include/cglm/vec4.h
View File

@@ -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)

220
src/vec3.c
View File

@@ -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);
}

2
test/src/test_cam.c
View File

@@ -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);

2
test/src/test_clamp.c
View File

@@ -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);

4
test/src/test_quat.c
View File

@@ -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);

68
test/src/test_vec3.c
View File

@@ -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);