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

Merge branch 'master' into master

Browse Source
This commit is contained in:
Recep Aslantas
2019-04-30 10:16:55 +03:00
committed by GitHub
parent d232ab7865 e3b52100e3
commit f28260e20b
54 changed files with 751 additions and 762 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -44,7 +44,7 @@
*/
CGLM_INLINE
void
glm_mul(const mat4 m1, const mat4 m2, mat4 dest) {
glm_mul(mat4 m1, mat4 m2, mat4 dest) {
#ifdef __AVX__
glm_mul_avx(m1, m2, dest);
#elif defined( __SSE__ ) || defined( __SSE2__ )
@@ -100,7 +100,7 @@ glm_mul(const mat4 m1, const mat4 m2, mat4 dest) {
*/
CGLM_INLINE
void
glm_mul_rot(const mat4 m1, const mat4 m2, mat4 dest) {
glm_mul_rot(mat4 m1, mat4 m2, mat4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glm_mul_rot_sse2(m1, m2, dest);
#else

36
include/cglm/affine.h
View File

@@ -42,7 +42,7 @@
CGLM_INLINE
void
glm_mat4_mul(const mat4 m1, const mat4 m2, mat4 dest);
glm_mat4_mul(mat4 m1, mat4 m2, mat4 dest);
/*!
* @brief translate existing transform matrix by v vector
@@ -53,7 +53,7 @@ glm_mat4_mul(const mat4 m1, const mat4 m2, mat4 dest);
*/
CGLM_INLINE
void
glm_translate(mat4 m, const vec3 v) {
glm_translate(mat4 m, vec3 v) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glmm_store(m[3],
_mm_add_ps(_mm_add_ps(_mm_mul_ps(glmm_load(m[0]),
@@ -89,7 +89,7 @@ glm_translate(mat4 m, const vec3 v) {
*/
CGLM_INLINE
void
glm_translate_to(const mat4 m, const vec3 v, mat4 dest) {
glm_translate_to(mat4 m, vec3 v, mat4 dest) {
glm_mat4_copy(m, dest);
glm_translate(dest, v);
}
@@ -168,7 +168,7 @@ glm_translate_z(mat4 m, float z) {
*/
CGLM_INLINE
void
glm_translate_make(mat4 m, const vec3 v) {
glm_translate_make(mat4 m, vec3 v) {
glm_mat4_identity(m);
glm_vec3_copy(v, m[3]);
}
@@ -183,7 +183,7 @@ glm_translate_make(mat4 m, const vec3 v) {
*/
CGLM_INLINE
void
glm_scale_to(const mat4 m, const vec3 v, mat4 dest) {
glm_scale_to(mat4 m, vec3 v, mat4 dest) {
glm_vec4_scale(m[0], v[0], dest[0]);
glm_vec4_scale(m[1], v[1], dest[1]);
glm_vec4_scale(m[2], v[2], dest[2]);
@@ -199,7 +199,7 @@ glm_scale_to(const mat4 m, const vec3 v, mat4 dest) {
*/
CGLM_INLINE
void
glm_scale_make(mat4 m, const vec3 v) {
glm_scale_make(mat4 m, vec3 v) {
glm_mat4_identity(m);
m[0][0] = v[0];
m[1][1] = v[1];
@@ -215,7 +215,7 @@ glm_scale_make(mat4 m, const vec3 v) {
*/
CGLM_INLINE
void
glm_scale(mat4 m, const vec3 v) {
glm_scale(mat4 m, vec3 v) {
glm_scale_to(m, v, m);
}
@@ -243,7 +243,7 @@ glm_scale_uni(mat4 m, float s) {
*/
CGLM_INLINE
void
glm_rotate_x(const mat4 m, float angle, mat4 dest) {
glm_rotate_x(mat4 m, float angle, mat4 dest) {
CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
float c, s;
@@ -268,7 +268,7 @@ glm_rotate_x(const mat4 m, float angle, mat4 dest) {
*/
CGLM_INLINE
void
glm_rotate_y(const mat4 m, float angle, mat4 dest) {
glm_rotate_y(mat4 m, float angle, mat4 dest) {
CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
float c, s;
@@ -293,7 +293,7 @@ glm_rotate_y(const mat4 m, float angle, mat4 dest) {
*/
CGLM_INLINE
void
glm_rotate_z(const mat4 m, float angle, mat4 dest) {
glm_rotate_z(mat4 m, float angle, mat4 dest) {
CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
float c, s;
@@ -319,7 +319,7 @@ glm_rotate_z(const mat4 m, float angle, mat4 dest) {
*/
CGLM_INLINE
void
glm_rotate_make(mat4 m, float angle, const vec3 axis) {
glm_rotate_make(mat4 m, float angle, vec3 axis) {
CGLM_ALIGN(8) vec3 axisn, v, vs;
float c;
@@ -350,7 +350,7 @@ glm_rotate_make(mat4 m, float angle, const vec3 axis) {
*/
CGLM_INLINE
void
glm_rotate(mat4 m, float angle, const vec3 axis) {
glm_rotate(mat4 m, float angle, vec3 axis) {
CGLM_ALIGN_MAT mat4 rot;
glm_rotate_make(rot, angle, axis);
glm_mul_rot(m, rot, m);
@@ -367,7 +367,7 @@ glm_rotate(mat4 m, float angle, const vec3 axis) {
*/
CGLM_INLINE
void
glm_rotate_at(mat4 m, const vec3 pivot, float angle, const vec3 axis) {
glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis) {
CGLM_ALIGN(8) vec3 pivotInv;
glm_vec3_negate_to(pivot, pivotInv);
@@ -392,7 +392,7 @@ glm_rotate_at(mat4 m, const vec3 pivot, float angle, const vec3 axis) {
*/
CGLM_INLINE
void
glm_rotate_atm(mat4 m, const vec3 pivot, float angle, const vec3 axis) {
glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis) {
CGLM_ALIGN(8) vec3 pivotInv;
glm_vec3_negate_to(pivot, pivotInv);
@@ -410,7 +410,7 @@ glm_rotate_atm(mat4 m, const vec3 pivot, float angle, const vec3 axis) {
*/
CGLM_INLINE
void
glm_decompose_scalev(const mat4 m, vec3 s) {
glm_decompose_scalev(mat4 m, vec3 s) {
s[0] = glm_vec3_norm(m[0]);
s[1] = glm_vec3_norm(m[1]);
s[2] = glm_vec3_norm(m[2]);
@@ -426,7 +426,7 @@ glm_decompose_scalev(const mat4 m, vec3 s) {
*/
CGLM_INLINE
bool
glm_uniscaled(const mat4 m) {
glm_uniscaled(mat4 m) {
CGLM_ALIGN(8) vec3 s;
glm_decompose_scalev(m, s);
return glm_vec3_eq_all(s);
@@ -442,7 +442,7 @@ glm_uniscaled(const mat4 m) {
*/
CGLM_INLINE
void
glm_decompose_rs(const mat4 m, mat4 r, vec3 s) {
glm_decompose_rs(mat4 m, mat4 r, vec3 s) {
CGLM_ALIGN(16) vec4 t = {0.0f, 0.0f, 0.0f, 1.0f};
CGLM_ALIGN(8) vec3 v;
@@ -482,7 +482,7 @@ glm_decompose_rs(const mat4 m, mat4 r, vec3 s) {
*/
CGLM_INLINE
void
glm_decompose(const mat4 m, vec4 t, mat4 r, vec3 s) {
glm_decompose(mat4 m, vec4 t, mat4 r, vec3 s) {
glm_vec4_copy(m[3], t);
glm_decompose_rs(m, r, s);
}

37
include/cglm/box.h
View File

@@ -22,7 +22,7 @@
*/
CGLM_INLINE
void
glm_aabb_transform(const vec3 box[2], const mat4 m, vec3 dest[2]) {
glm_aabb_transform(vec3 box[2], mat4 m, vec3 dest[2]) {
vec3 v[2], xa, xb, ya, yb, za, zb;
glm_vec3_scale(m[0], box[0][0], xa);
@@ -62,7 +62,7 @@ glm_aabb_transform(const vec3 box[2], const mat4 m, vec3 dest[2]) {
*/
CGLM_INLINE
void
glm_aabb_merge(const vec3 box1[2], const vec3 box2[2], vec3 dest[2]) {
glm_aabb_merge(vec3 box1[2], vec3 box2[2], vec3 dest[2]) {
dest[0][0] = glm_min(box1[0][0], box2[0][0]);
dest[0][1] = glm_min(box1[0][1], box2[0][1]);
dest[0][2] = glm_min(box1[0][2], box2[0][2]);
@@ -85,7 +85,7 @@ glm_aabb_merge(const vec3 box1[2], const vec3 box2[2], vec3 dest[2]) {
*/
CGLM_INLINE
void
glm_aabb_crop(const vec3 box[2], const vec3 cropBox[2], vec3 dest[2]) {
glm_aabb_crop(vec3 box[2], vec3 cropBox[2], vec3 dest[2]) {
dest[0][0] = glm_max(box[0][0], cropBox[0][0]);
dest[0][1] = glm_max(box[0][1], cropBox[0][1]);
dest[0][2] = glm_max(box[0][2], cropBox[0][2]);
@@ -109,10 +109,10 @@ glm_aabb_crop(const vec3 box[2], const vec3 cropBox[2], vec3 dest[2]) {
*/
CGLM_INLINE
void
glm_aabb_crop_until(const vec3 box[2],
const vec3 cropBox[2],
const vec3 clampBox[2],
vec3 dest[2]) {
glm_aabb_crop_until(vec3 box[2],
vec3 cropBox[2],
vec3 clampBox[2],
vec3 dest[2]) {
glm_aabb_crop(box, cropBox, dest);
glm_aabb_merge(clampBox, dest, dest);
}
@@ -133,10 +133,9 @@ glm_aabb_crop_until(const vec3 box[2],
*/
CGLM_INLINE
bool
glm_aabb_frustum(const vec3 box[2], const vec4 planes[6]) {
const float *p;
float dp;
int i;
glm_aabb_frustum(vec3 box[2], vec4 planes[6]) {
float *p, dp;
int i;
for (i = 0; i < 6; i++) {
p = planes[i];
@@ -170,7 +169,7 @@ glm_aabb_invalidate(vec3 box[2]) {
*/
CGLM_INLINE
bool
glm_aabb_isvalid(const vec3 box[2]) {
glm_aabb_isvalid(vec3 box[2]) {
return glm_vec3_max(box[0]) != FLT_MAX
&& glm_vec3_min(box[1]) != -FLT_MAX;
}
@@ -182,7 +181,7 @@ glm_aabb_isvalid(const vec3 box[2]) {
*/
CGLM_INLINE
float
glm_aabb_size(const vec3 box[2]) {
glm_aabb_size(vec3 box[2]) {
return glm_vec3_distance(box[0], box[1]);
}
@@ -193,7 +192,7 @@ glm_aabb_size(const vec3 box[2]) {
*/
CGLM_INLINE
float
glm_aabb_radius(const vec3 box[2]) {
glm_aabb_radius(vec3 box[2]) {
return glm_aabb_size(box) * 0.5f;
}
@@ -205,7 +204,7 @@ glm_aabb_radius(const vec3 box[2]) {
*/
CGLM_INLINE
void
glm_aabb_center(const vec3 box[2], vec3 dest) {
glm_aabb_center(vec3 box[2], vec3 dest) {
glm_vec3_center(box[0], box[1], dest);
}
@@ -217,7 +216,7 @@ glm_aabb_center(const vec3 box[2], vec3 dest) {
*/
CGLM_INLINE
bool
glm_aabb_aabb(const vec3 box[2], const vec3 other[2]) {
glm_aabb_aabb(vec3 box[2], vec3 other[2]) {
return (box[0][0] <= other[1][0] && box[1][0] >= other[0][0])
&& (box[0][1] <= other[1][1] && box[1][1] >= other[0][1])
&& (box[0][2] <= other[1][2] && box[1][2] >= other[0][2]);
@@ -234,7 +233,7 @@ glm_aabb_aabb(const vec3 box[2], const vec3 other[2]) {
*/
CGLM_INLINE
bool
glm_aabb_sphere(const vec3 box[2], const vec4 s) {
glm_aabb_sphere(vec3 box[2], vec4 s) {
float dmin;
int a, b, c;
@@ -257,7 +256,7 @@ glm_aabb_sphere(const vec3 box[2], const vec4 s) {
*/
CGLM_INLINE
bool
glm_aabb_point(const vec3 box[2], const vec3 point) {
glm_aabb_point(vec3 box[2], vec3 point) {
return (point[0] >= box[0][0] && point[0] <= box[1][0])
&& (point[1] >= box[0][1] && point[1] <= box[1][1])
&& (point[2] >= box[0][2] && point[2] <= box[1][2]);
@@ -271,7 +270,7 @@ glm_aabb_point(const vec3 box[2], const vec3 point) {
*/
CGLM_INLINE
bool
glm_aabb_contains(const vec3 box[2], const vec3 other[2]) {
glm_aabb_contains(vec3 box[2], vec3 other[2]) {
return (box[0][0] <= other[0][0] && box[1][0] >= other[1][0])
&& (box[0][1] <= other[0][1] && box[1][1] >= other[1][1])
&& (box[0][2] <= other[0][2] && box[1][2] >= other[1][2]);

38
include/cglm/call/affine.h
View File

@@ -15,15 +15,15 @@ extern "C" {
CGLM_EXPORT
void
glmc_translate_make(mat4 m, const vec3 v);
glmc_translate_make(mat4 m, vec3 v);
CGLM_EXPORT
void
glmc_translate_to(const mat4 m, const vec3 v, mat4 dest);
glmc_translate_to(mat4 m, vec3 v, mat4 dest);
CGLM_EXPORT
void
glmc_translate(mat4 m, const vec3 v);
glmc_translate(mat4 m, vec3 v);
CGLM_EXPORT
void
@@ -39,15 +39,15 @@ glmc_translate_z(mat4 m, float to);
CGLM_EXPORT
void
glmc_scale_make(mat4 m, const vec3 v);
glmc_scale_make(mat4 m, vec3 v);
CGLM_EXPORT
void
glmc_scale_to(const mat4 m, const vec3 v, mat4 dest);
glmc_scale_to(mat4 m, vec3 v, mat4 dest);
CGLM_EXPORT
void
glmc_scale(mat4 m, const vec3 v);
glmc_scale(mat4 m, vec3 v);
CGLM_EXPORT
void
@@ -55,57 +55,57 @@ glmc_scale_uni(mat4 m, float s);
CGLM_EXPORT
void
glmc_rotate_x(const mat4 m, float rad, mat4 dest);
glmc_rotate_x(mat4 m, float rad, mat4 dest);
CGLM_EXPORT
void
glmc_rotate_y(const mat4 m, float rad, mat4 dest);
glmc_rotate_y(mat4 m, float rad, mat4 dest);
CGLM_EXPORT
void
glmc_rotate_z(const mat4 m, float rad, mat4 dest);
glmc_rotate_z(mat4 m, float rad, mat4 dest);
CGLM_EXPORT
void
glmc_rotate_make(mat4 m, float angle, const vec3 axis);
glmc_rotate_make(mat4 m, float angle, vec3 axis);
CGLM_EXPORT
void
glmc_rotate(mat4 m, float angle, const vec3 axis);
glmc_rotate(mat4 m, float angle, vec3 axis);
CGLM_EXPORT
void
glmc_rotate_at(mat4 m, const vec3 pivot, float angle, const vec3 axis);
glmc_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis);
CGLM_EXPORT
void
glmc_rotate_atm(mat4 m, const vec3 pivot, float angle, const vec3 axis);
glmc_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis);
CGLM_EXPORT
void
glmc_decompose_scalev(const mat4 m, vec3 s);
glmc_decompose_scalev(mat4 m, vec3 s);
CGLM_EXPORT
bool
glmc_uniscaled(const mat4 m);
glmc_uniscaled(mat4 m);
CGLM_EXPORT
void
glmc_decompose_rs(const mat4 m, mat4 r, vec3 s);
glmc_decompose_rs(mat4 m, mat4 r, vec3 s);
CGLM_EXPORT
void
glmc_decompose(const mat4 m, vec4 t, mat4 r, vec3 s);
glmc_decompose(mat4 m, vec4 t, mat4 r, vec3 s);
/* affine-mat */
CGLM_EXPORT
void
glmc_mul(const mat4 m1, const mat4 m2, mat4 dest);
glmc_mul(mat4 m1, mat4 m2, mat4 dest);
CGLM_EXPORT
void
glmc_mul_rot(const mat4 m1, const mat4 m2, mat4 dest);
glmc_mul_rot(mat4 m1, mat4 m2, mat4 dest);
CGLM_EXPORT
void

32
include/cglm/call/box.h
View File

@@ -15,26 +15,26 @@ extern "C" {
CGLM_EXPORT
void
glmc_aabb_transform(const vec3 box[2], const mat4 m, vec3 dest[2]);
glmc_aabb_transform(vec3 box[2], mat4 m, vec3 dest[2]);
CGLM_EXPORT
void
glmc_aabb_merge(const vec3 box1[2], const vec3 box2[2], vec3 dest[2]);
glmc_aabb_merge(vec3 box1[2], vec3 box2[2], vec3 dest[2]);
CGLM_EXPORT
void
glmc_aabb_crop(const vec3 box[2], const vec3 cropBox[2], vec3 dest[2]);
glmc_aabb_crop(vec3 box[2], vec3 cropBox[2], vec3 dest[2]);
CGLM_EXPORT
void
glmc_aabb_crop_until(const vec3 box[2],
const vec3 cropBox[2],
const vec3 clampBox[2],
vec3 dest[2]);
glmc_aabb_crop_until(vec3 box[2],
vec3 cropBox[2],
vec3 clampBox[2],
vec3 dest[2]);
CGLM_EXPORT
bool
glmc_aabb_frustum(const vec3 box[2], vec4 planes[6]);
glmc_aabb_frustum(vec3 box[2], vec4 planes[6]);
CGLM_EXPORT
void
@@ -42,35 +42,35 @@ glmc_aabb_invalidate(vec3 box[2]);
CGLM_EXPORT
bool
glmc_aabb_isvalid(const vec3 box[2]);
glmc_aabb_isvalid(vec3 box[2]);
CGLM_EXPORT
float
glmc_aabb_size(const vec3 box[2]);
glmc_aabb_size(vec3 box[2]);
CGLM_EXPORT
float
glmc_aabb_radius(const vec3 box[2]);
glmc_aabb_radius(vec3 box[2]);
CGLM_EXPORT
void
glmc_aabb_center(const vec3 box[2], vec3 dest);
glmc_aabb_center(vec3 box[2], vec3 dest);
CGLM_EXPORT
bool
glmc_aabb_aabb(const vec3 box[2], const vec3 other[2]);
glmc_aabb_aabb(vec3 box[2], vec3 other[2]);
CGLM_EXPORT
bool
glmc_aabb_point(const vec3 box[2], const vec3 point);
glmc_aabb_point(vec3 box[2], vec3 point);
CGLM_EXPORT
bool
glmc_aabb_contains(const vec3 box[2], const vec3 other[2]);
glmc_aabb_contains(vec3 box[2], vec3 other[2]);
CGLM_EXPORT
bool
glmc_aabb_sphere(const vec3 box[2], const vec4 s);
glmc_aabb_sphere(vec3 box[2], vec4 s);
#ifdef __cplusplus
}

38
include/cglm/call/cam.h
View File

@@ -21,7 +21,7 @@ glmc_frustum(float left,
float top,
float nearVal,
float farVal,
mat4 dest);
mat4 dest);
CGLM_EXPORT
void
@@ -31,19 +31,19 @@ glmc_ortho(float left,
float top,
float nearVal,
float farVal,
mat4 dest);
mat4 dest);
CGLM_EXPORT
void
glmc_ortho_aabb(const vec3 box[2], mat4 dest);
glmc_ortho_aabb(vec3 box[2], mat4 dest);
CGLM_EXPORT
void
glmc_ortho_aabb_p(const vec3 box[2], float padding, mat4 dest);
glmc_ortho_aabb_p(vec3 box[2], float padding, mat4 dest);
CGLM_EXPORT
void
glmc_ortho_aabb_pz(const vec3 box[2], float padding, mat4 dest);
glmc_ortho_aabb_pz(vec3 box[2], float padding, mat4 dest);
CGLM_EXPORT
void
@@ -59,7 +59,7 @@ glmc_perspective(float fovy,
float aspect,
float nearVal,
float farVal,
mat4 dest);
mat4 dest);
CGLM_EXPORT
void
@@ -75,19 +75,19 @@ glmc_perspective_resize(float aspect, mat4 proj);
CGLM_EXPORT
void
glmc_lookat(const vec3 eye, const vec3 center, const vec3 up, mat4 dest);
glmc_lookat(vec3 eye, vec3 center, vec3 up, mat4 dest);
CGLM_EXPORT
void
glmc_look(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest);
glmc_look(vec3 eye, vec3 dir, vec3 up, mat4 dest);
CGLM_EXPORT
void
glmc_look_anyup(const vec3 eye, const vec3 dir, mat4 dest);
glmc_look_anyup(vec3 eye, vec3 dir, mat4 dest);
CGLM_EXPORT
void
glmc_persp_decomp(const mat4 proj,
glmc_persp_decomp(mat4 proj,
float * __restrict nearVal,
float * __restrict farVal,
float * __restrict top,
@@ -97,45 +97,45 @@ glmc_persp_decomp(const mat4 proj,
CGLM_EXPORT
void
glmc_persp_decompv(const mat4 proj, float dest[6]);
glmc_persp_decompv(mat4 proj, float dest[6]);
CGLM_EXPORT
void
glmc_persp_decomp_x(const mat4 proj,
glmc_persp_decomp_x(mat4 proj,
float * __restrict left,
float * __restrict right);
CGLM_EXPORT
void
glmc_persp_decomp_y(const mat4 proj,
glmc_persp_decomp_y(mat4 proj,
float * __restrict top,
float * __restrict bottom);
CGLM_EXPORT
void
glmc_persp_decomp_z(const mat4 proj,
glmc_persp_decomp_z(mat4 proj,
float * __restrict nearVal,
float * __restrict farVal);
CGLM_EXPORT
void
glmc_persp_decomp_far(const mat4 proj, float * __restrict farVal);
glmc_persp_decomp_far(mat4 proj, float * __restrict farVal);
CGLM_EXPORT
void
glmc_persp_decomp_near(const mat4 proj, float * __restrict nearVal);
glmc_persp_decomp_near(mat4 proj, float * __restrict nearVal);
CGLM_EXPORT
float
glmc_persp_fovy(const mat4 proj);
glmc_persp_fovy(mat4 proj);
CGLM_EXPORT
float
glmc_persp_aspect(const mat4 proj);
glmc_persp_aspect(mat4 proj);
CGLM_EXPORT
void
glmc_persp_sizes(const mat4 proj, float fovy, vec4 dest);
glmc_persp_sizes(mat4 proj, float fovy, vec4 dest);
#ifdef __cplusplus
}

2
include/cglm/call/curve.h
View File

@@ -15,7 +15,7 @@ extern "C" {
CGLM_EXPORT
float
glmc_smc(float s, const mat4 m, const vec4 c);
glmc_smc(float s, mat4 m, vec4 c);
#ifdef __cplusplus
}

18
include/cglm/call/euler.h
View File

@@ -15,39 +15,39 @@ extern "C" {
CGLM_EXPORT
void
glmc_euler_angles(const mat4 m, vec3 dest);
glmc_euler_angles(mat4 m, vec3 dest);
CGLM_EXPORT
void
glmc_euler(const vec3 angles, mat4 dest);
glmc_euler(vec3 angles, mat4 dest);
CGLM_EXPORT
void
glmc_euler_xyz(const vec3 angles, mat4 dest);
glmc_euler_xyz(vec3 angles, mat4 dest);
CGLM_EXPORT
void
glmc_euler_zyx(const vec3 angles, mat4 dest);
glmc_euler_zyx(vec3 angles, mat4 dest);
CGLM_EXPORT
void
glmc_euler_zxy(const vec3 angles, mat4 dest);
glmc_euler_zxy(vec3 angles, mat4 dest);
CGLM_EXPORT
void
glmc_euler_xzy(const vec3 angles, mat4 dest);
glmc_euler_xzy(vec3 angles, mat4 dest);
CGLM_EXPORT
void
glmc_euler_yzx(const vec3 angles, mat4 dest);
glmc_euler_yzx(vec3 angles, mat4 dest);
CGLM_EXPORT
void
glmc_euler_yxz(const vec3 angles, mat4 dest);
glmc_euler_yxz(vec3 angles, mat4 dest);
CGLM_EXPORT
void
glmc_euler_by_order(const vec3 angles, glm_euler_sq axis, mat4 dest);
glmc_euler_by_order(vec3 angles, glm_euler_sq axis, mat4 dest);
#ifdef __cplusplus
}

16
include/cglm/call/frustum.h
View File

@@ -15,26 +15,26 @@ extern "C" {
CGLM_EXPORT
void
glmc_frustum_planes(const mat4 m, vec4 dest[6]);
glmc_frustum_planes(mat4 m, vec4 dest[6]);
CGLM_EXPORT
void
glmc_frustum_corners(const mat4 invMat, vec4 dest[8]);
glmc_frustum_corners(mat4 invMat, vec4 dest[8]);
CGLM_EXPORT
void
glmc_frustum_center(const vec4 corners[8], vec4 dest);
glmc_frustum_center(vec4 corners[8], vec4 dest);
CGLM_EXPORT
void
glmc_frustum_box(const vec4 corners[8], const mat4 m, vec3 box[2]);
glmc_frustum_box(vec4 corners[8], mat4 m, vec3 box[2]);
CGLM_EXPORT
void
glmc_frustum_corners_at(const vec4 corners[8],
float splitDist,
float farDist,
vec4 planeCorners[4]);
glmc_frustum_corners_at(vec4 corners[8],
float splitDist,
float farDist,
vec4 planeCorners[4]);
#ifdef __cplusplus
}
#endif

20
include/cglm/call/io.h
View File

@@ -15,28 +15,28 @@ extern "C" {
CGLM_EXPORT
void
glmc_mat4_print(const mat4 matrix,
FILE * const __restrict ostream);
glmc_mat4_print(mat4 matrix,
FILE * __restrict ostream);
CGLM_EXPORT
void
glmc_mat3_print(const mat3 matrix,
FILE * const __restrict ostream);
glmc_mat3_print(mat3 matrix,
FILE * __restrict ostream);
CGLM_EXPORT
void
glmc_vec4_print(const vec4 vec,
FILE * const __restrict ostream);
glmc_vec4_print(vec4 vec,
FILE * __restrict ostream);
CGLM_EXPORT
void
glmc_vec3_print(const vec3 vec,
FILE * const __restrict ostream);
glmc_vec3_print(vec3 vec,
FILE * __restrict ostream);
CGLM_EXPORT
void
glmc_versor_print(const versor vec,
FILE * const __restrict ostream);
glmc_versor_print(versor vec,
FILE * __restrict ostream);
#ifdef __cplusplus
}

20
include/cglm/call/mat3.h
View File

@@ -18,7 +18,7 @@ extern "C" {
CGLM_EXPORT
void
glmc_mat3_copy(const mat3 mat, mat3 dest);
glmc_mat3_copy(mat3 mat, mat3 dest);
CGLM_EXPORT
void
@@ -26,15 +26,15 @@ glmc_mat3_identity(mat3 mat);
CGLM_EXPORT
void
glmc_mat3_identity_array(mat3 * const __restrict mat, size_t count);
glmc_mat3_identity_array(mat3 * __restrict mat, size_t count);
CGLM_EXPORT
void
glmc_mat3_mul(const mat3 m1, const mat3 m2, mat3 dest);
glmc_mat3_mul(mat3 m1, mat3 m2, mat3 dest);
CGLM_EXPORT
void
glmc_mat3_transpose_to(const mat3 m, mat3 dest);
glmc_mat3_transpose_to(mat3 m, mat3 dest);
CGLM_EXPORT
void
@@ -42,15 +42,15 @@ glmc_mat3_transpose(mat3 m);
CGLM_EXPORT
void
glmc_mat3_mulv(const mat3 m, const vec3 v, vec3 dest);
glmc_mat3_mulv(mat3 m, vec3 v, vec3 dest);
CGLM_EXPORT
float
glmc_mat3_trace(const mat3 m);
glmc_mat3_trace(mat3 m);
CGLM_EXPORT
void
glmc_mat3_quat(const mat3 m, versor dest);
glmc_mat3_quat(mat3 m, versor dest);
CGLM_EXPORT
void
@@ -58,11 +58,11 @@ glmc_mat3_scale(mat3 m, float s);
CGLM_EXPORT
float
glmc_mat3_det(const mat3 mat);
glmc_mat3_det(mat3 mat);
CGLM_EXPORT
void
glmc_mat3_inv(const mat3 mat, mat3 dest);
glmc_mat3_inv(mat3 mat, mat3 dest);
CGLM_EXPORT
void
@@ -74,7 +74,7 @@ glmc_mat3_swap_row(mat3 mat, int row1, int row2);
CGLM_EXPORT
float
glmc_mat3_rmc(const vec3 r, const mat3 m, const vec3 c);
glmc_mat3_rmc(vec3 r, mat3 m, vec3 c);
#ifdef __cplusplus
}

38
include/cglm/call/mat4.h
View File

@@ -19,11 +19,11 @@ extern "C" {
CGLM_EXPORT
void
glmc_mat4_ucopy(const mat4 mat, mat4 dest);
glmc_mat4_ucopy(mat4 mat, mat4 dest);
CGLM_EXPORT
void
glmc_mat4_copy(const mat4 mat, mat4 dest);
glmc_mat4_copy(mat4 mat, mat4 dest);
CGLM_EXPORT
void
@@ -31,51 +31,51 @@ glmc_mat4_identity(mat4 mat);
CGLM_EXPORT
void
glmc_mat4_identity_array(mat4 * const __restrict mat, size_t count);
glmc_mat4_identity_array(mat4 * __restrict mat, size_t count);
CGLM_EXPORT
void
glmc_mat4_pick3(const mat4 mat, mat3 dest);
glmc_mat4_pick3(mat4 mat, mat3 dest);
CGLM_EXPORT
void
glmc_mat4_pick3t(const mat4 mat, mat3 dest);
glmc_mat4_pick3t(mat4 mat, mat3 dest);
CGLM_EXPORT
void
glmc_mat4_ins3(const mat3 mat, mat4 dest);
glmc_mat4_ins3(mat3 mat, mat4 dest);
CGLM_EXPORT
void
glmc_mat4_mul(const mat4 m1, const mat4 m2, mat4 dest);
glmc_mat4_mul(mat4 m1, mat4 m2, mat4 dest);
CGLM_EXPORT
void
glmc_mat4_mulN(mat4 * const __restrict matrices[], uint32_t len, mat4 dest);
glmc_mat4_mulN(mat4 * __restrict matrices[], uint32_t len, mat4 dest);
CGLM_EXPORT
void
glmc_mat4_mulv(const mat4 m, const vec4 v, vec4 dest);
glmc_mat4_mulv(mat4 m, vec4 v, vec4 dest);
CGLM_EXPORT
void
glmc_mat4_mulv3(const mat4 m, const vec3 v, float last, vec3 dest);
glmc_mat4_mulv3(mat4 m, vec3 v, float last, vec3 dest);
CGLM_EXPORT
float
glmc_mat4_trace(const mat4 m);
glmc_mat4_trace(mat4 m);
CGLM_EXPORT
float
glmc_mat4_trace3(const mat4 m);
glmc_mat4_trace3(mat4 m);
CGLM_EXPORT
void
glmc_mat4_quat(const mat4 m, versor dest);
glmc_mat4_quat(mat4 m, versor dest);
CGLM_EXPORT
void
glmc_mat4_transpose_to(const mat4 m, mat4 dest);
glmc_mat4_transpose_to(mat4 m, mat4 dest);
CGLM_EXPORT
void
@@ -91,19 +91,19 @@ glmc_mat4_scale(mat4 m, float s);
CGLM_EXPORT
float
glmc_mat4_det(const mat4 mat);
glmc_mat4_det(mat4 mat);
CGLM_EXPORT
void
glmc_mat4_inv(const mat4 mat, mat4 dest);
glmc_mat4_inv(mat4 mat, mat4 dest);
CGLM_EXPORT
void
glmc_mat4_inv_precise(const mat4 mat, mat4 dest);
glmc_mat4_inv_precise(mat4 mat, mat4 dest);
CGLM_EXPORT
void
glmc_mat4_inv_fast(const mat4 mat, mat4 dest);
glmc_mat4_inv_fast(mat4 mat, mat4 dest);
CGLM_EXPORT
void
@@ -115,7 +115,7 @@ glmc_mat4_swap_row(mat4 mat, int row1, int row2);
CGLM_EXPORT
float
glmc_mat4_rmc(const vec4 r, const mat4 m, const vec4 c);
glmc_mat4_rmc(vec4 r, mat4 m, vec4 c);
#ifdef __cplusplus
}

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

@@ -15,15 +15,15 @@ extern "C" {
CGLM_EXPORT
void
glmc_unprojecti(const vec3 pos, const mat4 invMat, const vec4 vp, vec3 dest);
glmc_unprojecti(vec3 pos, mat4 invMat, vec4 vp, vec3 dest);
CGLM_EXPORT
void
glmc_unproject(const vec3 pos, const mat4 m, const vec4 vp, vec3 dest);
glmc_unproject(vec3 pos, mat4 m, vec4 vp, vec3 dest);
CGLM_EXPORT
void
glmc_project(const vec3 pos, const mat4 m, const vec4 vp, vec3 dest);
glmc_project(vec3 pos, mat4 m, vec4 vp, vec3 dest);
#ifdef __cplusplus
}

64
include/cglm/call/quat.h
View File

@@ -19,7 +19,7 @@ glmc_quat_identity(versor q);
CGLM_EXPORT
void
glmc_quat_identity_array(versor * const __restrict q, size_t count);
glmc_quat_identity_array(versor * __restrict q, size_t count);
CGLM_EXPORT
void
@@ -31,19 +31,19 @@ glmc_quat(versor q, float angle, float x, float y, float z);
CGLM_EXPORT
void
glmc_quatv(versor q, float angle, const vec3 axis);
glmc_quatv(versor q, float angle, vec3 axis);
CGLM_EXPORT
void
glmc_quat_copy(const versor q, versor dest);
glmc_quat_copy(versor q, versor dest);
CGLM_EXPORT
float
glmc_quat_norm(const versor q);
glmc_quat_norm(versor q);
CGLM_EXPORT
void
glmc_quat_normalize_to(const versor q, versor dest);
glmc_quat_normalize_to(versor q, versor dest);
CGLM_EXPORT
void
@@ -51,107 +51,103 @@ glmc_quat_normalize(versor q);
CGLM_EXPORT
float
glmc_quat_dot(const versor p, const versor q);
glmc_quat_dot(versor p, versor q);
CGLM_EXPORT
void
glmc_quat_conjugate(const versor q, versor dest);
glmc_quat_conjugate(versor q, versor dest);
CGLM_EXPORT
void
glmc_quat_inv(const versor q, versor dest);
glmc_quat_inv(versor q, versor dest);
CGLM_EXPORT
void
glmc_quat_add(const versor p, const versor q, versor dest);
glmc_quat_add(versor p, versor q, versor dest);
CGLM_EXPORT
void
glmc_quat_sub(const versor p, const versor q, versor dest);
glmc_quat_sub(versor p, versor q, versor dest);
CGLM_EXPORT
float
glmc_quat_real(const versor q);
glmc_quat_real(versor q);
CGLM_EXPORT
void
glmc_quat_imag(const versor q, vec3 dest);
glmc_quat_imag(versor q, vec3 dest);
CGLM_EXPORT
void
glmc_quat_imagn(const versor q, vec3 dest);
glmc_quat_imagn(versor q, vec3 dest);
CGLM_EXPORT
float
glmc_quat_imaglen(const versor q);
glmc_quat_imaglen(versor q);
CGLM_EXPORT
float
glmc_quat_angle(const versor q);
glmc_quat_angle(versor q);
CGLM_EXPORT
void
glmc_quat_axis(const versor q, versor dest);
glmc_quat_axis(versor q, versor dest);
CGLM_EXPORT
void
glmc_quat_mul(const versor p, const versor q, versor dest);
glmc_quat_mul(versor p, versor q, versor dest);
CGLM_EXPORT
void
glmc_quat_mat4(const versor q, mat4 dest);
glmc_quat_mat4(versor q, mat4 dest);
CGLM_EXPORT
void
glmc_quat_mat4t(const versor q, mat4 dest);
glmc_quat_mat4t(versor q, mat4 dest);
CGLM_EXPORT
void
glmc_quat_mat3(const versor q, mat3 dest);
glmc_quat_mat3(versor q, mat3 dest);
CGLM_EXPORT
void
glmc_quat_mat3t(const versor q, mat3 dest);
glmc_quat_mat3t(versor q, mat3 dest);
CGLM_EXPORT
void
glmc_quat_lerp(const versor from, const versor to, float t, versor dest);
glmc_quat_lerp(versor from, versor to, float t, versor dest);
CGLM_EXPORT
void
glmc_quat_slerp(const versor q, const versor r, float t, versor dest);
glmc_quat_slerp(versor q, versor r, float t, versor dest);
CGLM_EXPORT
void
glmc_quat_look(const vec3 eye, const versor ori, mat4 dest);
glmc_quat_look(vec3 eye, versor ori, mat4 dest);
CGLM_EXPORT
void
glmc_quat_for(const vec3 dir, const vec3 fwd, const vec3 up, versor dest);
glmc_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest);
CGLM_EXPORT
void
glmc_quat_forp(const vec3 from,
const vec3 to,
const vec3 fwd,
const vec3 up,
versor dest);
glmc_quat_forp(vec3 from, vec3 to, vec3 fwd, vec3 up, versor dest);
CGLM_EXPORT
void
glmc_quat_rotatev(const versor from, const vec3 to, vec3 dest);
glmc_quat_rotatev(versor from, vec3 to, vec3 dest);
CGLM_EXPORT
void
glmc_quat_rotate(const mat4 m, const versor q, mat4 dest);
glmc_quat_rotate(mat4 m, versor q, mat4 dest);
CGLM_EXPORT
void
glmc_quat_rotate_at(mat4 model, const versor q, const vec3 pivot);
glmc_quat_rotate_at(mat4 model, versor q, vec3 pivot);
CGLM_EXPORT
void
glmc_quat_rotate_atm(mat4 m, const versor q, const vec3 pivot);
glmc_quat_rotate_atm(mat4 m, versor q, vec3 pivot);
#ifdef __cplusplus
}

10
include/cglm/call/sphere.h
View File

@@ -15,23 +15,23 @@ extern "C" {
CGLM_EXPORT
float
glmc_sphere_radii(const vec4 s);
glmc_sphere_radii(vec4 s);
CGLM_EXPORT
void
glmc_sphere_transform(const vec4 s, const mat4 m, vec4 dest);
glmc_sphere_transform(vec4 s, mat4 m, vec4 dest);
CGLM_EXPORT
void
glmc_sphere_merge(const vec4 s1, const vec4 s2, vec4 dest);
glmc_sphere_merge(vec4 s1, vec4 s2, vec4 dest);
CGLM_EXPORT
bool
glmc_sphere_sphere(const vec4 s1, const vec4 s2);
glmc_sphere_sphere(vec4 s1, vec4 s2);
CGLM_EXPORT
bool
glmc_sphere_point(const vec4 s, const vec3 point);
glmc_sphere_point(vec4 s, vec3 point);
#ifdef __cplusplus
}

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

@@ -22,11 +22,11 @@ extern "C" {
CGLM_EXPORT
void
glmc_vec3(const vec4 v4, vec3 dest);
glmc_vec3(vec4 v4, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_copy(const vec3 a, vec3 dest);
glmc_vec3_copy(vec3 a, vec3 dest);
CGLM_EXPORT
void
@@ -38,27 +38,27 @@ glmc_vec3_one(vec3 v);
CGLM_EXPORT
float
glmc_vec3_dot(const vec3 a, const vec3 b);
glmc_vec3_dot(vec3 a, vec3 b);
CGLM_EXPORT
void
glmc_vec3_cross(const vec3 a, const vec3 b, vec3 dest);
glmc_vec3_cross(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_crossn(const vec3 a, const vec3 b, vec3 dest);
glmc_vec3_crossn(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
float
glmc_vec3_norm(const vec3 v);
glmc_vec3_norm(vec3 v);
CGLM_EXPORT
float
glmc_vec3_norm2(const vec3 v);
glmc_vec3_norm2(vec3 v);
CGLM_EXPORT
void
glmc_vec3_normalize_to(const vec3 v, vec3 dest);
glmc_vec3_normalize_to(vec3 v, vec3 dest);
CGLM_EXPORT
void
@@ -66,63 +66,63 @@ glmc_vec3_normalize(vec3 v);
CGLM_EXPORT
void
glmc_vec3_add(const vec3 a, const vec3 b, vec3 dest);
glmc_vec3_add(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_adds(const vec3 v, float s, vec3 dest);
glmc_vec3_adds(vec3 v, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_sub(const vec3 a, const vec3 b, vec3 dest);
glmc_vec3_sub(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_subs(const vec3 v, float s, vec3 dest);
glmc_vec3_subs(vec3 v, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_mul(const vec3 a, const vec3 b, vec3 d);
glmc_vec3_mul(vec3 a, vec3 b, vec3 d);
CGLM_EXPORT
void
glmc_vec3_scale(const vec3 v, float s, vec3 dest);
glmc_vec3_scale(vec3 v, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_scale_as(const vec3 v, float s, vec3 dest);
glmc_vec3_scale_as(vec3 v, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_div(const vec3 a, const vec3 b, vec3 dest);
glmc_vec3_div(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_divs(const vec3 a, float s, vec3 dest);
glmc_vec3_divs(vec3 a, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_addadd(const vec3 a, const vec3 b, vec3 dest);
glmc_vec3_addadd(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_subadd(const vec3 a, const vec3 b, vec3 dest);
glmc_vec3_subadd(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_muladd(const vec3 a, const vec3 b, vec3 dest);
glmc_vec3_muladd(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_muladds(const vec3 a, float s, vec3 dest);
glmc_vec3_muladds(vec3 a, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_maxadd(const vec3 a, const vec3 b, vec3 dest);
glmc_vec3_maxadd(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_minadd(const vec3 a, const vec3 b, vec3 dest);
glmc_vec3_minadd(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
@@ -130,47 +130,47 @@ glmc_vec3_negate(vec3 v);
CGLM_EXPORT
void
glmc_vec3_negate_to(const vec3 v, vec3 dest);
glmc_vec3_negate_to(vec3 v, vec3 dest);
CGLM_EXPORT
float
glmc_vec3_angle(const vec3 a, const vec3 b);
glmc_vec3_angle(vec3 a, vec3 b);
CGLM_EXPORT
void
glmc_vec3_rotate(vec3 v, float angle, const vec3 axis);
glmc_vec3_rotate(vec3 v, float angle, vec3 axis);
CGLM_EXPORT
void
glmc_vec3_rotate_m4(const mat4 m, const vec3 v, vec3 dest);
glmc_vec3_rotate_m4(mat4 m, vec3 v, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_rotate_m3(const mat3 m, const vec3 v, vec3 dest);
glmc_vec3_rotate_m3(mat3 m, vec3 v, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_proj(const vec3 a, const vec3 b, vec3 dest);
glmc_vec3_proj(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_center(const vec3 a, const vec3 b, vec3 dest);
glmc_vec3_center(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
float
glmc_vec3_distance2(const vec3 a, const vec3 b);
glmc_vec3_distance2(vec3 a, vec3 b);
CGLM_EXPORT
float
glmc_vec3_distance(const vec3 a, const vec3 b);
glmc_vec3_distance(vec3 a, vec3 b);
CGLM_EXPORT
void
glmc_vec3_maxv(const vec3 a, const vec3 b, vec3 dest);
glmc_vec3_maxv(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_minv(const vec3 a, const vec3 b, vec3 dest);
glmc_vec3_minv(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
@@ -178,17 +178,17 @@ glmc_vec3_clamp(vec3 v, float minVal, float maxVal);
CGLM_EXPORT
void
glmc_vec3_ortho(const vec3 v, vec3 dest);
glmc_vec3_ortho(vec3 v, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_lerp(const vec3 from, const vec3 to, float t, vec3 dest);
glmc_vec3_lerp(vec3 from, vec3 to, float t, vec3 dest);
/* ext */
CGLM_EXPORT
void
glmc_vec3_mulv(const vec3 a, const vec3 b, vec3 d);
glmc_vec3_mulv(vec3 a, vec3 b, vec3 d);
CGLM_EXPORT
void
@@ -196,51 +196,51 @@ glmc_vec3_broadcast(float val, vec3 d);
CGLM_EXPORT
bool
glmc_vec3_eq(const vec3 v, float val);
glmc_vec3_eq(vec3 v, float val);
CGLM_EXPORT
bool
glmc_vec3_eq_eps(const vec3 v, float val);
glmc_vec3_eq_eps(vec3 v, float val);
CGLM_EXPORT
bool
glmc_vec3_eq_all(const vec3 v);
glmc_vec3_eq_all(vec3 v);
CGLM_EXPORT
bool
glmc_vec3_eqv(const vec3 a, const vec3 b);
glmc_vec3_eqv(vec3 a, vec3 b);
CGLM_EXPORT
bool
glmc_vec3_eqv_eps(const vec3 a, const vec3 b);
glmc_vec3_eqv_eps(vec3 a, vec3 b);
CGLM_EXPORT
float
glmc_vec3_max(const vec3 v);
glmc_vec3_max(vec3 v);
CGLM_EXPORT
float
glmc_vec3_min(const vec3 v);
glmc_vec3_min(vec3 v);
CGLM_EXPORT
bool
glmc_vec3_isnan(const vec3 v);
glmc_vec3_isnan(vec3 v);
CGLM_EXPORT
bool
glmc_vec3_isinf(const vec3 v);
glmc_vec3_isinf(vec3 v);
CGLM_EXPORT
bool
glmc_vec3_isvalid(const vec3 v);
glmc_vec3_isvalid(vec3 v);
CGLM_EXPORT
void
glmc_vec3_sign(const vec3 v, vec3 dest);
glmc_vec3_sign(vec3 v, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_sqrt(const vec3 v, vec3 dest);
glmc_vec3_sqrt(vec3 v, vec3 dest);
#ifdef __cplusplus
}

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

@@ -23,7 +23,7 @@ extern "C" {
CGLM_EXPORT
void
glmc_vec4(const vec3 v3, float last, vec4 dest);
glmc_vec4(vec3 v3, float last, vec4 dest);
CGLM_EXPORT
void
@@ -35,31 +35,31 @@ glmc_vec4_one(vec4 v);
CGLM_EXPORT
void
glmc_vec4_copy3(const vec4 v, vec3 dest);
glmc_vec4_copy3(vec4 v, vec3 dest);
CGLM_EXPORT
void
glmc_vec4_copy(const vec4 v, vec4 dest);
glmc_vec4_copy(vec4 v, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_ucopy(const vec4 v, vec4 dest);
glmc_vec4_ucopy(vec4 v, vec4 dest);
CGLM_EXPORT
float
glmc_vec4_dot(const vec4 a, const vec4 b);
glmc_vec4_dot(vec4 a, vec4 b);
CGLM_EXPORT
float
glmc_vec4_norm(const vec4 v);
glmc_vec4_norm(vec4 v);
CGLM_EXPORT
float
glmc_vec4_norm2(const vec4 v);
glmc_vec4_norm2(vec4 v);
CGLM_EXPORT
void
glmc_vec4_normalize_to(const vec4 v, vec4 dest);
glmc_vec4_normalize_to(vec4 v, vec4 dest);
CGLM_EXPORT
void
@@ -67,63 +67,63 @@ glmc_vec4_normalize(vec4 v);
CGLM_EXPORT
void
glmc_vec4_add(const vec4 a, const vec4 b, vec4 dest);
glmc_vec4_add(vec4 a, vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_adds(const vec4 v, float s, vec4 dest);
glmc_vec4_adds(vec4 v, float s, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_sub(const vec4 a, const vec4 b, vec4 dest);
glmc_vec4_sub(vec4 a, vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_subs(const vec4 v, float s, vec4 dest);
glmc_vec4_subs(vec4 v, float s, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_mul(const vec4 a, const vec4 b, vec4 d);
glmc_vec4_mul(vec4 a, vec4 b, vec4 d);
CGLM_EXPORT
void
glmc_vec4_scale(const vec4 v, float s, vec4 dest);
glmc_vec4_scale(vec4 v, float s, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_scale_as(const vec3 v, float s, vec3 dest);
glmc_vec4_scale_as(vec3 v, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec4_div(const vec4 a, const vec4 b, vec4 dest);
glmc_vec4_div(vec4 a, vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_divs(const vec4 v, float s, vec4 dest);
glmc_vec4_divs(vec4 v, float s, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_addadd(const vec4 a, const vec4 b, vec4 dest);
glmc_vec4_addadd(vec4 a, vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_subadd(const vec4 a, const vec4 b, vec4 dest);
glmc_vec4_subadd(vec4 a, vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_muladd(const vec4 a, const vec4 b, vec4 dest);
glmc_vec4_muladd(vec4 a, vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_muladds(const vec4 a, float s, vec4 dest);
glmc_vec4_muladds(vec4 a, float s, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_maxadd(const vec4 a, const vec4 b, vec4 dest);
glmc_vec4_maxadd(vec4 a, vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_minadd(const vec4 a, const vec4 b, vec4 dest);
glmc_vec4_minadd(vec4 a, vec4 b, vec4 dest);
CGLM_EXPORT
void
@@ -131,19 +131,19 @@ glmc_vec4_negate(vec4 v);
CGLM_EXPORT
void
glmc_vec4_negate_to(const vec4 v, vec4 dest);
glmc_vec4_negate_to(vec4 v, vec4 dest);
CGLM_EXPORT
float
glmc_vec4_distance(const vec4 a, const vec4 b);
glmc_vec4_distance(vec4 a, vec4 b);
CGLM_EXPORT
void
glmc_vec4_maxv(const vec4 a, const vec4 b, vec4 dest);
glmc_vec4_maxv(vec4 a, vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_minv(const vec4 a, const vec4 b, vec4 dest);
glmc_vec4_minv(vec4 a, vec4 b, vec4 dest);
CGLM_EXPORT
void
@@ -151,7 +151,7 @@ glmc_vec4_clamp(vec4 v, float minVal, float maxVal);
CGLM_EXPORT
void
glmc_vec4_lerp(const vec4 from, const vec4 to, float t, vec4 dest);
glmc_vec4_lerp(vec4 from, vec4 to, float t, vec4 dest);
CGLM_EXPORT
void
@@ -161,7 +161,7 @@ glmc_vec4_cubic(float s, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_mulv(const vec4 a, const vec4 b, vec4 d);
glmc_vec4_mulv(vec4 a, vec4 b, vec4 d);
CGLM_EXPORT
void
@@ -169,51 +169,51 @@ glmc_vec4_broadcast(float val, vec4 d);
CGLM_EXPORT
bool
glmc_vec4_eq(const vec4 v, float val);
glmc_vec4_eq(vec4 v, float val);
CGLM_EXPORT
bool
glmc_vec4_eq_eps(const vec4 v, float val);
glmc_vec4_eq_eps(vec4 v, float val);
CGLM_EXPORT
bool
glmc_vec4_eq_all(const vec4 v);
glmc_vec4_eq_all(vec4 v);
CGLM_EXPORT
bool
glmc_vec4_eqv(const vec4 a, const vec4 b);
glmc_vec4_eqv(vec4 a, vec4 b);
CGLM_EXPORT
bool
glmc_vec4_eqv_eps(const vec4 a, const vec4 b);
glmc_vec4_eqv_eps(vec4 a, vec4 b);
CGLM_EXPORT
float
glmc_vec4_max(const vec4 v);
glmc_vec4_max(vec4 v);
CGLM_EXPORT
float
glmc_vec4_min(const vec4 v);
glmc_vec4_min(vec4 v);
CGLM_EXPORT
bool
glmc_vec4_isnan(const vec4 v);
glmc_vec4_isnan(vec4 v);
CGLM_EXPORT
bool
glmc_vec4_isinf(const vec4 v);
glmc_vec4_isinf(vec4 v);
CGLM_EXPORT
bool
glmc_vec4_isvalid(const vec4 v);
glmc_vec4_isvalid(vec4 v);
CGLM_EXPORT
void
glmc_vec4_sign(const vec4 v, vec4 dest);
glmc_vec4_sign(vec4 v, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_sqrt(const vec4 v, vec4 dest);
glmc_vec4_sqrt(vec4 v, vec4 dest);
#ifdef __cplusplus
}

42
include/cglm/cam.h
View File

@@ -147,7 +147,7 @@ glm_ortho(float left,
*/
CGLM_INLINE
void
glm_ortho_aabb(const vec3 box[2], mat4 dest) {
glm_ortho_aabb(vec3 box[2], mat4 dest) {
glm_ortho(box[0][0], box[1][0],
box[0][1], box[1][1],
-box[1][2], -box[0][2],
@@ -165,7 +165,7 @@ glm_ortho_aabb(const vec3 box[2], mat4 dest) {
*/
CGLM_INLINE
void
glm_ortho_aabb_p(const vec3 box[2], float padding, mat4 dest) {
glm_ortho_aabb_p(vec3 box[2], float padding, mat4 dest) {
glm_ortho(box[0][0] - padding, box[1][0] + padding,
box[0][1] - padding, box[1][1] + padding,
-(box[1][2] + padding), -(box[0][2] - padding),
@@ -183,7 +183,7 @@ glm_ortho_aabb_p(const vec3 box[2], float padding, mat4 dest) {
*/
CGLM_INLINE
void
glm_ortho_aabb_pz(const vec3 box[2], float padding, mat4 dest) {
glm_ortho_aabb_pz(vec3 box[2], float padding, mat4 dest) {
glm_ortho(box[0][0], box[1][0],
box[0][1], box[1][1],
-(box[1][2] + padding), -(box[0][2] - padding),
@@ -218,7 +218,9 @@ glm_ortho_default(float aspect, mat4 dest) {
*/
CGLM_INLINE
void
glm_ortho_default_s(float aspect, float size, mat4 dest) {
glm_ortho_default_s(float aspect,
float size,
mat4 dest) {
if (aspect >= 1.0f) {
glm_ortho(-size * aspect,
size * aspect,
@@ -336,10 +338,10 @@ glm_perspective_resize(float aspect, mat4 proj) {
*/
CGLM_INLINE
void
glm_lookat(const vec3 eye,
const vec3 center,
const vec3 up,
mat4 dest) {
glm_lookat(vec3 eye,
vec3 center,
vec3 up,
mat4 dest) {
CGLM_ALIGN(8) vec3 f, u, s;
glm_vec3_sub(center, eye, f);
@@ -380,7 +382,7 @@ glm_lookat(const vec3 eye,
*/
CGLM_INLINE
void
glm_look(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest) {
glm_look(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
CGLM_ALIGN(8) vec3 target;
glm_vec3_add(eye, dir, target);
glm_lookat(eye, target, up, dest);
@@ -398,7 +400,7 @@ glm_look(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest) {
*/
CGLM_INLINE
void
glm_look_anyup(const vec3 eye, const vec3 dir, mat4 dest) {
glm_look_anyup(vec3 eye, vec3 dir, mat4 dest) {
CGLM_ALIGN(8) vec3 up;
glm_vec3_ortho(dir, up);
glm_look(eye, dir, up, dest);
@@ -417,7 +419,7 @@ glm_look_anyup(const vec3 eye, const vec3 dir, mat4 dest) {
*/
CGLM_INLINE
void
glm_persp_decomp(const mat4 proj,
glm_persp_decomp(mat4 proj,
float * __restrict nearVal,
float * __restrict farVal,
float * __restrict top,
@@ -457,7 +459,7 @@ glm_persp_decomp(const mat4 proj,
*/
CGLM_INLINE
void
glm_persp_decompv(const mat4 proj, float dest[6]) {
glm_persp_decompv(mat4 proj, float dest[6]) {
glm_persp_decomp(proj, &dest[0], &dest[1], &dest[2],
&dest[3], &dest[4], &dest[5]);
}
@@ -472,7 +474,7 @@ glm_persp_decompv(const mat4 proj, float dest[6]) {
*/
CGLM_INLINE
void
glm_persp_decomp_x(const mat4 proj,
glm_persp_decomp_x(mat4 proj,
float * __restrict left,
float * __restrict right) {
float nearVal, m20, m00;
@@ -495,7 +497,7 @@ glm_persp_decomp_x(const mat4 proj,
*/
CGLM_INLINE
void
glm_persp_decomp_y(const mat4 proj,
glm_persp_decomp_y(mat4 proj,
float * __restrict top,
float * __restrict bottom) {
float nearVal, m21, m11;
@@ -518,7 +520,7 @@ glm_persp_decomp_y(const mat4 proj,
*/
CGLM_INLINE
void
glm_persp_decomp_z(const mat4 proj,
glm_persp_decomp_z(mat4 proj,
float * __restrict nearVal,
float * __restrict farVal) {
float m32, m22;
@@ -538,7 +540,7 @@ glm_persp_decomp_z(const mat4 proj,
*/
CGLM_INLINE
void
glm_persp_decomp_far(const mat4 proj, float * __restrict farVal) {
glm_persp_decomp_far(mat4 proj, float * __restrict farVal) {
*farVal = proj[3][2] / (proj[2][2] + 1.0f);
}
@@ -550,7 +552,7 @@ glm_persp_decomp_far(const mat4 proj, float * __restrict farVal) {
*/
CGLM_INLINE
void
glm_persp_decomp_near(const mat4 proj, float * __restrict nearVal) {
glm_persp_decomp_near(mat4 proj, float * __restrict nearVal) {
*nearVal = proj[3][2] / (proj[2][2] - 1.0f);
}
@@ -564,7 +566,7 @@ glm_persp_decomp_near(const mat4 proj, float * __restrict nearVal) {
*/
CGLM_INLINE
float
glm_persp_fovy(const mat4 proj) {
glm_persp_fovy(mat4 proj) {
return 2.0f * atanf(1.0f / proj[1][1]);
}
@@ -575,7 +577,7 @@ glm_persp_fovy(const mat4 proj) {
*/
CGLM_INLINE
float
glm_persp_aspect(const mat4 proj) {
glm_persp_aspect(mat4 proj) {
return proj[1][1] / proj[0][0];
}
@@ -588,7 +590,7 @@ glm_persp_aspect(const mat4 proj) {
*/
CGLM_INLINE
void
glm_persp_sizes(const mat4 proj, float fovy, vec4 dest) {
glm_persp_sizes(mat4 proj, float fovy, vec4 dest) {
float t, a, nearVal, farVal;
t = 2.0f * tanf(fovy * 0.5f);

2
include/cglm/color.h
View File

@@ -18,7 +18,7 @@
*/
CGLM_INLINE
float
glm_luminance(const vec3 rgb) {
glm_luminance(vec3 rgb) {
vec3 l = {0.212671f, 0.715160f, 0.072169f};
return glm_dot(rgb, l);
}

2
include/cglm/curve.h
View File

@@ -31,7 +31,7 @@
*/
CGLM_INLINE
float
glm_smc(float s, const mat4 m, const vec4 c) {
glm_smc(float s, mat4 m, vec4 c) {
vec4 vs;
glm_vec4_cubic(s, vs);
return glm_mat4_rmc(vs, m, c);

20
include/cglm/euler.h
View File

@@ -57,7 +57,7 @@ typedef enum glm_euler_sq {
CGLM_INLINE
glm_euler_sq
glm_euler_order(const int ord[3]) {
glm_euler_order(int ord[3]) {
return (glm_euler_sq)(ord[0] << 0 | ord[1] << 2 | ord[2] << 4);
}
@@ -69,7 +69,7 @@ glm_euler_order(const int ord[3]) {
*/
CGLM_INLINE
void
glm_euler_angles(const mat4 m, vec3 dest) {
glm_euler_angles(mat4 m, vec3 dest) {
float m00, m01, m10, m11, m20, m21, m22;
float thetaX, thetaY, thetaZ;
@@ -107,7 +107,7 @@ glm_euler_angles(const mat4 m, vec3 dest) {
*/
CGLM_INLINE
void
glm_euler_xyz(const vec3 angles, mat4 dest) {
glm_euler_xyz(vec3 angles, mat4 dest) {
float cx, cy, cz,
sx, sy, sz, czsx, cxcz, sysz;
@@ -145,7 +145,7 @@ glm_euler_xyz(const vec3 angles, mat4 dest) {
*/
CGLM_INLINE
void
glm_euler(const vec3 angles, mat4 dest) {
glm_euler(vec3 angles, mat4 dest) {
glm_euler_xyz(angles, dest);
}
@@ -157,7 +157,7 @@ glm_euler(const vec3 angles, mat4 dest) {
*/
CGLM_INLINE
void
glm_euler_xzy(const vec3 angles, mat4 dest) {
glm_euler_xzy(vec3 angles, mat4 dest) {
float cx, cy, cz,
sx, sy, sz, sxsy, cysx, cxsy, cxcy;
@@ -197,7 +197,7 @@ glm_euler_xzy(const vec3 angles, mat4 dest) {
*/
CGLM_INLINE
void
glm_euler_yxz(const vec3 angles, mat4 dest) {
glm_euler_yxz(vec3 angles, mat4 dest) {
float cx, cy, cz,
sx, sy, sz, cycz, sysz, czsy, cysz;
@@ -236,7 +236,7 @@ glm_euler_yxz(const vec3 angles, mat4 dest) {
*/
CGLM_INLINE
void
glm_euler_yzx(const vec3 angles, mat4 dest) {
glm_euler_yzx(vec3 angles, mat4 dest) {
float cx, cy, cz,
sx, sy, sz, sxsy, cxcy, cysx, cxsy;
@@ -275,7 +275,7 @@ glm_euler_yzx(const vec3 angles, mat4 dest) {
*/
CGLM_INLINE
void
glm_euler_zxy(const vec3 angles, mat4 dest) {
glm_euler_zxy(vec3 angles, mat4 dest) {
float cx, cy, cz,
sx, sy, sz, cycz, sxsy, cysz;
@@ -313,7 +313,7 @@ glm_euler_zxy(const vec3 angles, mat4 dest) {
*/
CGLM_INLINE
void
glm_euler_zyx(const vec3 angles, mat4 dest) {
glm_euler_zyx(vec3 angles, mat4 dest) {
float cx, cy, cz,
sx, sy, sz, czsx, cxcz, sysz;
@@ -352,7 +352,7 @@ glm_euler_zyx(const vec3 angles, mat4 dest) {
*/
CGLM_INLINE
void
glm_euler_by_order(const vec3 angles, glm_euler_sq ord, mat4 dest) {
glm_euler_by_order(vec3 angles, glm_euler_sq ord, mat4 dest) {
float cx, cy, cz,
sx, sy, sz;

16
include/cglm/frustum.h
View File

@@ -69,7 +69,7 @@
*/
CGLM_INLINE
void
glm_frustum_planes(const mat4 m, vec4 dest[6]) {
glm_frustum_planes(mat4 m, vec4 dest[6]) {
mat4 t;
glm_mat4_transpose_to(m, t);
@@ -114,7 +114,7 @@ glm_frustum_planes(const mat4 m, vec4 dest[6]) {
*/
CGLM_INLINE
void
glm_frustum_corners(const mat4 invMat, vec4 dest[8]) {
glm_frustum_corners(mat4 invMat, vec4 dest[8]) {
vec4 c[8];
/* indexOf(nearCoord) = indexOf(farCoord) + 4 */
@@ -157,7 +157,7 @@ glm_frustum_corners(const mat4 invMat, vec4 dest[8]) {
*/
CGLM_INLINE
void
glm_frustum_center(const vec4 corners[8], vec4 dest) {
glm_frustum_center(vec4 corners[8], vec4 dest) {
vec4 center;
glm_vec4_copy(corners[0], center);
@@ -182,7 +182,7 @@ glm_frustum_center(const vec4 corners[8], vec4 dest) {
*/
CGLM_INLINE
void
glm_frustum_box(const vec4 corners[8], const mat4 m, vec3 box[2]) {
glm_frustum_box(vec4 corners[8], mat4 m, vec3 box[2]) {
vec4 v;
vec3 min, max;
int i;
@@ -220,10 +220,10 @@ glm_frustum_box(const vec4 corners[8], const mat4 m, vec3 box[2]) {
*/
CGLM_INLINE
void
glm_frustum_corners_at(const vec4 corners[8],
float splitDist,
float farDist,
vec4 planeCorners[4]) {
glm_frustum_corners_at(vec4 corners[8],
float splitDist,
float farDist,
vec4 planeCorners[4]) {
vec4 corner;
float dist, sc;

28
include/cglm/io.h
View File

@@ -25,8 +25,8 @@
CGLM_INLINE
void
glm_mat4_print(const mat4 matrix,
FILE * const __restrict ostream) {
glm_mat4_print(mat4 matrix,
FILE * __restrict ostream) {
int i;
int j;
@@ -55,8 +55,8 @@ glm_mat4_print(const mat4 matrix,
CGLM_INLINE
void
glm_mat3_print(const mat3 matrix,
FILE * const __restrict ostream) {
glm_mat3_print(mat3 matrix,
FILE * __restrict ostream) {
int i;
int j;
@@ -85,8 +85,8 @@ glm_mat3_print(const mat3 matrix,
CGLM_INLINE
void
glm_vec4_print(const vec4 vec,
FILE * const __restrict ostream) {
glm_vec4_print(vec4 vec,
FILE * __restrict ostream) {
int i;
#define m 4
@@ -107,8 +107,8 @@ glm_vec4_print(const vec4 vec,
CGLM_INLINE
void
glm_vec3_print(const vec3 vec,
FILE * const __restrict ostream) {
glm_vec3_print(vec3 vec,
FILE * __restrict ostream) {
int i;
#define m 3
@@ -129,8 +129,8 @@ glm_vec3_print(const vec3 vec,
CGLM_INLINE
void
glm_ivec3_print(const ivec3 vec,
FILE * const __restrict ostream) {
glm_ivec3_print(ivec3 vec,
FILE * __restrict ostream) {
int i;
#define m 3
@@ -151,8 +151,8 @@ glm_ivec3_print(const ivec3 vec,
CGLM_INLINE
void
glm_versor_print(const versor vec,
FILE * const __restrict ostream) {
glm_versor_print(versor vec,
FILE * __restrict ostream) {
int i;
#define m 4
@@ -173,9 +173,9 @@ glm_versor_print(const versor vec,
CGLM_INLINE
void
glm_aabb_print(const vec3 bbox[2],
glm_aabb_print(vec3 bbox[2],
const char * __restrict tag,
FILE * const __restrict ostream) {
FILE * __restrict ostream) {
int i, j;
#define m 3

20
include/cglm/mat3.h
View File

@@ -65,7 +65,7 @@
*/
CGLM_INLINE
void
glm_mat3_copy(const mat3 mat, mat3 dest) {
glm_mat3_copy(mat3 mat, mat3 dest) {
dest[0][0] = mat[0][0];
dest[0][1] = mat[0][1];
dest[0][2] = mat[0][2];
@@ -110,7 +110,7 @@ glm_mat3_identity(mat3 mat) {
*/
CGLM_INLINE
void
glm_mat3_identity_array(mat3 * const __restrict mat, size_t count) {
glm_mat3_identity_array(mat3 * __restrict mat, size_t count) {
CGLM_ALIGN_MAT mat3 t = GLM_MAT3_IDENTITY_INIT;
size_t i;
@@ -147,7 +147,7 @@ glm_mat3_zero(mat3 mat) {
*/
CGLM_INLINE
void
glm_mat3_mul(const mat3 m1, const mat3 m2, mat3 dest) {
glm_mat3_mul(mat3 m1, mat3 m2, mat3 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glm_mat3_mul_sse2(m1, m2, dest);
#else
@@ -181,7 +181,7 @@ glm_mat3_mul(const mat3 m1, const mat3 m2, mat3 dest) {
*/
CGLM_INLINE
void
glm_mat3_transpose_to(const mat3 m, mat3 dest) {
glm_mat3_transpose_to(mat3 m, mat3 dest) {
dest[0][0] = m[0][0];
dest[0][1] = m[1][0];
dest[0][2] = m[2][0];
@@ -227,7 +227,7 @@ glm_mat3_transpose(mat3 m) {
*/
CGLM_INLINE
void
glm_mat3_mulv(const mat3 m, const vec3 v, vec3 dest) {
glm_mat3_mulv(mat3 m, vec3 v, vec3 dest) {
dest[0] = m[0][0] * v[0] + m[1][0] * v[1] + m[2][0] * v[2];
dest[1] = m[0][1] * v[0] + m[1][1] * v[1] + m[2][1] * v[2];
dest[2] = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2];
@@ -242,7 +242,7 @@ glm_mat3_mulv(const mat3 m, const vec3 v, vec3 dest) {
*/
CGLM_INLINE
float
glm_mat3_trace(const mat3 m) {
glm_mat3_trace(mat3 m) {
return m[0][0] + m[1][1] + m[2][2];
}
@@ -254,7 +254,7 @@ glm_mat3_trace(const mat3 m) {
*/
CGLM_INLINE
void
glm_mat3_quat(const mat3 m, versor dest) {
glm_mat3_quat(mat3 m, versor dest) {
float trace, r, rinv;
/* it seems using like m12 instead of m[1][2] causes extra instructions */
@@ -320,7 +320,7 @@ glm_mat3_scale(mat3 m, float s) {
*/
CGLM_INLINE
float
glm_mat3_det(const mat3 mat) {
glm_mat3_det(mat3 mat) {
float a = mat[0][0], b = mat[0][1], c = mat[0][2],
d = mat[1][0], e = mat[1][1], f = mat[1][2],
g = mat[2][0], h = mat[2][1], i = mat[2][2];
@@ -336,7 +336,7 @@ glm_mat3_det(const mat3 mat) {
*/
CGLM_INLINE
void
glm_mat3_inv(const mat3 mat, mat3 dest) {
glm_mat3_inv(mat3 mat, mat3 dest) {
float det;
float a = mat[0][0], b = mat[0][1], c = mat[0][2],
d = mat[1][0], e = mat[1][1], f = mat[1][2],
@@ -413,7 +413,7 @@ glm_mat3_swap_row(mat3 mat, int row1, int row2) {
*/
CGLM_INLINE
float
glm_mat3_rmc(const vec3 r, const mat3 m, const vec3 c) {
glm_mat3_rmc(vec3 r, mat3 m, vec3 c) {
vec3 tmp;
glm_mat3_mulv(m, c, tmp);
return glm_vec3_dot(r, tmp);

38
include/cglm/mat4.h
View File

@@ -100,7 +100,7 @@
*/
CGLM_INLINE
void
glm_mat4_ucopy(const mat4 mat, mat4 dest) {
glm_mat4_ucopy(mat4 mat, mat4 dest) {
dest[0][0] = mat[0][0]; dest[1][0] = mat[1][0];
dest[0][1] = mat[0][1]; dest[1][1] = mat[1][1];
dest[0][2] = mat[0][2]; dest[1][2] = mat[1][2];
@@ -120,7 +120,7 @@ glm_mat4_ucopy(const mat4 mat, mat4 dest) {
*/
CGLM_INLINE
void
glm_mat4_copy(const mat4 mat, mat4 dest) {
glm_mat4_copy(mat4 mat, mat4 dest) {
#ifdef __AVX__
glmm_store256(dest[0], glmm_load256(mat[0]));
glmm_store256(dest[2], glmm_load256(mat[2]));
@@ -170,7 +170,7 @@ glm_mat4_identity(mat4 mat) {
*/
CGLM_INLINE
void
glm_mat4_identity_array(mat4 * const __restrict mat, size_t count) {
glm_mat4_identity_array(mat4 * __restrict mat, size_t count) {
CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
size_t i;
@@ -199,7 +199,7 @@ glm_mat4_zero(mat4 mat) {
*/
CGLM_INLINE
void
glm_mat4_pick3(const mat4 mat, mat3 dest) {
glm_mat4_pick3(mat4 mat, mat3 dest) {
dest[0][0] = mat[0][0];
dest[0][1] = mat[0][1];
dest[0][2] = mat[0][2];
@@ -223,7 +223,7 @@ glm_mat4_pick3(const mat4 mat, mat3 dest) {
*/
CGLM_INLINE
void
glm_mat4_pick3t(const mat4 mat, mat3 dest) {
glm_mat4_pick3t(mat4 mat, mat3 dest) {
dest[0][0] = mat[0][0];
dest[0][1] = mat[1][0];
dest[0][2] = mat[2][0];
@@ -245,7 +245,7 @@ glm_mat4_pick3t(const mat4 mat, mat3 dest) {
*/
CGLM_INLINE
void
glm_mat4_ins3(const mat3 mat, mat4 dest) {
glm_mat4_ins3(mat3 mat, mat4 dest) {
dest[0][0] = mat[0][0];
dest[0][1] = mat[0][1];
dest[0][2] = mat[0][2];
@@ -275,7 +275,7 @@ glm_mat4_ins3(const mat3 mat, mat4 dest) {
*/
CGLM_INLINE
void
glm_mat4_mul(const mat4 m1, const mat4 m2, mat4 dest) {
glm_mat4_mul(mat4 m1, mat4 m2, mat4 dest) {
#ifdef __AVX__
glm_mat4_mul_avx(m1, m2, dest);
#elif defined( __SSE__ ) || defined( __SSE2__ )
@@ -333,7 +333,7 @@ glm_mat4_mul(const mat4 m1, const mat4 m2, mat4 dest) {
*/
CGLM_INLINE
void
glm_mat4_mulN(mat4 * const __restrict matrices[], uint32_t len, mat4 dest) {
glm_mat4_mulN(mat4 * __restrict matrices[], uint32_t len, mat4 dest) {
uint32_t i;
#ifdef DEBUG
@@ -355,7 +355,7 @@ glm_mat4_mulN(mat4 * const __restrict matrices[], uint32_t len, mat4 dest) {
*/
CGLM_INLINE
void
glm_mat4_mulv(const mat4 m, const vec4 v, vec4 dest) {
glm_mat4_mulv(mat4 m, vec4 v, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glm_mat4_mulv_sse2(m, v, dest);
#else
@@ -377,7 +377,7 @@ glm_mat4_mulv(const mat4 m, const vec4 v, vec4 dest) {
*/
CGLM_INLINE
float
glm_mat4_trace(const mat4 m) {
glm_mat4_trace(mat4 m) {
return m[0][0] + m[1][1] + m[2][2] + m[3][3];
}
@@ -390,7 +390,7 @@ glm_mat4_trace(const mat4 m) {
*/
CGLM_INLINE
float
glm_mat4_trace3(const mat4 m) {
glm_mat4_trace3(mat4 m) {
return m[0][0] + m[1][1] + m[2][2];
}
@@ -402,7 +402,7 @@ glm_mat4_trace3(const mat4 m) {
*/
CGLM_INLINE
void
glm_mat4_quat(const mat4 m, versor dest) {
glm_mat4_quat(mat4 m, versor dest) {
float trace, r, rinv;
/* it seems using like m12 instead of m[1][2] causes extra instructions */
@@ -453,7 +453,7 @@ glm_mat4_quat(const mat4 m, versor dest) {
*/
CGLM_INLINE
void
glm_mat4_mulv3(const mat4 m, const vec3 v, float last, vec3 dest) {
glm_mat4_mulv3(mat4 m, vec3 v, float last, vec3 dest) {
vec4 res;
glm_vec4(v, last, res);
glm_mat4_mulv(m, res, res);
@@ -470,7 +470,7 @@ glm_mat4_mulv3(const mat4 m, const vec3 v, float last, vec3 dest) {
*/
CGLM_INLINE
void
glm_mat4_transpose_to(const mat4 m, mat4 dest) {
glm_mat4_transpose_to(mat4 m, mat4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glm_mat4_transp_sse2(m, dest);
#else
@@ -553,7 +553,7 @@ glm_mat4_scale(mat4 m, float s) {
*/
CGLM_INLINE
float
glm_mat4_det(const mat4 mat) {
glm_mat4_det(mat4 mat) {
#if defined( __SSE__ ) || defined( __SSE2__ )
return glm_mat4_det_sse2(mat);
#else
@@ -586,7 +586,7 @@ glm_mat4_det(const mat4 mat) {
*/
CGLM_INLINE
void
glm_mat4_inv(const mat4 mat, mat4 dest) {
glm_mat4_inv(mat4 mat, mat4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glm_mat4_inv_sse2(mat, dest);
#else
@@ -647,7 +647,7 @@ glm_mat4_inv(const mat4 mat, mat4 dest) {
*/
CGLM_INLINE
void
glm_mat4_inv_fast(const mat4 mat, mat4 dest) {
glm_mat4_inv_fast(mat4 mat, mat4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glm_mat4_inv_fast_sse2(mat, dest);
#else
@@ -680,7 +680,7 @@ glm_mat4_swap_col(mat4 mat, int col1, int col2) {
*/
CGLM_INLINE
void
glm_mat4_swap_row(mat4 mat, const int row1, const int row2) {
glm_mat4_swap_row(mat4 mat, int row1, int row2) {
CGLM_ALIGN(16) vec4 tmp;
tmp[0] = mat[0][row1];
tmp[1] = mat[1][row1];
@@ -714,7 +714,7 @@ glm_mat4_swap_row(mat4 mat, const int row1, const int row2) {
*/
CGLM_INLINE
float
glm_mat4_rmc(const vec4 r, const mat4 m, const vec4 c) {
glm_mat4_rmc(vec4 r, mat4 m, vec4 c) {
vec4 tmp;
glm_mat4_mulv(m, c, tmp);
return glm_vec4_dot(r, tmp);

6
include/cglm/project.h
View File

@@ -41,7 +41,7 @@
*/
CGLM_INLINE
void
glm_unprojecti(const vec3 pos, const mat4 invMat, const vec4 vp, vec3 dest) {
glm_unprojecti(vec3 pos, mat4 invMat, vec4 vp, vec3 dest) {
vec4 v;
v[0] = 2.0f * (pos[0] - vp[0]) / vp[2] - 1.0f;
@@ -80,7 +80,7 @@ glm_unprojecti(const vec3 pos, const mat4 invMat, const vec4 vp, vec3 dest) {
*/
CGLM_INLINE
void
glm_unproject(const vec3 pos, const mat4 m, const vec4 vp, vec3 dest) {
glm_unproject(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
mat4 inv;
glm_mat4_inv(m, inv);
glm_unprojecti(pos, inv, vp, dest);
@@ -100,7 +100,7 @@ glm_unproject(const vec3 pos, const mat4 m, const vec4 vp, vec3 dest) {
*/
CGLM_INLINE
void
glm_project(const vec3 pos, const mat4 m, const vec4 vp, vec3 dest) {
glm_project(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
CGLM_ALIGN(16) vec4 pos4, vone = GLM_VEC4_ONE_INIT;
glm_vec4(pos, 1.0f, pos4);

70
include/cglm/quat.h
View File

@@ -68,15 +68,15 @@ glm_mat4_identity(mat4 mat);
CGLM_INLINE
void
glm_mat4_mulv(const mat4 m, const vec4 v, vec4 dest);
glm_mat4_mulv(mat4 m, vec4 v, vec4 dest);
CGLM_INLINE
void
glm_mul_rot(const mat4 m1, const mat4 m2, mat4 dest);
glm_mul_rot(mat4 m1, mat4 m2, mat4 dest);
CGLM_INLINE
void
glm_translate(mat4 m, const vec3 v);
glm_translate(mat4 m, vec3 v);
/*
* IMPORTANT:
@@ -113,7 +113,7 @@ glm_quat_identity(versor q) {
*/
CGLM_INLINE
void
glm_quat_identity_array(versor * const __restrict q, size_t count) {
glm_quat_identity_array(versor * __restrict q, size_t count) {
CGLM_ALIGN(16) versor v = GLM_QUAT_IDENTITY_INIT;
size_t i;
@@ -149,7 +149,7 @@ glm_quat_init(versor q, float x, float y, float z, float w) {
*/
CGLM_INLINE
void
glm_quatv(versor q, float angle, const vec3 axis) {
glm_quatv(versor q, float angle, vec3 axis) {
CGLM_ALIGN(8) vec3 k;
float a, c, s;
@@ -189,7 +189,7 @@ glm_quat(versor q, float angle, float x, float y, float z) {
*/
CGLM_INLINE
void
glm_quat_copy(const versor q, versor dest) {
glm_quat_copy(versor q, versor dest) {
glm_vec4_copy(q, dest);
}
@@ -200,7 +200,7 @@ glm_quat_copy(const versor q, versor dest) {
*/
CGLM_INLINE
float
glm_quat_norm(const versor q) {
glm_quat_norm(versor q) {
return glm_vec4_norm(q);
}
@@ -212,7 +212,7 @@ glm_quat_norm(const versor q) {
*/
CGLM_INLINE
void
glm_quat_normalize_to(const versor q, versor dest) {
glm_quat_normalize_to(versor q, versor dest) {
#if defined( __SSE2__ ) || defined( __SSE2__ )
__m128 xdot, x0;
float dot;
@@ -260,7 +260,7 @@ glm_quat_normalize(versor q) {
*/
CGLM_INLINE
float
glm_quat_dot(const versor p, const versor q) {
glm_quat_dot(versor p, versor q) {
return glm_vec4_dot(p, q);
}
@@ -272,7 +272,7 @@ glm_quat_dot(const versor p, const versor q) {
*/
CGLM_INLINE
void
glm_quat_conjugate(const versor q, versor dest) {
glm_quat_conjugate(versor q, versor dest) {
glm_vec4_negate_to(q, dest);
dest[3] = -dest[3];
}
@@ -285,7 +285,7 @@ glm_quat_conjugate(const versor q, versor dest) {
*/
CGLM_INLINE
void
glm_quat_inv(const versor q, versor dest) {
glm_quat_inv(versor q, versor dest) {
CGLM_ALIGN(16) versor conj;
glm_quat_conjugate(q, conj);
glm_vec4_scale(conj, 1.0f / glm_vec4_norm2(q), dest);
@@ -300,7 +300,7 @@ glm_quat_inv(const versor q, versor dest) {
*/
CGLM_INLINE
void
glm_quat_add(const versor p, const versor q, versor dest) {
glm_quat_add(versor p, versor q, versor dest) {
glm_vec4_add(p, q, dest);
}
@@ -313,7 +313,7 @@ glm_quat_add(const versor p, const versor q, versor dest) {
*/
CGLM_INLINE
void
glm_quat_sub(const versor p, const versor q, versor dest) {
glm_quat_sub(versor p, versor q, versor dest) {
glm_vec4_sub(p, q, dest);
}
@@ -324,7 +324,7 @@ glm_quat_sub(const versor p, const versor q, versor dest) {
*/
CGLM_INLINE
float
glm_quat_real(const versor q) {
glm_quat_real(versor q) {
return q[3];
}
@@ -336,7 +336,7 @@ glm_quat_real(const versor q) {
*/
CGLM_INLINE
void
glm_quat_imag(const versor q, vec3 dest) {
glm_quat_imag(versor q, vec3 dest) {
dest[0] = q[0];
dest[1] = q[1];
dest[2] = q[2];
@@ -349,7 +349,7 @@ glm_quat_imag(const versor q, vec3 dest) {
*/
CGLM_INLINE
void
glm_quat_imagn(const versor q, vec3 dest) {
glm_quat_imagn(versor q, vec3 dest) {
glm_normalize_to(q, dest);
}
@@ -360,7 +360,7 @@ glm_quat_imagn(const versor q, vec3 dest) {
*/
CGLM_INLINE
float
glm_quat_imaglen(const versor q) {
glm_quat_imaglen(versor q) {
return glm_vec3_norm(q);
}
@@ -371,7 +371,7 @@ glm_quat_imaglen(const versor q) {
*/
CGLM_INLINE
float
glm_quat_angle(const versor q) {
glm_quat_angle(versor q) {
/*
sin(theta / 2) = length(x*x + y*y + z*z)
cos(theta / 2) = w
@@ -388,7 +388,7 @@ glm_quat_angle(const versor q) {
*/
CGLM_INLINE
void
glm_quat_axis(const versor q, versor dest) {
glm_quat_axis(versor q, versor dest) {
glm_quat_imagn(q, dest);
}
@@ -406,7 +406,7 @@ glm_quat_axis(const versor q, versor dest) {
*/
CGLM_INLINE
void
glm_quat_mul(const versor p, const versor q, versor dest) {
glm_quat_mul(versor p, versor q, versor dest) {
/*
+ (a1 b2 + b1 a2 + c1 d2 − d1 c2)i
+ (a1 c2 − b1 d2 + c1 a2 + d1 b2)j
@@ -431,7 +431,7 @@ glm_quat_mul(const versor p, const versor q, versor dest) {
*/
CGLM_INLINE
void
glm_quat_mat4(const versor q, mat4 dest) {
glm_quat_mat4(versor q, mat4 dest) {
float w, x, y, z,
xx, yy, zz,
xy, yz, xz,
@@ -478,7 +478,7 @@ glm_quat_mat4(const versor q, mat4 dest) {
*/
CGLM_INLINE
void
glm_quat_mat4t(const versor q, mat4 dest) {
glm_quat_mat4t(versor q, mat4 dest) {
float w, x, y, z,
xx, yy, zz,
xy, yz, xz,
@@ -525,7 +525,7 @@ glm_quat_mat4t(const versor q, mat4 dest) {
*/
CGLM_INLINE
void
glm_quat_mat3(const versor q, mat3 dest) {
glm_quat_mat3(versor q, mat3 dest) {
float w, x, y, z,
xx, yy, zz,
xy, yz, xz,
@@ -564,7 +564,7 @@ glm_quat_mat3(const versor q, mat3 dest) {
*/
CGLM_INLINE
void
glm_quat_mat3t(const versor q, mat3 dest) {
glm_quat_mat3t(versor q, mat3 dest) {
float w, x, y, z,
xx, yy, zz,
xy, yz, xz,
@@ -606,7 +606,7 @@ glm_quat_mat3t(const versor q, mat3 dest) {
*/
CGLM_INLINE
void
glm_quat_lerp(const versor from, const versor to, float t, versor dest) {
glm_quat_lerp(versor from, versor to, float t, versor dest) {
glm_vec4_lerp(from, to, t, dest);
}
@@ -621,7 +621,7 @@ glm_quat_lerp(const versor from, const versor to, float t, versor dest) {
*/
CGLM_INLINE
void
glm_quat_slerp(const versor from, const versor to, float t, versor dest) {
glm_quat_slerp(versor from, versor to, float t, versor dest) {
CGLM_ALIGN(16) vec4 q1, q2;
float cosTheta, sinTheta, angle;
@@ -664,7 +664,7 @@ glm_quat_slerp(const versor from, const versor to, float t, versor dest) {
*/
CGLM_INLINE
void
glm_quat_look(const vec3 eye, const versor ori, mat4 dest) {
glm_quat_look(vec3 eye, versor ori, mat4 dest) {
/* orientation */
glm_quat_mat4t(ori, dest);
@@ -683,7 +683,7 @@ glm_quat_look(const vec3 eye, const versor ori, mat4 dest) {
*/
CGLM_INLINE
void
glm_quat_for(const vec3 dir, const vec3 fwd, const vec3 up, versor dest) {
glm_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest) {
CGLM_ALIGN(8) vec3 axis;
float dot, angle;
@@ -717,11 +717,7 @@ glm_quat_for(const vec3 dir, const vec3 fwd, const vec3 up, versor dest) {
*/
CGLM_INLINE
void
glm_quat_forp(const vec3 from,
const vec3 to,
const vec3 fwd,
const vec3 up,
versor dest) {
glm_quat_forp(vec3 from, vec3 to, vec3 fwd, vec3 up, versor dest) {
CGLM_ALIGN(8) vec3 dir;
glm_vec3_sub(to, from, dir);
glm_quat_for(dir, fwd, up, dest);
@@ -736,7 +732,7 @@ glm_quat_forp(const vec3 from,
*/
CGLM_INLINE
void
glm_quat_rotatev(const versor q, const vec3 v, vec3 dest) {
glm_quat_rotatev(versor q, vec3 v, vec3 dest) {
CGLM_ALIGN(16) versor p;
CGLM_ALIGN(8) vec3 u, v1, v2;
float s;
@@ -764,7 +760,7 @@ glm_quat_rotatev(const versor q, const vec3 v, vec3 dest) {
*/
CGLM_INLINE
void
glm_quat_rotate(const mat4 m, const versor q, mat4 dest) {
glm_quat_rotate(mat4 m, versor q, mat4 dest) {
CGLM_ALIGN_MAT mat4 rot;
glm_quat_mat4(q, rot);
glm_mul_rot(m, rot, dest);
@@ -779,7 +775,7 @@ glm_quat_rotate(const mat4 m, const versor q, mat4 dest) {
*/
CGLM_INLINE
void
glm_quat_rotate_at(mat4 m, const versor q, const vec3 pivot) {
glm_quat_rotate_at(mat4 m, versor q, vec3 pivot) {
CGLM_ALIGN(8) vec3 pivotInv;
glm_vec3_negate_to(pivot, pivotInv);
@@ -803,7 +799,7 @@ glm_quat_rotate_at(mat4 m, const versor q, const vec3 pivot) {
*/
CGLM_INLINE
void
glm_quat_rotate_atm(mat4 m, const versor q, const vec3 pivot) {
glm_quat_rotate_atm(mat4 m, versor q, vec3 pivot) {
CGLM_ALIGN(8) vec3 pivotInv;
glm_vec3_negate_to(pivot, pivotInv);

2
include/cglm/simd/avx/affine.h
View File

@@ -16,7 +16,7 @@
CGLM_INLINE
void
glm_mul_avx(const mat4 m1, const mat4 m2, mat4 dest) {
glm_mul_avx(mat4 m1, mat4 m2, mat4 dest) {
/* D = R * L (Column-Major) */
__m256 y0, y1, y2, y3, y4, y5, y6, y7, y8, y9;

2
include/cglm/simd/avx/mat4.h
View File

@@ -16,7 +16,7 @@
CGLM_INLINE
void
glm_mat4_mul_avx(const mat4 m1, const mat4 m2, mat4 dest) {
glm_mat4_mul_avx(mat4 m1, mat4 m2, mat4 dest) {
/* D = R * L (Column-Major) */
__m256 y0, y1, y2, y3, y4, y5, y6, y7, y8, y9;

2
include/cglm/simd/neon/mat4.h
View File

@@ -14,7 +14,7 @@
CGLM_INLINE
void
glm_mat4_mul_neon(const mat4 m1, const mat4 m2, mat4 dest) {
glm_mat4_mul_neon(mat4 m1, mat4 m2, mat4 dest) {
/* D = R * L (Column-Major) */
float32x4_t l0, l1, l2, l3, r, d0, d1, d2, d3;

4
include/cglm/simd/sse2/affine.h
View File

@@ -14,7 +14,7 @@
CGLM_INLINE
void
glm_mul_sse2(const mat4 m1, const mat4 m2, mat4 dest) {
glm_mul_sse2(mat4 m1, mat4 m2, mat4 dest) {
/* D = R * L (Column-Major) */
__m128 l0, l1, l2, l3, r;
@@ -51,7 +51,7 @@ glm_mul_sse2(const mat4 m1, const mat4 m2, mat4 dest) {
CGLM_INLINE
void
glm_mul_rot_sse2(const mat4 m1, const mat4 m2, mat4 dest) {
glm_mul_rot_sse2(mat4 m1, mat4 m2, mat4 dest) {
/* D = R * L (Column-Major) */
__m128 l0, l1, l2, l3, r;

2
include/cglm/simd/sse2/mat3.h
View File

@@ -14,7 +14,7 @@
CGLM_INLINE
void
glm_mat3_mul_sse2(const mat3 m1, const mat3 m2, mat3 dest) {
glm_mat3_mul_sse2(mat3 m1, mat3 m2, mat3 dest) {
__m128 l0, l1, l2;
__m128 r0, r1, r2;
__m128 x0, x1, x2;

12
include/cglm/simd/sse2/mat4.h
View File

@@ -28,7 +28,7 @@ glm_mat4_scale_sse2(mat4 m, float s) {
CGLM_INLINE
void
glm_mat4_transp_sse2(const mat4 m, mat4 dest) {
glm_mat4_transp_sse2(mat4 m, mat4 dest) {
__m128 r0, r1, r2, r3;
r0 = glmm_load(m[0]);
@@ -46,7 +46,7 @@ glm_mat4_transp_sse2(const mat4 m, mat4 dest) {
CGLM_INLINE
void
glm_mat4_mul_sse2(const mat4 m1, const mat4 m2, mat4 dest) {
glm_mat4_mul_sse2(mat4 m1, mat4 m2, mat4 dest) {
/* D = R * L (Column-Major) */
__m128 l0, l1, l2, l3, r;
@@ -85,7 +85,7 @@ glm_mat4_mul_sse2(const mat4 m1, const mat4 m2, mat4 dest) {
CGLM_INLINE
void
glm_mat4_mulv_sse2(const mat4 m, const vec4 v, vec4 dest) {
glm_mat4_mulv_sse2(mat4 m, vec4 v, vec4 dest) {
__m128 x0, x1, x2;
x0 = glmm_load(v);
@@ -100,7 +100,7 @@ glm_mat4_mulv_sse2(const mat4 m, const vec4 v, vec4 dest) {
CGLM_INLINE
float
glm_mat4_det_sse2(const mat4 mat) {
glm_mat4_det_sse2(mat4 mat) {
__m128 r0, r1, r2, r3, x0, x1, x2;
/* 127 <- 0, [square] det(A) = det(At) */
@@ -155,7 +155,7 @@ glm_mat4_det_sse2(const mat4 mat) {
CGLM_INLINE
void
glm_mat4_inv_fast_sse2(const mat4 mat, mat4 dest) {
glm_mat4_inv_fast_sse2(mat4 mat, mat4 dest) {
__m128 r0, r1, r2, r3,
v0, v1, v2, v3,
t0, t1, t2, t3, t4, t5,
@@ -279,7 +279,7 @@ glm_mat4_inv_fast_sse2(const mat4 mat, mat4 dest) {
CGLM_INLINE
void
glm_mat4_inv_sse2(const mat4 mat, mat4 dest) {
glm_mat4_inv_sse2(mat4 mat, mat4 dest) {
__m128 r0, r1, r2, r3,
v0, v1, v2, v3,
t0, t1, t2, t3, t4, t5,

2
include/cglm/simd/sse2/quat.h
View File

@@ -14,7 +14,7 @@
CGLM_INLINE
void
glm_quat_mul_sse2(const versor p, const versor q, versor dest) {
glm_quat_mul_sse2(versor p, versor q, versor dest) {
/*
+ (a1 b2 + b1 a2 + c1 d2 − d1 c2)i
+ (a1 c2 − b1 d2 + c1 a2 + d1 b2)j

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

@@ -103,7 +103,7 @@ glmm_vdot(__m128 a, __m128 b) {
static inline
float
glmm_dot(const __m128 a, const __m128 b) {
glmm_dot(__m128 a, __m128 b) {
return _mm_cvtss_f32(glmm_vdots(a, b));
}
@@ -115,7 +115,7 @@ glmm_norm(__m128 a) {
static inline
__m128
glmm_load3(const float v[3]) {
glmm_load3(float v[3]) {
__m128i xy;
__m128 z;

10
include/cglm/sphere.h
View File

@@ -27,7 +27,7 @@
*/
CGLM_INLINE
float
glm_sphere_radii(const vec4 s) {
glm_sphere_radii(vec4 s) {
return s[3];
}
@@ -40,7 +40,7 @@ glm_sphere_radii(const vec4 s) {
*/
CGLM_INLINE
void
glm_sphere_transform(const vec4 s, const mat4 m, vec4 dest) {
glm_sphere_transform(vec4 s, mat4 m, vec4 dest) {
glm_mat4_mulv3(m, s, 1.0f, dest);
dest[3] = s[3];
}
@@ -57,7 +57,7 @@ glm_sphere_transform(const vec4 s, const mat4 m, vec4 dest) {
*/
CGLM_INLINE
void
glm_sphere_merge(const vec4 s1, const vec4 s2, vec4 dest) {
glm_sphere_merge(vec4 s1, vec4 s2, vec4 dest) {
float dist, radii;
dist = glm_vec3_distance(s1, s2);
@@ -78,7 +78,7 @@ glm_sphere_merge(const vec4 s1, const vec4 s2, vec4 dest) {
*/
CGLM_INLINE
bool
glm_sphere_sphere(const vec4 s1, const vec4 s2) {
glm_sphere_sphere(vec4 s1, vec4 s2) {
return glm_vec3_distance2(s1, s2) <= glm_pow2(s1[3] + s2[3]);
}
@@ -90,7 +90,7 @@ glm_sphere_sphere(const vec4 s1, const vec4 s2) {
*/
CGLM_INLINE
bool
glm_sphere_point(const vec4 s, const vec3 point) {
glm_sphere_point(vec4 s, vec3 point) {
float rr;
rr = s[3] * s[3];
return glm_vec3_distance2(point, s) <= rr;

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

@@ -52,7 +52,7 @@ glm_vec3_broadcast(float val, vec3 d) {
*/
CGLM_INLINE
bool
glm_vec3_eq(const vec3 v, float val) {
glm_vec3_eq(vec3 v, float val) {
return v[0] == val && v[0] == v[1] && v[0] == v[2];
}
@@ -64,7 +64,7 @@ glm_vec3_eq(const vec3 v, float val) {
*/
CGLM_INLINE
bool
glm_vec3_eq_eps(const 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;
@@ -77,7 +77,7 @@ glm_vec3_eq_eps(const vec3 v, float val) {
*/
CGLM_INLINE
bool
glm_vec3_eq_all(const vec3 v) {
glm_vec3_eq_all(vec3 v) {
return v[0] == v[1] && v[0] == v[2];
}
@@ -89,7 +89,7 @@ glm_vec3_eq_all(const vec3 v) {
*/
CGLM_INLINE
bool
glm_vec3_eqv(const vec3 a, const vec3 b) {
glm_vec3_eqv(vec3 a, vec3 b) {
return a[0] == b[0]
&& a[1] == b[1]
&& a[2] == b[2];
@@ -103,7 +103,7 @@ glm_vec3_eqv(const vec3 a, const vec3 b) {
*/
CGLM_INLINE
bool
glm_vec3_eqv_eps(const vec3 a, const vec3 b) {
glm_vec3_eqv_eps(vec3 a, vec3 b) {
return fabsf(a[0] - b[0]) <= FLT_EPSILON
&& fabsf(a[1] - b[1]) <= FLT_EPSILON
&& fabsf(a[2] - b[2]) <= FLT_EPSILON;
@@ -116,7 +116,7 @@ glm_vec3_eqv_eps(const vec3 a, const vec3 b) {
*/
CGLM_INLINE
float
glm_vec3_max(const vec3 v) {
glm_vec3_max(vec3 v) {
float max;
max = v[0];
@@ -135,7 +135,7 @@ glm_vec3_max(const vec3 v) {
*/
CGLM_INLINE
float
glm_vec3_min(const vec3 v) {
glm_vec3_min(vec3 v) {
float min;
min = v[0];
@@ -155,7 +155,7 @@ glm_vec3_min(const vec3 v) {
*/
CGLM_INLINE
bool
glm_vec3_isnan(const vec3 v) {
glm_vec3_isnan(vec3 v) {
return isnan(v[0]) || isnan(v[1]) || isnan(v[2]);
}
@@ -167,7 +167,7 @@ glm_vec3_isnan(const vec3 v) {
*/
CGLM_INLINE
bool
glm_vec3_isinf(const vec3 v) {
glm_vec3_isinf(vec3 v) {
return isinf(v[0]) || isinf(v[1]) || isinf(v[2]);
}
@@ -179,7 +179,7 @@ glm_vec3_isinf(const vec3 v) {
*/
CGLM_INLINE
bool
glm_vec3_isvalid(const vec3 v) {
glm_vec3_isvalid(vec3 v) {
return !glm_vec3_isnan(v) && !glm_vec3_isinf(v);
}
@@ -192,7 +192,7 @@ glm_vec3_isvalid(const vec3 v) {
*/
CGLM_INLINE
void
glm_vec3_sign(const 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]);
@@ -206,7 +206,7 @@ glm_vec3_sign(const vec3 v, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec3_sqrt(const 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]);

78
include/cglm/vec3.h
View File

@@ -111,7 +111,7 @@
*/
CGLM_INLINE
void
glm_vec3(const vec4 v4, vec3 dest) {
glm_vec3(vec4 v4, vec3 dest) {
dest[0] = v4[0];
dest[1] = v4[1];
dest[2] = v4[2];
@@ -125,7 +125,7 @@ glm_vec3(const vec4 v4, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec3_copy(const vec3 a, vec3 dest) {
glm_vec3_copy(vec3 a, vec3 dest) {
dest[0] = a[0];
dest[1] = a[1];
dest[2] = a[2];
@@ -163,7 +163,7 @@ glm_vec3_one(vec3 v) {
*/
CGLM_INLINE
float
glm_vec3_dot(const vec3 a, const vec3 b) {
glm_vec3_dot(vec3 a, vec3 b) {
return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
}
@@ -180,7 +180,7 @@ glm_vec3_dot(const vec3 a, const vec3 b) {
*/
CGLM_INLINE
float
glm_vec3_norm2(const vec3 v) {
glm_vec3_norm2(vec3 v) {
return glm_vec3_dot(v, v);
}
@@ -193,7 +193,7 @@ glm_vec3_norm2(const vec3 v) {
*/
CGLM_INLINE
float
glm_vec3_norm(const vec3 v) {
glm_vec3_norm(vec3 v) {
return sqrtf(glm_vec3_norm2(v));
}
@@ -206,7 +206,7 @@ glm_vec3_norm(const vec3 v) {
*/
CGLM_INLINE
void
glm_vec3_add(const vec3 a, const 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];
@@ -221,7 +221,7 @@ glm_vec3_add(const vec3 a, const vec3 b, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec3_adds(const 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;
@@ -236,7 +236,7 @@ glm_vec3_adds(const vec3 v, float s, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec3_sub(const vec3 a, const 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];
@@ -251,7 +251,7 @@ glm_vec3_sub(const vec3 a, const vec3 b, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec3_subs(const 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;
@@ -266,7 +266,7 @@ glm_vec3_subs(const vec3 v, float s, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec3_mul(const vec3 a, const vec3 b, vec3 dest) {
glm_vec3_mul(vec3 a, vec3 b, vec3 dest) {
dest[0] = a[0] * b[0];
dest[1] = a[1] * b[1];
dest[2] = a[2] * b[2];
@@ -281,7 +281,7 @@ glm_vec3_mul(const vec3 a, const vec3 b, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec3_scale(const 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;
@@ -296,7 +296,7 @@ glm_vec3_scale(const vec3 v, float s, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec3_scale_as(const vec3 v, float s, vec3 dest) {
glm_vec3_scale_as(vec3 v, float s, vec3 dest) {
float norm;
norm = glm_vec3_norm(v);
@@ -317,7 +317,7 @@ glm_vec3_scale_as(const vec3 v, float s, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec3_div(const vec3 a, const 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];
@@ -332,7 +332,7 @@ glm_vec3_div(const vec3 a, const vec3 b, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec3_divs(const 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;
@@ -349,7 +349,7 @@ glm_vec3_divs(const vec3 v, float s, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec3_addadd(const vec3 a, const 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];
@@ -366,7 +366,7 @@ glm_vec3_addadd(const vec3 a, const vec3 b, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec3_subadd(const vec3 a, const 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];
@@ -383,7 +383,7 @@ glm_vec3_subadd(const vec3 a, const vec3 b, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec3_muladd(const vec3 a, const 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];
@@ -400,7 +400,7 @@ glm_vec3_muladd(const vec3 a, const vec3 b, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec3_muladds(const 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;
@@ -417,7 +417,7 @@ glm_vec3_muladds(const vec3 a, float s, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec3_maxadd(const vec3 a, const vec3 b, vec3 dest) {
glm_vec3_maxadd(vec3 a, vec3 b, vec3 dest) {
dest[0] += glm_max(a[0], b[0]);
dest[1] += glm_max(a[1], b[1]);
dest[2] += glm_max(a[2], b[2]);
@@ -434,7 +434,7 @@ glm_vec3_maxadd(const vec3 a, const vec3 b, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec3_minadd(const vec3 a, const vec3 b, vec3 dest) {
glm_vec3_minadd(vec3 a, vec3 b, vec3 dest) {
dest[0] += glm_min(a[0], b[0]);
dest[1] += glm_min(a[1], b[1]);
dest[2] += glm_min(a[2], b[2]);
@@ -448,7 +448,7 @@ glm_vec3_minadd(const vec3 a, const vec3 b, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec3_negate_to(const vec3 v, vec3 dest) {
glm_vec3_negate_to(vec3 v, vec3 dest) {
dest[0] = -v[0];
dest[1] = -v[1];
dest[2] = -v[2];
@@ -493,7 +493,7 @@ glm_vec3_normalize(vec3 v) {
*/
CGLM_INLINE
void
glm_vec3_normalize_to(const vec3 v, vec3 dest) {
glm_vec3_normalize_to(vec3 v, vec3 dest) {
float norm;
norm = glm_vec3_norm(v);
@@ -515,7 +515,7 @@ glm_vec3_normalize_to(const vec3 v, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec3_cross(const vec3 a, const vec3 b, vec3 dest) {
glm_vec3_cross(vec3 a, vec3 b, vec3 dest) {
/* (u2.v3 - u3.v2, u3.v1 - u1.v3, u1.v2 - u2.v1) */
dest[0] = a[1] * b[2] - a[2] * b[1];
dest[1] = a[2] * b[0] - a[0] * b[2];
@@ -531,7 +531,7 @@ glm_vec3_cross(const vec3 a, const vec3 b, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec3_crossn(const vec3 a, const vec3 b, vec3 dest) {
glm_vec3_crossn(vec3 a, vec3 b, vec3 dest) {
glm_vec3_cross(a, b, dest);
glm_vec3_normalize(dest);
}
@@ -546,7 +546,7 @@ glm_vec3_crossn(const vec3 a, const vec3 b, vec3 dest) {
*/
CGLM_INLINE
float
glm_vec3_angle(const vec3 a, const vec3 b) {
glm_vec3_angle(vec3 a, vec3 b) {
float norm, dot;
/* maybe compiler generate approximation instruction (rcp) */
@@ -570,7 +570,7 @@ glm_vec3_angle(const vec3 a, const vec3 b) {
*/
CGLM_INLINE
void
glm_vec3_rotate(vec3 v, float angle, const vec3 axis) {
glm_vec3_rotate(vec3 v, float angle, vec3 axis) {
vec3 v1, v2, k;
float c, s;
@@ -608,7 +608,7 @@ glm_vec3_rotate(vec3 v, float angle, const vec3 axis) {
*/
CGLM_INLINE
void
glm_vec3_rotate_m4(const mat4 m, const 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);
@@ -631,7 +631,7 @@ glm_vec3_rotate_m4(const mat4 m, const vec3 v, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec3_rotate_m3(const mat3 m, const 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);
@@ -658,7 +658,7 @@ glm_vec3_rotate_m3(const mat3 m, const vec3 v, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec3_proj(const vec3 a, const vec3 b, vec3 dest) {
glm_vec3_proj(vec3 a, vec3 b, vec3 dest) {
glm_vec3_scale(b,
glm_vec3_dot(a, b) / glm_vec3_norm2(b),
dest);
@@ -673,7 +673,7 @@ glm_vec3_proj(const vec3 a, const vec3 b, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec3_center(const vec3 a, const vec3 b, vec3 dest) {
glm_vec3_center(vec3 a, vec3 b, vec3 dest) {
glm_vec3_add(a, b, dest);
glm_vec3_scale(dest, 0.5f, dest);
}
@@ -687,7 +687,7 @@ glm_vec3_center(const vec3 a, const vec3 b, vec3 dest) {
*/
CGLM_INLINE
float
glm_vec3_distance2(const vec3 a, const vec3 b) {
glm_vec3_distance2(vec3 a, vec3 b) {
return glm_pow2(b[0] - a[0])
+ glm_pow2(b[1] - a[1])
+ glm_pow2(b[2] - a[2]);
@@ -702,7 +702,7 @@ glm_vec3_distance2(const vec3 a, const vec3 b) {
*/
CGLM_INLINE
float
glm_vec3_distance(const vec3 a, const vec3 b) {
glm_vec3_distance(vec3 a, vec3 b) {
return sqrtf(glm_vec3_distance2(a, b));
}
@@ -715,7 +715,7 @@ glm_vec3_distance(const vec3 a, const vec3 b) {
*/
CGLM_INLINE
void
glm_vec3_maxv(const vec3 a, const vec3 b, vec3 dest) {
glm_vec3_maxv(vec3 a, vec3 b, vec3 dest) {
dest[0] = glm_max(a[0], b[0]);
dest[1] = glm_max(a[1], b[1]);
dest[2] = glm_max(a[2], b[2]);
@@ -730,7 +730,7 @@ glm_vec3_maxv(const vec3 a, const vec3 b, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec3_minv(const vec3 a, const vec3 b, vec3 dest) {
glm_vec3_minv(vec3 a, vec3 b, vec3 dest) {
dest[0] = glm_min(a[0], b[0]);
dest[1] = glm_min(a[1], b[1]);
dest[2] = glm_min(a[2], b[2]);
@@ -744,7 +744,7 @@ glm_vec3_minv(const vec3 a, const vec3 b, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec3_ortho(const 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];
@@ -777,7 +777,7 @@ glm_vec3_clamp(vec3 v, float minVal, float maxVal) {
*/
CGLM_INLINE
void
glm_vec3_lerp(const vec3 from, const vec3 to, float t, vec3 dest) {
glm_vec3_lerp(vec3 from, vec3 to, float t, vec3 dest) {
vec3 s, v;
/* from + s * (to - from) */
@@ -798,7 +798,7 @@ glm_vec3_lerp(const vec3 from, const vec3 to, float t, vec3 dest) {
*/
CGLM_INLINE
void
glm_cross(const vec3 a, const vec3 b, vec3 d) {
glm_cross(vec3 a, vec3 b, vec3 d) {
glm_vec3_cross(a, b, d);
}
@@ -814,7 +814,7 @@ glm_cross(const vec3 a, const vec3 b, vec3 d) {
*/
CGLM_INLINE
float
glm_dot(const vec3 a, const vec3 b) {
glm_dot(vec3 a, vec3 b) {
return glm_vec3_dot(a, b);
}
@@ -841,7 +841,7 @@ glm_normalize(vec3 v) {
*/
CGLM_INLINE
void
glm_normalize_to(const vec3 v, vec3 dest) {
glm_normalize_to(vec3 v, vec3 dest) {
glm_vec3_normalize_to(v, dest);
}

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

@@ -56,7 +56,7 @@ glm_vec4_broadcast(float val, vec4 d) {
*/
CGLM_INLINE
bool
glm_vec4_eq(const vec4 v, float val) {
glm_vec4_eq(vec4 v, float val) {
return v[0] == val
&& v[0] == v[1]
&& v[0] == v[2]
@@ -71,7 +71,7 @@ glm_vec4_eq(const vec4 v, float val) {
*/
CGLM_INLINE
bool
glm_vec4_eq_eps(const vec4 v, float val) {
glm_vec4_eq_eps(vec4 v, float val) {
return fabsf(v[0] - val) <= FLT_EPSILON
&& fabsf(v[1] - val) <= FLT_EPSILON
&& fabsf(v[2] - val) <= FLT_EPSILON
@@ -85,7 +85,7 @@ glm_vec4_eq_eps(const vec4 v, float val) {
*/
CGLM_INLINE
bool
glm_vec4_eq_all(const vec4 v) {
glm_vec4_eq_all(vec4 v) {
return v[0] == v[1]
&& v[0] == v[2]
&& v[0] == v[3];
@@ -99,7 +99,7 @@ glm_vec4_eq_all(const vec4 v) {
*/
CGLM_INLINE
bool
glm_vec4_eqv(const vec4 a, const vec4 b) {
glm_vec4_eqv(vec4 a, vec4 b) {
return a[0] == b[0]
&& a[1] == b[1]
&& a[2] == b[2]
@@ -114,7 +114,7 @@ glm_vec4_eqv(const vec4 a, const vec4 b) {
*/
CGLM_INLINE
bool
glm_vec4_eqv_eps(const vec4 a, const vec4 b) {
glm_vec4_eqv_eps(vec4 a, vec4 b) {
return fabsf(a[0] - b[0]) <= FLT_EPSILON
&& fabsf(a[1] - b[1]) <= FLT_EPSILON
&& fabsf(a[2] - b[2]) <= FLT_EPSILON
@@ -128,7 +128,7 @@ glm_vec4_eqv_eps(const vec4 a, const vec4 b) {
*/
CGLM_INLINE
float
glm_vec4_max(const vec4 v) {
glm_vec4_max(vec4 v) {
float max;
max = glm_vec3_max(v);
@@ -145,7 +145,7 @@ glm_vec4_max(const vec4 v) {
*/
CGLM_INLINE
float
glm_vec4_min(const vec4 v) {
glm_vec4_min(vec4 v) {
float min;
min = glm_vec3_min(v);
@@ -163,7 +163,7 @@ glm_vec4_min(const vec4 v) {
*/
CGLM_INLINE
bool
glm_vec4_isnan(const vec4 v) {
glm_vec4_isnan(vec4 v) {
return isnan(v[0]) || isnan(v[1]) || isnan(v[2]) || isnan(v[3]);
}
@@ -175,7 +175,7 @@ glm_vec4_isnan(const vec4 v) {
*/
CGLM_INLINE
bool
glm_vec4_isinf(const vec4 v) {
glm_vec4_isinf(vec4 v) {
return isinf(v[0]) || isinf(v[1]) || isinf(v[2]) || isinf(v[3]);
}
@@ -187,7 +187,7 @@ glm_vec4_isinf(const vec4 v) {
*/
CGLM_INLINE
bool
glm_vec4_isvalid(const vec4 v) {
glm_vec4_isvalid(vec4 v) {
return !glm_vec4_isnan(v) && !glm_vec4_isinf(v);
}
@@ -200,7 +200,7 @@ glm_vec4_isvalid(const vec4 v) {
*/
CGLM_INLINE
void
glm_vec4_sign(const vec4 v, vec4 dest) {
glm_vec4_sign(vec4 v, vec4 dest) {
#if defined( __SSE2__ ) || defined( __SSE2__ )
__m128 x0, x1, x2, x3, x4;
@@ -228,7 +228,7 @@ glm_vec4_sign(const vec4 v, vec4 dest) {
*/
CGLM_INLINE
void
glm_vec4_sqrt(const vec4 v, vec4 dest) {
glm_vec4_sqrt(vec4 v, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glmm_store(dest, _mm_sqrt_ps(glmm_load(v)));
#else

56
include/cglm/vec4.h
View File

@@ -90,7 +90,7 @@
*/
CGLM_INLINE
void
glm_vec4(const vec3 v3, float last, vec4 dest) {
glm_vec4(vec3 v3, float last, vec4 dest) {
dest[0] = v3[0];
dest[1] = v3[1];
dest[2] = v3[2];
@@ -105,7 +105,7 @@ glm_vec4(const vec3 v3, float last, vec4 dest) {
*/
CGLM_INLINE
void
glm_vec4_copy3(const vec4 a, vec3 dest) {
glm_vec4_copy3(vec4 a, vec3 dest) {
dest[0] = a[0];
dest[1] = a[1];
dest[2] = a[2];
@@ -119,7 +119,7 @@ glm_vec4_copy3(const vec4 a, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec4_copy(const vec4 v, vec4 dest) {
glm_vec4_copy(vec4 v, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glmm_store(dest, glmm_load(v));
#elif defined(CGLM_NEON_FP)
@@ -142,7 +142,7 @@ glm_vec4_copy(const vec4 v, vec4 dest) {
*/
CGLM_INLINE
void
glm_vec4_ucopy(const vec4 v, vec4 dest) {
glm_vec4_ucopy(vec4 v, vec4 dest) {
dest[0] = v[0];
dest[1] = v[1];
dest[2] = v[2];
@@ -199,7 +199,7 @@ glm_vec4_one(vec4 v) {
*/
CGLM_INLINE
float
glm_vec4_dot(const vec4 a, const vec4 b) {
glm_vec4_dot(vec4 a, vec4 b) {
#if defined(CGLM_SIMD)
return glmm_dot(glmm_load(a), glmm_load(b));
#else
@@ -220,7 +220,7 @@ glm_vec4_dot(const vec4 a, const vec4 b) {
*/
CGLM_INLINE
float
glm_vec4_norm2(const vec4 v) {
glm_vec4_norm2(vec4 v) {
return glm_vec4_dot(v, v);
}
@@ -233,7 +233,7 @@ glm_vec4_norm2(const vec4 v) {
*/
CGLM_INLINE
float
glm_vec4_norm(const vec4 v) {
glm_vec4_norm(vec4 v) {
#if defined(CGLM_SIMD)
return glmm_norm(glmm_load(v));
#else
@@ -250,7 +250,7 @@ glm_vec4_norm(const vec4 v) {
*/
CGLM_INLINE
void
glm_vec4_add(const vec4 a, const vec4 b, vec4 dest) {
glm_vec4_add(vec4 a, vec4 b, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glmm_store(dest, _mm_add_ps(glmm_load(a), glmm_load(b)));
#elif defined(CGLM_NEON_FP)
@@ -272,7 +272,7 @@ glm_vec4_add(const vec4 a, const vec4 b, vec4 dest) {
*/
CGLM_INLINE
void
glm_vec4_adds(const vec4 v, float s, vec4 dest) {
glm_vec4_adds(vec4 v, float s, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glmm_store(dest, _mm_add_ps(glmm_load(v), _mm_set1_ps(s)));
#elif defined(CGLM_NEON_FP)
@@ -294,7 +294,7 @@ glm_vec4_adds(const vec4 v, float s, vec4 dest) {
*/
CGLM_INLINE
void
glm_vec4_sub(const vec4 a, const vec4 b, vec4 dest) {
glm_vec4_sub(vec4 a, vec4 b, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glmm_store(dest, _mm_sub_ps(glmm_load(a), glmm_load(b)));
#elif defined(CGLM_NEON_FP)
@@ -316,7 +316,7 @@ glm_vec4_sub(const vec4 a, const vec4 b, vec4 dest) {
*/
CGLM_INLINE
void
glm_vec4_subs(const vec4 v, float s, vec4 dest) {
glm_vec4_subs(vec4 v, float s, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glmm_store(dest, _mm_sub_ps(glmm_load(v), _mm_set1_ps(s)));
#elif defined(CGLM_NEON_FP)
@@ -338,7 +338,7 @@ glm_vec4_subs(const vec4 v, float s, vec4 dest) {
*/
CGLM_INLINE
void
glm_vec4_mul(const vec4 a, const vec4 b, vec4 dest) {
glm_vec4_mul(vec4 a, vec4 b, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glmm_store(dest, _mm_mul_ps(glmm_load(a), glmm_load(b)));
#elif defined(CGLM_NEON_FP)
@@ -360,7 +360,7 @@ glm_vec4_mul(const vec4 a, const vec4 b, vec4 dest) {
*/
CGLM_INLINE
void
glm_vec4_scale(const vec4 v, float s, vec4 dest) {
glm_vec4_scale(vec4 v, float s, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glmm_store(dest, _mm_mul_ps(glmm_load(v), _mm_set1_ps(s)));
#elif defined(CGLM_NEON_FP)
@@ -382,7 +382,7 @@ glm_vec4_scale(const vec4 v, float s, vec4 dest) {
*/
CGLM_INLINE
void
glm_vec4_scale_as(const vec4 v, float s, vec4 dest) {
glm_vec4_scale_as(vec4 v, float s, vec4 dest) {
float norm;
norm = glm_vec4_norm(v);
@@ -403,7 +403,7 @@ glm_vec4_scale_as(const vec4 v, float s, vec4 dest) {
*/
CGLM_INLINE
void
glm_vec4_div(const vec4 a, const vec4 b, vec4 dest) {
glm_vec4_div(vec4 a, vec4 b, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glmm_store(dest, _mm_div_ps(glmm_load(a), glmm_load(b)));
#else
@@ -423,7 +423,7 @@ glm_vec4_div(const vec4 a, const vec4 b, vec4 dest) {
*/
CGLM_INLINE
void
glm_vec4_divs(const vec4 v, float s, vec4 dest) {
glm_vec4_divs(vec4 v, float s, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glmm_store(dest, _mm_div_ps(glmm_load(v), _mm_set1_ps(s)));
#else
@@ -442,7 +442,7 @@ glm_vec4_divs(const vec4 v, float s, vec4 dest) {
*/
CGLM_INLINE
void
glm_vec4_addadd(const vec4 a, const vec4 b, vec4 dest) {
glm_vec4_addadd(vec4 a, vec4 b, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glmm_store(dest, _mm_add_ps(glmm_load(dest),
_mm_add_ps(glmm_load(a),
@@ -470,7 +470,7 @@ glm_vec4_addadd(const vec4 a, const vec4 b, vec4 dest) {
*/
CGLM_INLINE
void
glm_vec4_subadd(const vec4 a, const vec4 b, vec4 dest) {
glm_vec4_subadd(vec4 a, vec4 b, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glmm_store(dest, _mm_add_ps(glmm_load(dest),
_mm_sub_ps(glmm_load(a),
@@ -498,7 +498,7 @@ glm_vec4_subadd(const vec4 a, const vec4 b, vec4 dest) {
*/
CGLM_INLINE
void
glm_vec4_muladd(const vec4 a, const vec4 b, vec4 dest) {
glm_vec4_muladd(vec4 a, vec4 b, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glmm_store(dest, _mm_add_ps(glmm_load(dest),
_mm_mul_ps(glmm_load(a),
@@ -526,7 +526,7 @@ glm_vec4_muladd(const vec4 a, const vec4 b, vec4 dest) {
*/
CGLM_INLINE
void
glm_vec4_muladds(const vec4 a, float s, vec4 dest) {
glm_vec4_muladds(vec4 a, float s, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glmm_store(dest, _mm_add_ps(glmm_load(dest),
_mm_mul_ps(glmm_load(a),
@@ -554,7 +554,7 @@ glm_vec4_muladds(const vec4 a, float s, vec4 dest) {
*/
CGLM_INLINE
void
glm_vec4_maxadd(const vec4 a, const vec4 b, vec4 dest) {
glm_vec4_maxadd(vec4 a, vec4 b, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glmm_store(dest, _mm_add_ps(glmm_load(dest),
_mm_max_ps(glmm_load(a),
@@ -582,7 +582,7 @@ glm_vec4_maxadd(const vec4 a, const vec4 b, vec4 dest) {
*/
CGLM_INLINE
void
glm_vec4_minadd(const vec4 a,const vec4 b, vec4 dest) {
glm_vec4_minadd(vec4 a, vec4 b, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glmm_store(dest, _mm_add_ps(glmm_load(dest),
_mm_min_ps(glmm_load(a),
@@ -607,7 +607,7 @@ glm_vec4_minadd(const vec4 a,const vec4 b, vec4 dest) {
*/
CGLM_INLINE
void
glm_vec4_negate_to(const vec4 v, vec4 dest) {
glm_vec4_negate_to(vec4 v, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glmm_store(dest, _mm_xor_ps(glmm_load(v), _mm_set1_ps(-0.0f)));
#elif defined(CGLM_NEON_FP)
@@ -639,7 +639,7 @@ glm_vec4_negate(vec4 v) {
*/
CGLM_INLINE
void
glm_vec4_normalize_to(const vec4 v, vec4 dest) {
glm_vec4_normalize_to(vec4 v, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
__m128 xdot, x0;
float dot;
@@ -688,7 +688,7 @@ glm_vec4_normalize(vec4 v) {
*/
CGLM_INLINE
float
glm_vec4_distance(const vec4 a, const vec4 b) {
glm_vec4_distance(vec4 a, vec4 b) {
#if defined( __SSE__ ) || defined( __SSE2__ )
return glmm_norm(_mm_sub_ps(glmm_load(b), glmm_load(a)));
#elif defined(CGLM_NEON_FP)
@@ -710,7 +710,7 @@ glm_vec4_distance(const vec4 a, const vec4 b) {
*/
CGLM_INLINE
void
glm_vec4_maxv(const vec4 a, const vec4 b, vec4 dest) {
glm_vec4_maxv(vec4 a, vec4 b, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glmm_store(dest, _mm_max_ps(glmm_load(a), glmm_load(b)));
#elif defined(CGLM_NEON_FP)
@@ -732,7 +732,7 @@ glm_vec4_maxv(const vec4 a, const vec4 b, vec4 dest) {
*/
CGLM_INLINE
void
glm_vec4_minv(const vec4 a, const vec4 b, vec4 dest) {
glm_vec4_minv(vec4 a, vec4 b, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glmm_store(dest, _mm_min_ps(glmm_load(a), glmm_load(b)));
#elif defined(CGLM_NEON_FP)
@@ -781,7 +781,7 @@ glm_vec4_clamp(vec4 v, float minVal, float maxVal) {
*/
CGLM_INLINE
void
glm_vec4_lerp(const vec4 from, const vec4 to, float t, vec4 dest) {
glm_vec4_lerp(vec4 from, vec4 to, float t, vec4 dest) {
vec4 s, v;
/* from + s * (to - from) */

38
src/affine.c
View File

@@ -10,19 +10,19 @@
CGLM_EXPORT
void
glmc_translate_make(mat4 m, const vec3 v) {
glmc_translate_make(mat4 m, vec3 v) {
glm_translate_make(m, v);
}
CGLM_EXPORT
void
glmc_translate_to(const mat4 m, const vec3 v, mat4 dest) {
glmc_translate_to(mat4 m, vec3 v, mat4 dest) {
glm_translate_to(m, v, dest);
}
CGLM_EXPORT
void
glmc_translate(mat4 m, const vec3 v) {
glmc_translate(mat4 m, vec3 v) {
glm_translate(m, v);
}
@@ -46,19 +46,19 @@ glmc_translate_z(mat4 m, float to) {
CGLM_EXPORT
void
glmc_scale_make(mat4 m, const vec3 v) {
glmc_scale_make(mat4 m, vec3 v) {
glm_scale_make(m, v);
}
CGLM_EXPORT
void
glmc_scale_to(const mat4 m, const vec3 v, mat4 dest) {
glmc_scale_to(mat4 m, vec3 v, mat4 dest) {
glm_scale_to(m, v, dest);
}
CGLM_EXPORT
void
glmc_scale(mat4 m, const vec3 v) {
glmc_scale(mat4 m, vec3 v) {
glm_scale(m, v);
}
@@ -70,79 +70,79 @@ glmc_scale_uni(mat4 m, float s) {
CGLM_EXPORT
void
glmc_rotate_x(const mat4 m, float rad, mat4 dest) {
glmc_rotate_x(mat4 m, float rad, mat4 dest) {
glm_rotate_x(m, rad, dest);
}
CGLM_EXPORT
void
glmc_rotate_y(const mat4 m, float rad, mat4 dest) {
glmc_rotate_y(mat4 m, float rad, mat4 dest) {
glm_rotate_y(m, rad, dest);
}
CGLM_EXPORT
void
glmc_rotate_z(const mat4 m, float rad, mat4 dest) {
glmc_rotate_z(mat4 m, float rad, mat4 dest) {
glm_rotate_z(m, rad, dest);
}
CGLM_EXPORT
void
glmc_rotate_make(mat4 m, float angle, const vec3 axis) {
glmc_rotate_make(mat4 m, float angle, vec3 axis) {
glm_rotate_make(m, angle, axis);
}
CGLM_EXPORT
void
glmc_rotate(mat4 m, float angle, const vec3 axis) {
glmc_rotate(mat4 m, float angle, vec3 axis) {
glm_rotate(m, angle, axis);
}
CGLM_EXPORT
void
glmc_rotate_at(mat4 m, const vec3 pivot, float angle, const vec3 axis) {
glmc_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis) {
glm_rotate_at(m, pivot, angle, axis);
}
CGLM_EXPORT
void
glmc_rotate_atm(mat4 m, const vec3 pivot, float angle, const vec3 axis) {
glmc_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis) {
glm_rotate_atm(m, pivot, angle, axis);
}
CGLM_EXPORT
void
glmc_decompose_scalev(const mat4 m, vec3 s) {
glmc_decompose_scalev(mat4 m, vec3 s) {
glm_decompose_scalev(m, s);
}
CGLM_EXPORT
bool
glmc_uniscaled(const mat4 m) {
glmc_uniscaled(mat4 m) {
return glm_uniscaled(m);
}
CGLM_EXPORT
void
glmc_decompose_rs(const mat4 m, mat4 r, vec3 s) {
glmc_decompose_rs(mat4 m, mat4 r, vec3 s) {
glm_decompose_rs(m, r, s);
}
CGLM_EXPORT
void
glmc_decompose(const mat4 m, vec4 t, mat4 r, vec3 s) {
glmc_decompose(mat4 m, vec4 t, mat4 r, vec3 s) {
glm_decompose(m, t, r, s);
}
CGLM_EXPORT
void
glmc_mul(const mat4 m1, const mat4 m2, mat4 dest) {
glmc_mul(mat4 m1, mat4 m2, mat4 dest) {
glm_mul(m1, m2, dest);
}
CGLM_EXPORT
void
glmc_mul_rot(const mat4 m1, const mat4 m2, mat4 dest) {
glmc_mul_rot(mat4 m1, mat4 m2, mat4 dest) {
glm_mul_rot(m1, m2, dest);
}

32
src/box.c
View File

@@ -10,34 +10,34 @@
CGLM_EXPORT
void
glmc_aabb_transform(const vec3 box[2], const mat4 m, vec3 dest[2]) {
glmc_aabb_transform(vec3 box[2], mat4 m, vec3 dest[2]) {
glm_aabb_transform(box, m, dest);
}
CGLM_EXPORT
void
glmc_aabb_merge(const vec3 box1[2], const vec3 box2[2], vec3 dest[2]) {
glmc_aabb_merge(vec3 box1[2], vec3 box2[2], vec3 dest[2]) {
glm_aabb_merge(box1, box2, dest);
}
CGLM_EXPORT
void
glmc_aabb_crop(const vec3 box[2], const vec3 cropBox[2], vec3 dest[2]) {
glmc_aabb_crop(vec3 box[2], vec3 cropBox[2], vec3 dest[2]) {
glm_aabb_crop(box, cropBox, dest);
}
CGLM_EXPORT
void
glmc_aabb_crop_until(const vec3 box[2],
const vec3 cropBox[2],
const vec3 clampBox[2],
vec3 dest[2]) {
glmc_aabb_crop_until(vec3 box[2],
vec3 cropBox[2],
vec3 clampBox[2],
vec3 dest[2]) {
glm_aabb_crop_until(box, cropBox, clampBox, dest);
}
CGLM_EXPORT
bool
glmc_aabb_frustum(const vec3 box[2], vec4 planes[6]) {
glmc_aabb_frustum(vec3 box[2], vec4 planes[6]) {
return glm_aabb_frustum(box, planes);
}
@@ -49,48 +49,48 @@ glmc_aabb_invalidate(vec3 box[2]) {
CGLM_EXPORT
bool
glmc_aabb_isvalid(const vec3 box[2]) {
glmc_aabb_isvalid(vec3 box[2]) {
return glm_aabb_isvalid(box);
}
CGLM_EXPORT
float
glmc_aabb_size(const vec3 box[2]) {
glmc_aabb_size(vec3 box[2]) {
return glm_aabb_size(box);
}
CGLM_EXPORT
float
glmc_aabb_radius(const vec3 box[2]) {
glmc_aabb_radius(vec3 box[2]) {
return glm_aabb_radius(box);
}
CGLM_EXPORT
void
glmc_aabb_center(const vec3 box[2], vec3 dest) {
glmc_aabb_center(vec3 box[2], vec3 dest) {
glm_aabb_center(box, dest);
}
CGLM_EXPORT
bool
glmc_aabb_aabb(const vec3 box[2], const vec3 other[2]) {
glmc_aabb_aabb(vec3 box[2], vec3 other[2]) {
return glm_aabb_aabb(box, other);
}
CGLM_EXPORT
bool
glmc_aabb_point(const vec3 box[2], const vec3 point) {
glmc_aabb_point(vec3 box[2], vec3 point) {
return glm_aabb_point(box, point);
}
CGLM_EXPORT
bool
glmc_aabb_contains(const vec3 box[2], const vec3 other[2]) {
glmc_aabb_contains(vec3 box[2], vec3 other[2]) {
return glm_aabb_contains(box, other);
}
CGLM_EXPORT
bool
glmc_aabb_sphere(const vec3 box[2], const vec4 s) {
glmc_aabb_sphere(vec3 box[2], vec4 s) {
return glm_aabb_sphere(box, s);
}

44
src/cam.c
View File

@@ -16,7 +16,7 @@ glmc_frustum(float left,
float top,
float nearVal,
float farVal,
mat4 dest) {
mat4 dest) {
glm_frustum(left,
right,
bottom,
@@ -34,7 +34,7 @@ glmc_ortho(float left,
float top,
float nearVal,
float farVal,
mat4 dest) {
mat4 dest) {
glm_ortho(left,
right,
bottom,
@@ -46,19 +46,19 @@ glmc_ortho(float left,
CGLM_EXPORT
void
glmc_ortho_aabb(const vec3 box[2], mat4 dest) {
glmc_ortho_aabb(vec3 box[2], mat4 dest) {
glm_ortho_aabb(box, dest);
}
CGLM_EXPORT
void
glmc_ortho_aabb_p(const vec3 box[2], float padding, mat4 dest) {
glmc_ortho_aabb_p(vec3 box[2], float padding, mat4 dest) {
glm_ortho_aabb_p(box, padding, dest);
}
CGLM_EXPORT
void
glmc_ortho_aabb_pz(const vec3 box[2], float padding, mat4 dest) {
glmc_ortho_aabb_pz(vec3 box[2], float padding, mat4 dest) {
glm_ortho_aabb_pz(box, padding, dest);
}
@@ -80,7 +80,7 @@ glmc_perspective(float fovy,
float aspect,
float nearVal,
float farVal,
mat4 dest) {
mat4 dest) {
glm_perspective(fovy,
aspect,
nearVal,
@@ -108,28 +108,28 @@ glmc_perspective_resize(float aspect, mat4 proj) {
CGLM_EXPORT
void
glmc_lookat(const vec3 eye,
const vec3 center,
const vec3 up,
mat4 dest) {
glmc_lookat(vec3 eye,
vec3 center,
vec3 up,
mat4 dest) {
glm_lookat(eye, center, up, dest);
}
CGLM_EXPORT
void
glmc_look(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest) {
glmc_look(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
glm_look(eye, dir, up, dest);
}
CGLM_EXPORT
void
glmc_look_anyup(const vec3 eye, const vec3 dir, mat4 dest) {
glmc_look_anyup(vec3 eye, vec3 dir, mat4 dest) {
glm_look_anyup(eye, dir, dest);
}
CGLM_EXPORT
void
glmc_persp_decomp(const mat4 proj,
glmc_persp_decomp(mat4 proj,
float * __restrict nearVal,
float * __restrict farVal,
float * __restrict top,
@@ -141,13 +141,13 @@ glmc_persp_decomp(const mat4 proj,
CGLM_EXPORT
void
glmc_persp_decompv(const mat4 proj, float dest[6]) {
glmc_persp_decompv(mat4 proj, float dest[6]) {
glm_persp_decompv(proj, dest);
}
CGLM_EXPORT
void
glmc_persp_decomp_x(const mat4 proj,
glmc_persp_decomp_x(mat4 proj,
float * __restrict left,
float * __restrict right) {
glm_persp_decomp_x(proj, left, right);
@@ -155,7 +155,7 @@ glmc_persp_decomp_x(const mat4 proj,
CGLM_EXPORT
void
glmc_persp_decomp_y(const mat4 proj,
glmc_persp_decomp_y(mat4 proj,
float * __restrict top,
float * __restrict bottom) {
glm_persp_decomp_y(proj, top, bottom);
@@ -163,7 +163,7 @@ glmc_persp_decomp_y(const mat4 proj,
CGLM_EXPORT
void
glmc_persp_decomp_z(const mat4 proj,
glmc_persp_decomp_z(mat4 proj,
float * __restrict nearVal,
float * __restrict farVal) {
glm_persp_decomp_z(proj, nearVal, farVal);
@@ -171,30 +171,30 @@ glmc_persp_decomp_z(const mat4 proj,
CGLM_EXPORT
void
glmc_persp_decomp_far(const mat4 proj, float * __restrict farVal) {
glmc_persp_decomp_far(mat4 proj, float * __restrict farVal) {
glm_persp_decomp_far(proj, farVal);
}
CGLM_EXPORT
void
glmc_persp_decomp_near(const mat4 proj, float * __restrict nearVal) {
glmc_persp_decomp_near(mat4 proj, float * __restrict nearVal) {
glm_persp_decomp_near(proj, nearVal);
}
CGLM_EXPORT
float
glmc_persp_fovy(const mat4 proj) {
glmc_persp_fovy(mat4 proj) {
return glm_persp_fovy(proj);
}
CGLM_EXPORT
float
glmc_persp_aspect(const mat4 proj) {
glmc_persp_aspect(mat4 proj) {
return glm_persp_aspect(proj);
}
CGLM_EXPORT
void
glmc_persp_sizes(const mat4 proj, float fovy, vec4 dest) {
glmc_persp_sizes(mat4 proj, float fovy, vec4 dest) {
glm_persp_sizes(proj, fovy, dest);
}

2
src/curve.c
View File

@@ -10,6 +10,6 @@
CGLM_EXPORT
float
glmc_smc(float s, const mat4 m, const vec4 c) {
glmc_smc(float s, mat4 m, vec4 c) {
return glm_smc(s, m, c);
}

18
src/euler.c
View File

@@ -10,54 +10,54 @@
CGLM_EXPORT
void
glmc_euler_angles(const mat4 m, vec3 dest) {
glmc_euler_angles(mat4 m, vec3 dest) {
glm_euler_angles(m, dest);
}
CGLM_EXPORT
void
glmc_euler(const vec3 angles, mat4 dest) {
glmc_euler(vec3 angles, mat4 dest) {
glm_euler(angles, dest);
}
CGLM_EXPORT
void
glmc_euler_xyz(const vec3 angles, mat4 dest) {
glmc_euler_xyz(vec3 angles, mat4 dest) {
glm_euler_xyz(angles, dest);
}
CGLM_EXPORT
void
glmc_euler_zyx(const vec3 angles, mat4 dest) {
glmc_euler_zyx(vec3 angles, mat4 dest) {
glm_euler_zyx(angles, dest);
}
CGLM_EXPORT
void
glmc_euler_zxy(const vec3 angles, mat4 dest) {
glmc_euler_zxy(vec3 angles, mat4 dest) {
glm_euler_zxy(angles, dest);
}
CGLM_EXPORT
void
glmc_euler_xzy(const vec3 angles, mat4 dest) {
glmc_euler_xzy(vec3 angles, mat4 dest) {
glm_euler_xzy(angles, dest);
}
CGLM_EXPORT
void
glmc_euler_yzx(const vec3 angles, mat4 dest) {
glmc_euler_yzx(vec3 angles, mat4 dest) {
glm_euler_yzx(angles, dest);
}
CGLM_EXPORT
void
glmc_euler_yxz(const vec3 angles, mat4 dest) {
glmc_euler_yxz(vec3 angles, mat4 dest) {
glm_euler_yxz(angles, dest);
}
CGLM_EXPORT
void
glmc_euler_by_order(const vec3 angles, glm_euler_sq axis, mat4 dest) {
glmc_euler_by_order(vec3 angles, glm_euler_sq axis, mat4 dest) {
glm_euler_by_order(angles, axis, dest);
}

16
src/frustum.c
View File

@@ -10,33 +10,33 @@
CGLM_EXPORT
void
glmc_frustum_planes(const mat4 m, vec4 dest[6]) {
glmc_frustum_planes(mat4 m, vec4 dest[6]) {
glm_frustum_planes(m, dest);
}
CGLM_EXPORT
void
glmc_frustum_corners(const mat4 invMat, vec4 dest[8]) {
glmc_frustum_corners(mat4 invMat, vec4 dest[8]) {
glm_frustum_corners(invMat, dest);
}
CGLM_EXPORT
void
glmc_frustum_center(const vec4 corners[8], vec4 dest) {
glmc_frustum_center(vec4 corners[8], vec4 dest) {
glm_frustum_center(corners, dest);
}
CGLM_EXPORT
void
glmc_frustum_box(const vec4 corners[8], const mat4 m, vec3 box[2]) {
glmc_frustum_box(vec4 corners[8], mat4 m, vec3 box[2]) {
glm_frustum_box(corners, m, box);
}
CGLM_EXPORT
void
glmc_frustum_corners_at(const vec4 corners[8],
float splitDist,
float farDist,
vec4 planeCorners[4]) {
glmc_frustum_corners_at(vec4 corners[8],
float splitDist,
float farDist,
vec4 planeCorners[4]) {
glm_frustum_corners_at(corners, splitDist, farDist, planeCorners);
}

20
src/io.c
View File

@@ -10,35 +10,35 @@
CGLM_EXPORT
void
glmc_mat4_print(const mat4 matrix,
FILE * const __restrict ostream) {
glmc_mat4_print(mat4 matrix,
FILE * __restrict ostream) {
glm_mat4_print(matrix, ostream);
}
CGLM_EXPORT
void
glmc_mat3_print(const mat3 matrix,
FILE * const __restrict ostream) {
glmc_mat3_print(mat3 matrix,
FILE * __restrict ostream) {
glm_mat3_print(matrix, ostream);
}
CGLM_EXPORT
void
glmc_vec4_print(const vec4 vec,
FILE * const __restrict ostream) {
glmc_vec4_print(vec4 vec,
FILE * __restrict ostream) {
glm_vec4_print(vec, ostream);
}
CGLM_EXPORT
void
glmc_vec3_print(const vec3 vec,
FILE * const __restrict ostream) {
glmc_vec3_print(vec3 vec,
FILE * __restrict ostream) {
glm_vec3_print(vec, ostream);
}
CGLM_EXPORT
void
glmc_versor_print(const versor vec,
FILE * const __restrict ostream) {
glmc_versor_print(versor vec,
FILE * __restrict ostream) {
glm_versor_print(vec, ostream);
}

20
src/mat3.c
View File

@@ -10,7 +10,7 @@
CGLM_EXPORT
void
glmc_mat3_copy(const mat3 mat, mat3 dest) {
glmc_mat3_copy(mat3 mat, mat3 dest) {
glm_mat3_copy(mat, dest);
}
@@ -22,19 +22,19 @@ glmc_mat3_identity(mat3 mat) {
CGLM_EXPORT
void
glmc_mat3_identity_array(mat3 * const __restrict mat, size_t count) {
glmc_mat3_identity_array(mat3 * __restrict mat, size_t count) {
glm_mat3_identity_array(mat, count);
}
CGLM_EXPORT
void
glmc_mat3_mul(const mat3 m1, const mat3 m2, mat3 dest) {
glmc_mat3_mul(mat3 m1, mat3 m2, mat3 dest) {
glm_mat3_mul(m1, m2, dest);
}
CGLM_EXPORT
void
glmc_mat3_transpose_to(const mat3 m, mat3 dest) {
glmc_mat3_transpose_to(mat3 m, mat3 dest) {
glm_mat3_transpose_to(m, dest);
}
@@ -46,19 +46,19 @@ glmc_mat3_transpose(mat3 m) {
CGLM_EXPORT
void
glmc_mat3_mulv(const mat3 m, const vec3 v, vec3 dest) {
glmc_mat3_mulv(mat3 m, vec3 v, vec3 dest) {
glm_mat3_mulv(m, v, dest);
}
CGLM_EXPORT
float
glmc_mat3_trace(const mat3 m) {
glmc_mat3_trace(mat3 m) {
return glm_mat3_trace(m);
}
CGLM_EXPORT
void
glmc_mat3_quat(const mat3 m, versor dest) {
glmc_mat3_quat(mat3 m, versor dest) {
glm_mat3_quat(m, dest);
}
@@ -70,13 +70,13 @@ glmc_mat3_scale(mat3 m, float s) {
CGLM_EXPORT
float
glmc_mat3_det(const mat3 mat) {
glmc_mat3_det(mat3 mat) {
return glm_mat3_det(mat);
}
CGLM_EXPORT
void
glmc_mat3_inv(const mat3 mat, mat3 dest) {
glmc_mat3_inv(mat3 mat, mat3 dest) {
glm_mat3_inv(mat, dest);
}
@@ -94,6 +94,6 @@ glmc_mat3_swap_row(mat3 mat, int row1, int row2) {
CGLM_EXPORT
float
glmc_mat3_rmc(const vec3 r, const mat3 m, const vec3 c) {
glmc_mat3_rmc(vec3 r, mat3 m, vec3 c) {
return glm_mat3_rmc(r, m, c);
}

38
src/mat4.c
View File

@@ -10,13 +10,13 @@
CGLM_EXPORT
void
glmc_mat4_ucopy(const mat4 mat, mat4 dest) {
glmc_mat4_ucopy(mat4 mat, mat4 dest) {
glm_mat4_copy(mat, dest);
}
CGLM_EXPORT
void
glmc_mat4_copy(const mat4 mat, mat4 dest) {
glmc_mat4_copy(mat4 mat, mat4 dest) {
glm_mat4_copy(mat, dest);
}
@@ -28,73 +28,73 @@ glmc_mat4_identity(mat4 mat) {
CGLM_EXPORT
void
glmc_mat4_identity_array(mat4 * const __restrict mat, size_t count) {
glmc_mat4_identity_array(mat4 * __restrict mat, size_t count) {
glm_mat4_identity_array(mat, count);
}
CGLM_EXPORT
void
glmc_mat4_pick3(const mat4 mat, mat3 dest) {
glmc_mat4_pick3(mat4 mat, mat3 dest) {
glm_mat4_pick3(mat, dest);
}
CGLM_EXPORT
void
glmc_mat4_pick3t(const mat4 mat, mat3 dest) {
glmc_mat4_pick3t(mat4 mat, mat3 dest) {
glm_mat4_pick3t(mat, dest);
}
CGLM_EXPORT
void
glmc_mat4_ins3(const mat3 mat, mat4 dest) {
glmc_mat4_ins3(mat3 mat, mat4 dest) {
glm_mat4_ins3(mat, dest);
}
CGLM_EXPORT
void
glmc_mat4_mul(const mat4 m1, const mat4 m2, mat4 dest) {
glmc_mat4_mul(mat4 m1, mat4 m2, mat4 dest) {
glm_mat4_mul(m1, m2, dest);
}
CGLM_EXPORT
void
glmc_mat4_mulN(mat4 * const __restrict matrices[], uint32_t len, mat4 dest) {
glmc_mat4_mulN(mat4 * __restrict matrices[], uint32_t len, mat4 dest) {
glm_mat4_mulN(matrices, len, dest);
}
CGLM_EXPORT
void
glmc_mat4_mulv(const mat4 m, const vec4 v, vec4 dest) {
glmc_mat4_mulv(mat4 m, vec4 v, vec4 dest) {
glm_mat4_mulv(m, v, dest);
}
CGLM_EXPORT
void
glmc_mat4_mulv3(const mat4 m, const vec3 v, float last, vec3 dest) {
glmc_mat4_mulv3(mat4 m, vec3 v, float last, vec3 dest) {
glm_mat4_mulv3(m, v, last, dest);
}
CGLM_EXPORT
float
glmc_mat4_trace(const mat4 m) {
glmc_mat4_trace(mat4 m) {
return glm_mat4_trace(m);
}
CGLM_EXPORT
float
glmc_mat4_trace3(const mat4 m) {
glmc_mat4_trace3(mat4 m) {
return glm_mat4_trace3(m);
}
CGLM_EXPORT
void
glmc_mat4_quat(const mat4 m, versor dest) {
glmc_mat4_quat(mat4 m, versor dest) {
glm_mat4_quat(m, dest);
}
CGLM_EXPORT
void
glmc_mat4_transpose_to(const mat4 m, mat4 dest) {
glmc_mat4_transpose_to(mat4 m, mat4 dest) {
glm_mat4_transpose_to(m, dest);
}
@@ -118,25 +118,25 @@ glmc_mat4_scale(mat4 m, float s) {
CGLM_EXPORT
float
glmc_mat4_det(const mat4 mat) {
glmc_mat4_det(mat4 mat) {
return glm_mat4_det(mat);
}
CGLM_EXPORT
void
glmc_mat4_inv(const mat4 mat, mat4 dest) {
glmc_mat4_inv(mat4 mat, mat4 dest) {
glm_mat4_inv(mat, dest);
}
CGLM_EXPORT
void
glmc_mat4_inv_precise(const mat4 mat, mat4 dest) {
glmc_mat4_inv_precise(mat4 mat, mat4 dest) {
glm_mat4_inv_precise(mat, dest);
}
CGLM_EXPORT
void
glmc_mat4_inv_fast(const mat4 mat, mat4 dest) {
glmc_mat4_inv_fast(mat4 mat, mat4 dest) {
glm_mat4_inv_fast(mat, dest);
}
@@ -154,6 +154,6 @@ glmc_mat4_swap_row(mat4 mat, int row1, int row2) {
CGLM_EXPORT
float
glmc_mat4_rmc(const vec4 r, const mat4 m, const vec4 c) {
glmc_mat4_rmc(vec4 r, mat4 m, vec4 c) {
return glm_mat4_rmc(r, m, c);
}

6
src/project.c
View File

@@ -10,18 +10,18 @@
CGLM_EXPORT
void
glmc_unprojecti(const vec3 pos, const mat4 invMat, const vec4 vp, vec3 dest) {
glmc_unprojecti(vec3 pos, mat4 invMat, vec4 vp, vec3 dest) {
glm_unprojecti(pos, invMat, vp, dest);
}
CGLM_EXPORT
void
glmc_unproject(const vec3 pos, const mat4 m, const vec4 vp, vec3 dest) {
glmc_unproject(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
glm_unproject(pos, m, vp, dest);
}
CGLM_EXPORT
void
glmc_project(const vec3 pos, const mat4 m, const vec4 vp, vec3 dest) {
glmc_project(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
glm_project(pos, m, vp, dest);
}

64
src/quat.c
View File

@@ -16,7 +16,7 @@ glmc_quat_identity(versor q) {
CGLM_EXPORT
void
glmc_quat_identity_array(versor * const __restrict q, size_t count) {
glmc_quat_identity_array(versor * __restrict q, size_t count) {
glm_quat_identity_array(q, count);
}
@@ -34,25 +34,25 @@ glmc_quat(versor q, float angle, float x, float y, float z) {
CGLM_EXPORT
void
glmc_quatv(versor q, float angle, const vec3 axis) {
glmc_quatv(versor q, float angle, vec3 axis) {
glm_quatv(q, angle, axis);
}
CGLM_EXPORT
void
glmc_quat_copy(const versor q, versor dest) {
glmc_quat_copy(versor q, versor dest) {
glm_quat_copy(q, dest);
}
CGLM_EXPORT
float
glmc_quat_norm(const versor q) {
glmc_quat_norm(versor q) {
return glm_quat_norm(q);
}
CGLM_EXPORT
void
glmc_quat_normalize_to(const versor q, versor dest) {
glmc_quat_normalize_to(versor q, versor dest) {
glm_quat_normalize_to(q, dest);
}
@@ -64,154 +64,150 @@ glmc_quat_normalize(versor q) {
CGLM_EXPORT
float
glmc_quat_dot(const versor p, const versor q) {
glmc_quat_dot(versor p, versor q) {
return glm_quat_dot(p, q);
}
CGLM_EXPORT
void
glmc_quat_conjugate(const versor q, versor dest) {
glmc_quat_conjugate(versor q, versor dest) {
glm_quat_conjugate(q, dest);
}
CGLM_EXPORT
void
glmc_quat_inv(const versor q, versor dest) {
glmc_quat_inv(versor q, versor dest) {
glm_quat_inv(q, dest);
}
CGLM_EXPORT
void
glmc_quat_add(const versor p, const versor q, versor dest) {
glmc_quat_add(versor p, versor q, versor dest) {
glm_quat_add(p, q, dest);
}
CGLM_EXPORT
void
glmc_quat_sub(const versor p, const versor q, versor dest) {
glmc_quat_sub(versor p, versor q, versor dest) {
glm_quat_sub(p, q, dest);
}
CGLM_EXPORT
float
glmc_quat_real(const versor q) {
glmc_quat_real(versor q) {
return glm_quat_real(q);
}
CGLM_EXPORT
void
glmc_quat_imag(const versor q, vec3 dest) {
glmc_quat_imag(versor q, vec3 dest) {
glm_quat_imag(q, dest);
}
CGLM_EXPORT
void
glmc_quat_imagn(const versor q, vec3 dest) {
glmc_quat_imagn(versor q, vec3 dest) {
glm_quat_imagn(q, dest);
}
CGLM_EXPORT
float
glmc_quat_imaglen(const versor q) {
glmc_quat_imaglen(versor q) {
return glm_quat_imaglen(q);
}
CGLM_EXPORT
float
glmc_quat_angle(const versor q) {
glmc_quat_angle(versor q) {
return glm_quat_angle(q);
}
CGLM_EXPORT
void
glmc_quat_axis(const versor q, versor dest) {
glmc_quat_axis(versor q, versor dest) {
glm_quat_axis(q, dest);
}
CGLM_EXPORT
void
glmc_quat_mul(const versor p, const versor q, versor dest) {
glmc_quat_mul(versor p, versor q, versor dest) {
glm_quat_mul(p, q, dest);
}
CGLM_EXPORT
void
glmc_quat_mat4(const versor q, mat4 dest) {
glmc_quat_mat4(versor q, mat4 dest) {
glm_quat_mat4(q, dest);
}
CGLM_EXPORT
void
glmc_quat_mat4t(const versor q, mat4 dest) {
glmc_quat_mat4t(versor q, mat4 dest) {
glm_quat_mat4t(q, dest);
}
CGLM_EXPORT
void
glmc_quat_mat3(const versor q, mat3 dest) {
glmc_quat_mat3(versor q, mat3 dest) {
glm_quat_mat3(q, dest);
}
CGLM_EXPORT
void
glmc_quat_mat3t(const versor q, mat3 dest) {
glmc_quat_mat3t(versor q, mat3 dest) {
glm_quat_mat3t(q, dest);
}
CGLM_EXPORT
void
glmc_quat_lerp(const versor from, const versor to, float t, versor dest) {
glmc_quat_lerp(versor from, versor to, float t, versor dest) {
glm_quat_lerp(from, to, t, dest);
}
CGLM_EXPORT
void
glmc_quat_slerp(const versor from, const versor to, float t, versor dest) {
glmc_quat_slerp(versor from, versor to, float t, versor dest) {
glm_quat_slerp(from, to, t, dest);
}
CGLM_EXPORT
void
glmc_quat_look(const vec3 eye, const versor ori, mat4 dest) {
glmc_quat_look(vec3 eye, versor ori, mat4 dest) {
glm_quat_look(eye, ori, dest);
}
CGLM_EXPORT
void
glmc_quat_for(const vec3 dir, const vec3 fwd, const vec3 up, versor dest) {
glmc_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest) {
glm_quat_for(dir, fwd, up, dest);
}
CGLM_EXPORT
void
glmc_quat_forp(const vec3 from,
const vec3 to,
const vec3 fwd,
const vec3 up,
versor dest) {
glmc_quat_forp(vec3 from, vec3 to, vec3 fwd, vec3 up, versor dest) {
glm_quat_forp(from, to, fwd, up, dest);
}
CGLM_EXPORT
void
glmc_quat_rotatev(const versor q, const vec3 v, vec3 dest) {
glmc_quat_rotatev(versor q, vec3 v, vec3 dest) {
glm_quat_rotatev(q, v, dest);
}
CGLM_EXPORT
void
glmc_quat_rotate(const mat4 m, const versor q, mat4 dest) {
glmc_quat_rotate(mat4 m, versor q, mat4 dest) {
glm_quat_rotate(m, q, dest);
}
CGLM_EXPORT
void
glmc_quat_rotate_at(mat4 model, const versor q, const vec3 pivot) {
glmc_quat_rotate_at(mat4 model, versor q, vec3 pivot) {
glm_quat_rotate_at(model, q, pivot);
}
CGLM_EXPORT
void
glmc_quat_rotate_atm(mat4 m, const versor q, const vec3 pivot) {
glmc_quat_rotate_atm(mat4 m, versor q, vec3 pivot) {
glm_quat_rotate_atm(m, q, pivot);
}

10
src/sphere.c
View File

@@ -10,30 +10,30 @@
CGLM_EXPORT
float
glmc_sphere_radii(const vec4 s) {
glmc_sphere_radii(vec4 s) {
return glm_sphere_radii(s);
}
CGLM_EXPORT
void
glmc_sphere_transform(const vec4 s, const mat4 m, vec4 dest) {
glmc_sphere_transform(vec4 s, mat4 m, vec4 dest) {
glm_sphere_transform(s, m, dest);
}
CGLM_EXPORT
void
glmc_sphere_merge(const vec4 s1, const vec4 s2, vec4 dest) {
glmc_sphere_merge(vec4 s1, vec4 s2, vec4 dest) {
glm_sphere_merge(s1, s2, dest);
}
CGLM_EXPORT
bool
glmc_sphere_sphere(const vec4 s1, const vec4 s2) {
glmc_sphere_sphere(vec4 s1, vec4 s2) {
return glm_sphere_sphere(s1, s2);
}
CGLM_EXPORT
bool
glmc_sphere_point(const vec4 s, const vec3 point) {
glmc_sphere_point(vec4 s, vec3 point) {
return glm_sphere_point(s, point);
}

98
src/vec3.c
View File

@@ -10,13 +10,13 @@
CGLM_EXPORT
void
glmc_vec3(const vec4 v4, vec3 dest) {
glmc_vec3(vec4 v4, vec3 dest) {
glm_vec3(v4, dest);
}
CGLM_EXPORT
void
glmc_vec3_copy(const vec3 a, vec3 dest) {
glmc_vec3_copy(vec3 a, vec3 dest) {
glm_vec3_copy(a, dest);
}
@@ -34,31 +34,31 @@ glmc_vec3_one(vec3 v) {
CGLM_EXPORT
float
glmc_vec3_dot(const vec3 a, const vec3 b) {
glmc_vec3_dot(vec3 a, vec3 b) {
return glm_vec3_dot(a, b);
}
CGLM_EXPORT
void
glmc_vec3_cross(const vec3 a, const vec3 b, vec3 dest) {
glmc_vec3_cross(vec3 a, vec3 b, vec3 dest) {
glm_vec3_cross(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec3_crossn(const vec3 a, const vec3 b, vec3 dest) {
glmc_vec3_crossn(vec3 a, vec3 b, vec3 dest) {
glm_vec3_crossn(a, b, dest);
}
CGLM_EXPORT
float
glmc_vec3_norm(const vec3 v) {
glmc_vec3_norm(vec3 v) {
return glm_vec3_norm(v);
}
CGLM_EXPORT
void
glmc_vec3_normalize_to(const vec3 v, vec3 dest) {
glmc_vec3_normalize_to(vec3 v, vec3 dest) {
glm_vec3_normalize_to(v, dest);
}
@@ -70,97 +70,97 @@ glmc_vec3_normalize(vec3 v) {
CGLM_EXPORT
float
glmc_vec3_norm2(const vec3 v) {
glmc_vec3_norm2(vec3 v) {
return glm_vec3_norm2(v);
}
CGLM_EXPORT
void
glmc_vec3_add(const vec3 a, const vec3 b, vec3 dest) {
glmc_vec3_add(vec3 a, vec3 b, vec3 dest) {
glm_vec3_add(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec3_adds(const vec3 v, float s, vec3 dest) {
glmc_vec3_adds(vec3 v, float s, vec3 dest) {
glm_vec3_adds(v, s, dest);
}
CGLM_EXPORT
void
glmc_vec3_sub(const vec3 a, const vec3 b, vec3 dest) {
glmc_vec3_sub(vec3 a, vec3 b, vec3 dest) {
glm_vec3_sub(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec3_subs(const vec3 v, float s, vec3 dest) {
glmc_vec3_subs(vec3 v, float s, vec3 dest) {
glm_vec3_subs(v, s, dest);
}
CGLM_EXPORT
void
glmc_vec3_mul(const vec3 a, const vec3 b, vec3 d) {
glmc_vec3_mul(vec3 a, vec3 b, vec3 d) {
glm_vec3_mul(a, b, d);
}
CGLM_EXPORT
void
glmc_vec3_scale(const vec3 v, float s, vec3 dest) {
glmc_vec3_scale(vec3 v, float s, vec3 dest) {
glm_vec3_scale(v, s, dest);
}
CGLM_EXPORT
void
glmc_vec3_scale_as(const vec3 v, float s, vec3 dest) {
glmc_vec3_scale_as(vec3 v, float s, vec3 dest) {
glm_vec3_scale_as(v, s, dest);
}
CGLM_EXPORT
void
glmc_vec3_div(const vec3 a, const vec3 b, vec3 dest) {
glmc_vec3_div(vec3 a, vec3 b, vec3 dest) {
glm_vec3_div(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec3_divs(const vec3 a, float s, vec3 dest) {
glmc_vec3_divs(vec3 a, float s, vec3 dest) {
glm_vec3_divs(a, s, dest);
}
CGLM_EXPORT
void
glmc_vec3_addadd(const vec3 a, const vec3 b, vec3 dest) {
glmc_vec3_addadd(vec3 a, vec3 b, vec3 dest) {
glm_vec3_addadd(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec3_subadd(const vec3 a, const vec3 b, vec3 dest) {
glmc_vec3_subadd(vec3 a, vec3 b, vec3 dest) {
glm_vec3_subadd(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec3_muladd(const vec3 a, const vec3 b, vec3 dest) {
glmc_vec3_muladd(vec3 a, vec3 b, vec3 dest) {
glm_vec3_muladd(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec3_muladds(const vec3 a, float s, vec3 dest) {
glmc_vec3_muladds(vec3 a, float s, vec3 dest) {
glm_vec3_muladds(a, s, dest);
}
CGLM_EXPORT
void
glmc_vec3_maxadd(const vec3 a, const vec3 b, vec3 dest) {
glmc_vec3_maxadd(vec3 a, vec3 b, vec3 dest) {
glm_vec3_maxadd(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec3_minadd(const vec3 a, const vec3 b, vec3 dest) {
glmc_vec3_minadd(vec3 a, vec3 b, vec3 dest) {
glm_vec3_minadd(a, b, dest);
}
@@ -172,67 +172,67 @@ glmc_vec3_negate(vec3 v) {
CGLM_EXPORT
void
glmc_vec3_negate_to(const vec3 v, vec3 dest) {
glmc_vec3_negate_to(vec3 v, vec3 dest) {
glm_vec3_negate_to(v, dest);
}
CGLM_EXPORT
float
glmc_vec3_angle(const vec3 a, const vec3 b) {
glmc_vec3_angle(vec3 a, vec3 b) {
return glm_vec3_angle(a, b);
}
CGLM_EXPORT
void
glmc_vec3_rotate(vec3 v, float angle, const vec3 axis) {
glmc_vec3_rotate(vec3 v, float angle, vec3 axis) {
glm_vec3_rotate(v, angle, axis);
}
CGLM_EXPORT
void
glmc_vec3_rotate_m4(const mat4 m, const vec3 v, vec3 dest) {
glmc_vec3_rotate_m4(mat4 m, vec3 v, vec3 dest) {
glm_vec3_rotate_m4(m, v, dest);
}
CGLM_EXPORT
void
glmc_vec3_rotate_m3(const mat3 m, const vec3 v, vec3 dest) {
glmc_vec3_rotate_m3(mat3 m, vec3 v, vec3 dest) {
glm_vec3_rotate_m3(m, v, dest);
}
CGLM_EXPORT
void
glmc_vec3_proj(const vec3 a, const vec3 b, vec3 dest) {
glmc_vec3_proj(vec3 a, vec3 b, vec3 dest) {
glm_vec3_proj(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec3_center(const vec3 a, const vec3 b, vec3 dest) {
glmc_vec3_center(vec3 a, vec3 b, vec3 dest) {
glm_vec3_center(a, b, dest);
}
CGLM_EXPORT
float
glmc_vec3_distance2(const vec3 a, const vec3 b) {
glmc_vec3_distance2(vec3 a, vec3 b) {
return glm_vec3_distance2(a, b);
}
CGLM_EXPORT
float
glmc_vec3_distance(const vec3 a, const vec3 b) {
glmc_vec3_distance(vec3 a, vec3 b) {
return glm_vec3_distance(a, b);
}
CGLM_EXPORT
void
glmc_vec3_maxv(const vec3 a, const vec3 b, vec3 dest) {
glmc_vec3_maxv(vec3 a, vec3 b, vec3 dest) {
glm_vec3_minv(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec3_minv(const vec3 a, const vec3 b, vec3 dest) {
glmc_vec3_minv(vec3 a, vec3 b, vec3 dest) {
glm_vec3_maxv(a, b, dest);
}
@@ -244,13 +244,13 @@ glmc_vec3_clamp(vec3 v, float minVal, float maxVal) {
CGLM_EXPORT
void
glmc_vec3_ortho(const vec3 v, vec3 dest) {
glmc_vec3_ortho(vec3 v, vec3 dest) {
glm_vec3_ortho(v, dest);
}
CGLM_EXPORT
void
glmc_vec3_lerp(const vec3 from, const vec3 to, float t, vec3 dest) {
glmc_vec3_lerp(vec3 from, vec3 to, float t, vec3 dest) {
glm_vec3_lerp(from, to, t, dest);
}
@@ -258,7 +258,7 @@ glmc_vec3_lerp(const vec3 from, const vec3 to, float t, vec3 dest) {
CGLM_EXPORT
void
glmc_vec3_mulv(const vec3 a, const vec3 b, vec3 d) {
glmc_vec3_mulv(vec3 a, vec3 b, vec3 d) {
glm_vec3_mulv(a, b, d);
}
@@ -270,72 +270,72 @@ glmc_vec3_broadcast(float val, vec3 d) {
CGLM_EXPORT
bool
glmc_vec3_eq(const vec3 v, float val) {
glmc_vec3_eq(vec3 v, float val) {
return glm_vec3_eq(v, val);
}
CGLM_EXPORT
bool
glmc_vec3_eq_eps(const vec3 v, float val) {
glmc_vec3_eq_eps(vec3 v, float val) {
return glm_vec3_eq_eps(v, val);
}
CGLM_EXPORT
bool
glmc_vec3_eq_all(const vec3 v) {
glmc_vec3_eq_all(vec3 v) {
return glm_vec3_eq_all(v);
}
CGLM_EXPORT
bool
glmc_vec3_eqv(const vec3 a, const vec3 b) {
glmc_vec3_eqv(vec3 a, vec3 b) {
return glm_vec3_eqv(a, b);
}
CGLM_EXPORT
bool
glmc_vec3_eqv_eps(const vec3 a, const vec3 b) {
glmc_vec3_eqv_eps(vec3 a, vec3 b) {
return glm_vec3_eqv_eps(a, b);
}
CGLM_EXPORT
float
glmc_vec3_max(const vec3 v) {
glmc_vec3_max(vec3 v) {
return glm_vec3_max(v);
}
CGLM_EXPORT
float
glmc_vec3_min(const vec3 v) {
glmc_vec3_min(vec3 v) {
return glm_vec3_min(v);
}
CGLM_EXPORT
bool
glmc_vec3_isnan(const vec3 v) {
glmc_vec3_isnan(vec3 v) {
return glm_vec3_isnan(v);
}
CGLM_EXPORT
bool
glmc_vec3_isinf(const vec3 v) {
glmc_vec3_isinf(vec3 v) {
return glm_vec3_isinf(v);
}
CGLM_EXPORT
bool
glmc_vec3_isvalid(const vec3 v) {
glmc_vec3_isvalid(vec3 v) {
return glm_vec3_isvalid(v);
}
CGLM_EXPORT
void
glmc_vec3_sign(const vec3 v, vec3 dest) {
glmc_vec3_sign(vec3 v, vec3 dest) {
glm_vec3_sign(v, dest);
}
CGLM_EXPORT
void
glmc_vec3_sqrt(const vec3 v, vec3 dest) {
glmc_vec3_sqrt(vec3 v, vec3 dest) {
glm_vec3_sqrt(v, dest);
}

82
src/vec4.c
View File

@@ -10,7 +10,7 @@
CGLM_EXPORT
void
glmc_vec4(const vec3 v3, float last, vec4 dest) {
glmc_vec4(vec3 v3, float last, vec4 dest) {
glm_vec4(v3, last, dest);
}
@@ -28,37 +28,37 @@ glmc_vec4_one(vec4 v) {
CGLM_EXPORT
void
glmc_vec4_copy3(const vec4 v, vec3 dest) {
glmc_vec4_copy3(vec4 v, vec3 dest) {
glm_vec4_copy3(v, dest);
}
CGLM_EXPORT
void
glmc_vec4_copy(const vec4 v, vec4 dest) {
glmc_vec4_copy(vec4 v, vec4 dest) {
glm_vec4_copy(v, dest);
}
CGLM_EXPORT
void
glmc_vec4_ucopy(const vec4 v, vec4 dest) {
glmc_vec4_ucopy(vec4 v, vec4 dest) {
glm_vec4_ucopy(v, dest);
}
CGLM_EXPORT
float
glmc_vec4_dot(const vec4 a, const vec4 b) {
glmc_vec4_dot(vec4 a, vec4 b) {
return glm_vec4_dot(a, b);
}
CGLM_EXPORT
float
glmc_vec4_norm(const vec4 v) {
glmc_vec4_norm(vec4 v) {
return glm_vec4_norm(v);
}
CGLM_EXPORT
void
glmc_vec4_normalize_to(const vec4 v, vec4 dest) {
glmc_vec4_normalize_to(vec4 v, vec4 dest) {
glm_vec4_normalize_to(v, dest);
}
@@ -70,97 +70,97 @@ glmc_vec4_normalize(vec4 v) {
CGLM_EXPORT
float
glmc_vec4_norm2(const vec4 v) {
glmc_vec4_norm2(vec4 v) {
return glm_vec4_norm2(v);
}
CGLM_EXPORT
void
glmc_vec4_add(const vec4 a, const vec4 b, vec4 dest) {
glmc_vec4_add(vec4 a, vec4 b, vec4 dest) {
glm_vec4_add(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec4_adds(const vec4 v, float s, vec4 dest) {
glmc_vec4_adds(vec4 v, float s, vec4 dest) {
glm_vec4_adds(v, s, dest);
}
CGLM_EXPORT
void
glmc_vec4_sub(const vec4 a, const vec4 b, vec4 dest) {
glmc_vec4_sub(vec4 a, vec4 b, vec4 dest) {
glm_vec4_sub(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec4_subs(const vec4 v, float s, vec4 dest) {
glmc_vec4_subs(vec4 v, float s, vec4 dest) {
glm_vec4_subs(v, s, dest);
}
CGLM_EXPORT
void
glmc_vec4_mul(const vec4 a, const vec4 b, vec4 d) {
glmc_vec4_mul(vec4 a, vec4 b, vec4 d) {
glm_vec4_mul(a, b, d);
}
CGLM_EXPORT
void
glmc_vec4_scale(const vec4 v, float s, vec4 dest) {
glmc_vec4_scale(vec4 v, float s, vec4 dest) {
glm_vec4_scale(v, s, dest);
}
CGLM_EXPORT
void
glmc_vec4_scale_as(const vec4 v, float s, vec4 dest) {
glmc_vec4_scale_as(vec4 v, float s, vec4 dest) {
glm_vec4_scale_as(v, s, dest);
}
CGLM_EXPORT
void
glmc_vec4_div(const vec4 a, const vec4 b, vec4 dest) {
glmc_vec4_div(vec4 a, vec4 b, vec4 dest) {
glm_vec4_div(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec4_divs(const vec4 v, float s, vec4 dest) {
glmc_vec4_divs(vec4 v, float s, vec4 dest) {
glm_vec4_divs(v, s, dest);
}
CGLM_EXPORT
void
glmc_vec4_addadd(const vec4 a, const vec4 b, vec4 dest) {
glmc_vec4_addadd(vec4 a, vec4 b, vec4 dest) {
glm_vec4_addadd(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec4_subadd(const vec4 a, const vec4 b, vec4 dest) {
glmc_vec4_subadd(vec4 a, vec4 b, vec4 dest) {
glm_vec4_subadd(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec4_muladd(const vec4 a, const vec4 b, vec4 dest) {
glmc_vec4_muladd(vec4 a, vec4 b, vec4 dest) {
glm_vec4_muladd(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec4_muladds(const vec4 a, float s, vec4 dest) {
glmc_vec4_muladds(vec4 a, float s, vec4 dest) {
glm_vec4_muladds(a, s, dest);
}
CGLM_EXPORT
void
glmc_vec4_maxadd(const vec4 a, const vec4 b, vec4 dest) {
glmc_vec4_maxadd(vec4 a, vec4 b, vec4 dest) {
glm_vec4_maxadd(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec4_minadd(const vec4 a, const vec4 b, vec4 dest) {
glmc_vec4_minadd(vec4 a, vec4 b, vec4 dest) {
glm_vec4_minadd(a, b, dest);
}
@@ -172,25 +172,25 @@ glmc_vec4_negate(vec4 v) {
CGLM_EXPORT
void
glmc_vec4_negate_to(const vec4 v, vec4 dest) {
glmc_vec4_negate_to(vec4 v, vec4 dest) {
glm_vec4_negate_to(v, dest);
}
CGLM_EXPORT
float
glmc_vec4_distance(const vec4 a, const vec4 b) {
glmc_vec4_distance(vec4 a, vec4 b) {
return glm_vec4_distance(a, b);
}
CGLM_EXPORT
void
glmc_vec4_maxv(const vec4 a, const vec4 b, vec4 dest) {
glmc_vec4_maxv(vec4 a, vec4 b, vec4 dest) {
glm_vec4_minv(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec4_minv(const vec4 a, const vec4 b, vec4 dest) {
glmc_vec4_minv(vec4 a, vec4 b, vec4 dest) {
glm_vec4_maxv(a, b, dest);
}
@@ -202,7 +202,7 @@ glmc_vec4_clamp(vec4 v, float minVal, float maxVal) {
CGLM_EXPORT
void
glmc_vec4_lerp(const vec4 from, const vec4 to, float t, vec4 dest) {
glmc_vec4_lerp(vec4 from, vec4 to, float t, vec4 dest) {
glm_vec4_lerp(from, to, t, dest);
}
@@ -216,7 +216,7 @@ glmc_vec4_cubic(float s, vec4 dest) {
CGLM_EXPORT
void
glmc_vec4_mulv(const vec4 a, const vec4 b, vec4 d) {
glmc_vec4_mulv(vec4 a, vec4 b, vec4 d) {
glm_vec4_mulv(a, b, d);
}
@@ -228,72 +228,72 @@ glmc_vec4_broadcast(float val, vec4 d) {
CGLM_EXPORT
bool
glmc_vec4_eq(const vec4 v, float val) {
glmc_vec4_eq(vec4 v, float val) {
return glm_vec4_eq(v, val);
}
CGLM_EXPORT
bool
glmc_vec4_eq_eps(const vec4 v, float val) {
glmc_vec4_eq_eps(vec4 v, float val) {
return glm_vec4_eq_eps(v, val);
}
CGLM_EXPORT
bool
glmc_vec4_eq_all(const vec4 v) {
glmc_vec4_eq_all(vec4 v) {
return glm_vec4_eq_all(v);
}
CGLM_EXPORT
bool
glmc_vec4_eqv(const vec4 a, const vec4 b) {
glmc_vec4_eqv(vec4 a, vec4 b) {
return glm_vec4_eqv(a, b);
}
CGLM_EXPORT
bool
glmc_vec4_eqv_eps(const vec4 a, const vec4 b) {
glmc_vec4_eqv_eps(vec4 a, vec4 b) {
return glm_vec4_eqv_eps(a, b);
}
CGLM_EXPORT
float
glmc_vec4_max(const vec4 v) {
glmc_vec4_max(vec4 v) {
return glm_vec4_max(v);
}
CGLM_EXPORT
float
glmc_vec4_min(const vec4 v) {
glmc_vec4_min(vec4 v) {
return glm_vec4_min(v);
}
CGLM_EXPORT
bool
glmc_vec4_isnan(const vec4 v) {
glmc_vec4_isnan(vec4 v) {
return glm_vec4_isnan(v);
}
CGLM_EXPORT
bool
glmc_vec4_isinf(const vec4 v) {
glmc_vec4_isinf(vec4 v) {
return glm_vec4_isinf(v);
}
CGLM_EXPORT
bool
glmc_vec4_isvalid(const vec4 v) {
glmc_vec4_isvalid(vec4 v) {
return glm_vec4_isvalid(v);
}
CGLM_EXPORT
void
glmc_vec4_sign(const vec4 v, vec4 dest) {
glmc_vec4_sign(vec4 v, vec4 dest) {
glm_vec4_sign(v, dest);
}
CGLM_EXPORT
void
glmc_vec4_sqrt(const vec4 v, vec4 dest) {
glmc_vec4_sqrt(vec4 v, vec4 dest) {
glm_vec4_sqrt(v, dest);
}