mirror of
https://github.com/recp/cglm.git
synced 2025-10-03 16:51:35 +00:00
359 lines
6.3 KiB
C
359 lines
6.3 KiB
C
/*
|
|
* Copyright (c), Recep Aslantas.
|
|
*
|
|
* MIT License (MIT), http://opensource.org/licenses/MIT
|
|
* 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
|
|
*/
|
|
|
|
#ifndef cglm_vec_h
|
|
#define cglm_vec_h
|
|
|
|
#include "cglm-common.h"
|
|
#include "cglm-intrin.h"
|
|
|
|
/*!
|
|
* @brief copy all members of [a] to [dest]
|
|
*
|
|
* @param[in] a source
|
|
* @param[out] dest destination
|
|
*/
|
|
CGLM_INLINE
|
|
void
|
|
glm_vec_dup(vec3 a, vec3 dest) {
|
|
dest[0] = a[0];
|
|
dest[1] = a[1];
|
|
dest[2] = a[2];
|
|
}
|
|
|
|
/*!
|
|
* @brief copy first 3 members of [a] to [dest]
|
|
*
|
|
* @param[in] a source
|
|
* @param[out] dest destination
|
|
*/
|
|
CGLM_INLINE
|
|
void
|
|
glm_vec4_dup3(vec4 a, vec3 dest) {
|
|
dest[0] = a[0];
|
|
dest[1] = a[1];
|
|
dest[2] = a[2];
|
|
}
|
|
|
|
/*!
|
|
* @brief copy all members of [a] to [dest]
|
|
*
|
|
* @param[in] a source
|
|
* @param[out] dest destination
|
|
*/
|
|
CGLM_INLINE
|
|
void
|
|
glm_vec4_dup(vec4 v, vec4 dest) {
|
|
#if defined( __SSE__ ) || defined( __SSE2__ )
|
|
_mm_store_ps(dest, _mm_load_ps(v));
|
|
#else
|
|
dest[0] = v[0];
|
|
dest[1] = v[1];
|
|
dest[2] = v[2];
|
|
dest[3] = v[3];
|
|
#endif
|
|
}
|
|
|
|
/*!
|
|
* @brief vec3 dot product
|
|
*
|
|
* @param[in] a
|
|
* @param[in] b
|
|
*
|
|
* @return dot product
|
|
*/
|
|
CGLM_INLINE
|
|
float
|
|
glm_vec_dot(vec3 a, vec3 b) {
|
|
return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
|
|
}
|
|
|
|
/*!
|
|
* @brief vec4 dot product
|
|
*
|
|
* @param[in] a
|
|
* @param[in] b
|
|
*
|
|
* @return dot product
|
|
*/
|
|
CGLM_INLINE
|
|
float
|
|
glm_vec4_dot(vec4 a, vec4 b) {
|
|
return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
|
|
}
|
|
|
|
/*!
|
|
* @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 (magnitude) of vec3
|
|
*
|
|
* @param[in] vec
|
|
*
|
|
* @return norm
|
|
*/
|
|
CGLM_INLINE
|
|
float
|
|
glm_vec_norm(vec3 vec) {
|
|
return sqrtf(vec[0] * vec[0] + vec[1] * vec[1] + vec[2] * vec[2]);
|
|
}
|
|
|
|
/*!
|
|
* @brief norm (magnitude) of vec4
|
|
*
|
|
* @param[in] vec
|
|
*
|
|
* @return norm
|
|
*/
|
|
CGLM_INLINE
|
|
float
|
|
glm_vec4_norm(vec4 vec) {
|
|
return sqrtf(vec[0] * vec[0] + vec[1] * vec[1]
|
|
+ vec[2] * vec[2] + vec[3] * vec[3]);
|
|
}
|
|
|
|
/*!
|
|
* @brief normalize vec3 to dest
|
|
*
|
|
* @param[in] vec source
|
|
* @param[out] dest destination
|
|
*/
|
|
CGLM_INLINE
|
|
void
|
|
glm_vec_normalize_to(vec3 vec, vec3 dest) {
|
|
float norm;
|
|
|
|
norm = glm_vec_norm(vec);
|
|
|
|
if (norm == 0.0f) {
|
|
dest[0] = dest[1] = dest[2] = 0.0f;
|
|
return;
|
|
}
|
|
|
|
dest[0] = vec[0] / norm;
|
|
dest[1] = vec[1] / norm;
|
|
dest[2] = vec[2] / norm;
|
|
}
|
|
|
|
/*!
|
|
* @brief normalize vec3 and store result in same vec
|
|
*
|
|
* @param[in, out] v vector
|
|
*/
|
|
CGLM_INLINE
|
|
void
|
|
glm_vec_normalize(vec3 v) {
|
|
float norm;
|
|
|
|
norm = glm_vec_norm(v);
|
|
|
|
if (norm == 0.0f) {
|
|
v[0] = v[1] = v[2] = 0.0f;
|
|
return;
|
|
}
|
|
|
|
v[0] = v[0] / norm;
|
|
v[1] = v[1] / norm;
|
|
v[2] = v[2] / norm;
|
|
}
|
|
|
|
/*!
|
|
* @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_vec_norm(v);
|
|
|
|
if (norm == 0.0f) {
|
|
v[0] = v[1] = v[2] = v[3] = 0.0f;
|
|
return;
|
|
}
|
|
|
|
v[0] = v[0] / norm;
|
|
v[1] = v[1] / norm;
|
|
v[2] = v[2] / norm;
|
|
v[3] = v[3] / norm;
|
|
}
|
|
|
|
/*!
|
|
* @brief add v2 vector to v1 vector store result in dest
|
|
*
|
|
* @param[in] v1
|
|
* @param[in] v2
|
|
* @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];
|
|
}
|
|
|
|
/*!
|
|
* @brief add v2 vector to v1 vector store result in dest
|
|
*
|
|
* @param[in] v1
|
|
* @param[in] v2
|
|
* @param[out] dest destination vector
|
|
*/
|
|
CGLM_INLINE
|
|
void
|
|
glm_vec4_add(vec4 v1, vec4 v2, vec4 dest) {
|
|
#if defined( __SSE__ ) || defined( __SSE2__ )
|
|
_mm_store_ps(dest,
|
|
_mm_add_ps(_mm_load_ps(v1),
|
|
_mm_load_ps(v2)));
|
|
#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];
|
|
#endif
|
|
}
|
|
|
|
/*!
|
|
* @brief subtract v2 vector from v1 vector store result in dest
|
|
*
|
|
* @param[in] v1
|
|
* @param[in] v2
|
|
* @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];
|
|
}
|
|
|
|
/*!
|
|
* @brief subtract v2 vector from v1 vector store result in dest
|
|
*
|
|
* @param[in] v1
|
|
* @param[in] v2
|
|
* @param[out] dest destination vector
|
|
*/
|
|
CGLM_INLINE
|
|
void
|
|
glm_vec4_sub(vec4 v1, vec4 v2, vec4 dest) {
|
|
#if defined( __SSE__ ) || defined( __SSE2__ )
|
|
_mm_store_ps(dest,
|
|
_mm_sub_ps(_mm_load_ps(v1),
|
|
_mm_load_ps(v2)));
|
|
#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];
|
|
#endif
|
|
}
|
|
|
|
/*!
|
|
* @brief multiply vec3 vector with scalar
|
|
*
|
|
* @param[in] v vector
|
|
* @param[in] s scalar
|
|
* @param[out] dest destination vector
|
|
*/
|
|
CGLM_INLINE
|
|
void
|
|
glm_vec_scale(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
|
|
*
|
|
* @param[in] v vector
|
|
* @param[in] s scalar
|
|
* @param[out] dest destination vector
|
|
*/
|
|
CGLM_INLINE
|
|
void
|
|
glm_vec_flipsign(vec3 v) {
|
|
v[0] = -v[0];
|
|
v[1] = -v[1];
|
|
v[2] = -v[2];
|
|
}
|
|
|
|
/*!
|
|
* @brief flip sign of all vec4 members
|
|
*
|
|
* @param[in] v vector
|
|
* @param[in] s scalar
|
|
* @param[out] dest destination vector
|
|
*/
|
|
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)));
|
|
#else
|
|
v[0] = -v[0];
|
|
v[1] = -v[1];
|
|
v[2] = -v[2];
|
|
v[3] = -v[3];
|
|
#endif
|
|
}
|
|
|
|
/*!
|
|
* @brief multiply vec4 vector with scalar
|
|
*
|
|
* @param[in] v vector
|
|
* @param[in] s scalar
|
|
* @param[out] dest destination vector
|
|
*/
|
|
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)));
|
|
#else
|
|
dest[0] = v[0] * s;
|
|
dest[1] = v[1] * s;
|
|
dest[2] = v[2] * s;
|
|
dest[3] = v[3] * s;
|
|
#endif
|
|
}
|
|
|
|
CGLM_INLINE
|
|
void
|
|
glm_vec_addvN(vec3 * __restrict vecs[], int len, vec3 dest) {
|
|
/* TODO: */
|
|
}
|
|
|
|
#endif /* cglm_vec_h */
|