External/cglm
1
0
Fork 0
mirror of https://github.com/recp/cglm.git synced 2026-01-02 13:49:59 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into simd

Browse Source
This commit is contained in:
Recep Aslantas
2019-01-21 22:43:15 +03:00
committed by GitHub
parent 9aebdc76b3 07e60bd098
commit 01b93b0409
44 changed files with 1213 additions and 901 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -160,8 +160,8 @@ glm_inv_tr(mat4 mat) {
/* translate */
glm_mat3_mulv(r, mat[3], t);
glm_vec_flipsign(t);
glm_vec_copy(t, mat[3]);
glm_vec3_negate(t);
glm_vec3_copy(t, mat[3]);
#endif
}

44
include/cglm/affine.h
View File

@@ -170,7 +170,7 @@ CGLM_INLINE
void
glm_translate_make(mat4 m, vec3 v) {
glm_mat4_identity(m);
glm_vec_copy(v, m[3]);
glm_vec3_copy(v, m[3]);
}
/*!
@@ -325,13 +325,13 @@ glm_rotate_make(mat4 m, float angle, vec3 axis) {
c = cosf(angle);
glm_vec_normalize_to(axis, axisn);
glm_vec_scale(axisn, 1.0f - c, v);
glm_vec_scale(axisn, sinf(angle), vs);
glm_vec3_normalize_to(axis, axisn);
glm_vec3_scale(axisn, 1.0f - c, v);
glm_vec3_scale(axisn, sinf(angle), vs);
glm_vec_scale(axisn, v[0], m[0]);
glm_vec_scale(axisn, v[1], m[1]);
glm_vec_scale(axisn, v[2], m[2]);
glm_vec3_scale(axisn, v[0], m[0]);
glm_vec3_scale(axisn, v[1], m[1]);
glm_vec3_scale(axisn, v[2], m[2]);
m[0][0] += c; m[1][0] -= vs[2]; m[2][0] += vs[1];
m[0][1] += vs[2]; m[1][1] += c; m[2][1] -= vs[0];
@@ -370,7 +370,7 @@ void
glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis) {
CGLM_ALIGN(8) vec3 pivotInv;
glm_vec_inv_to(pivot, pivotInv);
glm_vec3_negate_to(pivot, pivotInv);
glm_translate(m, pivot);
glm_rotate(m, angle, axis);
@@ -395,7 +395,7 @@ void
glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis) {
CGLM_ALIGN(8) vec3 pivotInv;
glm_vec_inv_to(pivot, pivotInv);
glm_vec3_negate_to(pivot, pivotInv);
glm_translate_make(m, pivot);
glm_rotate(m, angle, axis);
@@ -411,9 +411,9 @@ glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis) {
CGLM_INLINE
void
glm_decompose_scalev(mat4 m, vec3 s) {
s[0] = glm_vec_norm(m[0]);
s[1] = glm_vec_norm(m[1]);
s[2] = glm_vec_norm(m[2]);
s[0] = glm_vec3_norm(m[0]);
s[1] = glm_vec3_norm(m[1]);
s[2] = glm_vec3_norm(m[2]);
}
/*!
@@ -429,7 +429,7 @@ bool
glm_uniscaled(mat4 m) {
CGLM_ALIGN(8) vec3 s;
glm_decompose_scalev(m, s);
return glm_vec_eq_all(s);
return glm_vec3_eq_all(s);
}
/*!
@@ -451,9 +451,9 @@ glm_decompose_rs(mat4 m, mat4 r, vec3 s) {
glm_vec4_copy(m[2], r[2]);
glm_vec4_copy(t, r[3]);
s[0] = glm_vec_norm(m[0]);
s[1] = glm_vec_norm(m[1]);
s[2] = glm_vec_norm(m[2]);
s[0] = glm_vec3_norm(m[0]);
s[1] = glm_vec3_norm(m[1]);
s[2] = glm_vec3_norm(m[2]);
glm_vec4_scale(r[0], 1.0f/s[0], r[0]);
glm_vec4_scale(r[1], 1.0f/s[1], r[1]);
@@ -462,12 +462,12 @@ glm_decompose_rs(mat4 m, mat4 r, vec3 s) {
/* Note from Apple Open Source (asume that the matrix is orthonormal):
check for a coordinate system flip. If the determinant
is -1, then negate the matrix and the scaling factors. */
glm_vec_cross(m[0], m[1], v);
if (glm_vec_dot(v, m[2]) < 0.0f) {
glm_vec4_flipsign(r[0]);
glm_vec4_flipsign(r[1]);
glm_vec4_flipsign(r[2]);
glm_vec_flipsign(s);
glm_vec3_cross(m[0], m[1], v);
if (glm_vec3_dot(v, m[2]) < 0.0f) {
glm_vec4_negate(r[0]);
glm_vec4_negate(r[1]);
glm_vec4_negate(r[2]);
glm_vec3_negate(s);
}
}

54
include/cglm/box.h
View File

@@ -23,35 +23,31 @@
CGLM_INLINE
void
glm_aabb_transform(vec3 box[2], mat4 m, vec3 dest[2]) {
vec3 v[2], xa, xb, ya, yb, za, zb, tmp;
vec3 v[2], xa, xb, ya, yb, za, zb;
glm_vec_scale(m[0], box[0][0], xa);
glm_vec_scale(m[0], box[1][0], xb);
glm_vec3_scale(m[0], box[0][0], xa);
glm_vec3_scale(m[0], box[1][0], xb);
glm_vec_scale(m[1], box[0][1], ya);
glm_vec_scale(m[1], box[1][1], yb);
glm_vec3_scale(m[1], box[0][1], ya);
glm_vec3_scale(m[1], box[1][1], yb);
glm_vec_scale(m[2], box[0][2], za);
glm_vec_scale(m[2], box[1][2], zb);
glm_vec3_scale(m[2], box[0][2], za);
glm_vec3_scale(m[2], box[1][2], zb);
/* min(xa, xb) + min(ya, yb) + min(za, zb) + translation */
glm_vec_minv(xa, xb, v[0]);
glm_vec_minv(ya, yb, tmp);
glm_vec_add(v[0], tmp, v[0]);
glm_vec_minv(za, zb, tmp);
glm_vec_add(v[0], tmp, v[0]);
glm_vec_add(v[0], m[3], v[0]);
/* translation + min(xa, xb) + min(ya, yb) + min(za, zb) */
glm_vec3(m[3], v[0]);
glm_vec3_minadd(xa, xb, v[0]);
glm_vec3_minadd(ya, yb, v[0]);
glm_vec3_minadd(za, zb, v[0]);
/* max(xa, xb) + max(ya, yb) + max(za, zb) + translation */
glm_vec_maxv(xa, xb, v[1]);
glm_vec_maxv(ya, yb, tmp);
glm_vec_add(v[1], tmp, v[1]);
glm_vec_maxv(za, zb, tmp);
glm_vec_add(v[1], tmp, v[1]);
glm_vec_add(v[1], m[3], v[1]);
/* translation + max(xa, xb) + max(ya, yb) + max(za, zb) */
glm_vec3(m[3], v[1]);
glm_vec3_maxadd(xa, xb, v[1]);
glm_vec3_maxadd(ya, yb, v[1]);
glm_vec3_maxadd(za, zb, v[1]);
glm_vec_copy(v[0], dest[0]);
glm_vec_copy(v[1], dest[1]);
glm_vec3_copy(v[0], dest[0]);
glm_vec3_copy(v[1], dest[1]);
}
/*!
@@ -162,8 +158,8 @@ glm_aabb_frustum(vec3 box[2], vec4 planes[6]) {
CGLM_INLINE
void
glm_aabb_invalidate(vec3 box[2]) {
glm_vec_broadcast(FLT_MAX, box[0]);
glm_vec_broadcast(-FLT_MAX, box[1]);
glm_vec3_broadcast(FLT_MAX, box[0]);
glm_vec3_broadcast(-FLT_MAX, box[1]);
}
/*!
@@ -174,8 +170,8 @@ glm_aabb_invalidate(vec3 box[2]) {
CGLM_INLINE
bool
glm_aabb_isvalid(vec3 box[2]) {
return glm_vec_max(box[0]) != FLT_MAX
&& glm_vec_min(box[1]) != -FLT_MAX;
return glm_vec3_max(box[0]) != FLT_MAX
&& glm_vec3_min(box[1]) != -FLT_MAX;
}
/*!
@@ -186,7 +182,7 @@ glm_aabb_isvalid(vec3 box[2]) {
CGLM_INLINE
float
glm_aabb_size(vec3 box[2]) {
return glm_vec_distance(box[0], box[1]);
return glm_vec3_distance(box[0], box[1]);
}
/*!
@@ -209,7 +205,7 @@ glm_aabb_radius(vec3 box[2]) {
CGLM_INLINE
void
glm_aabb_center(vec3 box[2], vec3 dest) {
glm_vec_center(box[0], box[1], dest);
glm_vec3_center(box[0], box[1], dest);
}
/*!

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

@@ -61,6 +61,10 @@ glmc_perspective(float fovy,
float farVal,
mat4 dest);
CGLM_EXPORT
void
glmc_persp_move_far(mat4 proj, float deltaFar);
CGLM_EXPORT
void
glmc_perspective_default(float aspect, mat4 dest);

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

@@ -44,6 +44,10 @@ CGLM_EXPORT
void
glmc_mat3_mulv(mat3 m, vec3 v, vec3 dest);
CGLM_EXPORT
float
glmc_mat3_trace(mat3 m);
CGLM_EXPORT
void
glmc_mat3_quat(mat3 m, versor dest);

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

@@ -61,6 +61,14 @@ CGLM_EXPORT
void
glmc_mat4_mulv3(mat4 m, vec3 v, float last, vec3 dest);
CGLM_EXPORT
float
glmc_mat4_trace(mat4 m);
CGLM_EXPORT
float
glmc_mat4_trace3(mat4 m);
CGLM_EXPORT
void
glmc_mat4_quat(mat4 m, versor dest);

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

@@ -14,7 +14,11 @@ extern "C" {
#include "../cglm.h"
/* DEPRECATED! use _copy, _ucopy versions */
#define glmc_vec_dup(v, dest) glmc_vec_copy(v, dest)
#define glmc_vec_dup(v, dest) glmc_vec3_copy(v, dest)
#define glmc_vec3_flipsign(v) glmc_vec3_negate(v)
#define glmc_vec3_flipsign_to(v, dest) glmc_vec3_negate_to(v, dest)
#define glmc_vec3_inv(v) glmc_vec3_negate(v)
#define glmc_vec3_inv_to(v, dest) glmc_vec3_negate_to(v, dest)
CGLM_EXPORT
void
@@ -22,217 +26,221 @@ glmc_vec3(vec4 v4, vec3 dest);
CGLM_EXPORT
void
glmc_vec_copy(vec3 a, vec3 dest);
glmc_vec3_copy(vec3 a, vec3 dest);
CGLM_EXPORT
void
glmc_vec_zero(vec3 v);
glmc_vec3_zero(vec3 v);
CGLM_EXPORT
void
glmc_vec_one(vec3 v);
glmc_vec3_one(vec3 v);
CGLM_EXPORT
float
glmc_vec_dot(vec3 a, vec3 b);
glmc_vec3_dot(vec3 a, vec3 b);
CGLM_EXPORT
void
glmc_vec_cross(vec3 a, vec3 b, vec3 d);
glmc_vec3_cross(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_crossn(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
float
glmc_vec_norm(vec3 vec);
glmc_vec3_norm(vec3 v);
CGLM_EXPORT
float
glmc_vec_norm2(vec3 vec);
glmc_vec3_norm2(vec3 v);
CGLM_EXPORT
void
glmc_vec_normalize_to(vec3 vec, vec3 dest);
glmc_vec3_normalize_to(vec3 v, vec3 dest);
CGLM_EXPORT
void
glmc_vec_normalize(vec3 v);
glmc_vec3_normalize(vec3 v);
CGLM_EXPORT
void
glmc_vec_add(vec3 v1, vec3 v2, vec3 dest);
glmc_vec3_add(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec_adds(vec3 v, float s, vec3 dest);
glmc_vec3_adds(vec3 v, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec_sub(vec3 a, vec3 b, vec3 dest);
glmc_vec3_sub(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec_subs(vec3 v, float s, vec3 dest);
glmc_vec3_subs(vec3 v, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec_mul(vec3 a, vec3 b, vec3 d);
glmc_vec3_mul(vec3 a, vec3 b, vec3 d);
CGLM_EXPORT
void
glmc_vec_scale(vec3 v, float s, vec3 dest);
glmc_vec3_scale(vec3 v, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec_scale_as(vec3 v, float s, vec3 dest);
glmc_vec3_scale_as(vec3 v, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec_div(vec3 a, vec3 b, vec3 dest);
glmc_vec3_div(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec_divs(vec3 a, float s, vec3 dest);
glmc_vec3_divs(vec3 a, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec_addadd(vec3 a, vec3 b, vec3 dest);
glmc_vec3_addadd(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec_subadd(vec3 a, vec3 b, vec3 dest);
glmc_vec3_subadd(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec_muladd(vec3 a, vec3 b, vec3 dest);
glmc_vec3_muladd(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec_muladds(vec3 a, float s, vec3 dest);
glmc_vec3_muladds(vec3 a, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec_flipsign(vec3 v);
glmc_vec3_maxadd(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec_flipsign_to(vec3 v, vec3 dest);
glmc_vec3_minadd(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec_inv(vec3 v);
glmc_vec3_negate(vec3 v);
CGLM_EXPORT
void
glmc_vec_inv_to(vec3 v, vec3 dest);
CGLM_EXPORT
float
glmc_vec_angle(vec3 v1, vec3 v2);
CGLM_EXPORT
void
glmc_vec_rotate(vec3 v, float angle, vec3 axis);
CGLM_EXPORT
void
glmc_vec_rotate_m4(mat4 m, vec3 v, vec3 dest);
CGLM_EXPORT
void
glmc_vec_rotate_m3(mat3 m, vec3 v, vec3 dest);
CGLM_EXPORT
void
glmc_vec_proj(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec_center(vec3 v1, vec3 v2, vec3 dest);
glmc_vec3_negate_to(vec3 v, vec3 dest);
CGLM_EXPORT
float
glmc_vec_distance2(vec3 v1, vec3 v2);
glmc_vec3_angle(vec3 a, vec3 b);
CGLM_EXPORT
void
glmc_vec3_rotate(vec3 v, float angle, vec3 axis);
CGLM_EXPORT
void
glmc_vec3_rotate_m4(mat4 m, vec3 v, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_rotate_m3(mat3 m, vec3 v, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_proj(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_center(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
float
glmc_vec_distance(vec3 v1, vec3 v2);
glmc_vec3_distance2(vec3 a, vec3 b);
CGLM_EXPORT
float
glmc_vec3_distance(vec3 a, vec3 b);
CGLM_EXPORT
void
glmc_vec_maxv(vec3 v1, vec3 v2, vec3 dest);
glmc_vec3_maxv(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec_minv(vec3 v1, vec3 v2, vec3 dest);
glmc_vec3_minv(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec_clamp(vec3 v, float minVal, float maxVal);
glmc_vec3_clamp(vec3 v, float minVal, float maxVal);
CGLM_EXPORT
void
glmc_vec_ortho(vec3 v, vec3 dest);
glmc_vec3_ortho(vec3 v, vec3 dest);
CGLM_EXPORT
void
glmc_vec_lerp(vec3 from, vec3 to, float t, vec3 dest);
glmc_vec3_lerp(vec3 from, vec3 to, float t, vec3 dest);
/* ext */
CGLM_EXPORT
void
glmc_vec_mulv(vec3 a, vec3 b, vec3 d);
glmc_vec3_mulv(vec3 a, vec3 b, vec3 d);
CGLM_EXPORT
void
glmc_vec_broadcast(float val, vec3 d);
glmc_vec3_broadcast(float val, vec3 d);
CGLM_EXPORT
bool
glmc_vec_eq(vec3 v, float val);
glmc_vec3_eq(vec3 v, float val);
CGLM_EXPORT
bool
glmc_vec_eq_eps(vec3 v, float val);
glmc_vec3_eq_eps(vec3 v, float val);
CGLM_EXPORT
bool
glmc_vec_eq_all(vec3 v);
glmc_vec3_eq_all(vec3 v);
CGLM_EXPORT
bool
glmc_vec_eqv(vec3 v1, vec3 v2);
glmc_vec3_eqv(vec3 a, vec3 b);
CGLM_EXPORT
bool
glmc_vec_eqv_eps(vec3 v1, vec3 v2);
glmc_vec3_eqv_eps(vec3 a, vec3 b);
CGLM_EXPORT
float
glmc_vec_max(vec3 v);
glmc_vec3_max(vec3 v);
CGLM_EXPORT
float
glmc_vec_min(vec3 v);
glmc_vec3_min(vec3 v);
CGLM_EXPORT
bool
glmc_vec_isnan(vec3 v);
glmc_vec3_isnan(vec3 v);
CGLM_EXPORT
bool
glmc_vec_isinf(vec3 v);
glmc_vec3_isinf(vec3 v);
CGLM_EXPORT
bool
glmc_vec_isvalid(vec3 v);
glmc_vec3_isvalid(vec3 v);
CGLM_EXPORT
void
glmc_vec_sign(vec3 v, vec3 dest);
glmc_vec3_sign(vec3 v, vec3 dest);
CGLM_EXPORT
void
glmc_vec_sqrt(vec3 v, vec3 dest);
glmc_vec3_sqrt(vec3 v, vec3 dest);
#ifdef __cplusplus
}

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

@@ -14,8 +14,12 @@ extern "C" {
#include "../cglm.h"
/* DEPRECATED! use _copy, _ucopy versions */
#define glmc_vec4_dup3(v, dest) glmc_vec4_copy3(v, dest)
#define glmc_vec4_dup(v, dest) glmc_vec4_copy(v, dest)
#define glmc_vec4_dup3(v, dest) glmc_vec4_copy3(v, dest)
#define glmc_vec4_dup(v, dest) glmc_vec4_copy(v, dest)
#define glmc_vec4_flipsign(v) glmc_vec4_negate(v)
#define glmc_vec4_flipsign_to(v, dest) glmc_vec4_negate_to(v, dest)
#define glmc_vec4_inv(v) glmc_vec4_negate(v)
#define glmc_vec4_inv_to(v, dest) glmc_vec4_negate_to(v, dest)
CGLM_EXPORT
void
@@ -31,7 +35,7 @@ glmc_vec4_one(vec4 v);
CGLM_EXPORT
void
glmc_vec4_copy3(vec4 a, vec3 dest);
glmc_vec4_copy3(vec4 v, vec3 dest);
CGLM_EXPORT
void
@@ -47,15 +51,15 @@ glmc_vec4_dot(vec4 a, vec4 b);
CGLM_EXPORT
float
glmc_vec4_norm(vec4 vec);
glmc_vec4_norm(vec4 v);
CGLM_EXPORT
float
glmc_vec4_norm2(vec4 vec);
glmc_vec4_norm2(vec4 v);
CGLM_EXPORT
void
glmc_vec4_normalize_to(vec4 vec, vec4 dest);
glmc_vec4_normalize_to(vec4 v, vec4 dest);
CGLM_EXPORT
void
@@ -115,31 +119,31 @@ glmc_vec4_muladds(vec4 a, float s, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_flipsign(vec4 v);
glmc_vec4_maxadd(vec4 a, vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_flipsign_to(vec4 v, vec4 dest);
glmc_vec4_minadd(vec4 a, vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_inv(vec4 v);
glmc_vec4_negate(vec4 v);
CGLM_EXPORT
void
glmc_vec4_inv_to(vec4 v, vec4 dest);
glmc_vec4_negate_to(vec4 v, vec4 dest);
CGLM_EXPORT
float
glmc_vec4_distance(vec4 v1, vec4 v2);
glmc_vec4_distance(vec4 a, vec4 b);
CGLM_EXPORT
void
glmc_vec4_maxv(vec4 v1, vec4 v2, vec4 dest);
glmc_vec4_maxv(vec4 a, vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_minv(vec4 v1, vec4 v2, vec4 dest);
glmc_vec4_minv(vec4 a, vec4 b, vec4 dest);
CGLM_EXPORT
void
@@ -173,11 +177,11 @@ glmc_vec4_eq_all(vec4 v);
CGLM_EXPORT
bool
glmc_vec4_eqv(vec4 v1, vec4 v2);
glmc_vec4_eqv(vec4 a, vec4 b);
CGLM_EXPORT
bool
glmc_vec4_eqv_eps(vec4 v1, vec4 v2);
glmc_vec4_eqv_eps(vec4 a, vec4 b);
CGLM_EXPORT
float

44
include/cglm/cam.h
View File

@@ -271,6 +271,30 @@ glm_perspective(float fovy,
dest[3][2] = 2.0f * nearVal * farVal * fn;
}
/*!
* @brief extend perspective projection matrix's far distance
*
* this function does not guarantee far >= near, be aware of that!
*
* @param[in, out] proj projection matrix to extend
* @param[in] deltaFar distance from existing far (negative to shink)
*/
CGLM_INLINE
void
glm_persp_move_far(mat4 proj, float deltaFar) {
float fn, farVal, nearVal, p22, p32;
p22 = proj[2][2];
p32 = proj[3][2];
nearVal = p32 / (p22 - 1.0f);
farVal = p32 / (p22 + 1.0f) + deltaFar;
fn = 1.0f / (nearVal - farVal);
proj[2][2] = (nearVal + farVal) * fn;
proj[3][2] = 2.0f * nearVal * farVal * fn;
}
/*!
* @brief set up perspective projection matrix with default near/far
* and angle values
@@ -320,13 +344,11 @@ glm_lookat(vec3 eye,
mat4 dest) {
CGLM_ALIGN(8) vec3 f, u, s;
glm_vec_sub(center, eye, f);
glm_vec_normalize(f);
glm_vec3_sub(center, eye, f);
glm_vec3_normalize(f);
glm_vec_cross(f, up, s);
glm_vec_normalize(s);
glm_vec_cross(s, f, u);
glm_vec3_crossn(f, up, s);
glm_vec3_cross(s, f, u);
dest[0][0] = s[0];
dest[0][1] = u[0];
@@ -337,9 +359,9 @@ glm_lookat(vec3 eye,
dest[2][0] = s[2];
dest[2][1] = u[2];
dest[2][2] =-f[2];
dest[3][0] =-glm_vec_dot(s, eye);
dest[3][1] =-glm_vec_dot(u, eye);
dest[3][2] = glm_vec_dot(f, eye);
dest[3][0] =-glm_vec3_dot(s, eye);
dest[3][1] =-glm_vec3_dot(u, eye);
dest[3][2] = glm_vec3_dot(f, eye);
dest[0][3] = dest[1][3] = dest[2][3] = 0.0f;
dest[3][3] = 1.0f;
}
@@ -362,7 +384,7 @@ CGLM_INLINE
void
glm_look(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
CGLM_ALIGN(8) vec3 target;
glm_vec_add(eye, dir, target);
glm_vec3_add(eye, dir, target);
glm_lookat(eye, target, up, dest);
}
@@ -380,7 +402,7 @@ CGLM_INLINE
void
glm_look_anyup(vec3 eye, vec3 dir, mat4 dest) {
CGLM_ALIGN(8) vec3 up;
glm_vec_ortho(dir, up);
glm_vec3_ortho(dir, up);
glm_look(eye, dir, up, dest);
}

12
include/cglm/frustum.h
View File

@@ -106,7 +106,7 @@ glm_frustum_planes(mat4 m, vec4 dest[6]) {
*
* Find center coordinates:
* for (j = 0; j < 4; j++) {
* glm_vec_center(corners[i], corners[i + 4], centerCorners[i]);
* glm_vec3_center(corners[i], corners[i + 4], centerCorners[i]);
* }
*
* @param[in] invMat matrix (see brief)
@@ -187,8 +187,8 @@ glm_frustum_box(vec4 corners[8], mat4 m, vec3 box[2]) {
vec3 min, max;
int i;
glm_vec_broadcast(FLT_MAX, min);
glm_vec_broadcast(-FLT_MAX, max);
glm_vec3_broadcast(FLT_MAX, min);
glm_vec3_broadcast(-FLT_MAX, max);
for (i = 0; i < 8; i++) {
glm_mat4_mulv(m, corners[i], v);
@@ -202,8 +202,8 @@ glm_frustum_box(vec4 corners[8], mat4 m, vec3 box[2]) {
max[2] = glm_max(max[2], v[2]);
}
glm_vec_copy(min, box[0]);
glm_vec_copy(max, box[1]);
glm_vec3_copy(min, box[0]);
glm_vec3_copy(max, box[1]);
}
/*!
@@ -228,7 +228,7 @@ glm_frustum_corners_at(vec4 corners[8],
float dist, sc;
/* because distance and scale is same for all */
dist = glm_vec_distance(corners[GLM_RTF], corners[GLM_RTN]);
dist = glm_vec3_distance(corners[GLM_RTF], corners[GLM_RTN]);
sc = dist * (splitDist / farDist);
/* left bottom */

19
include/cglm/mat3.h
View File

@@ -21,6 +21,7 @@
CGLM_INLINE void glm_mat3_transpose_to(mat3 m, mat3 dest);
CGLM_INLINE void glm_mat3_transpose(mat3 m);
CGLM_INLINE void glm_mat3_mulv(mat3 m, vec3 v, vec3 dest);
CGLM_INLINE float glm_mat3_trace(mat3 m);
CGLM_INLINE void glm_mat3_scale(mat3 m, float s);
CGLM_INLINE float glm_mat3_det(mat3 mat);
CGLM_INLINE void glm_mat3_inv(mat3 mat, mat3 dest);
@@ -207,6 +208,18 @@ glm_mat3_mulv(mat3 m, vec3 v, vec3 dest) {
dest[2] = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2];
}
/*!
* @brief trace of matrix
*
* sum of the elements on the main diagonal from upper left to the lower right
*
* @param[in] m matrix
*/
CGLM_INLINE
float
glm_mat3_trace(mat3 m) {
return m[0][0] + m[1][1] + m[2][2];
}
/*!
* @brief convert mat3 to quaternion
@@ -330,9 +343,9 @@ CGLM_INLINE
void
glm_mat3_swap_col(mat3 mat, int col1, int col2) {
vec3 tmp;
glm_vec_copy(mat[col1], tmp);
glm_vec_copy(mat[col2], mat[col1]);
glm_vec_copy(tmp, mat[col2]);
glm_vec3_copy(mat[col1], tmp);
glm_vec3_copy(mat[col2], mat[col1]);
glm_vec3_copy(tmp, mat[col2]);
}
/*!

30
include/cglm/mat4.h
View File

@@ -16,8 +16,6 @@
GLM_MAT4_ZERO_INIT
GLM_MAT4_IDENTITY
GLM_MAT4_ZERO
glm_mat4_udup(mat, dest)
glm_mat4_dup(mat, dest)
Functions:
CGLM_INLINE void glm_mat4_ucopy(mat4 mat, mat4 dest);
@@ -31,6 +29,8 @@
CGLM_INLINE void glm_mat4_mulN(mat4 *matrices[], int len, mat4 dest);
CGLM_INLINE void glm_mat4_mulv(mat4 m, vec4 v, vec4 dest);
CGLM_INLINE void glm_mat4_mulv3(mat4 m, vec3 v, vec3 dest);
CGLM_INLINE float glm_mat4_trace(mat4 m);
CGLM_INLINE float glm_mat4_trace3(mat4 m);
CGLM_INLINE void glm_mat4_transpose_to(mat4 m, mat4 dest);
CGLM_INLINE void glm_mat4_transpose(mat4 m);
CGLM_INLINE void glm_mat4_scale_p(mat4 m, float s);
@@ -340,6 +340,32 @@ glm_mat4_mulv(mat4 m, vec4 v, vec4 dest) {
#endif
}
/*!
* @brief trace of matrix
*
* sum of the elements on the main diagonal from upper left to the lower right
*
* @param[in] m matrix
*/
CGLM_INLINE
float
glm_mat4_trace(mat4 m) {
return m[0][0] + m[1][1] + m[2][2] + m[3][3];
}
/*!
* @brief trace of matrix (rotation part)
*
* sum of the elements on the main diagonal from upper left to the lower right
*
* @param[in] m matrix
*/
CGLM_INLINE
float
glm_mat4_trace3(mat4 m) {
return m[0][0] + m[1][1] + m[2][2];
}
/*!
* @brief convert mat4's rotation part to quaternion
*

2
include/cglm/plane.h
View File

@@ -30,7 +30,7 @@
CGLM_INLINE
void
glm_plane_normalize(vec4 plane) {
glm_vec4_scale(plane, 1.0f / glm_vec_norm(plane), plane);
glm_vec4_scale(plane, 1.0f / glm_vec3_norm(plane), plane);
}
#endif /* cglm_plane_h */

32
include/cglm/quat.h
View File

@@ -19,7 +19,7 @@
CGLM_INLINE float glm_quat_norm(versor q);
CGLM_INLINE void glm_quat_normalize(versor q);
CGLM_INLINE void glm_quat_normalize_to(versor q, versor dest);
CGLM_INLINE float glm_quat_dot(versor q1, versor q2);
CGLM_INLINE float glm_quat_dot(versor p, versor q);
CGLM_INLINE void glm_quat_conjugate(versor q, versor dest);
CGLM_INLINE void glm_quat_inv(versor q, versor dest);
CGLM_INLINE void glm_quat_add(versor p, versor q, versor dest);
@@ -273,7 +273,7 @@ glm_quat_dot(versor p, versor q) {
CGLM_INLINE
void
glm_quat_conjugate(versor q, versor dest) {
glm_vec4_flipsign_to(q, dest);
glm_vec4_negate_to(q, dest);
dest[3] = -dest[3];
}
@@ -286,7 +286,7 @@ glm_quat_conjugate(versor q, versor dest) {
CGLM_INLINE
void
glm_quat_inv(versor q, versor dest) {
CGLM_ALIGN(8) versor conj;
CGLM_ALIGN(16) versor conj;
glm_quat_conjugate(q, conj);
glm_vec4_scale(conj, 1.0f / glm_vec4_norm2(q), dest);
}
@@ -361,7 +361,7 @@ glm_quat_imagn(versor q, vec3 dest) {
CGLM_INLINE
float
glm_quat_imaglen(versor q) {
return glm_vec_norm(q);
return glm_vec3_norm(q);
}
/*!
@@ -634,7 +634,7 @@ glm_quat_slerp(versor from, versor to, float t, versor dest) {
}
if (cosTheta < 0.0f) {
glm_vec4_flipsign(q1);
glm_vec4_negate(q1);
cosTheta = -cosTheta;
}
@@ -670,7 +670,7 @@ glm_quat_look(vec3 eye, versor ori, mat4 dest) {
/* translate */
glm_mat4_mulv3(dest, eye, 1.0f, dest[3]);
glm_vec_flipsign(dest[3]);
glm_vec3_negate(dest[3]);
}
/*!
@@ -687,7 +687,7 @@ glm_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest) {
CGLM_ALIGN(8) vec3 axis;
float dot, angle;
dot = glm_vec_dot(dir, fwd);
dot = glm_vec3_dot(dir, fwd);
if (fabsf(dot + 1.0f) < 0.000001f) {
glm_quat_init(dest, up[0], up[1], up[2], GLM_PIf);
return;
@@ -719,7 +719,7 @@ CGLM_INLINE
void
glm_quat_forp(vec3 from, vec3 to, vec3 fwd, vec3 up, versor dest) {
CGLM_ALIGN(8) vec3 dir;
glm_vec_sub(to, from, dir);
glm_vec3_sub(to, from, dir);
glm_quat_for(dir, fwd, up, dest);
}
@@ -741,14 +741,14 @@ glm_quat_rotatev(versor q, vec3 v, vec3 dest) {
glm_quat_imag(p, u);
s = glm_quat_real(p);
glm_vec_scale(u, 2.0f * glm_vec_dot(u, v), v1);
glm_vec_scale(v, s * s - glm_vec_dot(u, u), v2);
glm_vec_add(v1, v2, v1);
glm_vec3_scale(u, 2.0f * glm_vec3_dot(u, v), v1);
glm_vec3_scale(v, s * s - glm_vec3_dot(u, u), v2);
glm_vec3_add(v1, v2, v1);
glm_vec_cross(u, v, v2);
glm_vec_scale(v2, 2.0f * s, v2);
glm_vec3_cross(u, v, v2);
glm_vec3_scale(v2, 2.0f * s, v2);
glm_vec_add(v1, v2, dest);
glm_vec3_add(v1, v2, dest);
}
/*!
@@ -778,7 +778,7 @@ void
glm_quat_rotate_at(mat4 m, versor q, vec3 pivot) {
CGLM_ALIGN(8) vec3 pivotInv;
glm_vec_inv_to(pivot, pivotInv);
glm_vec3_negate_to(pivot, pivotInv);
glm_translate(m, pivot);
glm_quat_rotate(m, q, m);
@@ -802,7 +802,7 @@ void
glm_quat_rotate_atm(mat4 m, versor q, vec3 pivot) {
CGLM_ALIGN(8) vec3 pivotInv;
glm_vec_inv_to(pivot, pivotInv);
glm_vec3_negate_to(pivot, pivotInv);
glm_translate_make(m, pivot);
glm_quat_rotate(m, q, m);

8
include/cglm/sphere.h
View File

@@ -60,13 +60,13 @@ void
glm_sphere_merge(vec4 s1, vec4 s2, vec4 dest) {
float dist, radii;
dist = glm_vec_distance(s1, s2);
dist = glm_vec3_distance(s1, s2);
radii = dist + s1[3] + s2[3];
radii = glm_max(radii, s1[3]);
radii = glm_max(radii, s2[3]);
glm_vec_center(s1, s2, dest);
glm_vec3_center(s1, s2, dest);
dest[3] = radii;
}
@@ -79,7 +79,7 @@ glm_sphere_merge(vec4 s1, vec4 s2, vec4 dest) {
CGLM_INLINE
bool
glm_sphere_sphere(vec4 s1, vec4 s2) {
return glm_vec_distance2(s1, s2) <= glm_pow2(s1[3] + s2[3]);
return glm_vec3_distance2(s1, s2) <= glm_pow2(s1[3] + s2[3]);
}
/*!
@@ -93,7 +93,7 @@ bool
glm_sphere_point(vec4 s, vec3 point) {
float rr;
rr = s[3] * s[3];
return glm_vec_distance2(point, s) <= rr;
return glm_vec3_distance2(point, s) <= rr;
}
#endif /* cglm_sphere_h */

20
include/cglm/types.h
View File

@@ -10,12 +10,12 @@
#if defined(_MSC_VER)
/* do not use alignment for older visual studio versions */
#if _MSC_VER < 1913 /* Visual Studio 2017 version 15.6 */
# define CGLM_ALL_UNALIGNED
# define CGLM_ALIGN(X) /* no alignment */
#else
# define CGLM_ALIGN(X) __declspec(align(X))
#endif
# if _MSC_VER < 1913 /* Visual Studio 2017 version 15.6 */
# define CGLM_ALL_UNALIGNED
# define CGLM_ALIGN(X) /* no alignment */
# else
# define CGLM_ALIGN(X) __declspec(align(X))
# endif
#else
# define CGLM_ALIGN(X) __attribute((aligned(X)))
#endif
@@ -33,20 +33,18 @@
#endif
typedef float vec2[2];
typedef CGLM_ALIGN_IF(8) float vec3[3];
typedef float vec3[3];
typedef int ivec3[3];
typedef CGLM_ALIGN_IF(16) float vec4[4];
typedef vec4 versor;
typedef vec3 mat3[3];
#ifdef __AVX__
typedef CGLM_ALIGN_IF(32) vec3 mat3[3];
typedef CGLM_ALIGN_IF(32) vec4 mat4[4];
#else
typedef vec3 mat3[3];
typedef CGLM_ALIGN_IF(16) vec4 mat4[4];
#endif
typedef vec4 versor;
#define GLM_E 2.71828182845904523536028747135266250 /* e */
#define GLM_LOG2E 1.44269504088896340735992468100189214 /* log2(e) */
#define GLM_LOG10E 0.434294481903251827651128918916605082 /* log10(e) */

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

@@ -11,15 +11,19 @@
/*
Functions:
CGLM_INLINE void glm_vec_mulv(vec3 a, vec3 b, vec3 d);
CGLM_INLINE void glm_vec_broadcast(float val, vec3 d);
CGLM_INLINE bool glm_vec_eq(vec3 v, float val);
CGLM_INLINE bool glm_vec_eq_eps(vec3 v, float val);
CGLM_INLINE bool glm_vec_eq_all(vec3 v);
CGLM_INLINE bool glm_vec_eqv(vec3 v1, vec3 v2);
CGLM_INLINE bool glm_vec_eqv_eps(vec3 v1, vec3 v2);
CGLM_INLINE float glm_vec_max(vec3 v);
CGLM_INLINE float glm_vec_min(vec3 v);
CGLM_INLINE void glm_vec3_broadcast(float val, vec3 d);
CGLM_INLINE bool glm_vec3_eq(vec3 v, float val);
CGLM_INLINE bool glm_vec3_eq_eps(vec3 v, float val);
CGLM_INLINE bool glm_vec3_eq_all(vec3 v);
CGLM_INLINE bool glm_vec3_eqv(vec3 a, vec3 b);
CGLM_INLINE bool glm_vec3_eqv_eps(vec3 a, vec3 b);
CGLM_INLINE float glm_vec3_max(vec3 v);
CGLM_INLINE float glm_vec3_min(vec3 v);
CGLM_INLINE bool glm_vec3_isnan(vec3 v);
CGLM_INLINE bool glm_vec3_isinf(vec3 v);
CGLM_INLINE bool glm_vec3_isvalid(vec3 v);
CGLM_INLINE void glm_vec3_sign(vec3 v, vec3 dest);
CGLM_INLINE void glm_vec3_sqrt(vec3 v, vec3 dest);
*/
#ifndef cglm_vec3_ext_h
@@ -31,21 +35,6 @@
#include <math.h>
#include <float.h>
/*!
* @brief DEPRECATED! use glm_vec_mul
*
* @param[in] a vec1
* @param[in] b vec2
* @param[out] d vec3 = (v1[0] * v2[0], v1[1] * v2[1], v1[2] * v2[2])
*/
CGLM_INLINE
void
glm_vec_mulv(vec3 a, vec3 b, vec3 d) {
d[0] = a[0] * b[0];
d[1] = a[1] * b[1];
d[2] = a[2] * b[2];
}
/*!
* @brief fill a vector with specified value
*
@@ -54,7 +43,7 @@ glm_vec_mulv(vec3 a, vec3 b, vec3 d) {
*/
CGLM_INLINE
void
glm_vec_broadcast(float val, vec3 d) {
glm_vec3_broadcast(float val, vec3 d) {
d[0] = d[1] = d[2] = val;
}
@@ -66,7 +55,7 @@ glm_vec_broadcast(float val, vec3 d) {
*/
CGLM_INLINE
bool
glm_vec_eq(vec3 v, float val) {
glm_vec3_eq(vec3 v, float val) {
return v[0] == val && v[0] == v[1] && v[0] == v[2];
}
@@ -78,7 +67,7 @@ glm_vec_eq(vec3 v, float val) {
*/
CGLM_INLINE
bool
glm_vec_eq_eps(vec3 v, float val) {
glm_vec3_eq_eps(vec3 v, float val) {
return fabsf(v[0] - val) <= FLT_EPSILON
&& fabsf(v[1] - val) <= FLT_EPSILON
&& fabsf(v[2] - val) <= FLT_EPSILON;
@@ -91,36 +80,36 @@ glm_vec_eq_eps(vec3 v, float val) {
*/
CGLM_INLINE
bool
glm_vec_eq_all(vec3 v) {
glm_vec3_eq_all(vec3 v) {
return v[0] == v[1] && v[0] == v[2];
}
/*!
* @brief check if vector is equal to another (without epsilon)
*
* @param[in] v1 vector
* @param[in] v2 vector
* @param[in] a vector
* @param[in] b vector
*/
CGLM_INLINE
bool
glm_vec_eqv(vec3 v1, vec3 v2) {
return v1[0] == v2[0]
&& v1[1] == v2[1]
&& v1[2] == v2[2];
glm_vec3_eqv(vec3 a, vec3 b) {
return a[0] == b[0]
&& a[1] == b[1]
&& a[2] == b[2];
}
/*!
* @brief check if vector is equal to another (with epsilon)
*
* @param[in] v1 vector
* @param[in] v2 vector
* @param[in] a vector
* @param[in] b vector
*/
CGLM_INLINE
bool
glm_vec_eqv_eps(vec3 v1, vec3 v2) {
return fabsf(v1[0] - v2[0]) <= FLT_EPSILON
&& fabsf(v1[1] - v2[1]) <= FLT_EPSILON
&& fabsf(v1[2] - v2[2]) <= FLT_EPSILON;
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;
}
/*!
@@ -130,7 +119,7 @@ glm_vec_eqv_eps(vec3 v1, vec3 v2) {
*/
CGLM_INLINE
float
glm_vec_max(vec3 v) {
glm_vec3_max(vec3 v) {
float max;
max = v[0];
@@ -149,7 +138,7 @@ glm_vec_max(vec3 v) {
*/
CGLM_INLINE
float
glm_vec_min(vec3 v) {
glm_vec3_min(vec3 v) {
float min;
min = v[0];
@@ -169,7 +158,7 @@ glm_vec_min(vec3 v) {
*/
CGLM_INLINE
bool
glm_vec_isnan(vec3 v) {
glm_vec3_isnan(vec3 v) {
return isnan(v[0]) || isnan(v[1]) || isnan(v[2]);
}
@@ -181,7 +170,7 @@ glm_vec_isnan(vec3 v) {
*/
CGLM_INLINE
bool
glm_vec_isinf(vec3 v) {
glm_vec3_isinf(vec3 v) {
return isinf(v[0]) || isinf(v[1]) || isinf(v[2]);
}
@@ -193,8 +182,8 @@ glm_vec_isinf(vec3 v) {
*/
CGLM_INLINE
bool
glm_vec_isvalid(vec3 v) {
return !glm_vec_isnan(v) && !glm_vec_isinf(v);
glm_vec3_isvalid(vec3 v) {
return !glm_vec3_isnan(v) && !glm_vec3_isinf(v);
}
/*!
@@ -206,7 +195,7 @@ glm_vec_isvalid(vec3 v) {
*/
CGLM_INLINE
void
glm_vec_sign(vec3 v, vec3 dest) {
glm_vec3_sign(vec3 v, vec3 dest) {
dest[0] = glm_signf(v[0]);
dest[1] = glm_signf(v[1]);
dest[2] = glm_signf(v[2]);
@@ -220,7 +209,7 @@ glm_vec_sign(vec3 v, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec_sqrt(vec3 v, vec3 dest) {
glm_vec3_sqrt(vec3 v, vec3 dest) {
dest[0] = sqrtf(v[0]);
dest[1] = sqrtf(v[1]);
dest[2] = sqrtf(v[2]);

413
include/cglm/vec3.h
View File

@@ -5,14 +5,8 @@
* Full license can be found in the LICENSE file
*/
/*!
* vec3 functions dont have suffix e.g glm_vec_dot (not glm_vec3_dot)
* all functions without suffix are vec3 functions
*/
/*
Macros:
glm_vec_dup(v, dest)
GLM_VEC3_ONE_INIT
GLM_VEC3_ZERO_INIT
GLM_VEC3_ONE
@@ -23,44 +17,64 @@
Functions:
CGLM_INLINE void glm_vec3(vec4 v4, vec3 dest);
CGLM_INLINE void glm_vec_copy(vec3 a, vec3 dest);
CGLM_INLINE float glm_vec_dot(vec3 a, vec3 b);
CGLM_INLINE void glm_vec_cross(vec3 a, vec3 b, vec3 d);
CGLM_INLINE float glm_vec_norm2(vec3 v);
CGLM_INLINE float glm_vec_norm(vec3 vec);
CGLM_INLINE void glm_vec_add(vec3 a, vec3 b, vec3 dest);
CGLM_INLINE void glm_vec_adds(vec3 a, float s, vec3 dest);
CGLM_INLINE void glm_vec_sub(vec3 a, vec3 b, vec3 dest);
CGLM_INLINE void glm_vec_subs(vec3 a, float s, vec3 dest);
CGLM_INLINE void glm_vec_mul(vec3 a, vec3 b, vec3 dest);
CGLM_INLINE void glm_vec_scale(vec3 v, float s, vec3 dest);
CGLM_INLINE void glm_vec_scale_as(vec3 v, float s, vec3 dest);
CGLM_INLINE void glm_vec_div(vec3 a, vec3 b, vec3 dest);
CGLM_INLINE void glm_vec_divs(vec3 a, float s, vec3 dest);
CGLM_INLINE void glm_vec_addadd(vec3 a, vec3 b, vec3 dest);
CGLM_INLINE void glm_vec_subadd(vec3 a, vec3 b, vec3 dest);
CGLM_INLINE void glm_vec_muladd(vec3 a, vec3 b, vec3 dest);
CGLM_INLINE void glm_vec_flipsign(vec3 v);
CGLM_INLINE void glm_vec_inv(vec3 v);
CGLM_INLINE void glm_vec_inv_to(vec3 v, vec3 dest);
CGLM_INLINE void glm_vec_normalize(vec3 v);
CGLM_INLINE void glm_vec_normalize_to(vec3 vec, vec3 dest);
CGLM_INLINE float glm_vec_distance(vec3 v1, vec3 v2);
CGLM_INLINE float glm_vec_angle(vec3 v1, vec3 v2);
CGLM_INLINE void glm_vec_rotate(vec3 v, float angle, vec3 axis);
CGLM_INLINE void glm_vec_rotate_m4(mat4 m, vec3 v, vec3 dest);
CGLM_INLINE void glm_vec_proj(vec3 a, vec3 b, vec3 dest);
CGLM_INLINE void glm_vec_center(vec3 v1, vec3 v2, vec3 dest);
CGLM_INLINE void glm_vec_maxv(vec3 v1, vec3 v2, vec3 dest);
CGLM_INLINE void glm_vec_minv(vec3 v1, vec3 v2, vec3 dest);
CGLM_INLINE void glm_vec_ortho(vec3 v, vec3 dest);
CGLM_INLINE void glm_vec_clamp(vec3 v, float minVal, float maxVal);
CGLM_INLINE void glm_vec3_copy(vec3 a, vec3 dest);
CGLM_INLINE void glm_vec3_zero(vec3 v);
CGLM_INLINE void glm_vec3_one(vec3 v);
CGLM_INLINE float glm_vec3_dot(vec3 a, vec3 b);
CGLM_INLINE float glm_vec3_norm2(vec3 v);
CGLM_INLINE float glm_vec3_norm(vec3 v);
CGLM_INLINE void glm_vec3_add(vec3 a, vec3 b, vec3 dest);
CGLM_INLINE void glm_vec3_adds(vec3 a, float s, vec3 dest);
CGLM_INLINE void glm_vec3_sub(vec3 a, vec3 b, vec3 dest);
CGLM_INLINE void glm_vec3_subs(vec3 a, float s, vec3 dest);
CGLM_INLINE void glm_vec3_mul(vec3 a, vec3 b, vec3 dest);
CGLM_INLINE void glm_vec3_scale(vec3 v, float s, vec3 dest);
CGLM_INLINE void glm_vec3_scale_as(vec3 v, float s, vec3 dest);
CGLM_INLINE void glm_vec3_div(vec3 a, vec3 b, vec3 dest);
CGLM_INLINE void glm_vec3_divs(vec3 a, float s, vec3 dest);
CGLM_INLINE void glm_vec3_addadd(vec3 a, vec3 b, vec3 dest);
CGLM_INLINE void glm_vec3_subadd(vec3 a, vec3 b, vec3 dest);
CGLM_INLINE void glm_vec3_muladd(vec3 a, vec3 b, vec3 dest);
CGLM_INLINE void glm_vec3_muladds(vec3 a, float s, vec3 dest);
CGLM_INLINE void glm_vec3_maxadd(vec3 a, vec3 b, vec3 dest);
CGLM_INLINE void glm_vec3_minadd(vec3 a, vec3 b, vec3 dest);
CGLM_INLINE void glm_vec3_flipsign(vec3 v);
CGLM_INLINE void glm_vec3_flipsign_to(vec3 v, vec3 dest);
CGLM_INLINE void glm_vec3_negate_to(vec3 v, vec3 dest);
CGLM_INLINE void glm_vec3_negate(vec3 v);
CGLM_INLINE void glm_vec3_inv(vec3 v);
CGLM_INLINE void glm_vec3_inv_to(vec3 v, vec3 dest);
CGLM_INLINE void glm_vec3_normalize(vec3 v);
CGLM_INLINE void glm_vec3_normalize_to(vec3 v, vec3 dest);
CGLM_INLINE void glm_vec3_cross(vec3 a, vec3 b, vec3 d);
CGLM_INLINE void glm_vec3_crossn(vec3 a, vec3 b, vec3 dest);
CGLM_INLINE float glm_vec3_distance(vec3 a, vec3 b);
CGLM_INLINE float glm_vec3_angle(vec3 a, vec3 b);
CGLM_INLINE void glm_vec3_rotate(vec3 v, float angle, vec3 axis);
CGLM_INLINE void glm_vec3_rotate_m4(mat4 m, vec3 v, vec3 dest);
CGLM_INLINE void glm_vec3_rotate_m3(mat3 m, vec3 v, vec3 dest);
CGLM_INLINE void glm_vec3_proj(vec3 a, vec3 b, vec3 dest);
CGLM_INLINE void glm_vec3_center(vec3 a, vec3 b, vec3 dest);
CGLM_INLINE float glm_vec3_distance2(vec3 a, vec3 b);
CGLM_INLINE void glm_vec3_maxv(vec3 a, vec3 b, vec3 dest);
CGLM_INLINE void glm_vec3_minv(vec3 a, vec3 b, vec3 dest);
CGLM_INLINE void glm_vec3_ortho(vec3 v, vec3 dest);
CGLM_INLINE void glm_vec3_clamp(vec3 v, float minVal, float maxVal);
CGLM_INLINE void glm_vec3_lerp(vec3 from, vec3 to, float t, vec3 dest);
Convenient:
CGLM_INLINE void glm_cross(vec3 a, vec3 b, vec3 d);
CGLM_INLINE float glm_dot(vec3 a, vec3 b);
CGLM_INLINE void glm_normalize(vec3 v);
CGLM_INLINE void glm_normalize_to(vec3 v, vec3 dest);
DEPRECATED:
glm_vec3_dup
glm_vec3_flipsign
glm_vec3_flipsign_to
glm_vec3_inv
glm_vec3_inv_to
glm_vec3_mulv
*/
#ifndef cglm_vec3_h
@@ -72,7 +86,12 @@
#include "util.h"
/* DEPRECATED! use _copy, _ucopy versions */
#define glm_vec_dup(v, dest) glm_vec_copy(v, dest)
#define glm_vec3_dup(v, dest) glm_vec3_copy(v, dest)
#define glm_vec3_flipsign(v) glm_vec3_negate(v)
#define glm_vec3_flipsign_to(v, dest) glm_vec3_negate_to(v, dest)
#define glm_vec3_inv(v) glm_vec3_negate(v)
#define glm_vec3_inv_to(v, dest) glm_vec3_negate_to(v, dest)
#define glm_vec3_mulv(a, b, d) glm_vec3_mul(a, b, d)
#define GLM_VEC3_ONE_INIT {1.0f, 1.0f, 1.0f}
#define GLM_VEC3_ZERO_INIT {0.0f, 0.0f, 0.0f}
@@ -106,7 +125,7 @@ glm_vec3(vec4 v4, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec_copy(vec3 a, vec3 dest) {
glm_vec3_copy(vec3 a, vec3 dest) {
dest[0] = a[0];
dest[1] = a[1];
dest[2] = a[2];
@@ -119,10 +138,8 @@ glm_vec_copy(vec3 a, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec_zero(vec3 v) {
v[0] = 0.0f;
v[1] = 0.0f;
v[2] = 0.0f;
glm_vec3_zero(vec3 v) {
v[0] = v[1] = v[2] = 0.0f;
}
/*!
@@ -132,10 +149,8 @@ glm_vec_zero(vec3 v) {
*/
CGLM_INLINE
void
glm_vec_one(vec3 v) {
v[0] = 1.0f;
v[1] = 1.0f;
v[2] = 1.0f;
glm_vec3_one(vec3 v) {
v[0] = v[1] = v[2] = 1.0f;
}
/*!
@@ -148,26 +163,10 @@ glm_vec_one(vec3 v) {
*/
CGLM_INLINE
float
glm_vec_dot(vec3 a, vec3 b) {
glm_vec3_dot(vec3 a, vec3 b) {
return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
}
/*!
* @brief vec3 cross product
*
* @param[in] a source 1
* @param[in] b source 2
* @param[out] d destination
*/
CGLM_INLINE
void
glm_vec_cross(vec3 a, vec3 b, vec3 d) {
/* (u2.v3 - u3.v2, u3.v1 - u1.v3, u1.v2 - u2.v1) */
d[0] = a[1] * b[2] - a[2] * b[1];
d[1] = a[2] * b[0] - a[0] * b[2];
d[2] = a[0] * b[1] - a[1] * b[0];
}
/*!
* @brief norm * norm (magnitude) of vec
*
@@ -181,21 +180,21 @@ glm_vec_cross(vec3 a, vec3 b, vec3 d) {
*/
CGLM_INLINE
float
glm_vec_norm2(vec3 v) {
return glm_vec_dot(v, v);
glm_vec3_norm2(vec3 v) {
return glm_vec3_dot(v, v);
}
/*!
* @brief norm (magnitude) of vec3
*
* @param[in] vec vector
* @param[in] v vector
*
* @return norm
*/
CGLM_INLINE
float
glm_vec_norm(vec3 vec) {
return sqrtf(glm_vec_norm2(vec));
glm_vec3_norm(vec3 v) {
return sqrtf(glm_vec3_norm2(v));
}
/*!
@@ -207,7 +206,7 @@ glm_vec_norm(vec3 vec) {
*/
CGLM_INLINE
void
glm_vec_add(vec3 a, vec3 b, vec3 dest) {
glm_vec3_add(vec3 a, vec3 b, vec3 dest) {
dest[0] = a[0] + b[0];
dest[1] = a[1] + b[1];
dest[2] = a[2] + b[2];
@@ -222,14 +221,14 @@ glm_vec_add(vec3 a, vec3 b, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec_adds(vec3 v, float s, vec3 dest) {
glm_vec3_adds(vec3 v, float s, vec3 dest) {
dest[0] = v[0] + s;
dest[1] = v[1] + s;
dest[2] = v[2] + s;
}
/*!
* @brief subtract v2 vector from v1 vector store result in dest
* @brief subtract b vector from a vector store result in dest
*
* @param[in] a vector1
* @param[in] b vector2
@@ -237,7 +236,7 @@ glm_vec_adds(vec3 v, float s, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec_sub(vec3 a, vec3 b, vec3 dest) {
glm_vec3_sub(vec3 a, vec3 b, vec3 dest) {
dest[0] = a[0] - b[0];
dest[1] = a[1] - b[1];
dest[2] = a[2] - b[2];
@@ -252,7 +251,7 @@ glm_vec_sub(vec3 a, vec3 b, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec_subs(vec3 v, float s, vec3 dest) {
glm_vec3_subs(vec3 v, float s, vec3 dest) {
dest[0] = v[0] - s;
dest[1] = v[1] - s;
dest[2] = v[2] - s;
@@ -261,16 +260,16 @@ glm_vec_subs(vec3 v, float s, vec3 dest) {
/*!
* @brief multiply two vector (component-wise multiplication)
*
* @param a v1
* @param b v2
* @param d v3 = (a[0] * b[0], a[1] * b[1], a[2] * b[2])
* @param a vector1
* @param b vector2
* @param dest v3 = (a[0] * b[0], a[1] * b[1], a[2] * b[2])
*/
CGLM_INLINE
void
glm_vec_mul(vec3 a, vec3 b, vec3 d) {
d[0] = a[0] * b[0];
d[1] = a[1] * b[1];
d[2] = a[2] * b[2];
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];
}
/*!
@@ -282,7 +281,7 @@ glm_vec_mul(vec3 a, vec3 b, vec3 d) {
*/
CGLM_INLINE
void
glm_vec_scale(vec3 v, float s, vec3 dest) {
glm_vec3_scale(vec3 v, float s, vec3 dest) {
dest[0] = v[0] * s;
dest[1] = v[1] * s;
dest[2] = v[2] * s;
@@ -297,16 +296,16 @@ glm_vec_scale(vec3 v, float s, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec_scale_as(vec3 v, float s, vec3 dest) {
glm_vec3_scale_as(vec3 v, float s, vec3 dest) {
float norm;
norm = glm_vec_norm(v);
norm = glm_vec3_norm(v);
if (norm == 0.0f) {
glm_vec_zero(dest);
glm_vec3_zero(dest);
return;
}
glm_vec_scale(v, s / norm, dest);
glm_vec3_scale(v, s / norm, dest);
}
/*!
@@ -318,7 +317,7 @@ glm_vec_scale_as(vec3 v, float s, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec_div(vec3 a, vec3 b, vec3 dest) {
glm_vec3_div(vec3 a, vec3 b, vec3 dest) {
dest[0] = a[0] / b[0];
dest[1] = a[1] / b[1];
dest[2] = a[2] / b[2];
@@ -333,7 +332,7 @@ glm_vec_div(vec3 a, vec3 b, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec_divs(vec3 v, float s, vec3 dest) {
glm_vec3_divs(vec3 v, float s, vec3 dest) {
dest[0] = v[0] / s;
dest[1] = v[1] / s;
dest[2] = v[2] / s;
@@ -350,7 +349,7 @@ glm_vec_divs(vec3 v, float s, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec_addadd(vec3 a, vec3 b, vec3 dest) {
glm_vec3_addadd(vec3 a, vec3 b, vec3 dest) {
dest[0] += a[0] + b[0];
dest[1] += a[1] + b[1];
dest[2] += a[2] + b[2];
@@ -367,7 +366,7 @@ glm_vec_addadd(vec3 a, vec3 b, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec_subadd(vec3 a, vec3 b, vec3 dest) {
glm_vec3_subadd(vec3 a, vec3 b, vec3 dest) {
dest[0] += a[0] - b[0];
dest[1] += a[1] - b[1];
dest[2] += a[2] - b[2];
@@ -384,7 +383,7 @@ glm_vec_subadd(vec3 a, vec3 b, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec_muladd(vec3 a, vec3 b, vec3 dest) {
glm_vec3_muladd(vec3 a, vec3 b, vec3 dest) {
dest[0] += a[0] * b[0];
dest[1] += a[1] * b[1];
dest[2] += a[2] * b[2];
@@ -401,60 +400,69 @@ glm_vec_muladd(vec3 a, vec3 b, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec_muladds(vec3 a, float s, vec3 dest) {
glm_vec3_muladds(vec3 a, float s, vec3 dest) {
dest[0] += a[0] * s;
dest[1] += a[1] * s;
dest[2] += a[2] * s;
}
/*!
* @brief flip sign of all vec3 members
* @brief add max of two vector to result/dest
*
* @param[in, out] v vector
* it applies += operator so dest must be initialized
*
* @param[in] a vector 1
* @param[in] b vector 2
* @param[out] dest dest += max(a, b)
*/
CGLM_INLINE
void
glm_vec_flipsign(vec3 v) {
v[0] = -v[0];
v[1] = -v[1];
v[2] = -v[2];
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]);
}
/*!
* @brief flip sign of all vec3 members and store result in dest
* @brief add min of two vector to result/dest
*
* it applies += operator so dest must be initialized
*
* @param[in] a vector
* @param[in] b scalar
* @param[out] dest dest += min(a, b)
*/
CGLM_INLINE
void
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]);
}
/*!
* @brief negate vector components and store result in dest
*
* @param[in] v vector
* @param[out] dest result vector
*/
CGLM_INLINE
void
glm_vec_flipsign_to(vec3 v, vec3 dest) {
glm_vec3_negate_to(vec3 v, vec3 dest) {
dest[0] = -v[0];
dest[1] = -v[1];
dest[2] = -v[2];
}
/*!
* @brief make vector as inverse/opposite of itself
* @brief negate vector components
*
* @param[in, out] v vector
*/
CGLM_INLINE
void
glm_vec_inv(vec3 v) {
glm_vec_flipsign(v);
}
/*!
* @brief inverse/opposite vector
*
* @param[in] v source
* @param[out] dest destination
*/
CGLM_INLINE
void
glm_vec_inv_to(vec3 v, vec3 dest) {
glm_vec_flipsign_to(v, dest);
glm_vec3_negate(vec3 v) {
glm_vec3_negate_to(v, v);
}
/*!
@@ -464,56 +472,93 @@ glm_vec_inv_to(vec3 v, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec_normalize(vec3 v) {
glm_vec3_normalize(vec3 v) {
float norm;
norm = glm_vec_norm(v);
norm = glm_vec3_norm(v);
if (norm == 0.0f) {
v[0] = v[1] = v[2] = 0.0f;
return;
}
glm_vec_scale(v, 1.0f / norm, v);
glm_vec3_scale(v, 1.0f / norm, v);
}
/*!
* @brief normalize vec3 to dest
*
* @param[in] vec source
* @param[in] v source
* @param[out] dest destination
*/
CGLM_INLINE
void
glm_vec_normalize_to(vec3 vec, vec3 dest) {
glm_vec3_normalize_to(vec3 v, vec3 dest) {
float norm;
norm = glm_vec_norm(vec);
norm = glm_vec3_norm(v);
if (norm == 0.0f) {
glm_vec_zero(dest);
glm_vec3_zero(dest);
return;
}
glm_vec_scale(vec, 1.0f / norm, dest);
glm_vec3_scale(v, 1.0f / norm, dest);
}
/*!
* @brief cross product of two vector (RH)
*
* @param[in] a vector 1
* @param[in] b vector 2
* @param[out] dest destination
*/
CGLM_INLINE
void
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];
dest[2] = a[0] * b[1] - a[1] * b[0];
}
/*!
* @brief cross product of two vector (RH) and normalize the result
*
* @param[in] a vector 1
* @param[in] b vector 2
* @param[out] dest destination
*/
CGLM_INLINE
void
glm_vec3_crossn(vec3 a, vec3 b, vec3 dest) {
glm_vec3_cross(a, b, dest);
glm_vec3_normalize(dest);
}
/*!
* @brief angle betwen two vector
*
* @param[in] v1 vector1
* @param[in] v2 vector2
* @param[in] a vector1
* @param[in] b vector2
*
* @return angle as radians
*/
CGLM_INLINE
float
glm_vec_angle(vec3 v1, vec3 v2) {
float norm;
glm_vec3_angle(vec3 a, vec3 b) {
float norm, dot;
/* maybe compiler generate approximation instruction (rcp) */
norm = 1.0f / (glm_vec_norm(v1) * glm_vec_norm(v2));
return acosf(glm_vec_dot(v1, v2) * norm);
norm = 1.0f / (glm_vec3_norm(a) * glm_vec3_norm(b));
dot = glm_vec3_dot(a, b) * norm;
if (dot > 1.0f)
return 0.0f;
else if (dot < -1.0f)
return CGLM_PI;
return acosf(dot);
}
/*!
@@ -525,27 +570,27 @@ glm_vec_angle(vec3 v1, vec3 v2) {
*/
CGLM_INLINE
void
glm_vec_rotate(vec3 v, float angle, vec3 axis) {
glm_vec3_rotate(vec3 v, float angle, vec3 axis) {
vec3 v1, v2, k;
float c, s;
c = cosf(angle);
s = sinf(angle);
glm_vec_normalize_to(axis, k);
glm_vec3_normalize_to(axis, k);
/* Right Hand, Rodrigues' rotation formula:
v = v*cos(t) + (kxv)sin(t) + k*(k.v)(1 - cos(t))
*/
glm_vec_scale(v, c, v1);
glm_vec3_scale(v, c, v1);
glm_vec_cross(k, v, v2);
glm_vec_scale(v2, s, v2);
glm_vec3_cross(k, v, v2);
glm_vec3_scale(v2, s, v2);
glm_vec_add(v1, v2, v1);
glm_vec3_add(v1, v2, v1);
glm_vec_scale(k, glm_vec_dot(k, v) * (1.0f - c), v2);
glm_vec_add(v1, v2, v);
glm_vec3_scale(k, glm_vec3_dot(k, v) * (1.0f - c), v2);
glm_vec3_add(v1, v2, v);
}
/*!
@@ -563,7 +608,7 @@ glm_vec_rotate(vec3 v, float angle, vec3 axis) {
*/
CGLM_INLINE
void
glm_vec_rotate_m4(mat4 m, vec3 v, vec3 dest) {
glm_vec3_rotate_m4(mat4 m, vec3 v, vec3 dest) {
vec4 x, y, z, res;
glm_vec4_normalize_to(m[0], x);
@@ -586,7 +631,7 @@ glm_vec_rotate_m4(mat4 m, vec3 v, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec_rotate_m3(mat3 m, vec3 v, vec3 dest) {
glm_vec3_rotate_m3(mat3 m, vec3 v, vec3 dest) {
vec4 res, x, y, z;
glm_vec4(m[0], 0.0f, x);
@@ -607,88 +652,88 @@ glm_vec_rotate_m3(mat3 m, vec3 v, vec3 dest) {
/*!
* @brief project a vector onto b vector
*
* @param[in] a vector1
* @param[in] b vector2
* @param[in] a vector1
* @param[in] b vector2
* @param[out] dest projected vector
*/
CGLM_INLINE
void
glm_vec_proj(vec3 a, vec3 b, vec3 dest) {
glm_vec_scale(b,
glm_vec_dot(a, b) / glm_vec_norm2(b),
dest);
glm_vec3_proj(vec3 a, vec3 b, vec3 dest) {
glm_vec3_scale(b,
glm_vec3_dot(a, b) / glm_vec3_norm2(b),
dest);
}
/**
* @brief find center point of two vector
*
* @param[in] v1 vector1
* @param[in] v2 vector2
* @param[in] a vector1
* @param[in] b vector2
* @param[out] dest center point
*/
CGLM_INLINE
void
glm_vec_center(vec3 v1, vec3 v2, vec3 dest) {
glm_vec_add(v1, v2, dest);
glm_vec_scale(dest, 0.5f, dest);
glm_vec3_center(vec3 a, vec3 b, vec3 dest) {
glm_vec3_add(a, b, dest);
glm_vec3_scale(dest, 0.5f, dest);
}
/**
* @brief squared distance between two vectors
*
* @param[in] v1 vector1
* @param[in] v2 vector2
* @param[in] a vector1
* @param[in] b vector2
* @return returns squared distance (distance * distance)
*/
CGLM_INLINE
float
glm_vec_distance2(vec3 v1, vec3 v2) {
return glm_pow2(v2[0] - v1[0])
+ glm_pow2(v2[1] - v1[1])
+ glm_pow2(v2[2] - v1[2]);
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]);
}
/**
* @brief distance between two vectors
*
* @param[in] v1 vector1
* @param[in] v2 vector2
* @param[in] a vector1
* @param[in] b vector2
* @return returns distance
*/
CGLM_INLINE
float
glm_vec_distance(vec3 v1, vec3 v2) {
return sqrtf(glm_vec_distance2(v1, v2));
glm_vec3_distance(vec3 a, vec3 b) {
return sqrtf(glm_vec3_distance2(a, b));
}
/*!
* @brief max values of vectors
*
* @param[in] v1 vector1
* @param[in] v2 vector2
* @param[in] a vector1
* @param[in] b vector2
* @param[out] dest destination
*/
CGLM_INLINE
void
glm_vec_maxv(vec3 v1, vec3 v2, vec3 dest) {
dest[0] = glm_max(v1[0], v2[0]);
dest[1] = glm_max(v1[1], v2[1]);
dest[2] = glm_max(v1[2], v2[2]);
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]);
}
/*!
* @brief min values of vectors
*
* @param[in] v1 vector1
* @param[in] v2 vector2
* @param[in] a vector1
* @param[in] b vector2
* @param[out] dest destination
*/
CGLM_INLINE
void
glm_vec_minv(vec3 v1, vec3 v2, vec3 dest) {
dest[0] = glm_min(v1[0], v2[0]);
dest[1] = glm_min(v1[1], v2[1]);
dest[2] = glm_min(v1[2], v2[2]);
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]);
}
/*!
@@ -699,7 +744,7 @@ glm_vec_minv(vec3 v1, vec3 v2, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec_ortho(vec3 v, vec3 dest) {
glm_vec3_ortho(vec3 v, vec3 dest) {
dest[0] = v[1] - v[2];
dest[1] = v[2] - v[0];
dest[2] = v[0] - v[1];
@@ -714,7 +759,7 @@ glm_vec_ortho(vec3 v, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec_clamp(vec3 v, float minVal, float maxVal) {
glm_vec3_clamp(vec3 v, float minVal, float maxVal) {
v[0] = glm_clamp(v[0], minVal, maxVal);
v[1] = glm_clamp(v[1], minVal, maxVal);
v[2] = glm_clamp(v[2], minVal, maxVal);
@@ -732,14 +777,14 @@ glm_vec_clamp(vec3 v, float minVal, float maxVal) {
*/
CGLM_INLINE
void
glm_vec_lerp(vec3 from, vec3 to, float t, vec3 dest) {
glm_vec3_lerp(vec3 from, vec3 to, float t, vec3 dest) {
vec3 s, v;
/* from + s * (to - from) */
glm_vec_broadcast(glm_clamp_zo(t), s);
glm_vec_sub(to, from, v);
glm_vec_mulv(s, v, v);
glm_vec_add(from, v, dest);
glm_vec3_broadcast(glm_clamp_zo(t), s);
glm_vec3_sub(to, from, v);
glm_vec3_mul(s, v, v);
glm_vec3_add(from, v, dest);
}
/*!
@@ -754,7 +799,7 @@ glm_vec_lerp(vec3 from, vec3 to, float t, vec3 dest) {
CGLM_INLINE
void
glm_cross(vec3 a, vec3 b, vec3 d) {
glm_vec_cross(a, b, d);
glm_vec3_cross(a, b, d);
}
/*!
@@ -770,7 +815,7 @@ glm_cross(vec3 a, vec3 b, vec3 d) {
CGLM_INLINE
float
glm_dot(vec3 a, vec3 b) {
return glm_vec_dot(a, b);
return glm_vec3_dot(a, b);
}
/*!
@@ -783,7 +828,7 @@ glm_dot(vec3 a, vec3 b) {
CGLM_INLINE
void
glm_normalize(vec3 v) {
glm_vec_normalize(v);
glm_vec3_normalize(v);
}
/*!
@@ -797,7 +842,7 @@ glm_normalize(vec3 v) {
CGLM_INLINE
void
glm_normalize_to(vec3 v, vec3 dest) {
glm_vec_normalize_to(v, dest);
glm_vec3_normalize_to(v, dest);
}
#endif /* cglm_vec3_h */

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

@@ -11,15 +11,19 @@
/*
Functions:
CGLM_INLINE void glm_vec4_mulv(vec4 a, vec4 b, vec4 d);
CGLM_INLINE void glm_vec4_broadcast(float val, vec4 d);
CGLM_INLINE bool glm_vec4_eq(vec4 v, float val);
CGLM_INLINE bool glm_vec4_eq_eps(vec4 v, float val);
CGLM_INLINE bool glm_vec4_eq_all(vec4 v);
CGLM_INLINE bool glm_vec4_eqv(vec4 v1, vec4 v2);
CGLM_INLINE bool glm_vec4_eqv_eps(vec4 v1, vec4 v2);
CGLM_INLINE bool glm_vec4_eqv(vec4 a, vec4 b);
CGLM_INLINE bool glm_vec4_eqv_eps(vec4 a, vec4 b);
CGLM_INLINE float glm_vec4_max(vec4 v);
CGLM_INLINE float glm_vec4_min(vec4 v);
CGLM_INLINE bool glm_vec4_isnan(vec4 v);
CGLM_INLINE bool glm_vec4_isinf(vec4 v);
CGLM_INLINE bool glm_vec4_isvalid(vec4 v);
CGLM_INLINE void glm_vec4_sign(vec4 v, vec4 dest);
CGLM_INLINE void glm_vec4_sqrt(vec4 v, vec4 dest);
*/
#ifndef cglm_vec4_ext_h
@@ -31,26 +35,6 @@
#include <math.h>
#include <float.h>
/*!
* @brief DEPRECATED! use glm_vec4_mul
*
* @param a v1
* @param b v2
* @param d v3 = (v1[0] * v2[0], v1[1] * v2[1], v1[2] * v2[2], v1[3] * v2[3])
*/
CGLM_INLINE
void
glm_vec4_mulv(vec4 a, vec4 b, vec4 d) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glmm_store(d, _mm_mul_ps(glmm_load(a), glmm_load(b)));
#else
d[0] = a[0] * b[0];
d[1] = a[1] * b[1];
d[2] = a[2] * b[2];
d[3] = a[3] * b[3];
#endif
}
/*!
* @brief fill a vector with specified value
*
@@ -113,31 +97,31 @@ glm_vec4_eq_all(vec4 v) {
/*!
* @brief check if vector is equal to another (without epsilon)
*
* @param v1 vector
* @param v2 vector
* @param a vector
* @param b vector
*/
CGLM_INLINE
bool
glm_vec4_eqv(vec4 v1, vec4 v2) {
return v1[0] == v2[0]
&& v1[1] == v2[1]
&& v1[2] == v2[2]
&& v1[3] == v2[3];
glm_vec4_eqv(vec4 a, vec4 b) {
return a[0] == b[0]
&& a[1] == b[1]
&& a[2] == b[2]
&& a[3] == b[3];
}
/*!
* @brief check if vector is equal to another (with epsilon)
*
* @param v1 vector
* @param v2 vector
* @param a vector
* @param b vector
*/
CGLM_INLINE
bool
glm_vec4_eqv_eps(vec4 v1, vec4 v2) {
return fabsf(v1[0] - v2[0]) <= FLT_EPSILON
&& fabsf(v1[1] - v2[1]) <= FLT_EPSILON
&& fabsf(v1[2] - v2[2]) <= FLT_EPSILON
&& fabsf(v1[3] - v2[3]) <= FLT_EPSILON;
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
&& fabsf(a[3] - b[3]) <= FLT_EPSILON;
}
/*!
@@ -150,7 +134,7 @@ float
glm_vec4_max(vec4 v) {
float max;
max = glm_vec_max(v);
max = glm_vec3_max(v);
if (v[3] > max)
max = v[3];
@@ -167,7 +151,7 @@ float
glm_vec4_min(vec4 v) {
float min;
min = glm_vec_min(v);
min = glm_vec3_min(v);
if (v[3] < min)
min = v[3];

203
include/cglm/vec4.h
View File

@@ -5,15 +5,8 @@
* Full license can be found in the LICENSE file
*/
/*!
* vec3 functions dont have suffix e.g glm_vec_dot (not glm_vec3_dot)
* all functions without suffix are vec3 functions
*/
/*
Macros:
glm_vec4_dup3(v, dest)
glm_vec4_dup(v, dest)
GLM_VEC4_ONE_INIT
GLM_VEC4_BLACK_INIT
GLM_VEC4_ZERO_INIT
@@ -28,7 +21,7 @@
CGLM_INLINE void glm_vec4_ucopy(vec4 v, vec4 dest);
CGLM_INLINE float glm_vec4_dot(vec4 a, vec4 b);
CGLM_INLINE float glm_vec4_norm2(vec4 v);
CGLM_INLINE float glm_vec4_norm(vec4 vec);
CGLM_INLINE float glm_vec4_norm(vec4 v);
CGLM_INLINE void glm_vec4_add(vec4 a, vec4 b, vec4 dest);
CGLM_INLINE void glm_vec4_adds(vec4 v, float s, vec4 dest);
CGLM_INLINE void glm_vec4_sub(vec4 a, vec4 b, vec4 dest);
@@ -41,16 +34,27 @@
CGLM_INLINE void glm_vec4_addadd(vec4 a, vec4 b, vec4 dest);
CGLM_INLINE void glm_vec4_subadd(vec4 a, vec4 b, vec4 dest);
CGLM_INLINE void glm_vec4_muladd(vec4 a, vec4 b, vec4 dest);
CGLM_INLINE void glm_vec4_flipsign(vec4 v);
CGLM_INLINE void glm_vec4_muladds(vec4 a, float s, vec4 dest);
CGLM_INLINE void glm_vec4_maxadd(vec4 a, vec4 b, vec4 dest);
CGLM_INLINE void glm_vec4_minadd(vec4 a, vec4 b, vec4 dest);
CGLM_INLINE void glm_vec4_negate(vec4 v);
CGLM_INLINE void glm_vec4_inv(vec4 v);
CGLM_INLINE void glm_vec4_inv_to(vec4 v, vec4 dest);
CGLM_INLINE void glm_vec4_normalize(vec4 v);
CGLM_INLINE void glm_vec4_normalize_to(vec4 vec, vec4 dest);
CGLM_INLINE float glm_vec4_distance(vec4 v1, vec4 v2);
CGLM_INLINE void glm_vec4_maxv(vec4 v1, vec4 v2, vec4 dest);
CGLM_INLINE void glm_vec4_minv(vec4 v1, vec4 v2, vec4 dest);
CGLM_INLINE float glm_vec4_distance(vec4 a, vec4 b);
CGLM_INLINE void glm_vec4_maxv(vec4 a, vec4 b, vec4 dest);
CGLM_INLINE void glm_vec4_minv(vec4 a, vec4 b, vec4 dest);
CGLM_INLINE void glm_vec4_clamp(vec4 v, float minVal, float maxVal);
CGLM_INLINE void glm_vec4_lerp(vec4 from, vec4 to, float t, vec4 dest)
DEPRECATED:
glm_vec4_dup
glm_vec4_flipsign
glm_vec4_flipsign_to
glm_vec4_inv
glm_vec4_inv_to
glm_vec4_mulv
*/
#ifndef cglm_vec4_h
@@ -60,9 +64,14 @@
#include "vec4-ext.h"
#include "util.h"
/* DEPRECATED! use _copy, _ucopy versions */
#define glm_vec4_dup3(v, dest) glm_vec4_copy3(v, dest)
#define glm_vec4_dup(v, dest) glm_vec4_copy(v, dest)
/* DEPRECATED! functions */
#define glm_vec4_dup3(v, dest) glm_vec4_copy3(v, dest)
#define glm_vec4_dup(v, dest) glm_vec4_copy(v, dest)
#define glm_vec4_flipsign(v) glm_vec4_negate(v)
#define glm_vec4_flipsign_to(v, dest) glm_vec4_negate_to(v, dest)
#define glm_vec4_inv(v) glm_vec4_negate(v)
#define glm_vec4_inv_to(v, dest) glm_vec4_negate_to(v, dest)
#define glm_vec4_mulv(a, b, d) glm_vec4_mul(a, b, d)
#define GLM_VEC4_ONE_INIT {1.0f, 1.0f, 1.0f, 1.0f}
#define GLM_VEC4_BLACK_INIT {0.0f, 0.0f, 0.0f, 1.0f}
@@ -223,24 +232,24 @@ glm_vec4_norm2(vec4 v) {
/*!
* @brief norm (magnitude) of vec4
*
* @param[in] vec vector
* @param[in] v vector
*
* @return norm
*/
CGLM_INLINE
float
glm_vec4_norm(vec4 vec) {
glm_vec4_norm(vec4 v) {
#if defined( __SSE__ ) || defined( __SSE2__ )
__m128 x0;
x0 = glmm_load(vec);
x0 = glmm_load(v);
return _mm_cvtss_f32(_mm_sqrt_ss(glmm_dot(x0, x0)));
#else
return sqrtf(glm_vec4_norm2(vec));
return sqrtf(glm_vec4_norm2(v));
#endif
}
/*!
* @brief add v2 vector to v1 vector store result in dest
* @brief add b vector to a vector store result in dest
*
* @param[in] a vector1
* @param[in] b vector2
@@ -280,7 +289,7 @@ glm_vec4_adds(vec4 v, float s, vec4 dest) {
}
/*!
* @brief subtract b vector from a vector store result in dest (d = v1 - v2)
* @brief subtract b vector from a vector store result in dest (d = a - b)
*
* @param[in] a vector1
* @param[in] b vector2
@@ -322,20 +331,20 @@ glm_vec4_subs(vec4 v, float s, vec4 dest) {
/*!
* @brief multiply two vector (component-wise multiplication)
*
* @param a v1
* @param b v2
* @param d v3 = (a[0] * b[0], a[1] * b[1], a[2] * b[2], a[3] * b[3])
* @param a vector1
* @param b vector2
* @param dest dest = (a[0] * b[0], a[1] * b[1], a[2] * b[2], a[3] * b[3])
*/
CGLM_INLINE
void
glm_vec4_mul(vec4 a, vec4 b, vec4 d) {
glm_vec4_mul(vec4 a, vec4 b, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glmm_store(d, _mm_mul_ps(glmm_load(a), glmm_load(b)));
glmm_store(dest, _mm_mul_ps(glmm_load(a), glmm_load(b)));
#else
d[0] = a[0] * b[0];
d[1] = a[1] * b[1];
d[2] = a[2] * b[2];
d[3] = a[3] * b[3];
dest[0] = a[0] * b[0];
dest[1] = a[1] * b[1];
dest[2] = a[2] * b[2];
dest[3] = a[3] * b[3];
#endif
}
@@ -381,7 +390,7 @@ glm_vec4_scale_as(vec4 v, float s, vec4 dest) {
}
/*!
* @brief div vector with another component-wise division: d = v1 / v2
* @brief div vector with another component-wise division: d = a / b
*
* @param[in] a vector 1
* @param[in] b vector 2
@@ -417,7 +426,6 @@ glm_vec4_divs(vec4 v, float s, vec4 dest) {
#endif
}
/*!
* @brief add two vectors and add result to sum
*
@@ -515,32 +523,62 @@ glm_vec4_muladds(vec4 a, float s, vec4 dest) {
}
/*!
* @brief flip sign of all vec4 members
* @brief add max of two vector to result/dest
*
* @param[in, out] v vector
* it applies += operator so dest must be initialized
*
* @param[in] a vector 1
* @param[in] b vector 2
* @param[out] dest dest += max(a, b)
*/
CGLM_INLINE
void
glm_vec4_flipsign(vec4 v) {
glm_vec4_maxadd(vec4 a, vec4 b, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glmm_store(v, _mm_xor_ps(glmm_load(v), _mm_set1_ps(-0.0f)));
glmm_store(dest, _mm_add_ps(glmm_load(dest),
_mm_max_ps(glmm_load(a),
glmm_load(b))));
#else
v[0] = -v[0];
v[1] = -v[1];
v[2] = -v[2];
v[3] = -v[3];
dest[0] += glm_max(a[0], b[0]);
dest[1] += glm_max(a[1], b[1]);
dest[2] += glm_max(a[2], b[2]);
dest[3] += glm_max(a[3], b[3]);
#endif
}
/*!
* @brief flip sign of all vec4 members and store result in dest
* @brief add min of two vector to result/dest
*
* @param[in] v vector
* @param[out] dest vector
* it applies += operator so dest must be initialized
*
* @param[in] a vector
* @param[in] b scalar
* @param[out] dest dest += min(a, b)
*/
CGLM_INLINE
void
glm_vec4_flipsign_to(vec4 v, 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),
glmm_load(b))));
#else
dest[0] += glm_min(a[0], b[0]);
dest[1] += glm_min(a[1], b[1]);
dest[2] += glm_min(a[2], b[2]);
dest[3] += glm_min(a[3], b[3]);
#endif
}
/*!
* @brief negate vector components and store result in dest
*
* @param[in] v vector
* @param[out] dest result vector
*/
CGLM_INLINE
void
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)));
#else
@@ -552,43 +590,30 @@ glm_vec4_flipsign_to(vec4 v, vec4 dest) {
}
/*!
* @brief make vector as inverse/opposite of itself
* @brief flip sign of all vec4 members
*
* @param[in, out] v vector
*/
CGLM_INLINE
void
glm_vec4_inv(vec4 v) {
glm_vec4_flipsign(v);
glm_vec4_negate(vec4 v) {
glm_vec4_negate_to(v, v);
}
/*!
* @brief inverse/opposite vector
* @brief normalize vec4 to dest
*
* @param[in] v source
* @param[out] dest destination
*/
CGLM_INLINE
void
glm_vec4_inv_to(vec4 v, vec4 dest) {
glm_vec4_copy(v, dest);
glm_vec4_flipsign(dest);
}
/*!
* @brief normalize vec4 to dest
*
* @param[in] vec source
* @param[out] dest destination
*/
CGLM_INLINE
void
glm_vec4_normalize_to(vec4 vec, vec4 dest) {
glm_vec4_normalize_to(vec4 v, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
__m128 xdot, x0;
float dot;
x0 = glmm_load(vec);
x0 = glmm_load(v);
xdot = glmm_dot(x0, x0);
dot = _mm_cvtss_f32(xdot);
@@ -601,14 +626,14 @@ glm_vec4_normalize_to(vec4 vec, vec4 dest) {
#else
float norm;
norm = glm_vec4_norm(vec);
norm = glm_vec4_norm(v);
if (norm == 0.0f) {
glm_vec4_zero(dest);
return;
}
glm_vec4_scale(vec, 1.0f / norm, dest);
glm_vec4_scale(v, 1.0f / norm, dest);
#endif
}
@@ -626,56 +651,56 @@ glm_vec4_normalize(vec4 v) {
/**
* @brief distance between two vectors
*
* @param[in] v1 vector1
* @param[in] v2 vector2
* @param[in] a vector1
* @param[in] b vector2
* @return returns distance
*/
CGLM_INLINE
float
glm_vec4_distance(vec4 v1, vec4 v2) {
return sqrtf(glm_pow2(v2[0] - v1[0])
+ glm_pow2(v2[1] - v1[1])
+ glm_pow2(v2[2] - v1[2])
+ glm_pow2(v2[3] - v1[3]));
glm_vec4_distance(vec4 a, vec4 b) {
return sqrtf(glm_pow2(b[0] - a[0])
+ glm_pow2(b[1] - a[1])
+ glm_pow2(b[2] - a[2])
+ glm_pow2(b[3] - a[3]));
}
/*!
* @brief max values of vectors
*
* @param[in] v1 vector1
* @param[in] v2 vector2
* @param[in] a vector1
* @param[in] b vector2
* @param[out] dest destination
*/
CGLM_INLINE
void
glm_vec4_maxv(vec4 v1, vec4 v2, vec4 dest) {
glm_vec4_maxv(vec4 a, vec4 b, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glmm_store(dest, _mm_max_ps(glmm_load(v1), glmm_load(v2)));
glmm_store(dest, _mm_max_ps(glmm_load(a), glmm_load(b)));
#else
dest[0] = glm_max(v1[0], v2[0]);
dest[1] = glm_max(v1[1], v2[1]);
dest[2] = glm_max(v1[2], v2[2]);
dest[3] = glm_max(v1[3], v2[3]);
dest[0] = glm_max(a[0], b[0]);
dest[1] = glm_max(a[1], b[1]);
dest[2] = glm_max(a[2], b[2]);
dest[3] = glm_max(a[3], b[3]);
#endif
}
/*!
* @brief min values of vectors
*
* @param[in] v1 vector1
* @param[in] v2 vector2
* @param[in] a vector1
* @param[in] b vector2
* @param[out] dest destination
*/
CGLM_INLINE
void
glm_vec4_minv(vec4 v1, vec4 v2, vec4 dest) {
glm_vec4_minv(vec4 a, vec4 b, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glmm_store(dest, _mm_min_ps(glmm_load(v1), glmm_load(v2)));
glmm_store(dest, _mm_min_ps(glmm_load(a), glmm_load(b)));
#else
dest[0] = glm_min(v1[0], v2[0]);
dest[1] = glm_min(v1[1], v2[1]);
dest[2] = glm_min(v1[2], v2[2]);
dest[3] = glm_min(v1[3], v2[3]);
dest[0] = glm_min(a[0], b[0]);
dest[1] = glm_min(a[1], b[1]);
dest[2] = glm_min(a[2], b[2]);
dest[3] = glm_min(a[3], b[3]);
#endif
}
@@ -718,7 +743,7 @@ glm_vec4_lerp(vec4 from, vec4 to, float t, vec4 dest) {
/* from + s * (to - from) */
glm_vec4_broadcast(glm_clamp_zo(t), s);
glm_vec4_sub(to, from, v);
glm_vec4_mulv(s, v, v);
glm_vec4_mul(s, v, v);
glm_vec4_add(from, v, dest);
}

4
include/cglm/version.h
View File

@@ -9,7 +9,7 @@
#define cglm_version_h
#define CGLM_VERSION_MAJOR 0
#define CGLM_VERSION_MINOR 4
#define CGLM_VERSION_PATCH 9
#define CGLM_VERSION_MINOR 5
#define CGLM_VERSION_PATCH 2
#endif /* cglm_version_h */