/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
/*
Macros:
GLMS_VEC3_ONE_INIT
GLMS_VEC3_ZERO_INIT
GLMS_VEC3_ONE
GLMS_VEC3_ZERO
GLMS_YUP
GLMS_ZUP
GLMS_XUP
Functions:
CGLM_INLINE vec3s glms_vec3(vec4s v4);
CGLM_INLINE void glms_vec3_pack(vec3s dst[], vec3 src[], size_t len);
CGLM_INLINE void glms_vec3_unpack(vec3 dst[], vec3s src[], size_t len);
CGLM_INLINE vec3s glms_vec3_zero(void);
CGLM_INLINE vec3s glms_vec3_one(void);
CGLM_INLINE float glms_vec3_dot(vec3s a, vec3s b);
CGLM_INLINE float glms_vec3_norm2(vec3s v);
CGLM_INLINE float glms_vec3_norm(vec3s v);
CGLM_INLINE float glms_vec3_norm_one(vec3s v);
CGLM_INLINE float glms_vec3_norm_inf(vec3s v);
CGLM_INLINE vec3s glms_vec3_add(vec3s a, vec3s b);
CGLM_INLINE vec3s glms_vec3_adds(vec3s a, float s);
CGLM_INLINE vec3s glms_vec3_sub(vec3s a, vec3s b);
CGLM_INLINE vec3s glms_vec3_subs(vec3s a, float s);
CGLM_INLINE vec3s glms_vec3_mul(vec3s a, vec3s b);
CGLM_INLINE vec3s glms_vec3_scale(vec3s v, float s);
CGLM_INLINE vec3s glms_vec3_scale_as(vec3s v, float s);
CGLM_INLINE vec3s glms_vec3_div(vec3s a, vec3s b);
CGLM_INLINE vec3s glms_vec3_divs(vec3s a, float s);
CGLM_INLINE vec3s glms_vec3_addadd(vec3s a, vec3s b, vec3s dest);
CGLM_INLINE vec3s glms_vec3_subadd(vec3s a, vec3s b, vec3s dest);
CGLM_INLINE vec3s glms_vec3_muladd(vec3s a, vec3s b, vec3s dest);
CGLM_INLINE vec3s glms_vec3_muladds(vec3s a, float s, vec3s dest);
CGLM_INLINE vec3s glms_vec3_maxadd(vec3s a, vec3s b, vec3s dest);
CGLM_INLINE vec3s glms_vec3_minadd(vec3s a, vec3s b, vec3s dest);
CGLM_INLINE vec3s glms_vec3_flipsign(vec3s v);
CGLM_INLINE vec3s glms_vec3_negate(vec3s v);
CGLM_INLINE vec3s glms_vec3_inv(vec3s v);
CGLM_INLINE vec3s glms_vec3_normalize(vec3s v);
CGLM_INLINE vec3s glms_vec3_cross(vec3s a, vec3s b);
CGLM_INLINE vec3s glms_vec3_crossn(vec3s a, vec3s b);
CGLM_INLINE float glms_vec3_angle(vec3s a, vec3s b);
CGLM_INLINE vec3s glms_vec3_rotate(vec3s v, float angle, vec3s axis);
CGLM_INLINE vec3s glms_vec3_rotate_m4(mat4s m, vec3s v);
CGLM_INLINE vec3s glms_vec3_rotate_m3(mat3s m, vec3s v);
CGLM_INLINE vec3s glms_vec3_proj(vec3s a, vec3s b);
CGLM_INLINE vec3s glms_vec3_center(vec3s a, vec3s b);
CGLM_INLINE float glms_vec3_distance(vec3s a, vec3s b);
CGLM_INLINE float glms_vec3_distance2(vec3s a, vec3s b);
CGLM_INLINE vec3s glms_vec3_maxv(vec3s a, vec3s b);
CGLM_INLINE vec3s glms_vec3_minv(vec3s a, vec3s b);
CGLM_INLINE vec3s glms_vec3_ortho(vec3s v);
CGLM_INLINE vec3s glms_vec3_clamp(vec3s v, float minVal, float maxVal);
CGLM_INLINE vec3s glms_vec3_lerp(vec3s from, vec3s to, float t);
CGLM_INLINE vec3s glms_vec3_lerpc(vec3s from, vec3s to, float t);
CGLM_INLINE vec3s glms_vec3_mix(vec3s from, vec3s to, float t);
CGLM_INLINE vec3s glms_vec3_mixc(vec3s from, vec3s to, float t);
CGLM_INLINE vec3s glms_vec3_step_uni(float edge, vec3s x);
CGLM_INLINE vec3s glms_vec3_step(vec3s edge, vec3s x);
CGLM_INLINE vec3s glms_vec3_smoothstep_uni(float edge0, float edge1, vec3s x);
CGLM_INLINE vec3s glms_vec3_smoothstep(vec3s edge0, vec3s edge1, vec3s x);
CGLM_INLINE vec3s glms_vec3_smoothinterp(vec3s from, vec3s to, float t);
CGLM_INLINE vec3s glms_vec3_smoothinterpc(vec3s from, vec3s to, float t);
CGLM_INLINE vec3s glms_vec3_swizzle(vec3s v, int mask);
Convenient:
CGLM_INLINE vec3s glms_cross(vec3s a, vec3s b);
CGLM_INLINE float glms_dot(vec3s a, vec3s b);
CGLM_INLINE vec3s glms_normalize(vec3s v);
*/
#ifndef cglms_vec3s_h
#define cglms_vec3s_h
#include "../common.h"
#include "../types-struct.h"
#include "../util.h"
#include "../vec3.h"
#include "vec3-ext.h"
#define GLMS_VEC3_ONE_INIT {GLM_VEC3_ONE_INIT}
#define GLMS_VEC3_ZERO_INIT {GLM_VEC3_ZERO_INIT}
#define GLMS_VEC3_ONE ((vec3s)GLMS_VEC3_ONE_INIT)
#define GLMS_VEC3_ZERO ((vec3s)GLMS_VEC3_ZERO_INIT)
#define GLMS_YUP ((vec3s){{0.0f, 1.0f, 0.0f}})
#define GLMS_ZUP ((vec3s){{0.0f, 0.0f, 1.0f}})
#define GLMS_XUP ((vec3s){{1.0f, 0.0f, 0.0f}})
/*!
* @brief init vec3 using vec4
*
* @param[in] v4 vector4
* @returns destination
*/
CGLM_INLINE
vec3s
glms_vec3(vec4s v4) {
vec3s r;
glm_vec3(v4.raw, r.raw);
return r;
}
/*!
* @brief pack an array of vec3 into an array of vec3s
*
* @param[out] dst array of vec3
* @param[in] src array of vec3s
* @param[in] len number of elements
*/
CGLM_INLINE
void
glms_vec3_pack(vec3s dst[], vec3 src[], size_t len) {
size_t i;
for (i = 0; i < len; i++) {
glm_vec3_copy(src[i], dst[i].raw);
}
}
/*!
* @brief unpack an array of vec3s into an array of vec3
*
* @param[out] dst array of vec3s
* @param[in] src array of vec3
* @param[in] len number of elements
*/
CGLM_INLINE
void
glms_vec3_unpack(vec3 dst[], vec3s src[], size_t len) {
size_t i;
for (i = 0; i < len; i++) {
glm_vec3_copy(src[i].raw, dst[i]);
}
}
/*!
* @brief make vector zero
*
* @returns zero vector
*/
CGLM_INLINE
vec3s
glms_vec3_zero(void) {
vec3s r;
glm_vec3_zero(r.raw);
return r;
}
/*!
* @brief make vector one
*
* @returns one vector
*/
CGLM_INLINE
vec3s
glms_vec3_one(void) {
vec3s r;
glm_vec3_one(r.raw);
return r;
}
/*!
* @brief vec3 dot product
*
* @param[in] a vector1
* @param[in] b vector2
*
* @return dot product
*/
CGLM_INLINE
float
glms_vec3_dot(vec3s a, vec3s b) {
return glm_vec3_dot(a.raw, b.raw);
}
/*!
* @brief norm * norm (magnitude) of vec
*
* we can use this func instead of calling norm * norm, because it would call
* sqrtf fuction twice but with this func we can avoid func call, maybe this is
* not good name for this func
*
* @param[in] v vector
*
* @return norm * norm
*/
CGLM_INLINE
float
glms_vec3_norm2(vec3s v) {
return glm_vec3_norm2(v.raw);
}
/*!
* @brief norm (magnitude) of vec3
*
* @param[in] v vector
*
* @return norm
*/
CGLM_INLINE
float
glms_vec3_norm(vec3s v) {
return glm_vec3_norm(v.raw);
}
/*!
* @brief L1 norm of vec3
* Also known as Manhattan Distance or Taxicab norm.
* L1 Norm is the sum of the magnitudes of the vectors in a space.
* It is calculated as the sum of the absolute values of the vector components.
* In this norm, all the components of the vector are weighted equally.
*
* This computes:
* R = |v[0]| + |v[1]| + |v[2]|
*
* @param[in] v vector
*
* @return L1 norm
*/
CGLM_INLINE
float
glms_vec3_norm_one(vec3s v) {
return glm_vec3_norm_one(v.raw);
}
/*!
* @brief Infinity norm of vec3
* Also known as Maximum norm.
* Infinity Norm is the largest magnitude among each element of a vector.
* It is calculated as the maximum of the absolute values of the vector components.
*
* This computes:
* inf norm = max(|v[0]|, |v[1]|, |v[2]|)
*
* @param[in] v vector
*
* @return Infinity norm
*/
CGLM_INLINE
float
glms_vec3_norm_inf(vec3s v) {
return glm_vec3_norm_inf(v.raw);
}
/*!
* @brief add a vector to b vector store result in dest
*
* @param[in] a vector1
* @param[in] b vector2
* @returns destination vector
*/
CGLM_INLINE
vec3s
glms_vec3_add(vec3s a, vec3s b) {
vec3s r;
glm_vec3_add(a.raw, b.raw, r.raw);
return r;
}
/*!
* @brief add scalar to v vector store result in dest (d = v + s)
*
* @param[in] a vector
* @param[in] s scalar
* @returns destination vector
*/
CGLM_INLINE
vec3s
glms_vec3_adds(vec3s a, float s) {
vec3s r;
glm_vec3_adds(a.raw, s, r.raw);
return r;
}
/*!
* @brief subtract b vector from a vector store result in dest
*
* @param[in] a vector1
* @param[in] b vector2
* @returns destination vector
*/
CGLM_INLINE
vec3s
glms_vec3_sub(vec3s a, vec3s b) {
vec3s r;
glm_vec3_sub(a.raw, b.raw, r.raw);
return r;
}
/*!
* @brief subtract scalar from v vector store result in dest (d = v - s)
*
* @param[in] a vector
* @param[in] s scalar
* @returns destination vector
*/
CGLM_INLINE
vec3s
glms_vec3_subs(vec3s a, float s) {
vec3s r;
glm_vec3_subs(a.raw, s, r.raw);
return r;
}
/*!
* @brief multiply two vector (component-wise multiplication)
*
* @param a vector1
* @param b vector2
* @returns v3 = (a[0] * b[0], a[1] * b[1], a[2] * b[2])
*/
CGLM_INLINE
vec3s
glms_vec3_mul(vec3s a, vec3s b) {
vec3s r;
glm_vec3_mul(a.raw, b.raw, r.raw);
return r;
}
/*!
* @brief multiply/scale vec3 vector with scalar: result = v * s
*
* @param[in] v vector
* @param[in] s scalar
* @returns destination vector
*/
CGLM_INLINE
vec3s
glms_vec3_scale(vec3s v, float s) {
vec3s r;
glm_vec3_scale(v.raw, s, r.raw);
return r;
}
/*!
* @brief make vec3 vector scale as specified: result = unit(v) * s
*
* @param[in] v vector
* @param[in] s scalar
* @returns destination vector
*/
CGLM_INLINE
vec3s
glms_vec3_scale_as(vec3s v, float s) {
vec3s r;
glm_vec3_scale_as(v.raw, s, r.raw);
return r;
}
/*!
* @brief div vector with another component-wise division: d = a / b
*
* @param[in] a vector 1
* @param[in] b vector 2
* @returns result = (a[0]/b[0], a[1]/b[1], a[2]/b[2])
*/
CGLM_INLINE
vec3s
glms_vec3_div(vec3s a, vec3s b) {
vec3s r;
glm_vec3_div(a.raw, b.raw, r.raw);
return r;
}
/*!
* @brief div vector with scalar: d = v / s
*
* @param[in] a vector
* @param[in] s scalar
* @returns result = (a[0]/s, a[1]/s, a[2]/s)
*/
CGLM_INLINE
vec3s
glms_vec3_divs(vec3s a, float s) {
vec3s r;
glm_vec3_divs(a.raw, s, r.raw);
return r;
}
/*!
* @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
* @returns dest += (a + b)
*/
CGLM_INLINE
vec3s
glms_vec3_addadd(vec3s a, vec3s b, vec3s dest) {
glm_vec3_addadd(a.raw, b.raw, dest.raw);
return dest;
}
/*!
* @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
* @returns dest += (a + b)
*/
CGLM_INLINE
vec3s
glms_vec3_subadd(vec3s a, vec3s b, vec3s dest) {
glm_vec3_subadd(a.raw, b.raw, dest.raw);
return dest;
}
/*!
* @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
* @returns dest += (a * b)
*/
CGLM_INLINE
vec3s
glms_vec3_muladd(vec3s a, vec3s b, vec3s dest) {
glm_vec3_muladd(a.raw, b.raw, dest.raw);
return dest;
}
/*!
* @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
* @returns dest += (a * b)
*/
CGLM_INLINE
vec3s
glms_vec3_muladds(vec3s a, float s, vec3s dest) {
glm_vec3_muladds(a.raw, s, dest.raw);
return dest;
}
/*!
* @brief add max of two vector to result/dest
*
* it applies += operator so dest must be initialized
*
* @param[in] a vector 1
* @param[in] b vector 2
* @returns dest += max(a, b)
*/
CGLM_INLINE
vec3s
glms_vec3_maxadd(vec3s a, vec3s b, vec3s dest) {
glm_vec3_maxadd(a.raw, b.raw, dest.raw);
return dest;
}
/*!
* @brief add min of two vector to result/dest
*
* it applies += operator so dest must be initialized
*
* @param[in] a vector 1
* @param[in] b vector 2
* @returns dest += min(a, b)
*/
CGLM_INLINE
vec3s
glms_vec3_minadd(vec3s a, vec3s b, vec3s dest) {
glm_vec3_minadd(a.raw, b.raw, dest.raw);
return dest;
}
/*!
* @brief negate vector components and store result in dest
*
* @param[in] v vector
* @returns result vector
*/
CGLM_INLINE
vec3s
glms_vec3_flipsign(vec3s v) {
glm_vec3_flipsign(v.raw);
return v;
}
/*!
* @brief negate vector components
*
* @param[in] v vector
* @returns negated vector
*/
CGLM_INLINE
vec3s
glms_vec3_negate(vec3s v) {
glm_vec3_negate(v.raw);
return v;
}
/*!
* @brief normalize vec3 and store result in same vec
*
* @param[in] v vector
* @returns normalized vector
*/
CGLM_INLINE
vec3s
glms_vec3_normalize(vec3s v) {
glm_vec3_normalize(v.raw);
return v;
}
/*!
* @brief cross product of two vector (RH)
*
* @param[in] a vector 1
* @param[in] b vector 2
* @returns destination
*/
CGLM_INLINE
vec3s
glms_vec3_cross(vec3s a, vec3s b) {
vec3s r;
glm_vec3_cross(a.raw, b.raw, r.raw);
return r;
}
/*!
* @brief cross product of two vector (RH) and normalize the result
*
* @param[in] a vector 1
* @param[in] b vector 2
* @returns destination
*/
CGLM_INLINE
vec3s
glms_vec3_crossn(vec3s a, vec3s b) {
vec3s r;
glm_vec3_crossn(a.raw, b.raw, r.raw);
return r;
}
/*!
* @brief angle betwen two vector
*
* @param[in] a vector1
* @param[in] b vector2
*
* @return angle as radians
*/
CGLM_INLINE
float
glms_vec3_angle(vec3s a, vec3s b) {
return glm_vec3_angle(a.raw, b.raw);
}
/*!
* @brief rotate vec3 around axis by angle using Rodrigues' rotation formula
*
* @param[in] v vector
* @param[in] axis axis vector (must be unit vector)
* @param[in] angle angle by radians
* @returns rotated vector
*/
CGLM_INLINE
vec3s
glms_vec3_rotate(vec3s v, float angle, vec3s axis) {
glm_vec3_rotate(v.raw, angle, axis.raw);
return v;
}
/*!
* @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
* @returns rotated vector
*/
CGLM_INLINE
vec3s
glms_vec3_rotate_m4(mat4s m, vec3s v) {
vec3s r;
glm_vec3_rotate_m4(m.raw, v.raw, r.raw);
return r;
}
/*!
* @brief apply rotation matrix to vector
*
* @param[in] m affine matrix or rot matrix
* @param[in] v vector
* @returns rotated vector
*/
CGLM_INLINE
vec3s
glms_vec3_rotate_m3(mat3s m, vec3s v) {
vec3s r;
glm_vec3_rotate_m3(m.raw, v.raw, r.raw);
return r;
}
/*!
* @brief project a vector onto b vector
*
* @param[in] a vector1
* @param[in] b vector2
* @returns projected vector
*/
CGLM_INLINE
vec3s
glms_vec3_proj(vec3s a, vec3s b) {
vec3s r;
glm_vec3_proj(a.raw, b.raw, r.raw);
return r;
}
/**
* @brief find center point of two vector
*
* @param[in] a vector1
* @param[in] b vector2
* @returns center point
*/
CGLM_INLINE
vec3s
glms_vec3_center(vec3s a, vec3s b) {
vec3s r;
glm_vec3_center(a.raw, b.raw, r.raw);
return r;
}
/**
* @brief distance between two vectors
*
* @param[in] a vector1
* @param[in] b vector2
* @return distance
*/
CGLM_INLINE
float
glms_vec3_distance(vec3s a, vec3s b) {
return glm_vec3_distance(a.raw, b.raw);
}
/**
* @brief squared distance between two vectors
*
* @param[in] a vector1
* @param[in] b vector2
* @return squared distance (distance * distance)
*/
CGLM_INLINE
float
glms_vec3_distance2(vec3s a, vec3s b) {
return glm_vec3_distance2(a.raw, b.raw);
}
/*!
* @brief max values of vectors
*
* @param[in] a vector1
* @param[in] b vector2
* @returns destination
*/
CGLM_INLINE
vec3s
glms_vec3_maxv(vec3s a, vec3s b) {
vec3s r;
glm_vec3_maxv(a.raw, b.raw, r.raw);
return r;
}
/*!
* @brief min values of vectors
*
* @param[in] a vector1
* @param[in] b vector2
* @returns destination
*/
CGLM_INLINE
vec3s
glms_vec3_minv(vec3s a, vec3s b) {
vec3s r;
glm_vec3_minv(a.raw, b.raw, r.raw);
return r;
}
/*!
* @brief possible orthogonal/perpendicular vector
*
* @param[in] v vector
* @returns orthogonal/perpendicular vector
*/
CGLM_INLINE
vec3s
glms_vec3_ortho(vec3s v) {
vec3s r;
glm_vec3_ortho(v.raw, r.raw);
return r;
}
/*!
* @brief clamp vector's individual members between min and max values
*
* @param[in] v vector
* @param[in] minVal minimum value
* @param[in] maxVal maximum value
* @returns clamped vector
*/
CGLM_INLINE
vec3s
glms_vec3_clamp(vec3s v, float minVal, float maxVal) {
glm_vec3_clamp(v.raw, minVal, maxVal);
return v;
}
/*!
* @brief linear interpolation between two vectors
*
* formula: from + s * (to - from)
*
* @param[in] from from value
* @param[in] to to value
* @param[in] t interpolant (amount)
* @returns destination
*/
CGLM_INLINE
vec3s
glms_vec3_lerp(vec3s from, vec3s to, float t) {
vec3s r;
glm_vec3_lerp(from.raw, to.raw, t, r.raw);
return r;
}
/*!
* @brief linear interpolation between two vectors (clamped)
*
* formula: from + s * (to - from)
*
* @param[in] from from value
* @param[in] to to value
* @param[in] t interpolant (amount) clamped between 0 and 1
* @returns destination
*/
CGLM_INLINE
vec3s
glms_vec3_lerpc(vec3s from, vec3s to, float t) {
vec3s r;
glm_vec3_lerpc(from.raw, to.raw, t, r.raw);
return r;
}
/*!
* @brief linear interpolation between two vectors
*
* formula: from + s * (to - from)
*
* @param[in] from from value
* @param[in] to to value
* @param[in] t interpolant (amount)
* @returns destination
*/
CGLM_INLINE
vec3s
glms_vec3_mix(vec3s from, vec3s to, float t) {
vec3s r;
glm_vec3_mix(from.raw, to.raw, t, r.raw);
return r;
}
/*!
* @brief linear interpolation between two vectors (clamped)
*
* formula: from + s * (to - from)
*
* @param[in] from from value
* @param[in] to to value
* @param[in] t interpolant (amount) clamped between 0 and 1
* @returns destination
*/
CGLM_INLINE
vec3s
glms_vec3_mixc(vec3s from, vec3s to, float t) {
vec3s r;
glm_vec3_mixc(from.raw, to.raw, t, r.raw);
return r;
}
/*!
* @brief threshold function (unidimensional)
*
* @param[in] edge threshold
* @param[in] x value to test against threshold
* @returns 0.0 if x < edge, else 1.0
*/
CGLM_INLINE
vec3s
glms_vec3_step_uni(float edge, vec3s x) {
vec3s r;
glm_vec3_step_uni(edge, x.raw, r.raw);
return r;
}
/*!
* @brief threshold function
*
* @param[in] edge threshold
* @param[in] x value to test against threshold
* @returns 0.0 if x < edge, else 1.0
*/
CGLM_INLINE
vec3s
glms_vec3_step(vec3s edge, vec3s x) {
vec3s r;
glm_vec3_step(edge.raw, x.raw, r.raw);
return r;
}
/*!
* @brief threshold function with a smooth transition (unidimensional)
*
* @param[in] edge0 low threshold
* @param[in] edge1 high threshold
* @param[in] x value to test against threshold
* @returns destination
*/
CGLM_INLINE
vec3s
glms_vec3_smoothstep_uni(float edge0, float edge1, vec3s x) {
vec3s r;
glm_vec3_smoothstep_uni(edge0, edge1, x.raw, r.raw);
return r;
}
/*!
* @brief threshold function with a smooth transition
*
* @param[in] edge0 low threshold
* @param[in] edge1 high threshold
* @param[in] x value to test against threshold
* @returns destination
*/
CGLM_INLINE
vec3s
glms_vec3_smoothstep(vec3s edge0, vec3s edge1, vec3s x) {
vec3s r;
glm_vec3_smoothstep(edge0.raw, edge1.raw, x.raw, r.raw);
return r;
}
/*!
* @brief smooth Hermite interpolation between two vectors
*
* formula: from + s * (to - from)
*
* @param[in] from from value
* @param[in] to to value
* @param[in] t interpolant (amount)
* @returns destination
*/
CGLM_INLINE
vec3s
glms_vec3_smoothinterp(vec3s from, vec3s to, float t) {
vec3s r;
glm_vec3_smoothinterp(from.raw, to.raw, t, r.raw);
return r;
}
/*!
* @brief smooth Hermite interpolation between two vectors (clamped)
*
* formula: from + s * (to - from)
*
* @param[in] from from value
* @param[in] to to value
* @param[in] t interpolant (amount) clamped between 0 and 1
* @returns destination
*/
CGLM_INLINE
vec3s
glms_vec3_smoothinterpc(vec3s from, vec3s to, float t) {
vec3s r;
glm_vec3_smoothinterpc(from.raw, to.raw, t, r.raw);
return r;
}
/*!
* @brief vec3 cross product
*
* this is just convenient wrapper
*
* @param[in] a source 1
* @param[in] b source 2
* @returns destination
*/
CGLM_INLINE
vec3s
glms_cross(vec3s a, vec3s b) {
vec3s r;
glm_cross(a.raw, b.raw, r.raw);
return r;
}
/*!
* @brief vec3 dot product
*
* this is just convenient wrapper
*
* @param[in] a vector1
* @param[in] b vector2
* @return dot product
*/
CGLM_INLINE
float
glms_dot(vec3s a, vec3s b) {
return glm_dot(a.raw, b.raw);
}
/*!
* @brief normalize vec3 and store result in same vec
*
* this is just convenient wrapper
*
* @param[in] v vector
* @returns normalized vector
*/
CGLM_INLINE
vec3s
glms_normalize(vec3s v) {
glm_normalize(v.raw);
return v;
}
/*!
* @brief swizzle vector components
*
* you can use existin masks e.g. GLM_XXX, GLM_ZYX
*
* @param[in] v source
* @param[in] mask mask
* @returns swizzled vector
*/
CGLM_INLINE
vec3s
glms_vec3_swizzle(vec3s v, int mask) {
vec3s dest;
glm_vec3_swizzle(v.raw, mask, dest.raw);
return dest;
}
#endif /* cglms_vec3s_h */