External/cglm
1
0
Fork 0
mirror of https://github.com/recp/cglm.git synced 2025-10-04 09:08:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

vec: add some new functions for vector

Browse Source 
* _mul: multiply two vector (replacement for _mulv)
* _div: div two vector
* _divs: div vector with scalar
* adds: add scalar to each components of vec
* subs: sub scalar from each components of vec
This commit is contained in:
Recep Aslantas
2018-04-13 15:12:56 +03:00
parent af5a2627b4
commit d841f8809d
12 changed files with 510 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files

64
docs/source/vec3.rst
View File

@@ -38,9 +38,14 @@ Functions:
#. :c:func:`glm_vec_norm2`
#. :c:func:`glm_vec_norm`
#. :c:func:`glm_vec_add`
#. :c:func:`glm_vec_adds`
#. :c:func:`glm_vec_sub`
#. :c:func:`glm_vec_subs`
#. :c:func:`glm_vec_mul`
#. :c:func:`glm_vec_scale`
#. :c:func:`glm_vec_scale_as`
#. :c:func:`glm_vec_div`
#. :c:func:`glm_vec_divs`
#. :c:func:`glm_vec_flipsign`
#. :c:func:`glm_vec_flipsign_to`
#. :c:func:`glm_vec_inv`
@@ -133,24 +138,51 @@ Functions documentation
Parameters:
| *[in]* **vec** vector
.. c:function:: void glm_vec_add(vec3 v1, vec3 v2, vec3 dest)
.. c:function:: void glm_vec_add(vec3 a, vec3 b, vec3 dest)
add v2 vector to v1 vector store result in dest
add a vector to b vector store result in dest
Parameters:
| *[in]* **v1** vector1
| *[in]* **v2** vector2
| *[in]* **a** vector1
| *[in]* **b** vector2
| *[out]* **dest** destination vector
.. c:function:: void glm_vec_adds(vec3 a, float s, vec3 dest)
add scalar to v vector store result in dest (d = v + vec(s))
Parameters:
| *[in]* **v** vector
| *[in]* **s** scalar
| *[out]* **dest** destination vector
.. c:function:: void glm_vec_sub(vec3 v1, vec3 v2, vec3 dest)
subtract v2 vector from v1 vector store result in dest
subtract b vector from a vector store result in dest (d = v1 - v2)
Parameters:
| *[in]* **v1** vector1
| *[in]* **v2** vector2
| *[in]* **a** vector1
| *[in]* **b** vector2
| *[out]* **dest** destination vector
.. c:function:: void glm_vec_subs(vec3 v, float s, vec3 dest)
subtract scalar from v vector store result in dest (d = v - vec(s))
Parameters:
| *[in]* **v** vector
| *[in]* **s** scalar
| *[out]* **dest** destination vector
.. c:function:: void glm_vec_mul(vec3 a, vec3 b, vec3 d)
multiply two vector (component-wise multiplication)
Parameters:
| *[in]* **a** vector
| *[in]* **b** scalar
| *[out]* **d** result = (a[0] * b[0], a[1] * b[1], a[2] * b[2])
.. c:function:: void glm_vec_scale(vec3 v, float s, vec3 dest)
multiply/scale vec3 vector with scalar: result = v * s
@@ -170,6 +202,24 @@ Functions documentation
| *[in]* **s** scalar
| *[out]* **dest** destination vector
.. c:function:: void glm_vec_div(vec3 a, vec3 b, vec3 dest)
div vector with another component-wise division: d = a / b
Parameters:
| *[in]* **a** vector 1
| *[in]* **b** vector 2
| *[out]* **dest** result = (a[0] / b[0], a[1] / b[1], a[2] / b[2])
.. c:function:: void glm_vec_divs(vec3 v, float s, vec3 dest)
div vector with scalar: d = v / s
Parameters:
| *[in]* **v** vector
| *[in]* **s** scalar
| *[out]* **dest** result = (a[0] / s, a[1] / s, a[2] / s])
.. c:function:: void glm_vec_flipsign(vec3 v)
flip sign of all vec3 members

66
docs/source/vec4.rst
View File

@@ -30,9 +30,14 @@ Functions:
#. :c:func:`glm_vec4_norm2`
#. :c:func:`glm_vec4_norm`
#. :c:func:`glm_vec4_add`
#. :c:func:`glm_vec4_adds`
#. :c:func:`glm_vec4_sub`
#. :c:func:`glm_vec4_subs`
#. :c:func:`glm_vec4_mul`
#. :c:func:`glm_vec4_scale`
#. :c:func:`glm_vec4_scale_as`
#. :c:func:`glm_vec4_div`
#. :c:func:`glm_vec4_divs`
#. :c:func:`glm_vec4_flipsign`
#. :c:func:`glm_vec_flipsign_to`
#. :c:func:`glm_vec4_inv`
@@ -119,24 +124,51 @@ Functions documentation
Parameters:
| *[in]* **vec** vector
.. c:function:: void glm_vec4_add(vec4 v1, vec4 v2, vec4 dest)
.. c:function:: void glm_vec4_add(vec4 a, vec4 b, vec4 dest)
add v2 vector to v1 vector store result in dest
add a vector to b vector store result in dest
Parameters:
| *[in]* **v1** vector1
| *[in]* **v2** vector2
| *[in]* **a** vector1
| *[in]* **b** vector2
| *[out]* **dest** destination vector
.. c:function:: void glm_vec4_sub(vec4 v1, vec4 v2, vec4 dest)
.. c:function:: void glm_vec4_adds(vec4 v, float s, vec4 dest)
subtract v2 vector from v1 vector store result in dest
add scalar to v vector store result in dest (d = v + vec(s))
Parameters:
| *[in]* **v1** vector1
| *[in]* **v2** vector2
| *[in]* **v** vector
| *[in]* **s** scalar
| *[out]* **dest** destination vector
.. c:function:: void glm_vec4_sub(vec4 a, vec4 b, vec4 dest)
subtract b vector from a vector store result in dest (d = v1 - v2)
Parameters:
| *[in]* **a** vector1
| *[in]* **b** vector2
| *[out]* **dest** destination vector
.. c:function:: void glm_vec4_subs(vec4 v, float s, vec4 dest)
subtract scalar from v vector store result in dest (d = v - vec(s))
Parameters:
| *[in]* **v** vector
| *[in]* **s** scalar
| *[out]* **dest** destination vector
.. c:function:: void glm_vec4_mul(vec4 a, vec4 b, vec4 d)
multiply two vector (component-wise multiplication)
Parameters:
| *[in]* **a** vector1
| *[in]* **b** vector2
| *[out]* **dest** result = (a[0] * b[0], a[1] * b[1], a[2] * b[2], a[3] * b[3])
.. c:function:: void glm_vec4_scale(vec4 v, float s, vec4 dest)
multiply/scale vec4 vector with scalar: result = v * s
@@ -155,6 +187,24 @@ Functions documentation
| *[in]* **s** scalar
| *[out]* **dest** destination vector
.. c:function:: void glm_vec4_div(vec4 a, vec4 b, vec4 dest)
div vector with another component-wise division: d = v1 / v2
Parameters:
| *[in]* **a** vector1
| *[in]* **b** vector2
| *[out]* **dest** result = (a[0] / b[0], a[1] / b[1], a[2] / b[2], a[3] / b[3])
.. c:function:: void glm_vec4_divs(vec4 v, float s, vec4 dest)
div vector with scalar: d = v / s
Parameters:
| *[in]* **v** vector
| *[in]* **s** scalar
| *[out]* **dest** result = (a[0] / s, a[1] / s, a[2] / s, a[3] / s)
.. c:function:: void glm_vec4_flipsign(vec4 v)
flip sign of all vec4 members

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

@@ -62,7 +62,19 @@ glmc_vec_add(vec3 v1, vec3 v2, vec3 dest);
CGLM_EXPORT
void
glmc_vec_sub(vec3 v1, vec3 v2, vec3 dest);
glmc_vec_adds(vec3 v, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec_sub(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec_subs(vec3 v, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec_mul(vec3 a, vec3 b, vec3 d);
CGLM_EXPORT
void
@@ -72,6 +84,14 @@ CGLM_EXPORT
void
glmc_vec_scale_as(vec3 v, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec_div(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec_divs(vec3 a, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec_flipsign(vec3 v);

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

@@ -59,11 +59,23 @@ glmc_vec4_normalize(vec4 v);
CGLM_EXPORT
void
glmc_vec4_add(vec4 v1, vec4 v2, vec4 dest);
glmc_vec4_add(vec4 a, vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_sub(vec4 v1, vec4 v2, vec4 dest);
glmc_vec4_adds(vec4 v, float s, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_sub(vec4 a, vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_subs(vec4 v, float s, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_mul(vec4 a, vec4 b, vec4 d);
CGLM_EXPORT
void
@@ -73,6 +85,14 @@ CGLM_EXPORT
void
glmc_vec4_scale_as(vec3 v, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec4_div(vec4 a, vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_divs(vec4 v, float s, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_flipsign(vec4 v);

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

@@ -32,7 +32,7 @@
#include <float.h>
/*!
* @brief multiplies individual items, just for convenient like SIMD
* @brief DEPRECATED! use glm_vec_mul
*
* @param[in] a vec1
* @param[in] b vec2

114
include/cglm/vec3.h
View File

@@ -28,10 +28,15 @@
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 v1, vec3 v2, vec3 dest);
CGLM_INLINE void glm_vec_sub(vec3 v1, vec3 v2, vec3 dest);
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_flipsign(vec3 v);
CGLM_INLINE void glm_vec_inv(vec3 v);
CGLM_INLINE void glm_vec_inv_to(vec3 v, vec3 dest);
@@ -110,7 +115,7 @@ glm_vec_copy(vec3 a, vec3 dest) {
*/
CGLM_INLINE
void
glm_vec_zero(vec4 v) {
glm_vec_zero(vec3 v) {
v[0] = 0.0f;
v[1] = 0.0f;
v[2] = 0.0f;
@@ -123,7 +128,7 @@ glm_vec_zero(vec4 v) {
*/
CGLM_INLINE
void
glm_vec_one(vec4 v) {
glm_vec_one(vec3 v) {
v[0] = 1.0f;
v[1] = 1.0f;
v[2] = 1.0f;
@@ -190,33 +195,78 @@ glm_vec_norm(vec3 vec) {
}
/*!
* @brief add v2 vector to v1 vector store result in dest
* @brief add a vector to b vector store result in dest
*
* @param[in] v1 vector1
* @param[in] v2 vector2
* @param[in] a vector1
* @param[in] b vector2
* @param[out] dest destination vector
*/
CGLM_INLINE
void
glm_vec_add(vec3 v1, vec3 v2, vec3 dest) {
dest[0] = v1[0] + v2[0];
dest[1] = v1[1] + v2[1];
dest[2] = v1[2] + v2[2];
glm_vec_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];
}
/*!
* @brief add scalar to v vector store result in dest (d = v + s)
*
* @param[in] v vector
* @param[in] s scalar
* @param[out] dest destination vector
*/
CGLM_INLINE
void
glm_vec_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
*
* @param[in] v1 vector1
* @param[in] v2 vector2
* @param[in] a vector1
* @param[in] b vector2
* @param[out] dest destination vector
*/
CGLM_INLINE
void
glm_vec_sub(vec3 v1, vec3 v2, vec3 dest) {
dest[0] = v1[0] - v2[0];
dest[1] = v1[1] - v2[1];
dest[2] = v1[2] - v2[2];
glm_vec_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];
}
/*!
* @brief subtract scalar from v vector store result in dest (d = v - s)
*
* @param[in] v vector
* @param[in] s scalar
* @param[out] dest destination vector
*/
CGLM_INLINE
void
glm_vec_subs(vec3 v, float s, vec3 dest) {
dest[0] = v[0] - s;
dest[1] = v[1] - s;
dest[2] = v[2] - s;
}
/*!
* @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])
*/
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];
}
/*!
@@ -255,6 +305,36 @@ glm_vec_scale_as(vec3 v, float s, vec3 dest) {
glm_vec_scale(v, s / norm, dest);
}
/*!
* @brief div vector with another component-wise division: d = a / b
*
* @param[in] a vector 1
* @param[in] b vector 2
* @param[out] dest result = (a[0]/b[0], a[1]/b[1], a[2]/b[2])
*/
CGLM_INLINE
void
glm_vec_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];
}
/*!
* @brief div vector with scalar: d = v / s
*
* @param[in] v vector
* @param[in] s scalar
* @param[out] dest result = (a[0]/s, a[1]/s, a[2]/s)
*/
CGLM_INLINE
void
glm_vec_divs(vec3 v, float s, vec3 dest) {
dest[0] = v[0] / s;
dest[1] = v[1] / s;
dest[2] = v[2] / s;
}
/*!
* @brief flip sign of all vec3 members
*

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

@@ -32,7 +32,7 @@
#include <float.h>
/*!
* @brief multiplies individual items, just for convenient like SIMD
* @brief DEPRECATED! use glm_vec4_mul
*
* @param a v1
* @param b v2

152
include/cglm/vec4.h
View File

@@ -28,10 +28,15 @@
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 void glm_vec4_add(vec4 v1, vec4 v2, vec4 dest);
CGLM_INLINE void glm_vec4_sub(vec4 v1, vec4 v2, vec4 dest);
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);
CGLM_INLINE void glm_vec4_subs(vec4 v, float s, vec4 dest);
CGLM_INLINE void glm_vec4_mul(vec4 a, vec4 b, vec4 dest);
CGLM_INLINE void glm_vec4_scale(vec4 v, float s, vec4 dest);
CGLM_INLINE void glm_vec4_scale_as(vec4 v, float s, vec4 dest);
CGLM_INLINE void glm_vec4_div(vec4 a, vec4 b, vec4 dest);
CGLM_INLINE void glm_vec4_divs(vec4 v, float s, vec4 dest);
CGLM_INLINE void glm_vec4_flipsign(vec4 v);
CGLM_INLINE void glm_vec4_inv(vec4 v);
CGLM_INLINE void glm_vec4_inv_to(vec4 v, vec4 dest);
@@ -41,6 +46,7 @@
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 void glm_vec4_clamp(vec4 v, float minVal, float maxVal);
CGLM_INLINE void glm_vec4_lerp(vec4 from, vec4 to, float t, vec4 dest)
*/
#ifndef cglm_vec4_h
@@ -215,44 +221,100 @@ glm_vec4_norm(vec4 vec) {
/*!
* @brief add v2 vector to v1 vector store result in dest
*
* @param[in] v1 vector1
* @param[in] v2 vector2
* @param[in] a vector1
* @param[in] b vector2
* @param[out] dest destination vector
*/
CGLM_INLINE
void
glm_vec4_add(vec4 v1, vec4 v2, vec4 dest) {
glm_vec4_add(vec4 a, vec4 b, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
_mm_store_ps(dest,
_mm_add_ps(_mm_load_ps(v1),
_mm_load_ps(v2)));
_mm_store_ps(dest, _mm_add_ps(_mm_load_ps(a), _mm_load_ps(b)));
#else
dest[0] = v1[0] + v2[0];
dest[1] = v1[1] + v2[1];
dest[2] = v1[2] + v2[2];
dest[3] = v1[3] + v2[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
}
/*!
* @brief subtract v2 vector from v1 vector store result in dest
* @brief add scalar to v vector store result in dest (d = v + vec(s))
*
* @param[in] v1 vector1
* @param[in] v2 vector2
* @param[in] v vector
* @param[in] s scalar
* @param[out] dest destination vector
*/
CGLM_INLINE
void
glm_vec4_sub(vec4 v1, vec4 v2, vec4 dest) {
glm_vec4_adds(vec4 v, float s, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
_mm_store_ps(dest,
_mm_sub_ps(_mm_load_ps(v1),
_mm_load_ps(v2)));
_mm_store_ps(dest, _mm_add_ps(_mm_load_ps(v), _mm_set1_ps(s)));
#else
dest[0] = v1[0] - v2[0];
dest[1] = v1[1] - v2[1];
dest[2] = v1[2] - v2[2];
dest[3] = v1[3] - v2[3];
dest[0] = v1[0] + s;
dest[1] = v1[1] + s;
dest[2] = v1[2] + s;
dest[3] = v1[3] + s;
#endif
}
/*!
* @brief subtract b vector from a vector store result in dest (d = v1 - v2)
*
* @param[in] a vector1
* @param[in] b vector2
* @param[out] dest destination vector
*/
CGLM_INLINE
void
glm_vec4_sub(vec4 a, vec4 b, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
_mm_store_ps(dest, _mm_sub_ps(_mm_load_ps(a), _mm_load_ps(b)));
#else
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
}
/*!
* @brief subtract scalar from v vector store result in dest (d = v - vec(s))
*
* @param[in] v vector
* @param[in] s scalar
* @param[out] dest destination vector
*/
CGLM_INLINE
void
glm_vec4_subs(vec4 v, float s, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
_mm_store_ps(dest, _mm_sub_ps(_mm_load_ps(v), _mm_set1_ps(s)));
#else
dest[0] = v1[0] - s;
dest[1] = v1[1] - s;
dest[2] = v1[2] - s;
dest[3] = v1[3] - s;
#endif
}
/*!
* @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])
*/
CGLM_INLINE
void
glm_vec4_mul(vec4 a, vec4 b, vec4 d) {
#if defined( __SSE__ ) || defined( __SSE2__ )
_mm_store_ps(d, _mm_mul_ps(_mm_load_ps(a), _mm_load_ps(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
}
@@ -267,9 +329,7 @@ CGLM_INLINE
void
glm_vec4_scale(vec4 v, float s, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
_mm_store_ps(dest,
_mm_mul_ps(_mm_load_ps(v),
_mm_set1_ps(s)));
_mm_store_ps(dest, _mm_mul_ps(_mm_load_ps(v), _mm_set1_ps(s)));
#else
dest[0] = v[0] * s;
dest[1] = v[1] * s;
@@ -299,6 +359,43 @@ glm_vec4_scale_as(vec4 v, float s, vec4 dest) {
glm_vec4_scale(v, s / norm, dest);
}
/*!
* @brief div vector with another component-wise division: d = v1 / v2
*
* @param[in] a vector 1
* @param[in] b vector 2
* @param[out] dest result = (a[0]/b[0], a[1]/b[1], a[2]/b[2], a[3]/b[3])
*/
CGLM_INLINE
void
glm_vec4_div(vec4 a, vec4 b, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
_mm_store_ps(dest, _mm_div_ps(_mm_load_ps(a), _mm_load_ps(b)));
#else
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
}
/*!
* @brief div vec4 vector with scalar: d = v / s
*
* @param[in] v vector
* @param[in] s scalar
* @param[out] dest destination vector
*/
CGLM_INLINE
void
glm_vec4_divs(vec4 v, float s, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
_mm_store_ps(dest, _mm_div_ps(_mm_load_ps(v), _mm_set1_ps(s)));
#else
glm_vec4_scale(v, 1.0f / s, dest);
#endif
}
/*!
* @brief flip sign of all vec4 members
*
@@ -308,8 +405,7 @@ CGLM_INLINE
void
glm_vec4_flipsign(vec4 v) {
#if defined( __SSE__ ) || defined( __SSE2__ )
_mm_store_ps(v, _mm_xor_ps(_mm_load_ps(v),
_mm_set1_ps(-0.0f)));
_mm_store_ps(v, _mm_xor_ps(_mm_load_ps(v), _mm_set1_ps(-0.0f)));
#else
v[0] = -v[0];
v[1] = -v[1];

34
src/vec3.c
View File

@@ -76,8 +76,26 @@ glmc_vec_add(vec3 v1, vec3 v2, vec3 dest) {
CGLM_EXPORT
void
glmc_vec_sub(vec3 v1, vec3 v2, vec3 dest) {
glm_vec_sub(v1, v2, dest);
glmc_vec_adds(vec3 v, float s, vec3 dest) {
glm_vec_adds(v, s, dest);
}
CGLM_EXPORT
void
glmc_vec_sub(vec3 a, vec3 b, vec3 dest) {
glm_vec_sub(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec_subs(vec3 v, float s, vec3 dest) {
glm_vec_subs(v, s, dest);
}
CGLM_EXPORT
void
glmc_vec_mul(vec3 a, vec3 b, vec3 d) {
glm_vec_mul(a, b, d);
}
CGLM_EXPORT
@@ -92,6 +110,18 @@ glmc_vec_scale_as(vec3 v, float s, vec3 dest) {
glm_vec_scale_as(v, s, dest);
}
CGLM_EXPORT
void
glmc_vec_div(vec3 a, vec3 b, vec3 dest) {
glm_vec_div(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec_divs(vec3 a, float s, vec3 dest) {
glm_vec_divs(a, s, dest);
}
CGLM_EXPORT
void
glmc_vec_flipsign(vec3 v) {

38
src/vec4.c
View File

@@ -70,14 +70,32 @@ glmc_vec4_norm2(vec4 vec) {
CGLM_EXPORT
void
glmc_vec4_add(vec4 v1, vec4 v2, vec4 dest) {
glm_vec4_add(v1, v2, dest);
glmc_vec4_add(vec4 a, vec4 b, vec4 dest) {
glm_vec4_add(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec4_sub(vec4 v1, vec4 v2, vec4 dest) {
glm_vec4_sub(v1, v2, dest);
glmc_vec4_adds(vec4 v, float s, vec4 dest) {
glm_vec4_adds(v, s, dest);
}
CGLM_EXPORT
void
glmc_vec4_sub(vec4 a, vec4 b, vec4 dest) {
glm_vec4_sub(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec4_subs(vec4 v, float s, vec4 dest) {
glm_vec4_subs(v, s, dest);
}
CGLM_EXPORT
void
glmc_vec4_mul(vec4 a, vec4 b, vec4 d) {
glm_vec4_mul(a, b, d);
}
CGLM_EXPORT
@@ -92,6 +110,18 @@ glmc_vec4_scale_as(vec3 v, float s, vec3 dest) {
glm_vec4_scale_as(v, s, dest);
}
CGLM_EXPORT
void
glmc_vec4_div(vec4 a, vec4 b, vec4 dest) {
glm_vec4_div(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec4_divs(vec4 v, float s, vec4 dest) {
glm_vec4_divs(v, s, dest);
}
CGLM_EXPORT
void
glmc_vec4_flipsign(vec4 v) {

33
test/src/test_vec3.c
View File

@@ -9,7 +9,7 @@
void
test_vec3(void **state) {
vec3 v;
vec3 v, v1;
/* test zero */
glm_vec_zero(v);
@@ -18,4 +18,35 @@ test_vec3(void **state) {
/* test one */
glm_vec_one(v);
test_assert_vec3_eq(GLM_VEC3_ONE, v);
/* adds, subs, div, divs, mul */
glm_vec_add(v, GLM_VEC3_ONE, v);
assert_true(glmc_vec_eq_eps(v, 2));
glm_vec_adds(v, 10, v);
assert_true(glmc_vec_eq_eps(v, 12));
glm_vec_sub(v, GLM_VEC3_ONE, v);
assert_true(glmc_vec_eq_eps(v, 11));
glm_vec_subs(v, 1, v);
assert_true(glmc_vec_eq_eps(v, 10));
glm_vec_broadcast(2, v1);
glm_vec_div(v, v1, v);
assert_true(glmc_vec_eq_eps(v, 5));
glm_vec_divs(v, 0.5, v);
assert_true(glmc_vec_eq_eps(v, 10));
glm_vec_mul(v, v1, v);
assert_true(glmc_vec_eq_eps(v, 20));
glm_vec_scale(v, 0.5, v);
assert_true(glmc_vec_eq_eps(v, 10));
glm_vec_normalize_to(v, v1);
glm_vec_scale(v1, 0.8, v1);
glm_vec_scale_as(v, 0.8, v);
test_assert_vec3_eq(v1, v);
}

31
test/src/test_vec4.c
View File

@@ -78,4 +78,35 @@ test_vec4(void **state) {
/* test one */
glm_vec4_one(v);
test_assert_vec4_eq(GLM_VEC4_ONE, v);
/* adds, subs, div, divs, mul */
glm_vec4_add(v, GLM_VEC4_ONE, v);
assert_true(glmc_vec4_eq_eps(v, 2));
glm_vec4_adds(v, 10, v);
assert_true(glmc_vec4_eq_eps(v, 12));
glm_vec4_sub(v, GLM_VEC4_ONE, v);
assert_true(glmc_vec4_eq_eps(v, 11));
glm_vec4_subs(v, 1, v);
assert_true(glmc_vec4_eq_eps(v, 10));
glm_vec4_broadcast(2, v1);
glm_vec4_div(v, v1, v);
assert_true(glmc_vec4_eq_eps(v, 5));
glm_vec4_divs(v, 0.5, v);
assert_true(glmc_vec4_eq_eps(v, 10));
glm_vec4_mul(v, v1, v);
assert_true(glmc_vec4_eq_eps(v, 20));
glm_vec4_scale(v, 0.5, v);
assert_true(glmc_vec4_eq_eps(v, 10));
glm_vec4_normalize_to(v, v1);
glm_vec4_scale(v1, 0.8, v1);
glm_vec4_scale_as(v, 0.8, v);
test_assert_vec4_eq(v1, v);
}