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

Merge pull request #44 from recp/vector

Browse Source 
new vector functions and optimizations
This commit is contained in:
Recep Aslantas
2018-04-14 09:19:51 +03:00
committed by GitHub
parent 725fac75d0 d6395d4fb8
commit ca9f61dd74
18 changed files with 1222 additions and 108 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -24,6 +24,14 @@ CGLM_EXPORT
void
glmc_vec_copy(vec3 a, vec3 dest);
CGLM_EXPORT
void
glmc_vec_zero(vec3 v);
CGLM_EXPORT
void
glmc_vec_one(vec3 v);
CGLM_EXPORT
float
glmc_vec_dot(vec3 a, vec3 b);
@@ -54,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
@@ -64,6 +84,30 @@ 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_addadd(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec_subadd(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec_muladd(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec_muladds(vec3 a, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec_flipsign(vec3 v);

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

@@ -21,6 +21,14 @@ CGLM_EXPORT
void
glmc_vec4(vec3 v3, float last, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_zero(vec4 v);
CGLM_EXPORT
void
glmc_vec4_one(vec4 v);
CGLM_EXPORT
void
glmc_vec4_copy3(vec4 a, vec3 dest);
@@ -51,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
@@ -65,6 +85,30 @@ 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_addadd(vec4 a, vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_subadd(vec4 a, vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_muladd(vec4 a, vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_muladds(vec4 a, float s, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_flipsign(vec4 v);

6
include/cglm/simd/intrin.h
View File

@@ -40,6 +40,12 @@ glm_simd_dot(__m128 a, __m128 b) {
return _mm_add_ps(x0, _mm_shuffle1_ps(x0, 0, 1, 0, 1));
}
CGLM_INLINE
__m128
glm_simd_norm(__m128 a) {
return _mm_sqrt_ps(glm_simd_dot(a, a));
}
#endif
/* x86, x64 */

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

261
include/cglm/vec3.h
View File

@@ -28,10 +28,18 @@
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_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);
@@ -59,6 +67,7 @@
#define cglm_vec3_h
#include "common.h"
#include "vec4.h"
#include "vec3-ext.h"
#include "util.h"
@@ -103,6 +112,32 @@ glm_vec_copy(vec3 a, vec3 dest) {
dest[2] = a[2];
}
/*!
* @brief make vector zero
*
* @param[in, out] v vector
*/
CGLM_INLINE
void
glm_vec_zero(vec3 v) {
v[0] = 0.0f;
v[1] = 0.0f;
v[2] = 0.0f;
}
/*!
* @brief make vector one
*
* @param[in, out] v vector
*/
CGLM_INLINE
void
glm_vec_one(vec3 v) {
v[0] = 1.0f;
v[1] = 1.0f;
v[2] = 1.0f;
}
/*!
* @brief vec3 dot product
*
@@ -164,33 +199,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];
}
/*!
@@ -221,14 +301,112 @@ glm_vec_scale_as(vec3 v, float s, vec3 dest) {
float norm;
norm = glm_vec_norm(v);
if (norm == 0) {
glm_vec_copy(v, dest);
if (norm == 0.0f) {
glm_vec_zero(dest);
return;
}
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 add two vectors and add result to sum
*
* it applies += operator so dest must be initialized
*
* @param[in] a vector 1
* @param[in] b vector 2
* @param[out] dest dest += (a + b)
*/
CGLM_INLINE
void
glm_vec_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];
}
/*!
* @brief sub two vectors and add result to dest
*
* it applies += operator so dest must be initialized
*
* @param[in] a vector 1
* @param[in] b vector 2
* @param[out] dest dest += (a + b)
*/
CGLM_INLINE
void
glm_vec_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];
}
/*!
* @brief mul two vectors and add result to dest
*
* it applies += operator so dest must be initialized
*
* @param[in] a vector 1
* @param[in] b vector 2
* @param[out] dest dest += (a * b)
*/
CGLM_INLINE
void
glm_vec_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];
}
/*!
* @brief mul vector with scalar and add result to sum
*
* it applies += operator so dest must be initialized
*
* @param[in] a vector
* @param[in] s scalar
* @param[out] dest dest += (a * b)
*/
CGLM_INLINE
void
glm_vec_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
*
@@ -374,6 +552,12 @@ glm_vec_rotate(vec3 v, float angle, vec3 axis) {
/*!
* @brief apply rotation matrix to vector
*
* matrix format should be (no perspective):
* a b c x
* e f g y
* i j k z
* 0 0 0 w
*
* @param[in] m affine matrix or rot matrix
* @param[in] v vector
* @param[out] dest rotated vector
@@ -381,17 +565,44 @@ glm_vec_rotate(vec3 v, float angle, vec3 axis) {
CGLM_INLINE
void
glm_vec_rotate_m4(mat4 m, vec3 v, vec3 dest) {
vec3 res, x, y, z;
vec4 x, y, z, res;
glm_vec_normalize_to(m[0], x);
glm_vec_normalize_to(m[1], y);
glm_vec_normalize_to(m[2], z);
glm_vec4_normalize_to(m[0], x);
glm_vec4_normalize_to(m[1], y);
glm_vec4_normalize_to(m[2], z);
res[0] = x[0] * v[0] + y[0] * v[1] + z[0] * v[2];
res[1] = x[1] * v[0] + y[1] * v[1] + z[1] * v[2];
res[2] = x[2] * v[0] + y[2] * v[1] + z[2] * v[2];
glm_vec4_scale(x, v[0], res);
glm_vec4_muladds(y, v[1], res);
glm_vec4_muladds(y, v[2], res);
glm_vec_copy(res, dest);
glm_vec3(res, dest);
}
/*!
* @brief apply rotation matrix to vector
*
* @param[in] m affine matrix or rot matrix
* @param[in] v vector
* @param[out] dest rotated vector
*/
CGLM_INLINE
void
glm_vec_rotate_m3(mat3 m, vec3 v, vec3 dest) {
vec4 res, x, y, z;
glm_vec4(m[0], 0.0f, x);
glm_vec4(m[1], 0.0f, y);
glm_vec4(m[2], 0.0f, z);
glm_vec4_normalize(x);
glm_vec4_normalize(y);
glm_vec4_normalize(z);
glm_vec4_scale(x, v[0], res);
glm_vec4_muladds(y, v[1], res);
glm_vec4_muladds(y, v[2], res);
glm_vec3(res, dest);
}
/*!

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

356
include/cglm/vec4.h
View File

@@ -28,10 +28,18 @@
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_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_inv(vec4 v);
CGLM_INLINE void glm_vec4_inv_to(vec4 v, vec4 dest);
@@ -41,6 +49,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
@@ -111,6 +120,42 @@ glm_vec4_copy(vec4 v, vec4 dest) {
#endif
}
/*!
* @brief make vector zero
*
* @param[in, out] v vector
*/
CGLM_INLINE
void
glm_vec4_zero(vec4 v) {
#if defined( __SSE__ ) || defined( __SSE2__ )
_mm_store_ps(v, _mm_setzero_ps());
#else
v[0] = 0.0f;
v[1] = 0.0f;
v[2] = 0.0f;
v[3] = 0.0f;
#endif
}
/*!
* @brief make vector one
*
* @param[in, out] v vector
*/
CGLM_INLINE
void
glm_vec4_one(vec4 v) {
#if defined( __SSE__ ) || defined( __SSE2__ )
_mm_store_ps(v, _mm_set1_ps(1.0f));
#else
v[0] = 1.0f;
v[1] = 1.0f;
v[2] = 1.0f;
v[3] = 1.0f;
#endif
}
/*!
* @brief vec4 dot product
*
@@ -146,7 +191,15 @@ glm_vec4_dot(vec4 a, vec4 b) {
CGLM_INLINE
float
glm_vec4_norm2(vec4 v) {
return glm_vec4_dot(v, v);
#if defined( __SSE__ ) || defined( __SSE2__ )
__m128 x0;
x0 = _mm_load_ps(v);
x0 = _mm_mul_ps(x0, x0);
x0 = _mm_add_ps(x0, _mm_shuffle1_ps(x0, 1, 0, 3, 2));
return _mm_cvtss_f32(_mm_add_ss(x0, _mm_shuffle1_ps(x0, 0, 1, 0, 1)));
#else
return v[0] * v[0] + v[1] * v[1] + v[2] * v[2] + v[3] * v[3];
#endif
}
/*!
@@ -159,50 +212,112 @@ glm_vec4_norm2(vec4 v) {
CGLM_INLINE
float
glm_vec4_norm(vec4 vec) {
#if defined( __SSE__ ) || defined( __SSE2__ )
__m128 x0;
x0 = _mm_load_ps(vec);
return _mm_cvtss_f32(_mm_sqrt_ss(glm_simd_dot(x0, x0)));
#else
return sqrtf(glm_vec4_norm2(vec));
#endif
}
/*!
* @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] = v[0] + s;
dest[1] = v[1] + s;
dest[2] = v[2] + s;
dest[3] = v[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] = v[0] - s;
dest[1] = v[1] - s;
dest[2] = v[2] - s;
dest[3] = v[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
}
@@ -217,9 +332,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;
@@ -241,14 +354,148 @@ glm_vec4_scale_as(vec4 v, float s, vec4 dest) {
float norm;
norm = glm_vec4_norm(v);
if (norm == 0) {
glm_vec4_copy(v, dest);
if (norm == 0.0f) {
glm_vec4_zero(dest);
return;
}
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 add two vectors and add result to sum
*
* it applies += operator so dest must be initialized
*
* @param[in] a vector 1
* @param[in] b vector 2
* @param[out] dest dest += (a + b)
*/
CGLM_INLINE
void
glm_vec4_addadd(vec4 a, vec4 b, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
_mm_store_ps(dest, _mm_add_ps(_mm_load_ps(dest),
_mm_add_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 sub two vectors and add result to dest
*
* it applies += operator so dest must be initialized
*
* @param[in] a vector 1
* @param[in] b vector 2
* @param[out] dest dest += (a - b)
*/
CGLM_INLINE
void
glm_vec4_subadd(vec4 a, vec4 b, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
_mm_store_ps(dest, _mm_add_ps(_mm_load_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 mul two vectors and add result to dest
*
* it applies += operator so dest must be initialized
*
* @param[in] a vector 1
* @param[in] b vector 2
* @param[out] dest dest += (a * b)
*/
CGLM_INLINE
void
glm_vec4_muladd(vec4 a, vec4 b, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
_mm_store_ps(dest, _mm_add_ps(_mm_load_ps(dest),
_mm_mul_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 mul vector with scalar and add result to sum
*
* it applies += operator so dest must be initialized
*
* @param[in] a vector
* @param[in] s scalar
* @param[out] dest dest += (a * b)
*/
CGLM_INLINE
void
glm_vec4_muladds(vec4 a, float s, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
_mm_store_ps(dest, _mm_add_ps(_mm_load_ps(dest),
_mm_mul_ps(_mm_load_ps(a),
_mm_set1_ps(s))));
#else
dest[0] += a[0] * s;
dest[1] += a[1] * s;
dest[2] += a[2] * s;
dest[3] += a[3] * s;
#endif
}
/*!
* @brief flip sign of all vec4 members
*
@@ -258,8 +505,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];
@@ -312,26 +558,6 @@ glm_vec4_inv_to(vec4 v, vec4 dest) {
glm_vec4_flipsign(dest);
}
/*!
* @brief normalize vec4 and store result in same vec
*
* @param[in, out] v vector
*/
CGLM_INLINE
void
glm_vec4_normalize(vec4 v) {
float norm;
norm = glm_vec4_norm(v);
if (norm == 0.0f) {
v[0] = v[1] = v[2] = v[3] = 0.0f;
return;
}
glm_vec4_scale(v, 1.0f / norm, v);
}
/*!
* @brief normalize vec4 to dest
*
@@ -341,16 +567,44 @@ glm_vec4_normalize(vec4 v) {
CGLM_INLINE
void
glm_vec4_normalize_to(vec4 vec, vec4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
__m128 xdot, x0;
float dot;
x0 = _mm_load_ps(vec);
xdot = glm_simd_dot(x0, x0);
dot = _mm_cvtss_f32(xdot);
if (dot == 0.0f) {
_mm_store_ps(dest, _mm_setzero_ps());
return;
}
_mm_store_ps(dest, _mm_div_ps(x0, _mm_sqrt_ps(xdot)));
#else
float norm;
norm = glm_vec4_norm(vec);
if (norm == 0.0f) {
dest[0] = dest[1] = dest[2] = dest[3] = 0.0f;
glm_vec4_broadcast(0.0f, dest);
return;
}
glm_vec4_scale(vec, 1.0f / norm, dest);
#endif
}
/*!
* @brief normalize vec4 and store result in same vec
*
* @param[in, out] v vector
*/
CGLM_INLINE
void
glm_vec4_normalize(vec4 v) {
glm_vec4_normalize_to(v, v);
}
/**