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

vec: rename parameter names

Browse Source
This commit is contained in:
Recep Aslantas
2018-11-29 09:55:27 +03:00
parent aee381d869
commit 4e08b7e335
9 changed files with 202 additions and 238 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -46,15 +46,15 @@ glmc_vec3_cross(vec3 a, vec3 b, vec3 d);
CGLM_EXPORT
float
glmc_vec3_norm(vec3 vec);
glmc_vec3_norm(vec3 v);
CGLM_EXPORT
float
glmc_vec3_norm2(vec3 vec);
glmc_vec3_norm2(vec3 v);
CGLM_EXPORT
void
glmc_vec3_normalize_to(vec3 vec, vec3 dest);
glmc_vec3_normalize_to(vec3 v, vec3 dest);
CGLM_EXPORT
void
@@ -62,7 +62,7 @@ glmc_vec3_normalize(vec3 v);
CGLM_EXPORT
void
glmc_vec3_add(vec3 v1, vec3 v2, vec3 dest);
glmc_vec3_add(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
@@ -122,7 +122,7 @@ glmc_vec3_negate_to(vec3 v, vec3 dest);
CGLM_EXPORT
float
glmc_vec3_angle(vec3 v1, vec3 v2);
glmc_vec3_angle(vec3 a, vec3 b);
CGLM_EXPORT
void
@@ -142,23 +142,23 @@ glmc_vec3_proj(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_center(vec3 v1, vec3 v2, vec3 dest);
glmc_vec3_center(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
float
glmc_vec3_distance2(vec3 v1, vec3 v2);
glmc_vec3_distance2(vec3 a, vec3 b);
CGLM_EXPORT
float
glmc_vec3_distance(vec3 v1, vec3 v2);
glmc_vec3_distance(vec3 a, vec3 b);
CGLM_EXPORT
void
glmc_vec3_maxv(vec3 v1, vec3 v2, vec3 dest);
glmc_vec3_maxv(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_minv(vec3 v1, vec3 v2, vec3 dest);
glmc_vec3_minv(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
@@ -196,11 +196,11 @@ glmc_vec3_eq_all(vec3 v);
CGLM_EXPORT
bool
glmc_vec3_eqv(vec3 v1, vec3 v2);
glmc_vec3_eqv(vec3 a, vec3 b);
CGLM_EXPORT
bool
glmc_vec3_eqv_eps(vec3 v1, vec3 v2);
glmc_vec3_eqv_eps(vec3 a, vec3 b);
CGLM_EXPORT
float

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

@@ -35,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
@@ -51,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
@@ -127,15 +127,15 @@ 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
@@ -169,11 +169,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

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

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

@@ -11,13 +11,12 @@
/*
Functions:
CGLM_INLINE void glm_vec3_mulv(vec3 a, vec3 b, vec3 d);
CGLM_INLINE void glm_vec3_broadcast(float val, vec3 d);
CGLM_INLINE bool glm_vec3_eq(vec3 v, float val);
CGLM_INLINE bool glm_vec3_eq_eps(vec3 v, float val);
CGLM_INLINE bool glm_vec3_eq_all(vec3 v);
CGLM_INLINE bool glm_vec3_eqv(vec3 v1, vec3 v2);
CGLM_INLINE bool glm_vec3_eqv_eps(vec3 v1, vec3 v2);
CGLM_INLINE 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);
@@ -36,21 +35,6 @@
#include <math.h>
#include <float.h>
/*!
* @brief DEPRECATED! use glm_vec3_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_vec3_mulv(vec3 a, vec3 b, vec3 d) {
d[0] = a[0] * b[0];
d[1] = a[1] * b[1];
d[2] = a[2] * b[2];
}
/*!
* @brief fill a vector with specified value
*
@@ -103,29 +87,29 @@ glm_vec3_eq_all(vec3 v) {
/*!
* @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_vec3_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_vec3_eqv_eps(vec3 v1, vec3 v2) {
return fabsf(v1[0] - v2[0]) <= FLT_EPSILON
&& fabsf(v1[1] - v2[1]) <= FLT_EPSILON
&& fabsf(v1[2] - v2[2]) <= FLT_EPSILON;
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;
}
/*!

115
include/cglm/vec3.h
View File

@@ -7,7 +7,6 @@
/*
Macros:
glm_vec3_dup(v, dest)
GLM_VEC3_ONE_INIT
GLM_VEC3_ZERO_INIT
GLM_VEC3_ONE
@@ -24,7 +23,7 @@
CGLM_INLINE float glm_vec3_dot(vec3 a, vec3 b);
CGLM_INLINE void glm_vec3_cross(vec3 a, vec3 b, vec3 d);
CGLM_INLINE float glm_vec3_norm2(vec3 v);
CGLM_INLINE float glm_vec3_norm(vec3 vec);
CGLM_INLINE 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);
@@ -45,17 +44,17 @@
CGLM_INLINE void glm_vec3_inv(vec3 v);
CGLM_INLINE void glm_vec3_inv_to(vec3 v, vec3 dest);
CGLM_INLINE void glm_vec3_normalize(vec3 v);
CGLM_INLINE void glm_vec3_normalize_to(vec3 vec, vec3 dest);
CGLM_INLINE float glm_vec3_distance(vec3 v1, vec3 v2);
CGLM_INLINE float glm_vec3_angle(vec3 v1, vec3 v2);
CGLM_INLINE void glm_vec3_normalize_to(vec3 v, 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 v1, vec3 v2, vec3 dest);
CGLM_INLINE float glm_vec3_distance2(vec3 v1, vec3 v2);
CGLM_INLINE void glm_vec3_maxv(vec3 v1, vec3 v2, vec3 dest);
CGLM_INLINE void glm_vec3_minv(vec3 v1, vec3 v2, vec3 dest);
CGLM_INLINE void glm_vec3_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);
@@ -72,6 +71,7 @@
glm_vec3_flipsign_to
glm_vec3_inv
glm_vec3_inv_to
glm_vec3_mulv
*/
#ifndef cglm_vec3_h
@@ -88,6 +88,7 @@
#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}
@@ -199,14 +200,14 @@ glm_vec3_norm2(vec3 v) {
/*!
* @brief norm (magnitude) of vec3
*
* @param[in] vec vector
* @param[in] v vector
*
* @return norm
*/
CGLM_INLINE
float
glm_vec3_norm(vec3 vec) {
return sqrtf(glm_vec3_norm2(vec));
glm_vec3_norm(vec3 v) {
return sqrtf(glm_vec3_norm2(v));
}
/*!
@@ -240,7 +241,7 @@ glm_vec3_adds(vec3 v, float s, vec3 dest) {
}
/*!
* @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
@@ -272,16 +273,16 @@ glm_vec3_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_vec3_mul(vec3 a, vec3 b, vec3 d) {
d[0] = a[0] * b[0];
d[1] = a[1] * b[1];
d[2] = a[2] * b[2];
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];
}
/*!
@@ -466,40 +467,40 @@ glm_vec3_normalize(vec3 v) {
/*!
* @brief normalize vec3 to dest
*
* @param[in] vec source
* @param[in] v source
* @param[out] dest destination
*/
CGLM_INLINE
void
glm_vec3_normalize_to(vec3 vec, vec3 dest) {
glm_vec3_normalize_to(vec3 v, vec3 dest) {
float norm;
norm = glm_vec3_norm(vec);
norm = glm_vec3_norm(v);
if (norm == 0.0f) {
glm_vec3_zero(dest);
return;
}
glm_vec3_scale(vec, 1.0f / norm, dest);
glm_vec3_scale(v, 1.0f / norm, 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_vec3_angle(vec3 v1, vec3 v2) {
glm_vec3_angle(vec3 a, vec3 b) {
float norm, dot;
/* maybe compiler generate approximation instruction (rcp) */
norm = 1.0f / (glm_vec3_norm(v1) * glm_vec3_norm(v2));
dot = glm_vec3_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;
@@ -600,8 +601,8 @@ glm_vec3_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
@@ -615,73 +616,73 @@ glm_vec3_proj(vec3 a, vec3 b, vec3 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_vec3_center(vec3 v1, vec3 v2, vec3 dest) {
glm_vec3_add(v1, v2, 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_vec3_distance2(vec3 v1, vec3 v2) {
return glm_pow2(v2[0] - v1[0])
+ glm_pow2(v2[1] - v1[1])
+ glm_pow2(v2[2] - v1[2]);
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_vec3_distance(vec3 v1, vec3 v2) {
return sqrtf(glm_vec3_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_vec3_maxv(vec3 v1, vec3 v2, vec3 dest) {
dest[0] = glm_max(v1[0], v2[0]);
dest[1] = glm_max(v1[1], v2[1]);
dest[2] = glm_max(v1[2], v2[2]);
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_vec3_minv(vec3 v1, vec3 v2, vec3 dest) {
dest[0] = glm_min(v1[0], v2[0]);
dest[1] = glm_min(v1[1], v2[1]);
dest[2] = glm_min(v1[2], v2[2]);
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]);
}
/*!

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

@@ -11,13 +11,12 @@
/*
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);
@@ -36,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
*
@@ -118,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;
}
/*!

100
include/cglm/vec4.h
View File

@@ -7,8 +7,6 @@
/*
Macros:
glm_vec4_dup3(v, dest)
glm_vec4_dup(v, dest)
GLM_VEC4_ONE_INIT
GLM_VEC4_BLACK_INIT
GLM_VEC4_ZERO_INIT
@@ -23,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,9 +39,9 @@
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)
@@ -54,6 +52,7 @@
glm_vec4_flipsign_to
glm_vec4_inv
glm_vec4_inv_to
glm_vec4_mulv
*/
#ifndef cglm_vec4_h
@@ -70,6 +69,7 @@
#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}
@@ -230,24 +230,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
@@ -287,7 +287,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
@@ -329,20 +329,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 d 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
}
@@ -388,7 +388,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
@@ -554,17 +554,17 @@ glm_vec4_negate(vec4 v) {
/*!
* @brief normalize vec4 to dest
*
* @param[in] vec source
* @param[in] v 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);
@@ -577,14 +577,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
}
@@ -602,56 +602,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
}

48
src/vec3.c
View File

@@ -46,14 +46,14 @@ glmc_vec3_cross(vec3 a, vec3 b, vec3 d) {
CGLM_EXPORT
float
glmc_vec3_norm(vec3 vec) {
return glm_vec3_norm(vec);
glmc_vec3_norm(vec3 v) {
return glm_vec3_norm(v);
}
CGLM_EXPORT
void
glmc_vec3_normalize_to(vec3 vec, vec3 dest) {
glm_vec3_normalize_to(vec, dest);
glmc_vec3_normalize_to(vec3 v, vec3 dest) {
glm_vec3_normalize_to(v, dest);
}
CGLM_EXPORT
@@ -64,14 +64,14 @@ glmc_vec3_normalize(vec3 v) {
CGLM_EXPORT
float
glmc_vec3_norm2(vec3 vec) {
return glm_vec3_norm2(vec);
glmc_vec3_norm2(vec3 v) {
return glm_vec3_norm2(v);
}
CGLM_EXPORT
void
glmc_vec3_add(vec3 v1, vec3 v2, vec3 dest) {
glm_vec3_add(v1, v2, dest);
glmc_vec3_add(vec3 a, vec3 b, vec3 dest) {
glm_vec3_add(a, b, dest);
}
CGLM_EXPORT
@@ -160,8 +160,8 @@ glmc_vec3_negate_to(vec3 v, vec3 dest) {
CGLM_EXPORT
float
glmc_vec3_angle(vec3 v1, vec3 v2) {
return glm_vec3_angle(v1, v2);
glmc_vec3_angle(vec3 a, vec3 b) {
return glm_vec3_angle(a, b);
}
CGLM_EXPORT
@@ -190,32 +190,32 @@ glmc_vec3_proj(vec3 a, vec3 b, vec3 dest) {
CGLM_EXPORT
void
glmc_vec3_center(vec3 v1, vec3 v2, vec3 dest) {
glm_vec3_center(v1, v2, dest);
glmc_vec3_center(vec3 a, vec3 b, vec3 dest) {
glm_vec3_center(a, b, dest);
}
CGLM_EXPORT
float
glmc_vec3_distance2(vec3 v1, vec3 v2) {
return glm_vec3_distance2(v1, v2);
glmc_vec3_distance2(vec3 a, vec3 b) {
return glm_vec3_distance2(a, b);
}
CGLM_EXPORT
float
glmc_vec3_distance(vec3 v1, vec3 v2) {
return glm_vec3_distance(v1, v2);
glmc_vec3_distance(vec3 a, vec3 b) {
return glm_vec3_distance(a, b);
}
CGLM_EXPORT
void
glmc_vec3_maxv(vec3 v1, vec3 v2, vec3 dest) {
glm_vec3_minv(v1, v2, dest);
glmc_vec3_maxv(vec3 a, vec3 b, vec3 dest) {
glm_vec3_minv(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec3_minv(vec3 v1, vec3 v2, vec3 dest) {
glm_vec3_maxv(v1, v2, dest);
glmc_vec3_minv(vec3 a, vec3 b, vec3 dest) {
glm_vec3_maxv(a, b, dest);
}
CGLM_EXPORT
@@ -270,14 +270,14 @@ glmc_vec3_eq_all(vec3 v) {
CGLM_EXPORT
bool
glmc_vec3_eqv(vec3 v1, vec3 v2) {
return glm_vec3_eqv(v1, v2);
glmc_vec3_eqv(vec3 a, vec3 b) {
return glm_vec3_eqv(a, b);
}
CGLM_EXPORT
bool
glmc_vec3_eqv_eps(vec3 v1, vec3 v2) {
return glm_vec3_eqv_eps(v1, v2);
glmc_vec3_eqv_eps(vec3 a, vec3 b) {
return glm_vec3_eqv_eps(a, b);
}
CGLM_EXPORT

36
src/vec4.c
View File

@@ -28,8 +28,8 @@ glmc_vec4_one(vec4 v) {
CGLM_EXPORT
void
glmc_vec4_copy3(vec4 a, vec3 dest) {
glm_vec4_copy3(a, dest);
glmc_vec4_copy3(vec4 v, vec3 dest) {
glm_vec4_copy3(v, dest);
}
CGLM_EXPORT
@@ -52,14 +52,14 @@ glmc_vec4_dot(vec4 a, vec4 b) {
CGLM_EXPORT
float
glmc_vec4_norm(vec4 vec) {
return glm_vec4_norm(vec);
glmc_vec4_norm(vec4 v) {
return glm_vec4_norm(v);
}
CGLM_EXPORT
void
glmc_vec4_normalize_to(vec4 vec, vec4 dest) {
glm_vec4_normalize_to(vec, dest);
glmc_vec4_normalize_to(vec4 v, vec4 dest) {
glm_vec4_normalize_to(v, dest);
}
CGLM_EXPORT
@@ -70,8 +70,8 @@ glmc_vec4_normalize(vec4 v) {
CGLM_EXPORT
float
glmc_vec4_norm2(vec4 vec) {
return glm_vec4_norm2(vec);
glmc_vec4_norm2(vec4 v) {
return glm_vec4_norm2(v);
}
CGLM_EXPORT
@@ -166,20 +166,20 @@ glmc_vec4_negate_to(vec4 v, vec4 dest) {
CGLM_EXPORT
float
glmc_vec4_distance(vec4 v1, vec4 v2) {
return glm_vec4_distance(v1, v2);
glmc_vec4_distance(vec4 a, vec4 b) {
return glm_vec4_distance(a, b);
}
CGLM_EXPORT
void
glmc_vec4_maxv(vec4 v1, vec4 v2, vec4 dest) {
glm_vec4_minv(v1, v2, dest);
glmc_vec4_maxv(vec4 a, vec4 b, vec4 dest) {
glm_vec4_minv(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec4_minv(vec4 v1, vec4 v2, vec4 dest) {
glm_vec4_maxv(v1, v2, dest);
glmc_vec4_minv(vec4 a, vec4 b, vec4 dest) {
glm_vec4_maxv(a, b, dest);
}
CGLM_EXPORT
@@ -228,14 +228,14 @@ glmc_vec4_eq_all(vec4 v) {
CGLM_EXPORT
bool
glmc_vec4_eqv(vec4 v1, vec4 v2) {
return glm_vec4_eqv(v1, v2);
glmc_vec4_eqv(vec4 a, vec4 b) {
return glm_vec4_eqv(a, b);
}
CGLM_EXPORT
bool
glmc_vec4_eqv_eps(vec4 v1, vec4 v2) {
return glm_vec4_eqv_eps(v1, v2);
glmc_vec4_eqv_eps(vec4 a, vec4 b) {
return glm_vec4_eqv_eps(a, b);
}
CGLM_EXPORT