YourWishes/cglm
1
0
Fork 0
mirror of https://github.com/recp/cglm.git synced 2026-02-17 03:39:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #97 from recp/vec2_mat2

Browse Source 
vec2 and mat2 support
This commit is contained in:
Recep Aslantas
2020-02-25 14:54:22 +03:00
committed by GitHub
parent 4a7c153d2d eb0d47cfa1
commit 8e008511f4
32 changed files with 4102 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
CREDITS
View File

@@ -61,3 +61,7 @@ https://forums.khronos.org/showthread.php/10264-Animations-in-1-4-1-release-note
https://forums.khronos.org/showthread.php/10644-Animation-Bezier-interpolation
https://forums.khronos.org/showthread.php/10387-2D-Tangents-in-Bezier-Splines?p=34164&viewfull=1#post34164
https://forums.khronos.org/showthread.php/10651-Animation-TCB-Spline-Interpolation-in-COLLADA?highlight=bezier
12. vec2 cross product
http://allenchou.net/2013/07/cross-product-of-2d-vectors/

9
Makefile.am
View File

@@ -42,7 +42,10 @@ cglm_HEADERS = include/cglm/version.h \
include/cglm/io.h \
include/cglm/mat4.h \
include/cglm/mat3.h \
include/cglm/mat2.h \
include/cglm/affine.h \
include/cglm/vec2.h \
include/cglm/vec2-ext.h \
include/cglm/vec3.h \
include/cglm/vec3-ext.h \
include/cglm/vec4.h \
@@ -65,6 +68,8 @@ cglm_HEADERS = include/cglm/version.h \
cglm_calldir=$(includedir)/cglm/call
cglm_call_HEADERS = include/cglm/call/mat4.h \
include/cglm/call/mat3.h \
include/cglm/call/mat2.h \
include/cglm/call/vec2.h \
include/cglm/call/vec3.h \
include/cglm/call/vec4.h \
include/cglm/call/affine.h \
@@ -102,6 +107,8 @@ cglm_simd_neon_HEADERS = include/cglm/simd/neon/mat4.h
cglm_structdir=$(includedir)/cglm/struct
cglm_struct_HEADERS = include/cglm/struct/mat4.h \
include/cglm/struct/mat3.h \
include/cglm/struct/vec2.h \
include/cglm/struct/vec2-ext.h \
include/cglm/struct/vec3.h \
include/cglm/struct/vec3-ext.h \
include/cglm/struct/vec4.h \
@@ -125,8 +132,10 @@ libcglm_la_SOURCES=\
src/io.c \
src/quat.c \
src/cam.c \
src/vec2.c \
src/vec3.c \
src/vec4.c \
src/mat2.c \
src/mat3.c \
src/mat4.c \
src/plane.c \

4
include/cglm/call.h
View File

@@ -12,10 +12,12 @@ extern "C" {
#endif
#include "cglm.h"
#include "call/vec2.h"
#include "call/vec3.h"
#include "call/vec4.h"
#include "call/mat4.h"
#include "call/mat2.h"
#include "call/mat3.h"
#include "call/mat4.h"
#include "call/affine.h"
#include "call/cam.h"
#include "call/quat.h"

79
include/cglm/call/mat2.h Normal file
View File

@@ -0,0 +1,79 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_mat2_h
#define cglmc_mat2_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../cglm.h"
CGLM_EXPORT
void
glmc_mat2_copy(mat2 mat, mat2 dest);
CGLM_EXPORT
void
glmc_mat2_identity(mat2 mat);
CGLM_EXPORT
void
glmc_mat2_identity_array(mat2 * __restrict mat, size_t count);
CGLM_EXPORT
void
glmc_mat2_zero(mat2 mat);
CGLM_EXPORT
void
glmc_mat2_mul(mat2 m1, mat2 m2, mat2 dest);
CGLM_EXPORT
void
glmc_mat2_transpose_to(mat2 m, mat2 dest);
CGLM_EXPORT
void
glmc_mat2_transpose(mat2 m);
CGLM_EXPORT
void
glmc_mat2_mulv(mat2 m, vec2 v, vec2 dest);
CGLM_EXPORT
float
glmc_mat2_trace(mat2 m);
CGLM_EXPORT
void
glmc_mat2_scale(mat2 m, float s);
CGLM_EXPORT
float
glmc_mat2_det(mat2 mat);
CGLM_EXPORT
void
glmc_mat2_inv(mat2 mat, mat2 dest);
CGLM_EXPORT
void
glmc_mat2_swap_col(mat2 mat, int col1, int col2);
CGLM_EXPORT
void
glmc_mat2_swap_row(mat2 mat, int row1, int row2);
CGLM_EXPORT
float
glmc_mat2_rmc(vec2 r, mat2 m, vec2 c);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_mat2_h */

155
include/cglm/call/vec2.h Normal file
View File

@@ -0,0 +1,155 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_vec2_h
#define cglmc_vec2_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../cglm.h"
CGLM_EXPORT
void
glmc_vec2(float * __restrict v, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_copy(vec2 a, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_zero(vec2 v);
CGLM_EXPORT
void
glmc_vec2_one(vec2 v);
CGLM_EXPORT
float
glmc_vec2_dot(vec2 a, vec2 b);
CGLM_EXPORT
float
glmc_vec2_cross(vec2 a, vec2 b);
CGLM_EXPORT
float
glmc_vec2_norm2(vec2 v);
CGLM_EXPORT
float
glmc_vec2_norm(vec2 v);
CGLM_EXPORT
void
glmc_vec2_add(vec2 a, vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_adds(vec2 v, float s, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_sub(vec2 a, vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_subs(vec2 v, float s, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_mul(vec2 a, vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_scale(vec2 v, float s, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_scale_as(vec2 v, float s, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_div(vec2 a, vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_divs(vec2 v, float s, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_addadd(vec2 a, vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_subadd(vec2 a, vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_muladd(vec2 a, vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_muladds(vec2 a, float s, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_maxadd(vec2 a, vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_minadd(vec2 a, vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_negate_to(vec2 v, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_negate(vec2 v);
CGLM_EXPORT
void
glmc_vec2_normalize(vec2 v);
CGLM_EXPORT
void
glmc_vec2_normalize_to(vec2 v, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_rotate(vec2 v, float angle, vec2 dest);
CGLM_EXPORT
float
glmc_vec2_distance2(vec2 a, vec2 b);
CGLM_EXPORT
float
glmc_vec2_distance(vec2 a, vec2 b);
CGLM_EXPORT
void
glmc_vec2_maxv(vec2 a, vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_minv(vec2 a, vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_clamp(vec2 v, float minval, float maxval);
CGLM_EXPORT
void
glmc_vec2_lerp(vec2 from, vec2 to, float t, vec2 dest);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_vec2_h */

2
include/cglm/cglm.h
View File

@@ -9,10 +9,12 @@
#define cglm_h
#include "common.h"
#include "vec2.h"
#include "vec3.h"
#include "vec4.h"
#include "mat4.h"
#include "mat3.h"
#include "mat2.h"
#include "affine.h"
#include "cam.h"
#include "frustum.h"

52
include/cglm/io.h
View File

@@ -83,6 +83,36 @@ glm_mat3_print(mat3 matrix,
#undef n
}
CGLM_INLINE
void
glm_mat2_print(mat2 matrix,
FILE * __restrict ostream) {
int i;
int j;
#define m 2
#define n 2
fprintf(ostream, "Matrix (float%dx%d):\n", m, n);
for (i = 0; i < m; i++) {
fprintf(ostream, "\t|");
for (j = 0; j < n; j++) {
fprintf(ostream, "%0.4f", matrix[j][i]);;
if (j != n - 1)
fprintf(ostream, "\t");
}
fprintf(ostream, "|\n");
}
fprintf(ostream, "\n");
#undef m
#undef n
}
CGLM_INLINE
void
glm_vec4_print(vec4 vec,
@@ -149,6 +179,28 @@ glm_ivec3_print(ivec3 vec,
#undef m
}
CGLM_INLINE
void
glm_vec2_print(vec2 vec,
FILE * __restrict ostream) {
int i;
#define m 2
fprintf(ostream, "Vector (float%d):\n\t|", m);
for (i = 0; i < m; i++) {
fprintf(ostream, "%0.4f", vec[i]);
if (i != m - 1)
fprintf(ostream, "\t");
}
fprintf(ostream, "|\n\n");
#undef m
}
CGLM_INLINE
void
glm_versor_print(versor vec,

322
include/cglm/mat2.h Normal file
View File

@@ -0,0 +1,322 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
/*
Macros:
GLM_MAT2_IDENTITY_INIT
GLM_MAT2_ZERO_INIT
GLM_MAT2_IDENTITY
GLM_MAT2_ZERO
Functions:
CGLM_INLINE void glm_mat2_copy(mat2 mat, mat2 dest)
CGLM_INLINE void glm_mat2_identity(mat2 mat)
CGLM_INLINE void glm_mat2_identity_array(mat2 * restrict mat, size_t count)
CGLM_INLINE void glm_mat2_zero(mat2 mat)
CGLM_INLINE void glm_mat2_mul(mat2 m1, mat2 m2, mat2 dest)
CGLM_INLINE void glm_mat2_transpose_to(mat2 m, mat2 dest)
CGLM_INLINE void glm_mat2_transpose(mat2 m)
CGLM_INLINE void glm_mat2_mulv(mat2 m, vec2 v, vec2 dest)
CGLM_INLINE float glm_mat2_trace(mat2 m)
CGLM_INLINE void glm_mat2_scale(mat2 m, float s)
CGLM_INLINE float glm_mat2_det(mat2 mat)
CGLM_INLINE void glm_mat2_inv(mat2 mat, mat2 dest)
CGLM_INLINE void glm_mat2_swap_col(mat2 mat, int col1, int col2)
CGLM_INLINE void glm_mat2_swap_row(mat2 mat, int row1, int row2)
CGLM_INLINE float glm_mat2_rmc(vec2 r, mat2 m, vec2 c)
*/
#ifndef cglm_mat2_h
#define cglm_mat2_h
#include "common.h"
#include "vec2.h"
#ifdef CGLM_SSE_FP
# include "simd/sse2/mat2.h"
#endif
#define GLM_MAT2_IDENTITY_INIT {{1.0f, 0.0f}, {0.0f, 1.0f}}
#define GLM_MAT2_ZERO_INIT {{0.0f, 0.0f}, {0.0f, 0.0f}}
/* for C only */
#define GLM_MAT2_IDENTITY ((mat2)GLM_MAT2_IDENTITY_INIT)
#define GLM_MAT2_ZERO ((mat2)GLM_MAT2_ZERO_INIT)
/*!
* @brief copy all members of [mat] to [dest]
*
* @param[in] mat source
* @param[out] dest destination
*/
CGLM_INLINE
void
glm_mat2_copy(mat2 mat, mat2 dest) {
glm_vec4_copy(mat[0], dest[0]);
}
/*!
* @brief make given matrix identity. It is identical with below,
* but it is more easy to do that with this func especially for members
* e.g. glm_mat2_identity(aStruct->aMatrix);
*
* @code
* glm_mat2_copy(GLM_MAT2_IDENTITY, mat); // C only
*
* // or
* mat2 mat = GLM_MAT2_IDENTITY_INIT;
* @endcode
*
* @param[in, out] mat destination
*/
CGLM_INLINE
void
glm_mat2_identity(mat2 mat) {
CGLM_ALIGN_MAT mat2 t = GLM_MAT2_IDENTITY_INIT;
glm_mat2_copy(t, mat);
}
/*!
* @brief make given matrix array's each element identity matrix
*
* @param[in, out] mat matrix array (must be aligned (16)
* if alignment is not disabled)
*
* @param[in] count count of matrices
*/
CGLM_INLINE
void
glm_mat2_identity_array(mat2 * __restrict mat, size_t count) {
CGLM_ALIGN_MAT mat2 t = GLM_MAT2_IDENTITY_INIT;
size_t i;
for (i = 0; i < count; i++) {
glm_mat2_copy(t, mat[i]);
}
}
/*!
* @brief make given matrix zero.
*
* @param[in, out] mat matrix
*/
CGLM_INLINE
void
glm_mat2_zero(mat2 mat) {
CGLM_ALIGN_MAT mat2 t = GLM_MAT2_ZERO_INIT;
glm_mat2_copy(t, mat);
}
/*!
* @brief multiply m1 and m2 to dest
*
* m1, m2 and dest matrices can be same matrix, it is possible to write this:
*
* @code
* mat2 m = GLM_MAT2_IDENTITY_INIT;
* glm_mat2_mul(m, m, m);
* @endcode
*
* @param[in] m1 left matrix
* @param[in] m2 right matrix
* @param[out] dest destination matrix
*/
CGLM_INLINE
void
glm_mat2_mul(mat2 m1, mat2 m2, mat2 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glm_mat2_mul_sse2(m1, m2, dest);
#else
float a00 = m1[0][0], a01 = m1[0][1],
a10 = m1[1][0], a11 = m1[1][1],
b00 = m2[0][0], b01 = m2[0][1],
b10 = m2[1][0], b11 = m2[1][1];
dest[0][0] = a00 * b00 + a10 * b01;
dest[0][1] = a01 * b00 + a11 * b01;
dest[1][0] = a00 * b10 + a10 * b11;
dest[1][1] = a01 * b10 + a11 * b11;
#endif
}
/*!
* @brief transpose mat2 and store in dest
*
* source matrix will not be transposed unless dest is m
*
* @param[in] m matrix
* @param[out] dest result
*/
CGLM_INLINE
void
glm_mat2_transpose_to(mat2 m, mat2 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glm_mat2_transp_sse2(m, dest);
#else
dest[0][0] = m[0][0];
dest[0][1] = m[1][0];
dest[1][0] = m[0][1];
dest[1][1] = m[1][1];
#endif
}
/*!
* @brief tranpose mat2 and store result in same matrix
*
* @param[in, out] m source and dest
*/
CGLM_INLINE
void
glm_mat2_transpose(mat2 m) {
float tmp;
tmp = m[0][1];
m[0][1] = m[1][0];
m[1][0] = tmp;
}
/*!
* @brief multiply mat2 with vec2 (column vector) and store in dest vector
*
* @param[in] m mat2 (left)
* @param[in] v vec2 (right, column vector)
* @param[out] dest vec2 (result, column vector)
*/
CGLM_INLINE
void
glm_mat2_mulv(mat2 m, vec2 v, vec2 dest) {
dest[0] = m[0][0] * v[0] + m[1][0] * v[1];
dest[1] = m[0][1] * v[0] + m[1][1] * v[1];
}
/*!
* @brief trace of matrix
*
* sum of the elements on the main diagonal from upper left to the lower right
*
* @param[in] m matrix
*/
CGLM_INLINE
float
glm_mat2_trace(mat2 m) {
return m[0][0] + m[1][1];
}
/*!
* @brief scale (multiply with scalar) matrix
*
* multiply matrix with scalar
*
* @param[in, out] m matrix
* @param[in] s scalar
*/
CGLM_INLINE
void
glm_mat2_scale(mat2 m, float s) {
glm_vec4_scale(m[0], s, m[0]);
}
/*!
* @brief mat2 determinant
*
* @param[in] mat matrix
*
* @return determinant
*/
CGLM_INLINE
float
glm_mat2_det(mat2 mat) {
return mat[0][0] * mat[1][1] - mat[1][0] * mat[0][1];
}
/*!
* @brief inverse mat2 and store in dest
*
* @param[in] mat matrix
* @param[out] dest inverse matrix
*/
CGLM_INLINE
void
glm_mat2_inv(mat2 mat, mat2 dest) {
float det;
float a = mat[0][0], b = mat[0][1],
c = mat[1][0], d = mat[1][1];
det = 1.0f / (a * d - b * c);
dest[0][0] = d * det;
dest[0][1] = -b * det;
dest[1][0] = -c * det;
dest[1][1] = a * det;
}
/*!
* @brief swap two matrix columns
*
* @param[in,out] mat matrix
* @param[in] col1 col1
* @param[in] col2 col2
*/
CGLM_INLINE
void
glm_mat2_swap_col(mat2 mat, int col1, int col2) {
float a, b;
a = mat[col1][0];
b = mat[col1][1];
mat[col1][0] = mat[col2][0];
mat[col1][1] = mat[col2][1];
mat[col2][0] = a;
mat[col2][1] = b;
}
/*!
* @brief swap two matrix rows
*
* @param[in,out] mat matrix
* @param[in] row1 row1
* @param[in] row2 row2
*/
CGLM_INLINE
void
glm_mat2_swap_row(mat2 mat, int row1, int row2) {
float a, b;
a = mat[0][row1];
b = mat[1][row1];
mat[0][row1] = mat[0][row2];
mat[1][row1] = mat[1][row2];
mat[0][row2] = a;
mat[1][row2] = b;
}
/*!
* @brief helper for R (row vector) * M (matrix) * C (column vector)
*
* rmc stands for Row * Matrix * Column
*
* the result is scalar because R * M = Matrix1x2 (row vector),
* then Matrix1x2 * Vec2 (column vector) = Matrix1x1 (Scalar)
*
* @param[in] r row vector or matrix1x2
* @param[in] m matrix2x2
* @param[in] c column vector or matrix2x1
*
* @return scalar value e.g. Matrix1x1
*/
CGLM_INLINE
float
glm_mat2_rmc(vec2 r, mat2 m, vec2 c) {
vec2 tmp;
glm_mat2_mulv(m, c, tmp);
return glm_vec2_dot(r, tmp);
}
#endif /* cglm_mat2_h */

45
include/cglm/simd/sse2/mat2.h Normal file
View File

@@ -0,0 +1,45 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglm_mat2_sse_h
#define cglm_mat2_sse_h
#if defined( __SSE__ ) || defined( __SSE2__ )
#include "../../common.h"
#include "../intrin.h"
CGLM_INLINE
void
glm_mat2_mul_sse2(mat2 m1, mat2 m2, mat2 dest) {
__m128 x0, x1, x2;
x1 = glmm_load(m1[0]); /* d c b a */
x2 = glmm_load(m2[0]); /* h g f e */
/*
dest[0][0] = a * e + c * f;
dest[0][1] = b * e + d * f;
dest[1][0] = a * g + c * h;
dest[1][1] = b * g + d * h;
*/
x0 = _mm_mul_ps(_mm_movelh_ps(x1, x1), glmm_shuff1(x2, 2, 2, 0, 0));
x1 = _mm_mul_ps(_mm_movehl_ps(x1, x1), glmm_shuff1(x2, 3, 3, 1, 1));
x1 = _mm_add_ps(x0, x1);
glmm_store(dest[0], x1);
}
CGLM_INLINE
void
glm_mat2_transp_sse2(mat2 m, mat2 dest) {
/* d c b a */
/* d b c a */
glmm_store(dest[0], glmm_shuff1(glmm_load(m[0]), 3, 1, 2, 0));
}
#endif
#endif /* cglm_mat2_sse_h */

2
include/cglm/struct.h
View File

@@ -13,8 +13,10 @@ extern "C" {
#include "cglm.h"
#include "types-struct.h"
#include "struct/vec2.h"
#include "struct/vec3.h"
#include "struct/vec4.h"
#include "struct/mat2.h"
#include "struct/mat3.h"
#include "struct/mat4.h"
#include "struct/affine.h"

258
include/cglm/struct/mat2.h Normal file
View File

@@ -0,0 +1,258 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
/*
Macros:
GLM_MAT2_IDENTITY_INIT
GLM_MAT2_ZERO_INIT
GLM_MAT2_IDENTITY
GLM_MAT2_ZERO
Functions:
CGLM_INLINE void glms_mat2_identity(mat2 mat)
CGLM_INLINE void glms_mat2_identity_array(mat2 * restrict mat, size_t count)
CGLM_INLINE void glms_mat2_zero(mat2 mat)
CGLM_INLINE void glms_mat2_mul(mat2 m1, mat2 m2, mat2 dest)
CGLM_INLINE void glms_mat2_transpose_to(mat2 m, mat2 dest)
CGLM_INLINE void glms_mat2_transpose(mat2 m)
CGLM_INLINE void glms_mat2_mulv(mat2 m, vec2 v, vec2 dest)
CGLM_INLINE float glms_mat2_trace(mat2 m)
CGLM_INLINE void glms_mat2_scale(mat2 m, float s)
CGLM_INLINE float glms_mat2_det(mat2 mat)
CGLM_INLINE void glms_mat2_inv(mat2 mat, mat2 dest)
CGLM_INLINE void glms_mat2_swap_col(mat2 mat, int col1, int col2)
CGLM_INLINE void glms_mat2_swap_row(mat2 mat, int row1, int row2)
CGLM_INLINE float glms_mat2_rmc(vec2 r, mat2 m, vec2 c)
*/
#ifndef cglms_mat2_h
#define cglms_mat2_h
#include "../common.h"
#include "../types-struct.h"
#include "../mat2.h"
#define GLMS_MAT2_IDENTITY_INIT {1.0f, 0.0f, 0.0f, 1.0f}
#define GLMS_MAT2_ZERO_INIT {0.0f, 0.0f, 0.0f, 0.0f}
/* for C only */
#define GLMS_MAT2_IDENTITY ((mat3s)GLMS_MAT2_IDENTITY_INIT)
#define GLMS_MAT2_ZERO ((mat3s)GLMS_MAT2_ZERO_INIT)
/*!
* @brief make given matrix identity. It is identical with below,
* but it is more easy to do that with this func especially for members
* e.g. glm_mat2_identity(aStruct->aMatrix);
*
* @code
* glm_mat2_copy(GLM_MAT2_IDENTITY, mat); // C only
*
* // or
* mat2 mat = GLM_MAT2_IDENTITY_INIT;
* @endcode
*
* @returns identity matrix
*/
CGLM_INLINE
mat2s
glms_mat2_identity(void) {
mat2s r;
glm_mat2_identity(r.raw);
return r;
}
/*!
* @brief make given matrix array's each element identity matrix
*
* @param[in, out] mat matrix array (must be aligned (16)
* if alignment is not disabled)
*
* @param[in] count count of matrices
*/
CGLM_INLINE
void
glms_mat2_identity_array(mat2s * __restrict mat, size_t count) {
CGLM_ALIGN_MAT mat2s t = GLMS_MAT2_IDENTITY_INIT;
size_t i;
for (i = 0; i < count; i++) {
glm_mat2_copy(t.raw, mat[i].raw);
}
}
/*!
* @brief make given matrix zero.
*
* @returns matrix
*/
CGLM_INLINE
mat2s
glms_mat2_zero(void) {
mat2s r;
glm_mat2_zero(r.raw);
return r;
}
/*!
* @brief multiply m1 and m2 to dest
*
* m1, m2 and dest matrices can be same matrix, it is possible to write this:
*
* @code
* mat2 m = GLM_MAT2_IDENTITY_INIT;
* glm_mat2_mul(m, m, m);
* @endcode
*
* @param[in] m1 left matrix
* @param[in] m2 right matrix
*
* @returns matrix
*/
CGLM_INLINE
mat2s
glms_mat2_mul(mat2s m1, mat2s m2) {
mat2s r;
glm_mat2_mul(m1.raw, m2.raw, r.raw);
return r;
}
/*!
* @brief transpose mat2
*
* @param[in] m matrix to transpose
*
* @returns transposed matrix
*/
CGLM_INLINE
mat2s
glms_mat2_transpose(mat2s m) {
glm_mat2_transpose(m.raw);
return m;
}
/*!
* @brief multiply mat2 with vec2 (column vector) and store in dest vector
*
* @param[in] m mat2 (left)
* @param[in] v vec2 (right, column vector)
* @returns vec2 (result, column vector)
*/
CGLM_INLINE
vec2s
glms_mat2_mulv(mat2s m, vec2s v) {
vec2s r;
glm_mat2_mulv(m.raw, v.raw, r.raw);
return r;
}
/*!
* @brief trace of matrix
*
* sum of the elements on the main diagonal from upper left to the lower right
*
* @param[in] m matrix
*/
CGLM_INLINE
float
glms_mat2_trace(mat2s m) {
return glm_mat2_trace(m.raw);
}
/*!
* @brief scale (multiply with scalar) matrix
*
* multiply matrix with scalar
*
* @param[in, out] m matrix
* @param[in] s scalar
* @returns matrix
*/
CGLM_INLINE
mat2s
glms_mat2_scale(mat2s m, float s) {
glm_mat2_scale(m.raw, s);
return m;
}
/*!
* @brief mat2 determinant
*
* @param[in] mat matrix
*
* @return determinant
*/
CGLM_INLINE
float
glms_mat2_det(mat2s mat) {
return glm_mat2_det(mat.raw);
}
/*!
* @brief inverse mat2 and store in dest
*
* @param[in] mat matrix
* @returns matrix
*/
CGLM_INLINE
mat2s
glms_mat2_inv(mat2s mat) {
mat2s r;
glm_mat2_inv(mat.raw, r.raw);
return r;
}
/*!
* @brief swap two matrix columns
*
* @param[in] mat matrix
* @param[in] col1 col1
* @param[in] col2 col2
* @returns matrix
*/
CGLM_INLINE
mat2s
glms_mat2_swap_col(mat2s mat, int col1, int col2) {
glm_mat2_swap_col(mat.raw, col1, col2);
return mat;
}
/*!
* @brief swap two matrix rows
*
* @param[in] mat matrix
* @param[in] row1 row1
* @param[in] row2 row2
* @returns matrix
*/
CGLM_INLINE
mat2s
glms_mat2_swap_row(mat2s mat, int row1, int row2) {
glm_mat2_swap_row(mat.raw, row1, row2);
return mat;
}
/*!
* @brief helper for R (row vector) * M (matrix) * C (column vector)
*
* rmc stands for Row * Matrix * Column
*
* the result is scalar because R * M = Matrix1x2 (row vector),
* then Matrix1x2 * Vec2 (column vector) = Matrix1x1 (Scalar)
*
* @param[in] r row vector or matrix1x2
* @param[in] m matrix2x2
* @param[in] c column vector or matrix2x1
*
* @return scalar value e.g. Matrix1x1
*/
CGLM_INLINE
float
glms_mat2_rmc(vec2s r, mat2s m, vec2s c) {
return glm_mat2_rmc(r.raw, m.raw, c.raw);
}
#endif /* cglms_mat2_h */

198
include/cglm/struct/vec2-ext.h Normal file
View File

@@ -0,0 +1,198 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
/*!
* @brief SIMD like functions
*/
/*
Functions:
CGLM_INLINE vec2s glms_vec2_fill(float val)
CGLM_INLINE bool glms_vec2_eq(vec2s v, float val)
CGLM_INLINE bool glms_vec2_eq_eps(vec2s v, float val)
CGLM_INLINE bool glms_vec2_eq_all(vec2s v)
CGLM_INLINE bool glms_vec2_eqv(vec2s a, vec2s b)
CGLM_INLINE bool glms_vec2_eqv_eps(vec2s a, vec2s b)
CGLM_INLINE float glms_vec2_max(vec2s v)
CGLM_INLINE float glms_vec2_min(vec2s v)
CGLM_INLINE bool glms_vec2_isnan(vec2s v)
CGLM_INLINE bool glms_vec2_isinf(vec2s v)
CGLM_INLINE bool glms_vec2_isvalid(vec2s v)
CGLM_INLINE vec2s glms_vec2_sign(vec2s v)
CGLM_INLINE vec2s glms_vec2_sqrt(vec2s v)
*/
#ifndef cglms_vec2s_ext_h
#define cglms_vec2s_ext_h
#include "../common.h"
#include "../types-struct.h"
#include "../util.h"
#include "../vec2-ext.h"
/*!
* @brief fill a vector with specified value
*
* @param[in] val value
* @returns dest
*/
CGLM_INLINE
vec2s
glms_vec2_fill(float val) {
vec2s r;
glm_vec2_fill(r.raw, val);
return r;
}
/*!
* @brief check if vector is equal to value (without epsilon)
*
* @param[in] v vector
* @param[in] val value
*/
CGLM_INLINE
bool
glms_vec2_eq(vec2s v, float val) {
return glm_vec2_eq(v.raw, val);
}
/*!
* @brief check if vector is equal to value (with epsilon)
*
* @param[in] v vector
* @param[in] val value
*/
CGLM_INLINE
bool
glms_vec2_eq_eps(vec2s v, float val) {
return glm_vec2_eq_eps(v.raw, val);
}
/*!
* @brief check if vectors members are equal (without epsilon)
*
* @param[in] v vector
*/
CGLM_INLINE
bool
glms_vec2_eq_all(vec2s v) {
return glm_vec2_eq_all(v.raw);
}
/*!
* @brief check if vector is equal to another (without epsilon)
*
* @param[in] a vector
* @param[in] b vector
*/
CGLM_INLINE
bool
glms_vec2_eqv(vec2s a, vec2s b) {
return glm_vec2_eqv(a.raw, b.raw);
}
/*!
* @brief check if vector is equal to another (with epsilon)
*
* @param[in] a vector
* @param[in] b vector
*/
CGLM_INLINE
bool
glms_vec2_eqv_eps(vec2s a, vec2s b) {
return glm_vec2_eqv_eps(a.raw, b.raw);
}
/*!
* @brief max value of vector
*
* @param[in] v vector
*/
CGLM_INLINE
float
glms_vec2_max(vec2s v) {
return glm_vec2_max(v.raw);
}
/*!
* @brief min value of vector
*
* @param[in] v vector
*/
CGLM_INLINE
float
glms_vec2_min(vec2s v) {
return glm_vec2_min(v.raw);
}
/*!
* @brief check if all items are NaN (not a number)
* you should only use this in DEBUG mode or very critical asserts
*
* @param[in] v vector
*/
CGLM_INLINE
bool
glms_vec2_isnan(vec2s v) {
return glm_vec2_isnan(v.raw);
}
/*!
* @brief check if all items are INFINITY
* you should only use this in DEBUG mode or very critical asserts
*
* @param[in] v vector
*/
CGLM_INLINE
bool
glms_vec2_isinf(vec2s v) {
return glm_vec2_isinf(v.raw);
}
/*!
* @brief check if all items are valid number
* you should only use this in DEBUG mode or very critical asserts
*
* @param[in] v vector
*/
CGLM_INLINE
bool
glms_vec2_isvalid(vec2s v) {
return glm_vec2_isvalid(v.raw);
}
/*!
* @brief get sign of 32 bit float as +1, -1, 0
*
* Important: It returns 0 for zero/NaN input
*
* @param v vector
* @returns sign vector
*/
CGLM_INLINE
vec2s
glms_vec2_sign(vec2s v) {
vec2s r;
glm_vec2_sign(v.raw, r.raw);
return r;
}
/*!
* @brief square root of each vector item
*
* @param[in] v vector
* @returns destination vector
*/
CGLM_INLINE
vec2s
glms_vec2_sqrt(vec2s v) {
vec2s r;
glm_vec2_sqrt(v.raw, r.raw);
return r;
}
#endif /* cglms_vec2s_ext_h */

561
include/cglm/struct/vec2.h Normal file
View File

@@ -0,0 +1,561 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
/*
Macros:
GLMS_VEC2_ONE_INIT
GLMS_VEC2_ZERO_INIT
GLMS_VEC2_ONE
GLMS_VEC2_ZERO
Functions:
CGLM_INLINE vec2s glms_vec2(vec3s v3)
CGLM_INLINE void glms_vec2_pack(vec2s dst[], vec2 src[], size_t len)
CGLM_INLINE void glms_vec2_unpack(vec2 dst[], vec2s src[], size_t len)
CGLM_INLINE vec2s glms_vec2_zero(void)
CGLM_INLINE vec2s glms_vec2_one(void)
CGLM_INLINE float glms_vec2_dot(vec2s a, vec2s b)
CGLM_INLINE float glms_vec2_cross(vec2s a, vec2s b)
CGLM_INLINE float glms_vec2_norm2(vec2s v)
CGLM_INLINE float glms_vec2_norm(vec2s v)
CGLM_INLINE vec2s glms_vec2_add(vec2s a, vec2s b)
CGLM_INLINE vec2s glms_vec2_adds(vec2s a, float s)
CGLM_INLINE vec2s glms_vec2_sub(vec2s a, vec2s b)
CGLM_INLINE vec2s glms_vec2_subs(vec2s a, float s)
CGLM_INLINE vec2s glms_vec2_mul(vec2s a, vec2s b)
CGLM_INLINE vec2s glms_vec2_scale(vec2s v, float s)
CGLM_INLINE vec2s glms_vec2_scale_as(vec2s v, float s)
CGLM_INLINE vec2s glms_vec2_div(vec2s a, vec2s b)
CGLM_INLINE vec2s glms_vec2_divs(vec2s a, float s)
CGLM_INLINE vec2s glms_vec2_addadd(vec2s a, vec2s b, vec2s dest)
CGLM_INLINE vec2s glms_vec2_subadd(vec2s a, vec2s b, vec2s dest)
CGLM_INLINE vec2s glms_vec2_muladd(vec2s a, vec2s b, vec2s dest)
CGLM_INLINE vec2s glms_vec2_muladds(vec2s a, float s, vec2s dest)
CGLM_INLINE vec2s glms_vec2_maxadd(vec2s a, vec2s b, vec2s dest)
CGLM_INLINE vec2s glms_vec2_minadd(vec2s a, vec2s b, vec2s dest)
CGLM_INLINE vec2s glms_vec2_negate(vec2s v)
CGLM_INLINE vec2s glms_vec2_normalize(vec2s v)
CGLM_INLINE vec2s glms_vec2_rotate(vec2s v, float angle, vec2s axis)
CGLM_INLINE float glms_vec2_distance(vec2s a, vec2s b)
CGLM_INLINE float glms_vec2_distance2(vec2s a, vec2s b)
CGLM_INLINE vec2s glms_vec2_maxv(vec2s a, vec2s b)
CGLM_INLINE vec2s glms_vec2_minv(vec2s a, vec2s b)
CGLM_INLINE vec2s glms_vec2_clamp(vec2s v, float minVal, float maxVal)
CGLM_INLINE vec2s glms_vec2_lerp(vec2s from, vec2s to, float t)
*/
#ifndef cglms_vec2s_h
#define cglms_vec2s_h
#include "../common.h"
#include "../types-struct.h"
#include "../util.h"
#include "../vec2.h"
#include "vec2-ext.h"
#define GLMS_VEC2_ONE_INIT {GLM_VEC2_ONE_INIT}
#define GLMS_VEC2_ZERO_INIT {GLM_VEC2_ZERO_INIT}
#define GLMS_VEC2_ONE ((vec2s)GLMS_VEC2_ONE_INIT)
#define GLMS_VEC2_ZERO ((vec2s)GLMS_VEC2_ZERO_INIT)
/*!
* @brief init vec2 using vec2
*
* @param[in] v4 vector3
* @returns destination
*/
CGLM_INLINE
vec2s
glms_vec2(vec3s v3) {
vec2s r;
glm_vec2(v3.raw, r.raw);
return r;
}
/*!
* @brief pack an array of vec2 into an array of vec2s
*
* @param[out] dst array of vec2
* @param[in] src array of vec2s
* @param[in] len number of elements
*/
CGLM_INLINE
void
glms_vec2_pack(vec2s dst[], vec2 src[], size_t len) {
size_t i;
for (i = 0; i < len; i++) {
glm_vec2_copy(src[i], dst[i].raw);
}
}
/*!
* @brief unpack an array of vec2s into an array of vec2
*
* @param[out] dst array of vec2s
* @param[in] src array of vec2
* @param[in] len number of elements
*/
CGLM_INLINE
void
glms_vec2_unpack(vec2 dst[], vec2s src[], size_t len) {
size_t i;
for (i = 0; i < len; i++) {
glm_vec2_copy(src[i].raw, dst[i]);
}
}
/*!
* @brief make vector zero
*
* @returns zero vector
*/
CGLM_INLINE
vec2s
glms_vec2_zero(void) {
vec2s r;
glm_vec2_zero(r.raw);
return r;
}
/*!
* @brief make vector one
*
* @returns one vector
*/
CGLM_INLINE
vec2s
glms_vec2_one(void) {
vec2s r;
glm_vec2_one(r.raw);
return r;
}
/*!
* @brief vec2 dot product
*
* @param[in] a vector1
* @param[in] b vector2
*
* @return dot product
*/
CGLM_INLINE
float
glms_vec2_dot(vec2s a, vec2s b) {
return glm_vec2_dot(a.raw, b.raw);
}
/*!
* @brief vec2 cross product
*
* REF: http://allenchou.net/2013/07/cross-product-of-2d-vectors/
*
* @param[in] a vector1
* @param[in] b vector2
*
* @return Z component of cross product
*/
CGLM_INLINE
float
glms_vec2_cross(vec2s a, vec2s b) {
return glm_vec2_cross(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_vec2_norm2(vec2s v) {
return glm_vec2_norm2(v.raw);
}
/*!
* @brief norm (magnitude) of vec2
*
* @param[in] v vector
*
* @return norm
*/
CGLM_INLINE
float
glms_vec2_norm(vec2s v) {
return glm_vec2_norm(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
vec2s
glms_vec2_add(vec2s a, vec2s b) {
vec2s r;
glm_vec2_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
vec2s
glms_vec2_adds(vec2s a, float s) {
vec2s r;
glm_vec2_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
vec2s
glms_vec2_sub(vec2s a, vec2s b) {
vec2s r;
glm_vec2_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
vec2s
glms_vec2_subs(vec2s a, float s) {
vec2s r;
glm_vec2_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
vec2s
glms_vec2_mul(vec2s a, vec2s b) {
vec2s r;
glm_vec2_mul(a.raw, b.raw, r.raw);
return r;
}
/*!
* @brief multiply/scale vec2 vector with scalar: result = v * s
*
* @param[in] v vector
* @param[in] s scalar
* @returns destination vector
*/
CGLM_INLINE
vec2s
glms_vec2_scale(vec2s v, float s) {
vec2s r;
glm_vec2_scale(v.raw, s, r.raw);
return r;
}
/*!
* @brief make vec2 vector scale as specified: result = unit(v) * s
*
* @param[in] v vector
* @param[in] s scalar
* @returns destination vector
*/
CGLM_INLINE
vec2s
glms_vec2_scale_as(vec2s v, float s) {
vec2s r;
glm_vec2_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
vec2s
glms_vec2_div(vec2s a, vec2s b) {
vec2s r;
glm_vec2_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
vec2s
glms_vec2_divs(vec2s a, float s) {
vec2s r;
glm_vec2_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
vec2s
glms_vec2_addadd(vec2s a, vec2s b, vec2s dest) {
glm_vec2_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
vec2s
glms_vec2_subadd(vec2s a, vec2s b, vec2s dest) {
glm_vec2_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
vec2s
glms_vec2_muladd(vec2s a, vec2s b, vec2s dest) {
glm_vec2_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
vec2s
glms_vec2_muladds(vec2s a, float s, vec2s dest) {
glm_vec2_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
vec2s
glms_vec2_maxadd(vec2s a, vec2s b, vec2s dest) {
glm_vec2_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
vec2s
glms_vec2_minadd(vec2s a, vec2s b, vec2s dest) {
glm_vec2_minadd(a.raw, b.raw, dest.raw);
return dest;
}
/*!
* @brief negate vector components
*
* @param[in] v vector
* @returns negated vector
*/
CGLM_INLINE
vec2s
glms_vec2_negate(vec2s v) {
glm_vec2_negate(v.raw);
return v;
}
/*!
* @brief normalize vec2 and store result in same vec
*
* @param[in] v vector
* @returns normalized vector
*/
CGLM_INLINE
vec2s
glms_vec2_normalize(vec2s v) {
glm_vec2_normalize(v.raw);
return v;
}
/*!
* @brief rotate vec2 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
vec2s
glms_vec2_rotate(vec2s v, float angle, vec2s axis) {
glm_vec2_rotate(v.raw, angle, axis.raw);
return v;
}
/**
* @brief distance between two vectors
*
* @param[in] a vector1
* @param[in] b vector2
* @return distance
*/
CGLM_INLINE
float
glms_vec2_distance(vec2s a, vec2s b) {
return glm_vec2_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_vec2_distance2(vec2s a, vec2s b) {
return glm_vec2_distance2(a.raw, b.raw);
}
/*!
* @brief max values of vectors
*
* @param[in] a vector1
* @param[in] b vector2
* @returns destination
*/
CGLM_INLINE
vec2s
glms_vec2_maxv(vec2s a, vec2s b) {
vec2s r;
glm_vec2_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
vec2s
glms_vec2_minv(vec2s a, vec2s b) {
vec2s r;
glm_vec2_minv(a.raw, b.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
vec2s
glms_vec2_clamp(vec2s v, float minVal, float maxVal) {
glm_vec2_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
vec2s
glms_vec2_lerp(vec2s from, vec2s to, float t) {
vec2s r;
glm_vec2_lerp(from.raw, to.raw, t, r.raw);
return r;
}
#endif /* cglms_vec2s_h */

15
include/cglm/types-struct.h
View File

@@ -101,8 +101,19 @@ typedef union CGLM_ALIGN_IF(16) versors {
#endif
} versors;
typedef union mat2s {
mat2 raw;
vec2s col[2];
#if CGLM_USE_ANONYMOUS_STRUCT
struct {
float m00, m01;
float m10, m11;
};
#endif
} mat2s;
typedef union mat3s {
mat3 raw;
mat3 raw;
vec3s col[3];
#if CGLM_USE_ANONYMOUS_STRUCT
struct {
@@ -114,7 +125,7 @@ typedef union mat3s {
} mat3s;
typedef union CGLM_ALIGN_MAT mat4s {
mat4 raw;
mat4 raw;
vec4s col[4];
#if CGLM_USE_ANONYMOUS_STRUCT
struct {

3
include/cglm/types.h
View File

@@ -38,7 +38,8 @@ typedef int ivec3[3];
typedef CGLM_ALIGN_IF(16) float vec4[4];
typedef vec4 versor; /* |x, y, z, w| -> w is the last */
typedef vec3 mat3[3];
typedef CGLM_ALIGN_MAT vec4 mat4[4];
typedef CGLM_ALIGN_IF(16) vec2 mat2[2];
typedef CGLM_ALIGN_MAT vec4 mat4[4];
/*
Important: cglm stores quaternion as [x, y, z, w] in memory since v0.4.0

189
include/cglm/vec2-ext.h Normal file
View File

@@ -0,0 +1,189 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
/*
Functions:
CGLM_INLINE void glm_vec2_fill(vec2 v, float val)
CGLM_INLINE bool glm_vec2_eq(vec2 v, float val);
CGLM_INLINE bool glm_vec2_eq_eps(vec2 v, float val);
CGLM_INLINE bool glm_vec2_eq_all(vec2 v);
CGLM_INLINE bool glm_vec2_eqv(vec2 a, vec2 b);
CGLM_INLINE bool glm_vec2_eqv_eps(vec2 a, vec2 b);
CGLM_INLINE float glm_vec2_max(vec2 v);
CGLM_INLINE float glm_vec2_min(vec2 v);
CGLM_INLINE bool glm_vec2_isnan(vec2 v);
CGLM_INLINE bool glm_vec2_isinf(vec2 v);
CGLM_INLINE bool glm_vec2_isvalid(vec2 v);
CGLM_INLINE void glm_vec2_sign(vec2 v, vec2 dest);
CGLM_INLINE void glm_vec2_sqrt(vec2 v, vec2 dest);
*/
#ifndef cglm_vec2_ext_h
#define cglm_vec2_ext_h
#include "common.h"
#include "util.h"
/*!
* @brief fill a vector with specified value
*
* @param[out] v dest
* @param[in] val value
*/
CGLM_INLINE
void
glm_vec2_fill(vec2 v, float val) {
v[0] = v[1] = val;
}
/*!
* @brief check if vector is equal to value (without epsilon)
*
* @param[in] v vector
* @param[in] val value
*/
CGLM_INLINE
bool
glm_vec2_eq(vec2 v, float val) {
return v[0] == val && v[0] == v[1];
}
/*!
* @brief check if vector is equal to value (with epsilon)
*
* @param[in] v vector
* @param[in] val value
*/
CGLM_INLINE
bool
glm_vec2_eq_eps(vec2 v, float val) {
return fabsf(v[0] - val) <= FLT_EPSILON
&& fabsf(v[1] - val) <= FLT_EPSILON;
}
/*!
* @brief check if vectors members are equal (without epsilon)
*
* @param[in] v vector
*/
CGLM_INLINE
bool
glm_vec2_eq_all(vec2 v) {
return v[0] == v[1];
}
/*!
* @brief check if vector is equal to another (without epsilon)
*
* @param[in] a vector
* @param[in] b vector
*/
CGLM_INLINE
bool
glm_vec2_eqv(vec2 a, vec2 b) {
return a[0] == b[0] && a[1] == b[1];
}
/*!
* @brief check if vector is equal to another (with epsilon)
*
* @param[in] a vector
* @param[in] b vector
*/
CGLM_INLINE
bool
glm_vec2_eqv_eps(vec2 a, vec2 b) {
return fabsf(a[0] - b[0]) <= FLT_EPSILON
&& fabsf(a[1] - b[1]) <= FLT_EPSILON;
}
/*!
* @brief max value of vector
*
* @param[in] v vector
*/
CGLM_INLINE
float
glm_vec2_max(vec2 v) {
return glm_max(v[0], v[1]);
}
/*!
* @brief min value of vector
*
* @param[in] v vector
*/
CGLM_INLINE
float
glm_vec2_min(vec2 v) {
return glm_min(v[0], v[1]);
}
/*!
* @brief check if all items are NaN (not a number)
* you should only use this in DEBUG mode or very critical asserts
*
* @param[in] v vector
*/
CGLM_INLINE
bool
glm_vec2_isnan(vec2 v) {
return isnan(v[0]) || isnan(v[1]);
}
/*!
* @brief check if all items are INFINITY
* you should only use this in DEBUG mode or very critical asserts
*
* @param[in] v vector
*/
CGLM_INLINE
bool
glm_vec2_isinf(vec2 v) {
return isinf(v[0]) || isinf(v[1]);
}
/*!
* @brief check if all items are valid number
* you should only use this in DEBUG mode or very critical asserts
*
* @param[in] v vector
*/
CGLM_INLINE
bool
glm_vec2_isvalid(vec2 v) {
return !glm_vec2_isnan(v) && !glm_vec2_isinf(v);
}
/*!
* @brief get sign of 32 bit float as +1, -1, 0
*
* Important: It returns 0 for zero/NaN input
*
* @param v vector
*/
CGLM_INLINE
void
glm_vec2_sign(vec2 v, vec2 dest) {
dest[0] = glm_signf(v[0]);
dest[1] = glm_signf(v[1]);
}
/*!
* @brief square root of each vector item
*
* @param[in] v vector
* @param[out] dest destination vector
*/
CGLM_INLINE
void
glm_vec2_sqrt(vec2 v, vec2 dest) {
dest[0] = sqrtf(v[0]);
dest[1] = sqrtf(v[1]);
}
#endif /* cglm_vec2_ext_h */

585
include/cglm/vec2.h Normal file
View File

@@ -0,0 +1,585 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
/*
Macros:
GLM_VEC2_ONE_INIT
GLM_VEC2_ZERO_INIT
GLM_VEC2_ONE
GLM_VEC2_ZERO
Functions:
CGLM_INLINE void glm_vec2(float * __restrict v, vec2 dest)
CGLM_INLINE void glm_vec2_copy(vec2 a, vec2 dest)
CGLM_INLINE void glm_vec2_zero(vec2 v)
CGLM_INLINE void glm_vec2_one(vec2 v)
CGLM_INLINE float glm_vec2_dot(vec2 a, vec2 b)
CGLM_INLINE float glm_vec2_cross(vec2 a, vec2 b)
CGLM_INLINE float glm_vec2_norm2(vec2 v)
CGLM_INLINE float glm_vec2_norm(vec2 vec)
CGLM_INLINE void glm_vec2_add(vec2 a, vec2 b, vec2 dest)
CGLM_INLINE void glm_vec2_adds(vec2 v, float s, vec2 dest)
CGLM_INLINE void glm_vec2_sub(vec2 a, vec2 b, vec2 dest)
CGLM_INLINE void glm_vec2_subs(vec2 v, float s, vec2 dest)
CGLM_INLINE void glm_vec2_mul(vec2 a, vec2 b, vec2 d)
CGLM_INLINE void glm_vec2_scale(vec2 v, float s, vec2 dest)
CGLM_INLINE void glm_vec2_scale_as(vec2 v, float s, vec2 dest)
CGLM_INLINE void glm_vec2_div(vec2 a, vec2 b, vec2 dest)
CGLM_INLINE void glm_vec2_divs(vec2 v, float s, vec2 dest)
CGLM_INLINE void glm_vec2_addadd(vec2 a, vec2 b, vec2 dest)
CGLM_INLINE void glm_vec2_subadd(vec2 a, vec2 b, vec2 dest)
CGLM_INLINE void glm_vec2_muladd(vec2 a, vec2 b, vec2 dest)
CGLM_INLINE void glm_vec2_muladds(vec2 a, float s, vec2 dest)
CGLM_INLINE void glm_vec2_maxadd(vec2 a, vec2 b, vec2 dest)
CGLM_INLINE void glm_vec2_minadd(vec2 a, vec2 b, vec2 dest)
CGLM_INLINE void glm_vec2_negate_to(vec2 v, vec2 dest)
CGLM_INLINE void glm_vec2_negate(vec2 v)
CGLM_INLINE void glm_vec2_normalize(vec2 v)
CGLM_INLINE void glm_vec2_normalize_to(vec2 vec, vec2 dest)
CGLM_INLINE void glm_vec2_rotate(vec2 v, float angle, vec2 dest)
CGLM_INLINE float glm_vec2_distance2(vec2 a, vec2 b)
CGLM_INLINE float glm_vec2_distance(vec2 a, vec2 b)
CGLM_INLINE void glm_vec2_maxv(vec2 v1, vec2 v2, vec2 dest)
CGLM_INLINE void glm_vec2_minv(vec2 v1, vec2 v2, vec2 dest)
CGLM_INLINE void glm_vec2_clamp(vec2 v, float minVal, float maxVal)
CGLM_INLINE void glm_vec2_lerp(vec2 from, vec2 to, float t, vec2 dest)
*/
#ifndef cglm_vec2_h
#define cglm_vec2_h
#include "common.h"
#include "util.h"
#include "vec2-ext.h"
#define GLM_VEC2_ONE_INIT {1.0f, 1.0f}
#define GLM_VEC2_ZERO_INIT {0.0f, 0.0f}
#define GLM_VEC2_ONE ((vec2)GLM_VEC2_ONE_INIT)
#define GLM_VEC2_ZERO ((vec2)GLM_VEC2_ZERO_INIT)
/*!
* @brief init vec2 using another vector
*
* @param[in] v a vector
* @param[out] dest destination
*/
CGLM_INLINE
void
glm_vec2(float * __restrict v, vec2 dest) {
dest[0] = v[0];
dest[1] = v[1];
}
/*!
* @brief copy all members of [a] to [dest]
*
* @param[in] a source
* @param[out] dest destination
*/
CGLM_INLINE
void
glm_vec2_copy(vec2 a, vec2 dest) {
dest[0] = a[0];
dest[1] = a[1];
}
/*!
* @brief make vector zero
*
* @param[in, out] v vector
*/
CGLM_INLINE
void
glm_vec2_zero(vec2 v) {
v[0] = v[1] = 0.0f;
}
/*!
* @brief make vector one
*
* @param[in, out] v vector
*/
CGLM_INLINE
void
glm_vec2_one(vec2 v) {
v[0] = v[1] = 1.0f;
}
/*!
* @brief vec2 dot product
*
* @param[in] a vector1
* @param[in] b vector2
*
* @return dot product
*/
CGLM_INLINE
float
glm_vec2_dot(vec2 a, vec2 b) {
return a[0] * b[0] + a[1] * b[1];
}
/*!
* @brief vec2 cross product
*
* REF: http://allenchou.net/2013/07/cross-product-of-2d-vectors/
*
* @param[in] a vector1
* @param[in] b vector2
*
* @return Z component of cross product
*/
CGLM_INLINE
float
glm_vec2_cross(vec2 a, vec2 b) {
/* just calculate the z-component */
return a[0] * b[1] - a[1] * b[0];
}
/*!
* @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
glm_vec2_norm2(vec2 v) {
return glm_vec2_dot(v, v);
}
/*!
* @brief norm (magnitude) of vec2
*
* @param[in] vec vector
*
* @return norm
*/
CGLM_INLINE
float
glm_vec2_norm(vec2 vec) {
return sqrtf(glm_vec2_norm2(vec));
}
/*!
* @brief add a vector to b vector store result in dest
*
* @param[in] a vector1
* @param[in] b vector2
* @param[out] dest destination vector
*/
CGLM_INLINE
void
glm_vec2_add(vec2 a, vec2 b, vec2 dest) {
dest[0] = a[0] + b[0];
dest[1] = a[1] + b[1];
}
/*!
* @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_vec2_adds(vec2 v, float s, vec2 dest) {
dest[0] = v[0] + s;
dest[1] = v[1] + s;
}
/*!
* @brief subtract b vector from a vector store result in dest
*
* @param[in] a vector1
* @param[in] b vector2
* @param[out] dest destination vector
*/
CGLM_INLINE
void
glm_vec2_sub(vec2 a, vec2 b, vec2 dest) {
dest[0] = a[0] - b[0];
dest[1] = a[1] - b[1];
}
/*!
* @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_vec2_subs(vec2 v, float s, vec2 dest) {
dest[0] = v[0] - s;
dest[1] = v[1] - s;
}
/*!
* @brief multiply two vector (component-wise multiplication)
*
* @param a v1
* @param b v2
* @param dest v3 = (a[0] * b[0], a[1] * b[1])
*/
CGLM_INLINE
void
glm_vec2_mul(vec2 a, vec2 b, vec2 dest) {
dest[0] = a[0] * b[0];
dest[1] = a[1] * b[1];
}
/*!
* @brief multiply/scale vector with scalar: result = v * s
*
* @param[in] v vector
* @param[in] s scalar
* @param[out] dest destination vector
*/
CGLM_INLINE
void
glm_vec2_scale(vec2 v, float s, vec2 dest) {
dest[0] = v[0] * s;
dest[1] = v[1] * s;
}
/*!
* @brief scale as vector specified: result = unit(v) * s
*
* @param[in] v vector
* @param[in] s scalar
* @param[out] dest destination vector
*/
CGLM_INLINE
void
glm_vec2_scale_as(vec2 v, float s, vec2 dest) {
float norm;
norm = glm_vec2_norm(v);
if (norm == 0.0f) {
glm_vec2_zero(dest);
return;
}
glm_vec2_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])
*/
CGLM_INLINE
void
glm_vec2_div(vec2 a, vec2 b, vec2 dest) {
dest[0] = a[0] / b[0];
dest[1] = a[1] / b[1];
}
/*!
* @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)
*/
CGLM_INLINE
void
glm_vec2_divs(vec2 v, float s, vec2 dest) {
dest[0] = v[0] / s;
dest[1] = v[1] / 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_vec2_addadd(vec2 a, vec2 b, vec2 dest) {
dest[0] += a[0] + b[0];
dest[1] += a[1] + b[1];
}
/*!
* @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_vec2_subadd(vec2 a, vec2 b, vec2 dest) {
dest[0] += a[0] - b[0];
dest[1] += a[1] - b[1];
}
/*!
* @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_vec2_muladd(vec2 a, vec2 b, vec2 dest) {
dest[0] += a[0] * b[0];
dest[1] += a[1] * b[1];
}
/*!
* @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_vec2_muladds(vec2 a, float s, vec2 dest) {
dest[0] += a[0] * s;
dest[1] += a[1] * s;
}
/*!
* @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
* @param[out] dest dest += max(a, b)
*/
CGLM_INLINE
void
glm_vec2_maxadd(vec2 a, vec2 b, vec2 dest) {
dest[0] += glm_max(a[0], b[0]);
dest[1] += glm_max(a[1], b[1]);
}
/*!
* @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
* @param[out] dest dest += min(a, b)
*/
CGLM_INLINE
void
glm_vec2_minadd(vec2 a, vec2 b, vec2 dest) {
dest[0] += glm_min(a[0], b[0]);
dest[1] += glm_min(a[1], b[1]);
}
/*!
* @brief negate vector components and store result in dest
*
* @param[in] v vector
* @param[out] dest result vector
*/
CGLM_INLINE
void
glm_vec2_negate_to(vec2 v, vec2 dest) {
dest[0] = -v[0];
dest[1] = -v[1];
}
/*!
* @brief negate vector components
*
* @param[in, out] v vector
*/
CGLM_INLINE
void
glm_vec2_negate(vec2 v) {
glm_vec2_negate_to(v, v);
}
/*!
* @brief normalize vector and store result in same vec
*
* @param[in, out] v vector
*/
CGLM_INLINE
void
glm_vec2_normalize(vec2 v) {
float norm;
norm = glm_vec2_norm(v);
if (norm == 0.0f) {
v[0] = v[1] = 0.0f;
return;
}
glm_vec2_scale(v, 1.0f / norm, v);
}
/*!
* @brief normalize vector to dest
*
* @param[in] v source
* @param[out] dest destination
*/
CGLM_INLINE
void
glm_vec2_normalize_to(vec2 v, vec2 dest) {
float norm;
norm = glm_vec2_norm(v);
if (norm == 0.0f) {
glm_vec2_zero(dest);
return;
}
glm_vec2_scale(v, 1.0f / norm, dest);
}
/*!
* @brief rotate vec2 around origin by angle (CCW: counterclockwise)
*
* Formula:
* 𝑥2 = cos(a)𝑥1 − sin(a)𝑦1
* 𝑦2 = sin(a)𝑥1 + cos(a)𝑦1
*
* @param[in] v vector to rotate
* @param[in] angle angle by radians
* @param[out] dest destination vector
*/
CGLM_INLINE
void
glm_vec2_rotate(vec2 v, float angle, vec2 dest) {
float c, s, x1, y1;
c = cosf(angle);
s = sinf(angle);
x1 = v[0];
y1 = v[1];
dest[0] = c * x1 - s * y1;
dest[1] = s * x1 + c * y1;
}
/**
* @brief squared distance between two vectors
*
* @param[in] a vector1
* @param[in] b vector2
* @return returns squared distance (distance * distance)
*/
CGLM_INLINE
float
glm_vec2_distance2(vec2 a, vec2 b) {
return glm_pow2(b[0] - a[0]) + glm_pow2(b[1] - a[1]);
}
/**
* @brief distance between two vectors
*
* @param[in] a vector1
* @param[in] b vector2
* @return returns distance
*/
CGLM_INLINE
float
glm_vec2_distance(vec2 a, vec2 b) {
return sqrtf(glm_vec2_distance2(a, b));
}
/*!
* @brief max values of vectors
*
* @param[in] a vector1
* @param[in] b vector2
* @param[out] dest destination
*/
CGLM_INLINE
void
glm_vec2_maxv(vec2 a, vec2 b, vec2 dest) {
dest[0] = glm_max(a[0], b[0]);
dest[1] = glm_max(a[1], b[1]);
}
/*!
* @brief min values of vectors
*
* @param[in] a vector1
* @param[in] b vector2
* @param[out] dest destination
*/
CGLM_INLINE
void
glm_vec2_minv(vec2 a, vec2 b, vec2 dest) {
dest[0] = glm_min(a[0], b[0]);
dest[1] = glm_min(a[1], b[1]);
}
/*!
* @brief clamp vector's individual members between min and max values
*
* @param[in, out] v vector
* @param[in] minval minimum value
* @param[in] maxval maximum value
*/
CGLM_INLINE
void
glm_vec2_clamp(vec2 v, float minval, float maxval) {
v[0] = glm_clamp(v[0], minval, maxval);
v[1] = glm_clamp(v[1], minval, maxval);
}
/*!
* @brief linear interpolation between two vector
*
* 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
* @param[out] dest destination
*/
CGLM_INLINE
void
glm_vec2_lerp(vec2 from, vec2 to, float t, vec2 dest) {
vec2 s, v;
/* from + s * (to - from) */
glm_vec2_fill(s, glm_clamp_zo(t));
glm_vec2_sub(to, from, v);
glm_vec2_mul(s, v, v);
glm_vec2_add(from, v, dest);
}
#endif /* cglm_vec2_h */

99
src/mat2.c Normal file
View File

@@ -0,0 +1,99 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#include "../include/cglm/cglm.h"
#include "../include/cglm/call.h"
CGLM_EXPORT
void
glmc_mat2_copy(mat2 mat, mat2 dest) {
glm_mat2_copy(mat, dest);
}
CGLM_EXPORT
void
glmc_mat2_identity(mat2 mat) {
glm_mat2_identity(mat);
}
CGLM_EXPORT
void
glmc_mat2_identity_array(mat2 * __restrict mat, size_t count) {
glm_mat2_identity_array(mat, count);
}
CGLM_EXPORT
void
glmc_mat2_zero(mat2 mat) {
glm_mat2_zero(mat);
}
CGLM_EXPORT
void
glmc_mat2_mul(mat2 m1, mat2 m2, mat2 dest) {
glm_mat2_mul(m1, m2, dest);
}
CGLM_EXPORT
void
glmc_mat2_transpose_to(mat2 m, mat2 dest) {
glm_mat2_transpose_to(m, dest);
}
CGLM_EXPORT
void
glmc_mat2_transpose(mat2 m) {
glm_mat2_transpose(m);
}
CGLM_EXPORT
void
glmc_mat2_mulv(mat2 m, vec2 v, vec2 dest) {
glm_mat2_mulv(m, v, dest);
}
CGLM_EXPORT
float
glmc_mat2_trace(mat2 m) {
return glm_mat2_trace(m);
}
CGLM_EXPORT
void
glmc_mat2_scale(mat2 m, float s) {
glm_mat2_scale(m, s);
}
CGLM_EXPORT
float
glmc_mat2_det(mat2 mat) {
return glm_mat2_det(mat);
}
CGLM_EXPORT
void
glmc_mat2_inv(mat2 mat, mat2 dest) {
glm_mat2_inv(mat, dest);
}
CGLM_EXPORT
void
glmc_mat2_swap_col(mat2 mat, int col1, int col2) {
glm_mat2_swap_col(mat, col1, col2);
}
CGLM_EXPORT
void
glmc_mat2_swap_row(mat2 mat, int row1, int row2) {
glm_mat2_swap_row(mat, row1, row2);
}
CGLM_EXPORT
float
glmc_mat2_rmc(vec2 r, mat2 m, vec2 c) {
return glm_mat2_rmc(r, m, c);
}

213
src/vec2.c Normal file
View File

@@ -0,0 +1,213 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#include "../include/cglm/cglm.h"
#include "../include/cglm/call.h"
CGLM_EXPORT
void
glmc_vec2(float * __restrict v, vec2 dest) {
glm_vec2(v, dest);
}
CGLM_EXPORT
void
glmc_vec2_copy(vec2 a, vec2 dest) {
glm_vec2_copy(a, dest);
}
CGLM_EXPORT
void
glmc_vec2_zero(vec2 v) {
glm_vec2_zero(v);
}
CGLM_EXPORT
void
glmc_vec2_one(vec2 v) {
glm_vec2_one(v);
}
CGLM_EXPORT
float
glmc_vec2_dot(vec2 a, vec2 b) {
return glm_vec2_dot(a, b);
}
CGLM_EXPORT
float
glmc_vec2_cross(vec2 a, vec2 b) {
return glm_vec2_cross(a, b);
}
CGLM_EXPORT
float
glmc_vec2_norm2(vec2 v) {
return glm_vec2_norm2(v);
}
CGLM_EXPORT
float
glmc_vec2_norm(vec2 v) {
return glm_vec2_norm(v);
}
CGLM_EXPORT
void
glmc_vec2_add(vec2 a, vec2 b, vec2 dest) {
glm_vec2_add(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec2_adds(vec2 v, float s, vec2 dest) {
glm_vec2_adds(v, s, dest);
}
CGLM_EXPORT
void
glmc_vec2_sub(vec2 a, vec2 b, vec2 dest) {
glm_vec2_sub(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec2_subs(vec2 v, float s, vec2 dest) {
glm_vec2_subs(v, s, dest);
}
CGLM_EXPORT
void
glmc_vec2_mul(vec2 a, vec2 b, vec2 dest) {
glm_vec2_mul(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec2_scale(vec2 v, float s, vec2 dest) {
glm_vec2_scale(v, s, dest);
}
CGLM_EXPORT
void
glmc_vec2_scale_as(vec2 v, float s, vec2 dest) {
glm_vec2_scale_as(v, s, dest);
}
CGLM_EXPORT
void
glmc_vec2_div(vec2 a, vec2 b, vec2 dest) {
glm_vec2_div(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec2_divs(vec2 v, float s, vec2 dest) {
glm_vec2_divs(v, s, dest);
}
CGLM_EXPORT
void
glmc_vec2_addadd(vec2 a, vec2 b, vec2 dest) {
glm_vec2_addadd(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec2_subadd(vec2 a, vec2 b, vec2 dest) {
glm_vec2_subadd(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec2_muladd(vec2 a, vec2 b, vec2 dest) {
glm_vec2_muladd(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec2_muladds(vec2 a, float s, vec2 dest) {
glm_vec2_muladds(a, s, dest);
}
CGLM_EXPORT
void
glmc_vec2_maxadd(vec2 a, vec2 b, vec2 dest) {
glm_vec2_maxadd(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec2_minadd(vec2 a, vec2 b, vec2 dest) {
glm_vec2_minadd(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec2_negate_to(vec2 v, vec2 dest) {
glm_vec2_negate_to(v, dest);
}
CGLM_EXPORT
void
glmc_vec2_negate(vec2 v) {
glm_vec2_negate(v);
}
CGLM_EXPORT
void
glmc_vec2_normalize(vec2 v) {
glm_vec2_normalize(v);
}
CGLM_EXPORT
void
glmc_vec2_normalize_to(vec2 v, vec2 dest) {
glm_vec2_normalize_to(v, dest);
}
CGLM_EXPORT
void
glmc_vec2_rotate(vec2 v, float angle, vec2 dest) {
glm_vec2_rotate(v, angle, dest);
}
CGLM_EXPORT
float
glmc_vec2_distance2(vec2 a, vec2 b) {
return glm_vec2_distance2(a, b);
}
CGLM_EXPORT
float
glmc_vec2_distance(vec2 a, vec2 b) {
return glm_vec2_distance(a, b);
}
CGLM_EXPORT
void
glmc_vec2_maxv(vec2 a, vec2 b, vec2 dest) {
glm_vec2_maxv(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec2_minv(vec2 a, vec2 b, vec2 dest) {
glm_vec2_minv(a, b, dest);
}
CGLM_EXPORT
void
glmc_vec2_clamp(vec2 v, float minval, float maxval) {
glm_vec2_clamp(v, minval, maxval);
}
CGLM_EXPORT
void
glmc_vec2_lerp(vec2 from, vec2 to, float t, vec2 dest) {
glm_vec2_lerp(from, to, t, dest);
}

6
test/src/test_affine.h
View File

@@ -571,7 +571,7 @@ TEST_IMPL(GLM_PREFIX, decompose_rs) {
glm_mat4_mul(m2, r, m2);
glm_scale(m2, s1);
ASSERTIFY(test_assert_mat4_eq2(m1, m2, 0.00001));
ASSERTIFY(test_assert_mat4_eq2(m1, m2, 0.00001f));
TEST_SUCCESS
}
@@ -607,7 +607,7 @@ TEST_IMPL(GLM_PREFIX, decompose) {
glm_mat4_mul(m2, r, m2);
glm_scale(m2, s);
ASSERTIFY(test_assert_mat4_eq2(m1, m2, 0.00001));
ASSERTIFY(test_assert_mat4_eq2(m1, m2, 0.00001f));
glm_mat4_identity(m1);
glm_translate(m1, (vec3){56.0f, 13.0f, 90.0f});
@@ -628,7 +628,7 @@ TEST_IMPL(GLM_PREFIX, decompose) {
glm_translate(m2, t);
glm_mat4_mul(m2, r, m2);
glm_scale(m2, s);
ASSERTIFY(test_assert_mat4_eq2(m1, m2, 0.00001));
ASSERTIFY(test_assert_mat4_eq2(m1, m2, 0.00001f));
TEST_SUCCESS
}

129
test/src/test_common.c
View File

@@ -14,10 +14,10 @@ test_rand_mat4(mat4 dest) {
dest[3][0] = drand48();
dest[3][1] = drand48();
dest[3][2] = drand48();
/* random rotatation around random axis with random angle */
glm_rotate(dest, drand48(), (vec3){drand48(), drand48(), drand48()});
/* random scale */
/* glm_scale(dest, (vec3){drand48(), drand48(), drand48()}); */
}
@@ -31,6 +31,14 @@ test_rand_mat3(mat3 dest) {
glm_mat4_pick3(m4, dest);
}
void
test_rand_mat2(mat2 dest) {
dest[0][0] = drand48();
dest[0][1] = drand48();
dest[1][0] = drand48();
dest[1][1] = drand48();
}
void
test_rand_vec3(vec3 dest) {
dest[0] = drand48();
@@ -39,7 +47,7 @@ test_rand_vec3(vec3 dest) {
}
vec3s
test_rand_vec3s() {
test_rand_vec3s(void) {
vec3s r;
test_rand_vec3(r.raw);
return r;
@@ -54,7 +62,7 @@ test_rand_vec4(vec4 dest) {
}
vec4s
test_rand_vec4s() {
test_rand_vec4s(void) {
vec4s r;
test_rand_vec4(r.raw);
return r;
@@ -73,68 +81,119 @@ test_rand_quat(versor q) {
test_status_t
test_assert_mat4_eq(mat4 m1, mat4 m2) {
int i, j, k;
int i, j;
for (i = 0; i < 4; i++) {
for (j = 0; j < 4; j++) {
for (k = 0; k < 4; k++)
ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009)
ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009)
}
}
TEST_SUCCESS
}
test_status_t
test_assert_mat4_eqt(mat4 m1, mat4 m2) {
int i, j, k;
int i, j;
for (i = 0; i < 4; i++) {
for (j = 0; j < 4; j++) {
for (k = 0; k < 4; k++)
ASSERT(fabsf(m1[j][i] - m2[i][j]) <= 0.0000009)
ASSERT(fabsf(m1[j][i] - m2[i][j]) <= 0.0000009)
}
}
TEST_SUCCESS
}
test_status_t
test_assert_mat4_eq2(mat4 m1, mat4 m2, float eps) {
int i, j, k;
int i, j;
for (i = 0; i < 4; i++) {
for (j = 0; j < 4; j++) {
for (k = 0; k < 4; k++)
ASSERT(fabsf(m1[i][j] - m2[i][j]) <= eps);
ASSERT(fabsf(m1[i][j] - m2[i][j]) <= eps);
}
}
TEST_SUCCESS
}
test_status_t
test_assert_mat2_eqt(mat2 m1, mat2 m2) {
int i, j;
for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++) {
ASSERT(fabsf(m1[j][i] - m2[i][j]) <= 0.0000009);
}
}
TEST_SUCCESS
}
test_status_t
test_assert_mat2_eq(mat2 m1, mat2 m2) {
int i, j;
for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++) {
ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009);
}
}
TEST_SUCCESS
}
test_status_t
test_assert_mat2_eq_identity(mat2 m2) {
int i, j;
for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++) {
if (i == j) {
ASSERT(test_eq(m2[i][j], 1.0f))
} else {
ASSERT(test_eq(m2[i][j], 0.0f))
}
}
}
TEST_SUCCESS
}
test_status_t
test_assert_mat2_eq_zero(mat2 m2) {
int i, j;
for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++) {
ASSERT(test_eq(m2[i][j], 0.0f))
}
}
TEST_SUCCESS
}
test_status_t
test_assert_mat3_eq(mat3 m1, mat3 m2) {
int i, j, k;
int i, j;
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
for (k = 0; k < 3; k++)
ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009);
ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009);
}
}
TEST_SUCCESS
}
test_status_t
test_assert_mat3_eqt(mat3 m1, mat3 m2) {
int i, j, k;
int i, j;
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
for (k = 0; k < 3; k++)
ASSERT(fabsf(m1[j][i] - m2[i][j]) <= 0.0000009);
ASSERT(fabsf(m1[j][i] - m2[i][j]) <= 0.0000009);
}
}
@@ -204,7 +263,15 @@ test_assert_mat4_eq_zero(mat4 m4) {
test_status_t
test_assert_eqf(float a, float b) {
ASSERT(fabsf(a - b) <= 0.000009); /* rounding errors */
TEST_SUCCESS
}
test_status_t
test_assert_vec2_eq(vec2 v1, vec2 v2) {
ASSERT(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */
ASSERT(fabsf(v1[1] - v2[1]) <= 0.000009);
TEST_SUCCESS
}
@@ -213,14 +280,14 @@ test_assert_vec3_eq(vec3 v1, vec3 v2) {
ASSERT(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */
ASSERT(fabsf(v1[1] - v2[1]) <= 0.000009);
ASSERT(fabsf(v1[2] - v2[2]) <= 0.000009);
TEST_SUCCESS
}
test_status_t
test_assert_vec3s_eq(vec3s v1, vec3s v2) {
test_assert_vec3_eq(v1.raw, v2.raw);
TEST_SUCCESS
}
@@ -230,14 +297,14 @@ test_assert_vec4_eq(vec4 v1, vec4 v2) {
ASSERT(fabsf(v1[1] - v2[1]) <= 0.000009);
ASSERT(fabsf(v1[2] - v2[2]) <= 0.000009);
ASSERT(fabsf(v1[3] - v2[3]) <= 0.000009);
TEST_SUCCESS
}
test_status_t
test_assert_vec4s_eq(vec4s v1, vec4s v2) {
test_assert_vec4_eq(v1.raw, v2.raw);
TEST_SUCCESS
}
@@ -247,7 +314,7 @@ test_assert_quat_eq_abs(versor v1, versor v2) {
ASSERT(fabsf(fabsf(v1[1]) - fabsf(v2[1])) <= 0.0009);
ASSERT(fabsf(fabsf(v1[2]) - fabsf(v2[2])) <= 0.0009);
ASSERT(fabsf(fabsf(v1[3]) - fabsf(v2[3])) <= 0.0009);
TEST_SUCCESS
}
@@ -257,7 +324,7 @@ test_assert_quat_eq(versor v1, versor v2) {
ASSERT(fabsf(v1[1] - v2[1]) <= 0.000009);
ASSERT(fabsf(v1[2] - v2[2]) <= 0.000009);
ASSERT(fabsf(v1[3] - v2[3]) <= 0.000009);
TEST_SUCCESS
}

18
test/src/test_common.h
View File

@@ -16,6 +16,9 @@ test_rand_mat4(mat4 dest);
void
test_rand_mat3(mat3 dest);
void
test_rand_mat2(mat2 dest);
test_status_t
test_assert_eqf(float a, float b);
@@ -34,9 +37,24 @@ test_assert_mat4_eq_identity(mat4 m4);
test_status_t
test_assert_mat4_eq_zero(mat4 m4);
test_status_t
test_assert_mat2_eqt(mat2 m1, mat2 m2);
test_status_t
test_assert_mat2_eq(mat2 m1, mat2 m2);
test_status_t
test_assert_mat2_eq_identity(mat2 m2);
test_status_t
test_assert_mat2_eq_zero(mat2 m2);
test_status_t
test_assert_mat3_eq(mat3 m1, mat3 m2);
test_status_t
test_assert_vec2_eq(vec2 v1, vec2 v2);
test_status_t
test_assert_mat3_eqt(mat3 m1, mat3 m2);

286
test/src/test_mat2.h Normal file
View File

@@ -0,0 +1,286 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#include "test_common.h"
#define A_MATRIX2x2 {{1,2},{5,6}}
#ifndef CGLM_TEST_MAT2_ONCE
#define CGLM_TEST_MAT2_ONCE
TEST_IMPL(MACRO_GLM_MAT2_IDENTITY_INIT) {
mat2 m = GLM_MAT2_IDENTITY_INIT;
ASSERT(test_eq(m[0][0], 1.0f))
ASSERT(test_eq(m[0][1], 0.0f))
ASSERT(test_eq(m[1][0], 0.0f))
ASSERT(test_eq(m[1][1], 1.0f))
TEST_SUCCESS
}
TEST_IMPL(MACRO_GLM_MAT2_ZERO_INIT) {
mat2 m = GLM_MAT2_ZERO_INIT;
ASSERT(test_eq(m[0][0], 0.0f))
ASSERT(test_eq(m[0][1], 0.0f))
ASSERT(test_eq(m[1][0], 0.0f))
ASSERT(test_eq(m[1][1], 0.0f))
TEST_SUCCESS
}
TEST_IMPL(MACRO_GLM_MAT2_IDENTITY) {
ASSERT(test_eq(GLM_MAT2_IDENTITY[0][0], 1.0f))
ASSERT(test_eq(GLM_MAT2_IDENTITY[0][1], 0.0f))
ASSERT(test_eq(GLM_MAT2_IDENTITY[1][0], 0.0f))
ASSERT(test_eq(GLM_MAT2_IDENTITY[1][1], 1.0f))
TEST_SUCCESS
}
TEST_IMPL(MACRO_GLM_MAT2_ZERO) {
ASSERT(test_eq(GLM_MAT2_ZERO[0][0], 0.0f))
ASSERT(test_eq(GLM_MAT2_ZERO[0][1], 0.0f))
ASSERT(test_eq(GLM_MAT2_ZERO[1][0], 0.0f))
ASSERT(test_eq(GLM_MAT2_ZERO[1][1], 0.0f))
TEST_SUCCESS
}
#endif /* CGLM_TEST_MAT2_ONCE */
TEST_IMPL(GLM_PREFIX, mat2_copy) {
mat2 m1 = A_MATRIX2x2;
mat2 m2 = GLM_MAT2_IDENTITY_INIT;
GLM(mat2_copy)(m1, m2);
test_assert_mat2_eq(m1, m2);
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, mat2_identity) {
mat2 m1 = GLM_MAT2_IDENTITY_INIT;
mat2 m2 = GLM_MAT2_IDENTITY_INIT;
mat2 m3;
GLM(mat2_identity)(m3);
ASSERTIFY(test_assert_mat2_eq_identity(m1))
ASSERTIFY(test_assert_mat2_eq_identity(m2))
ASSERTIFY(test_assert_mat2_eq_identity(m3))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, mat2_identity_array) {
int i, count;
mat2 matrices[4] = {
A_MATRIX2x2,
A_MATRIX2x2,
A_MATRIX2x2,
A_MATRIX2x2
};
count = 4;
GLM(mat2_identity_array)(matrices, count);
for (i = 0; i < count; i++) {
ASSERTIFY(test_assert_mat2_eq_identity(matrices[i]))
}
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, mat2_zero) {
mat2 m1 = GLM_MAT2_ZERO_INIT;
mat2 m2 = GLM_MAT2_ZERO_INIT;
mat2 m3;
GLM(mat2_zero)(m3);
ASSERTIFY(test_assert_mat2_eq_zero(m1))
ASSERTIFY(test_assert_mat2_eq_zero(m2))
ASSERTIFY(test_assert_mat2_eq_zero(m3))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, mat2_mul) {
mat2 m1 = GLM_MAT2_IDENTITY_INIT;
mat2 m2 = GLM_MAT2_IDENTITY_INIT;
mat2 m3;
mat2 m4 = GLM_MAT2_ZERO_INIT;
int i, j, k;
/* test random matrices */
/* random matrices */
test_rand_mat2(m1);
test_rand_mat2(m2);
GLM(mat2_mul)(m1, m2, m3);
for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++) {
for (k = 0; k < 2; k++)
/* column-major */
m4[i][j] += m1[k][j] * m2[i][k];
}
}
ASSERTIFY(test_assert_mat2_eq(m3, m4))
/* test pre compiled */
GLM(mat2_mul)(m1, m2, m3);
ASSERTIFY(test_assert_mat2_eq(m3, m4))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, mat2_transpose_to) {
mat2 mat = A_MATRIX2x2;
mat2 m1;
GLM(mat2_transpose_to)(mat, m1);
ASSERTIFY(test_assert_mat2_eqt(mat, m1))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, mat2_transpose) {
mat2 mat = A_MATRIX2x2;
mat2 m1;
GLM(mat2_copy)(mat, m1);
GLM(mat2_transpose)(m1);
ASSERTIFY(test_assert_mat2_eqt(mat, m1))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, mat2_mulv) {
vec2 res;
mat2 mat = A_MATRIX2x2;
vec2 v = {11.0f, 21.0f};
int i;
GLM(mat2_mulv)(mat, v, res);
for (i = 0; i < 2; i++) {
ASSERT(test_eq(res[i], v[0] * mat[0][i] + v[1] * mat[1][i]))
}
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, mat2_trace) {
mat2 mat = A_MATRIX2x2;
float trace;
trace = GLM(mat2_trace)(mat);
ASSERT(test_eq(trace, mat[0][0] + mat[1][1]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, mat2_scale) {
mat2 m1 = A_MATRIX2x2;
mat2 m2 = A_MATRIX2x2;
int i, j, scale;
scale = rand() % 100;
GLM(mat2_scale)(m1, (float)scale);
for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++) {
ASSERT(test_eq(m1[i][j], m2[i][j] * scale))
}
}
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, mat2_det) {
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, mat2_inv) {
mat2 m1 = GLM_MAT2_IDENTITY_INIT;
mat2 m2 = GLM_MAT2_IDENTITY_INIT;
mat2 m3;
int i;
m1[0][0] = 41.0f;
m1[0][1] = 0.0f;
m1[1][0] = 0.0f;
m1[1][1] = 70.0f;
for (i = 0; i < 10000; i++) {
/* test inverse precise */
GLM(mat2_inv)(m1, m2);
GLM(mat2_inv)(m2, m3);
ASSERTIFY(test_assert_mat2_eq(m1, m3))
}
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, mat2_swap_col) {
mat2 m1 = A_MATRIX2x2;
mat2 m2 = A_MATRIX2x2;
GLM(mat2_swap_col)(m1, 0, 1);
ASSERTIFY(test_assert_vec2_eq(m1[0], m2[1]))
ASSERTIFY(test_assert_vec2_eq(m1[1], m2[0]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, mat2_swap_row) {
mat2 m1 = A_MATRIX2x2;
mat2 m2 = A_MATRIX2x2;
GLM(mat2_swap_row)(m1, 0, 1);
ASSERT(test_eq(m1[0][0], m2[0][1]))
ASSERT(test_eq(m1[0][1], m2[0][0]))
ASSERT(test_eq(m1[1][0], m2[1][1]))
ASSERT(test_eq(m1[1][1], m2[1][0]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, mat2_rmc) {
mat2 mat = A_MATRIX2x2;
vec2 v = {11.0f, 12.0f};
vec2 v1;
float r1, r2;
int i;
r1 = GLM(mat2_rmc)(v, mat, v);
for (i = 0; i < 2; i++) {
v1[i] = v[0] * mat[i][0] + v[1] * mat[i][1];
}
r2 = v[0] * v1[0] + v[1] * v1[1];
ASSERT(test_eq(r1, r2))
TEST_SUCCESS
}
#undef A_MATRIX2x2

596
test/src/test_vec2.h Normal file
View File

@@ -0,0 +1,596 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#include "test_common.h"
#ifndef CGLM_TEST_VEC2_ONCE
#define CGLM_TEST_VEC2_ONCE
/* Macros */
TEST_IMPL(MACRO_GLM_VEC2_ONE_INIT) {
vec2 v = GLM_VEC2_ONE_INIT;
ASSERT(test_eq(v[0], 1.0f))
ASSERT(test_eq(v[1], 1.0f))
TEST_SUCCESS
}
TEST_IMPL(MACRO_GLM_VEC2_ZERO_INIT) {
vec2 v = GLM_VEC2_ZERO_INIT;
ASSERT(test_eq(v[0], 0.0f))
ASSERT(test_eq(v[1], 0.0f))
TEST_SUCCESS
}
TEST_IMPL(MACRO_GLM_VEC2_ONE) {
ASSERT(test_eq(GLM_VEC2_ONE[0], 1.0f))
ASSERT(test_eq(GLM_VEC2_ONE[1], 1.0f))
TEST_SUCCESS
}
TEST_IMPL(MACRO_GLM_VEC2_ZERO) {
ASSERT(test_eq(GLM_VEC2_ZERO[0], 0.0f))
ASSERT(test_eq(GLM_VEC2_ZERO[0], 0.0f))
TEST_SUCCESS
}
#endif /* CGLM_TEST_VEC2_ONCE */
TEST_IMPL(GLM_PREFIX, vec2) {
vec4 v4 = {10.0f, 9.0f, 8.0f, 7.0f};
vec3 v3 = {11.0f, 12.0f, 13.0f};
vec2 v2;
GLM(vec2)(v4, v2);
ASSERT(test_eq(v2[0], v4[0]))
ASSERT(test_eq(v2[1], v4[1]))
GLM(vec2)(v3, v2);
ASSERT(test_eq(v2[0], v3[0]))
ASSERT(test_eq(v2[1], v3[1]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_copy) {
vec2 v1 = {10.0f, 9.0f};
vec2 v2 = {1.0f, 2.0f};
GLM(vec2_copy)(v1, v2);
ASSERTIFY(test_assert_vec2_eq(v1, v2))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_zero) {
vec2 v1 = {10.0f, 9.0f};
vec2 v2 = {1.0f, 2.0f};
GLM(vec2_zero)(v1);
GLM(vec2_zero)(v2);
ASSERTIFY(test_assert_vec2_eq(v1, GLM_VEC2_ZERO))
ASSERTIFY(test_assert_vec2_eq(v2, GLM_VEC2_ZERO))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_one) {
vec2 v1 = {10.0f, 9.0f};
vec2 v2 = {1.0f, 2.0f};
GLM(vec2_one)(v1);
GLM(vec2_one)(v2);
ASSERTIFY(test_assert_vec2_eq(v1, GLM_VEC2_ONE))
ASSERTIFY(test_assert_vec2_eq(v2, GLM_VEC2_ONE))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_dot) {
vec2 a = {10.0f, 9.0f};
vec2 b = {1.0f, 2.0f};
float dot1, dot2;
dot1 = GLM(vec2_dot)(a, b);
dot2 = a[0] * b[0] + a[1] * b[1];
ASSERT(test_eq(dot1, dot2))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_cross) {
vec2 a = {10.0f, 9.0f};
vec2 b = {1.0f, 2.0f};
float cprod;
cprod = a[0] * b[1] - a[1] * b[0];
ASSERT(test_eq(glm_vec2_cross(a, b), cprod))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_norm2) {
vec2 a = {10.0f, 9.0f};
float n1, n2;
n1 = GLM(vec2_norm2)(a);
n2 = a[0] * a[0] + a[1] * a[1];
ASSERT(test_eq(n1, n2))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_norm) {
vec2 a = {10.0f, 9.0f};
float n1, n2;
n1 = GLM(vec2_norm)(a);
n2 = sqrtf(a[0] * a[0] + a[1] * a[1]);
ASSERT(test_eq(n1, n2))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_add) {
vec2 a = {-10.0f, 9.0f};
vec2 b = {12.0f, 19.0f};
vec2 c, d;
c[0] = a[0] + b[0];
c[1] = a[1] + b[1];
GLM(vec2_add)(a, b, d);
ASSERTIFY(test_assert_vec2_eq(c, d))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_adds) {
vec4 a = {-10.0f, 9.0f};
vec4 c, d;
float s = 7.0f;
c[0] = a[0] + s;
c[1] = a[1] + s;
GLM(vec2_adds)(a, s, d);
ASSERTIFY(test_assert_vec2_eq(c, d))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_sub) {
vec2 a = {-10.0f, 9.0f};
vec2 b = {12.0f, 19.0f};
vec2 c, d;
c[0] = a[0] - b[0];
c[1] = a[1] - b[1];
GLM(vec2_sub)(a, b, d);
ASSERTIFY(test_assert_vec2_eq(c, d))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_subs) {
vec2 a = {-10.0f, 9.0f};
vec2 c, d;
float s = 7.0f;
c[0] = a[0] - s;
c[1] = a[1] - s;
GLM(vec2_subs)(a, s, d);
ASSERTIFY(test_assert_vec2_eq(c, d))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_mul) {
vec2 v1 = {2.0f, -3.0f},
v2 = {-3.0f, 4.0f},
v3;
GLM(vec2_mul)(v1, v2, v3);
ASSERT(test_eq(v1[0] * v2[0], v3[0]))
ASSERT(test_eq(v1[1] * v2[1], v3[1]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_scale) {
vec2 v1 = {2.0f, -3.0f}, v2;
float s = 7.0f;
GLM(vec2_scale)(v1, s, v2);
ASSERT(test_eq(v1[0] * s, v2[0]))
ASSERT(test_eq(v1[1] * s, v2[1]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_scale_as) {
vec2 v1 = {2.0f, -3.0f}, v2;
float s = 7.0f;
float norm;
GLM(vec2_scale_as)(v1, s, v2);
norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1]);
if (norm == 0.0f) {
ASSERT(test_eq(v1[0], 0.0f))
ASSERT(test_eq(v1[1], 0.0f))
TEST_SUCCESS
}
norm = s / norm;
ASSERT(test_eq(v1[0] * norm, v2[0]))
ASSERT(test_eq(v1[1] * norm, v2[1]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_div) {
vec2 v1 = {2.0f, -3.0f},
v2 = {-3.0f, 4.0f},
v3;
GLM(vec2_div)(v1, v2, v3);
ASSERT(test_eq(v1[0] / v2[0], v3[0]))
ASSERT(test_eq(v1[1] / v2[1], v3[1]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_divs) {
vec2 v1 = {2.0f, -3.0f}, v2;
float s = 7.0f;
GLM(vec2_divs)(v1, s, v2);
ASSERT(test_eq(v1[0] / s, v2[0]))
ASSERT(test_eq(v1[1] / s, v2[1]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_addadd) {
vec2 v1 = {2.0f, -3.0f},
v2 = {-3.0f, 4.0f},
v3 = {1.0f, 2.0f},
v4 = {1.0f, 2.0f};
GLM(vec2_addadd)(v1, v2, v4);
ASSERT(test_eq(v3[0] + v1[0] + v2[0], v4[0]))
ASSERT(test_eq(v3[1] + v1[1] + v2[1], v4[1]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_subadd) {
vec2 v1 = {2.0f, -3.0f},
v2 = {-3.0f, 4.0f},
v3 = {1.0f, 2.0f},
v4 = {1.0f, 2.0f};
GLM(vec2_subadd)(v1, v2, v4);
ASSERT(test_eq(v3[0] + v1[0] - v2[0], v4[0]))
ASSERT(test_eq(v3[1] + v1[1] - v2[1], v4[1]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_muladd) {
vec2 v1 = {2.0f, -3.0f},
v2 = {-3.0f, 4.0f},
v3 = {1.0f, 2.0f},
v4 = {1.0f, 2.0f};
GLM(vec2_muladd)(v1, v2, v4);
ASSERT(test_eq(v3[0] + v1[0] * v2[0], v4[0]))
ASSERT(test_eq(v3[1] + v1[1] * v2[1], v4[1]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_muladds) {
vec2 v1 = {2.0f, -3.0f},
v2 = {1.0f, 2.0f},
v3 = {1.0f, 2.0f};
float s = 9.0f;
GLM(vec2_muladds)(v1, s, v3);
ASSERT(test_eq(v2[0] + v1[0] * s, v3[0]))
ASSERT(test_eq(v2[1] + v1[1] * s, v3[1]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_maxadd) {
vec2 v1 = {2.0f, -3.0f},
v2 = {-3.0f, 4.0f},
v3 = {1.0f, 2.0f},
v4 = {1.0f, 2.0f};
GLM(vec2_maxadd)(v1, v2, v4);
ASSERT(test_eq(v3[0] + glm_max(v1[0], v2[0]), v4[0]))
ASSERT(test_eq(v3[1] + glm_max(v1[1], v2[1]), v4[1]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_minadd) {
vec2 v1 = {2.0f, -3.0f},
v2 = {-3.0f, 4.0f},
v3 = {1.0f, 2.0f},
v4 = {1.0f, 2.0f};
GLM(vec2_minadd)(v1, v2, v4);
ASSERT(test_eq(v3[0] + glm_min(v1[0], v2[0]), v4[0]))
ASSERT(test_eq(v3[1] + glm_min(v1[1], v2[1]), v4[1]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_negate_to) {
vec2 v1 = {2.0f, -3.0f},
v2 = {-3.0f, 4.0f},
v3, v4;
GLM(vec2_negate_to)(v1, v3);
GLM(vec2_negate_to)(v2, v4);
ASSERT(test_eq(-v1[0], v3[0]))
ASSERT(test_eq(-v1[1], v3[1]))
ASSERT(test_eq(-v2[0], v4[0]))
ASSERT(test_eq(-v2[1], v4[1]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_negate) {
vec2 v1 = {2.0f, -3.0f},
v2 = {-3.0f, 4.0f},
v3 = {2.0f, -3.0f},
v4 = {-3.0f, 4.0f};
GLM(vec2_negate)(v1);
GLM(vec2_negate)(v2);
ASSERT(test_eq(-v1[0], v3[0]))
ASSERT(test_eq(-v1[1], v3[1]))
ASSERT(test_eq(-v2[0], v4[0]))
ASSERT(test_eq(-v2[1], v4[1]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_normalize) {
vec2 v1 = {2.0f, -3.0f}, v2 = {2.0f, -3.0f};
float s = 1.0f;
float norm;
GLM(vec2_normalize)(v2);
norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1]);
if (norm == 0.0f) {
ASSERT(test_eq(v1[0], 0.0f))
ASSERT(test_eq(v1[1], 0.0f))
TEST_SUCCESS
}
norm = s / norm;
ASSERT(test_eq(v1[0] * norm, v2[0]))
ASSERT(test_eq(v1[1] * norm, v2[1]))
glm_vec2_zero(v1);
GLM(vec2_normalize)(v1);
ASSERTIFY(test_assert_vec2_eq(v1, GLM_VEC2_ZERO))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_normalize_to) {
vec2 v1 = {2.0f, -3.0f}, v2;
float s = 1.0f;
float norm;
GLM(vec2_normalize_to)(v1, v2);
norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1]);
if (norm == 0.0f) {
ASSERT(test_eq(v1[0], 0.0f))
ASSERT(test_eq(v1[1], 0.0f))
TEST_SUCCESS
}
norm = s / norm;
ASSERT(test_eq(v1[0] * norm, v2[0]))
ASSERT(test_eq(v1[1] * norm, v2[1]))
glm_vec2_zero(v1);
GLM(vec2_normalize_to)(v1, v2);
ASSERTIFY(test_assert_vec2_eq(v2, GLM_VEC2_ZERO))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_rotate) {
vec2 v1 = {1.0f, 0.0f};
GLM(vec2_rotate)(v1, GLM_PI_2f, v1);
ASSERT(test_eq(v1[0], 0.0f))
ASSERT(test_eq(v1[1], 1.0f))
GLM(vec2_rotate)(v1, GLM_PI_2f, v1);
ASSERT(test_eq(v1[0], -1.0f))
ASSERT(test_eq(v1[1], 0.0f))
GLM(vec2_rotate)(v1, GLM_PI_2f, v1);
ASSERT(test_eq(v1[0], 0.0f))
ASSERT(test_eq(v1[1], -1.0f))
GLM(vec2_rotate)(v1, GLM_PI_2f, v1);
ASSERT(test_eq(v1[0], 1.0f))
ASSERT(test_eq(v1[1], 0.0f))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_distance2) {
vec2 v1 = {30.0f, 0.0f},
v2 = {0.0f, 0.0f},
v3 = {3.0f, 10.0f},
v4 = {0.46f, 4.0f};
float d;
d = GLM(vec2_distance2)(v1, v2);
ASSERT(test_eq(d, 30.0f * 30.0f))
d = GLM(vec2_distance2)(v3, v4);
ASSERT(test_eq(powf(v3[0] - v4[0], 2.0f)
+ powf(v3[1] - v4[1], 2.0f), d))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_distance) {
vec2 v1 = {30.0f, 0.0f},
v2 = {0.0f, 0.0f},
v3 = {3.0f, 10.0f},
v4 = {0.46f, 4.0f};
float d;
d = GLM(vec2_distance)(v1, v2);
ASSERT(test_eq(d, 30.0f))
d = GLM(vec2_distance)(v3, v4);
ASSERT(test_eq(sqrtf(powf(v3[0] - v4[0], 2.0f)
+ powf(v3[1] - v4[1], 2.0f)), d))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_maxv) {
vec2 v1, v2, v3;
vec2 v5 = {-1.456f, -1.456f};
vec2 v6 = {11.0f, 11.0f};
vec2 v7 = {78.0f, -78.0f};
GLM(vec2_maxv)(v5, v6, v1);
GLM(vec2_maxv)(v5, v7, v2);
GLM(vec2_maxv)(v6, v7, v3);
ASSERT(test_eq(v1[0], 11.0f))
ASSERT(test_eq(v1[1], 11.0f))
ASSERT(test_eq(v2[0], 78.0f))
ASSERT(test_eq(v2[1], -1.456f))
ASSERT(test_eq(v3[0], 78.0f))
ASSERT(test_eq(v3[1], 11.0f))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_minv) {
vec2 v1, v2, v3;
vec2 v5 = {-1.456f, -1.456f};
vec2 v6 = {11.0f, 11.0f};
vec2 v7 = {78.0f, -78.0f};
GLM(vec2_minv)(v5, v6, v1);
GLM(vec2_minv)(v5, v7, v2);
GLM(vec2_minv)(v6, v7, v3);
ASSERT(test_eq(v1[0], -1.456f))
ASSERT(test_eq(v1[1], -1.456f))
ASSERT(test_eq(v2[0], -1.456f))
ASSERT(test_eq(v2[1], -78.0f))
ASSERT(test_eq(v3[0], 11.0f))
ASSERT(test_eq(v3[1], -78.0f))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_clamp) {
vec2 v1 = {-1.456f, -11.456f};
vec2 v2 = {0.110f, 111.0f};
vec2 v3 = {78.0f, 32.0f};
GLM(vec2_clamp)(v1, -1.03f, 30.0f);
GLM(vec2_clamp)(v2, 0.11f, 111.0f);
GLM(vec2_clamp)(v3, -88.0f, 70.0f);
ASSERT(test_eq(v1[0], -1.03f))
ASSERT(test_eq(v1[1], -1.03f))
ASSERT(test_eq(v2[0], 0.11f))
ASSERT(test_eq(v2[1], 111.0f))
ASSERT(test_eq(v3[0], 70.0f))
ASSERT(test_eq(v3[1], 32.0f))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_lerp) {
vec2 v1 = {-100.0f, -200.0f};
vec2 v2 = {100.0f, 200.0f};
vec2 v3;
GLM(vec2_lerp)(v1, v2, 0.5f, v3);
ASSERT(test_eq(v3[0], 0.0f))
ASSERT(test_eq(v3[1], 0.0f))
GLM(vec2_lerp)(v1, v2, 0.75f, v3);
ASSERT(test_eq(v3[0], 50.0f))
ASSERT(test_eq(v3[1], 100.0f))
TEST_SUCCESS
}

23
test/src/test_vec3.h
View File

@@ -233,7 +233,7 @@ TEST_IMPL(GLM_PREFIX, vec3_zero) {
GLM(vec3_zero)(v2);
ASSERTIFY(test_assert_vec3_eq(v1, GLM_VEC3_ZERO))
ASSERTIFY(test_assert_vec3_eq(v1, GLM_VEC3_ZERO))
ASSERTIFY(test_assert_vec3_eq(v2, GLM_VEC3_ZERO))
TEST_SUCCESS
}
@@ -335,9 +335,9 @@ TEST_IMPL(GLM_PREFIX, vec3_norm_inf) {
}
TEST_IMPL(GLM_PREFIX, vec3_add) {
vec4 a = {-10.0f, 9.0f, -8.0f};
vec4 b = {12.0f, 19.0f, -18.0f};
vec4 c, d;
vec3 a = {-10.0f, 9.0f, -8.0f};
vec3 b = {12.0f, 19.0f, -18.0f};
vec3 c, d;
c[0] = a[0] + b[0];
c[1] = a[1] + b[1];
@@ -351,8 +351,8 @@ TEST_IMPL(GLM_PREFIX, vec3_add) {
}
TEST_IMPL(GLM_PREFIX, vec3_adds) {
vec4 a = {-10.0f, 9.0f, -8.0f};
vec4 c, d;
vec3 a = {-10.0f, 9.0f, -8.0f};
vec3 c, d;
float s = 7.0f;
c[0] = a[0] + s;
@@ -367,9 +367,9 @@ TEST_IMPL(GLM_PREFIX, vec3_adds) {
}
TEST_IMPL(GLM_PREFIX, vec3_sub) {
vec4 a = {-10.0f, 9.0f, -8.0f};
vec4 b = {12.0f, 19.0f, -18.0f};
vec4 c, d;
vec3 a = {-10.0f, 9.0f, -8.0f};
vec3 b = {12.0f, 19.0f, -18.0f};
vec3 c, d;
c[0] = a[0] - b[0];
c[1] = a[1] - b[1];
@@ -383,8 +383,8 @@ TEST_IMPL(GLM_PREFIX, vec3_sub) {
}
TEST_IMPL(GLM_PREFIX, vec3_subs) {
vec4 a = {-10.0f, 9.0f, -8.0f};
vec4 c, d;
vec3 a = {-10.0f, 9.0f, -8.0f};
vec3 c, d;
float s = 7.0f;
c[0] = a[0] - s;
@@ -928,7 +928,6 @@ TEST_IMPL(GLM_PREFIX, vec3_rotate_m4) {
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec3_rotate_m3) {
vec3 v1 = {1.0f, 0.0f, 0.0f}, v2 = {1.0f, 1.0f, 1.0f};
mat4 x0, y0, z0;

4
test/src/test_vec4.h
View File

@@ -217,7 +217,7 @@ TEST_IMPL(GLM_PREFIX, vec4_zero) {
GLM(vec4_zero)(v2);
ASSERTIFY(test_assert_vec4_eq(v1, GLM_VEC4_ZERO))
ASSERTIFY(test_assert_vec4_eq(v1, GLM_VEC4_ZERO))
ASSERTIFY(test_assert_vec4_eq(v2, GLM_VEC4_ZERO))
TEST_SUCCESS
}
@@ -230,7 +230,7 @@ TEST_IMPL(GLM_PREFIX, vec4_one) {
GLM(vec4_one)(v2);
ASSERTIFY(test_assert_vec4_eq(v1, GLM_VEC4_ONE))
ASSERTIFY(test_assert_vec4_eq(v1, GLM_VEC4_ONE))
ASSERTIFY(test_assert_vec4_eq(v2, GLM_VEC4_ONE))
TEST_SUCCESS
}

4
test/src/tests.c
View File

@@ -12,8 +12,10 @@
#define GLM_PREFIX glm_
#define GLM(X) (glm_ ## X)
#include "test_vec2.h"
#include "test_vec3.h"
#include "test_vec4.h"
#include "test_mat2.h"
#include "test_mat3.h"
#include "test_mat4.h"
#include "test_quat.h"
@@ -31,8 +33,10 @@
#define GLM_PREFIX glmc_
#define GLM(X) (glmc_ ## X)
#include "test_vec2.h"
#include "test_vec3.h"
#include "test_vec4.h"
#include "test_mat2.h"
#include "test_mat3.h"
#include "test_mat4.h"
#include "test_quat.h"

229
test/tests.h
View File

@@ -159,6 +159,42 @@ TEST_DECLARE(glmc_mat3_swap_col)
TEST_DECLARE(glmc_mat3_swap_row)
TEST_DECLARE(glmc_mat3_rmc)
TEST_DECLARE(MACRO_GLM_MAT2_IDENTITY_INIT)
TEST_DECLARE(MACRO_GLM_MAT2_ZERO_INIT)
TEST_DECLARE(MACRO_GLM_MAT2_IDENTITY)
TEST_DECLARE(MACRO_GLM_MAT2_ZERO)
TEST_DECLARE(glm_mat2_copy)
TEST_DECLARE(glm_mat2_identity)
TEST_DECLARE(glm_mat2_identity_array)
TEST_DECLARE(glm_mat2_zero)
TEST_DECLARE(glm_mat2_mul)
TEST_DECLARE(glm_mat2_transpose_to)
TEST_DECLARE(glm_mat2_transpose)
TEST_DECLARE(glm_mat2_mulv)
TEST_DECLARE(glm_mat2_trace)
TEST_DECLARE(glm_mat2_scale)
TEST_DECLARE(glm_mat2_det)
TEST_DECLARE(glm_mat2_inv)
TEST_DECLARE(glm_mat2_swap_col)
TEST_DECLARE(glm_mat2_swap_row)
TEST_DECLARE(glm_mat2_rmc)
TEST_DECLARE(glmc_mat2_copy)
TEST_DECLARE(glmc_mat2_identity)
TEST_DECLARE(glmc_mat2_identity_array)
TEST_DECLARE(glmc_mat2_zero)
TEST_DECLARE(glmc_mat2_mul)
TEST_DECLARE(glmc_mat2_transpose_to)
TEST_DECLARE(glmc_mat2_transpose)
TEST_DECLARE(glmc_mat2_mulv)
TEST_DECLARE(glmc_mat2_trace)
TEST_DECLARE(glmc_mat2_scale)
TEST_DECLARE(glmc_mat2_det)
TEST_DECLARE(glmc_mat2_inv)
TEST_DECLARE(glmc_mat2_swap_col)
TEST_DECLARE(glmc_mat2_swap_row)
TEST_DECLARE(glmc_mat2_rmc)
/* camera */
TEST_DECLARE(camera_lookat)
TEST_DECLARE(camera_decomp)
@@ -261,6 +297,85 @@ TEST_DECLARE(glmc_quat_rotate_atm)
/* bezier */
TEST_DECLARE(bezier)
/* Macros */
TEST_DECLARE(MACRO_GLM_VEC2_ONE_INIT)
TEST_DECLARE(MACRO_GLM_VEC2_ZERO_INIT)
TEST_DECLARE(MACRO_GLM_VEC2_ONE)
TEST_DECLARE(MACRO_GLM_VEC2_ZERO)
TEST_DECLARE(glm_vec2)
TEST_DECLARE(glm_vec2_copy)
TEST_DECLARE(glm_vec2_zero)
TEST_DECLARE(glm_vec2_one)
TEST_DECLARE(glm_vec2_dot)
TEST_DECLARE(glm_vec2_cross)
TEST_DECLARE(glm_vec2_norm2)
TEST_DECLARE(glm_vec2_norm)
TEST_DECLARE(glm_vec2_add)
TEST_DECLARE(glm_vec2_adds)
TEST_DECLARE(glm_vec2_sub)
TEST_DECLARE(glm_vec2_subs)
TEST_DECLARE(glm_vec2_mul)
TEST_DECLARE(glm_vec2_scale)
TEST_DECLARE(glm_vec2_scale_as)
TEST_DECLARE(glm_vec2_div)
TEST_DECLARE(glm_vec2_divs)
TEST_DECLARE(glm_vec2_addadd)
TEST_DECLARE(glm_vec2_subadd)
TEST_DECLARE(glm_vec2_muladd)
TEST_DECLARE(glm_vec2_muladds)
TEST_DECLARE(glm_vec2_maxadd)
TEST_DECLARE(glm_vec2_minadd)
TEST_DECLARE(glm_vec2_negate_to)
TEST_DECLARE(glm_vec2_negate)
TEST_DECLARE(glm_vec2_normalize)
TEST_DECLARE(glm_vec2_normalize_to)
TEST_DECLARE(glm_vec2_rotate)
TEST_DECLARE(glm_vec2_distance2)
TEST_DECLARE(glm_vec2_distance)
TEST_DECLARE(glm_vec2_maxv)
TEST_DECLARE(glm_vec2_minv)
TEST_DECLARE(glm_vec2_clamp)
TEST_DECLARE(glm_vec2_lerp)
TEST_DECLARE(glmc_vec2)
TEST_DECLARE(glmc_vec2_copy)
TEST_DECLARE(glmc_vec2_zero)
TEST_DECLARE(glmc_vec2_one)
TEST_DECLARE(glmc_vec2_dot)
TEST_DECLARE(glmc_vec2_cross)
TEST_DECLARE(glmc_vec2_norm2)
TEST_DECLARE(glmc_vec2_norm)
TEST_DECLARE(glmc_vec2_add)
TEST_DECLARE(glmc_vec2_adds)
TEST_DECLARE(glmc_vec2_sub)
TEST_DECLARE(glmc_vec2_subs)
TEST_DECLARE(glmc_vec2_mul)
TEST_DECLARE(glmc_vec2_scale)
TEST_DECLARE(glmc_vec2_scale_as)
TEST_DECLARE(glmc_vec2_div)
TEST_DECLARE(glmc_vec2_divs)
TEST_DECLARE(glmc_vec2_addadd)
TEST_DECLARE(glmc_vec2_subadd)
TEST_DECLARE(glmc_vec2_muladd)
TEST_DECLARE(glmc_vec2_muladds)
TEST_DECLARE(glmc_vec2_maxadd)
TEST_DECLARE(glmc_vec2_minadd)
TEST_DECLARE(glmc_vec2_negate_to)
TEST_DECLARE(glmc_vec2_negate)
TEST_DECLARE(glmc_vec2_normalize)
TEST_DECLARE(glmc_vec2_normalize_to)
TEST_DECLARE(glmc_vec2_rotate)
TEST_DECLARE(glmc_vec2_distance2)
TEST_DECLARE(glmc_vec2_distance)
TEST_DECLARE(glmc_vec2_maxv)
TEST_DECLARE(glmc_vec2_minv)
TEST_DECLARE(glmc_vec2_clamp)
TEST_DECLARE(glmc_vec2_lerp)
/* vec3 */
TEST_DECLARE(MACRO_GLM_VEC3_ONE_INIT)
TEST_DECLARE(MACRO_GLM_VEC3_ZERO_INIT)
@@ -696,7 +811,6 @@ TEST_LIST {
TEST_ENTRY(glmc_mat4_swap_row)
TEST_ENTRY(glmc_mat4_rmc)
/* mat3 */
TEST_ENTRY(glm_mat3_copy)
TEST_ENTRY(glm_mat3_identity)
@@ -732,6 +846,42 @@ TEST_LIST {
TEST_ENTRY(glmc_mat3_swap_row)
TEST_ENTRY(glmc_mat3_rmc)
TEST_ENTRY(MACRO_GLM_MAT2_IDENTITY_INIT)
TEST_ENTRY(MACRO_GLM_MAT2_ZERO_INIT)
TEST_ENTRY(MACRO_GLM_MAT2_IDENTITY)
TEST_ENTRY(MACRO_GLM_MAT2_ZERO)
TEST_ENTRY(glm_mat2_copy)
TEST_ENTRY(glm_mat2_identity)
TEST_ENTRY(glm_mat2_identity_array)
TEST_ENTRY(glm_mat2_zero)
TEST_ENTRY(glm_mat2_mul)
TEST_ENTRY(glm_mat2_transpose_to)
TEST_ENTRY(glm_mat2_transpose)
TEST_ENTRY(glm_mat2_mulv)
TEST_ENTRY(glm_mat2_trace)
TEST_ENTRY(glm_mat2_scale)
TEST_ENTRY(glm_mat2_det)
TEST_ENTRY(glm_mat2_inv)
TEST_ENTRY(glm_mat2_swap_col)
TEST_ENTRY(glm_mat2_swap_row)
TEST_ENTRY(glm_mat2_rmc)
TEST_ENTRY(glmc_mat2_copy)
TEST_ENTRY(glmc_mat2_identity)
TEST_ENTRY(glmc_mat2_identity_array)
TEST_ENTRY(glmc_mat2_zero)
TEST_ENTRY(glmc_mat2_mul)
TEST_ENTRY(glmc_mat2_transpose_to)
TEST_ENTRY(glmc_mat2_transpose)
TEST_ENTRY(glmc_mat2_mulv)
TEST_ENTRY(glmc_mat2_trace)
TEST_ENTRY(glmc_mat2_scale)
TEST_ENTRY(glmc_mat2_det)
TEST_ENTRY(glmc_mat2_inv)
TEST_ENTRY(glmc_mat2_swap_col)
TEST_ENTRY(glmc_mat2_swap_row)
TEST_ENTRY(glmc_mat2_rmc)
/* camera */
TEST_ENTRY(camera_lookat)
TEST_ENTRY(camera_decomp)
@@ -834,6 +984,83 @@ TEST_LIST {
/* bezier */
TEST_ENTRY(bezier)
/* Macros */
TEST_ENTRY(MACRO_GLM_VEC2_ONE_INIT)
TEST_ENTRY(MACRO_GLM_VEC2_ZERO_INIT)
TEST_ENTRY(MACRO_GLM_VEC2_ONE)
TEST_ENTRY(MACRO_GLM_VEC2_ZERO)
TEST_ENTRY(glm_vec2)
TEST_ENTRY(glm_vec2_copy)
TEST_ENTRY(glm_vec2_zero)
TEST_ENTRY(glm_vec2_one)
TEST_ENTRY(glm_vec2_dot)
TEST_ENTRY(glm_vec2_cross)
TEST_ENTRY(glm_vec2_norm2)
TEST_ENTRY(glm_vec2_norm)
TEST_ENTRY(glm_vec2_add)
TEST_ENTRY(glm_vec2_adds)
TEST_ENTRY(glm_vec2_sub)
TEST_ENTRY(glm_vec2_subs)
TEST_ENTRY(glm_vec2_mul)
TEST_ENTRY(glm_vec2_scale)
TEST_ENTRY(glm_vec2_scale_as)
TEST_ENTRY(glm_vec2_div)
TEST_ENTRY(glm_vec2_divs)
TEST_ENTRY(glm_vec2_addadd)
TEST_ENTRY(glm_vec2_subadd)
TEST_ENTRY(glm_vec2_muladd)
TEST_ENTRY(glm_vec2_muladds)
TEST_ENTRY(glm_vec2_maxadd)
TEST_ENTRY(glm_vec2_minadd)
TEST_ENTRY(glm_vec2_negate_to)
TEST_ENTRY(glm_vec2_negate)
TEST_ENTRY(glm_vec2_normalize)
TEST_ENTRY(glm_vec2_normalize_to)
TEST_ENTRY(glm_vec2_rotate)
TEST_ENTRY(glm_vec2_distance2)
TEST_ENTRY(glm_vec2_distance)
TEST_ENTRY(glm_vec2_maxv)
TEST_ENTRY(glm_vec2_minv)
TEST_ENTRY(glm_vec2_clamp)
TEST_ENTRY(glm_vec2_lerp)
TEST_ENTRY(glmc_vec2)
TEST_ENTRY(glmc_vec2_copy)
TEST_ENTRY(glmc_vec2_zero)
TEST_ENTRY(glmc_vec2_one)
TEST_ENTRY(glmc_vec2_dot)
TEST_ENTRY(glmc_vec2_cross)
TEST_ENTRY(glmc_vec2_norm2)
TEST_ENTRY(glmc_vec2_norm)
TEST_ENTRY(glmc_vec2_add)
TEST_ENTRY(glmc_vec2_adds)
TEST_ENTRY(glmc_vec2_sub)
TEST_ENTRY(glmc_vec2_subs)
TEST_ENTRY(glmc_vec2_mul)
TEST_ENTRY(glmc_vec2_scale)
TEST_ENTRY(glmc_vec2_scale_as)
TEST_ENTRY(glmc_vec2_div)
TEST_ENTRY(glmc_vec2_divs)
TEST_ENTRY(glmc_vec2_addadd)
TEST_ENTRY(glmc_vec2_subadd)
TEST_ENTRY(glmc_vec2_muladd)
TEST_ENTRY(glmc_vec2_muladds)
TEST_ENTRY(glmc_vec2_maxadd)
TEST_ENTRY(glmc_vec2_minadd)
TEST_ENTRY(glmc_vec2_negate_to)
TEST_ENTRY(glmc_vec2_negate)
TEST_ENTRY(glmc_vec2_normalize)
TEST_ENTRY(glmc_vec2_normalize_to)
TEST_ENTRY(glmc_vec2_rotate)
TEST_ENTRY(glmc_vec2_distance2)
TEST_ENTRY(glmc_vec2_distance)
TEST_ENTRY(glmc_vec2_maxv)
TEST_ENTRY(glmc_vec2_minv)
TEST_ENTRY(glmc_vec2_clamp)
TEST_ENTRY(glmc_vec2_lerp)
/* vec3 */
/* Macros */

5
win/cglm-test.vcxproj
View File

@@ -30,11 +30,16 @@
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\test\include\common.h" />
<ClInclude Include="..\test\src\test_affine.h" />
<ClInclude Include="..\test\src\test_affine_mat.h" />
<ClInclude Include="..\test\src\test_common.h" />
<ClInclude Include="..\test\src\test_mat2.h" />
<ClInclude Include="..\test\src\test_mat3.h" />
<ClInclude Include="..\test\src\test_mat4.h" />
<ClInclude Include="..\test\src\test_plane.h" />
<ClInclude Include="..\test\src\test_project.h" />
<ClInclude Include="..\test\src\test_quat.h" />
<ClInclude Include="..\test\src\test_vec2.h" />
<ClInclude Include="..\test\src\test_vec3.h" />
<ClInclude Include="..\test\src\test_vec4.h" />
<ClInclude Include="..\test\tests.h" />

15
win/cglm-test.vcxproj.filters
View File

@@ -64,5 +64,20 @@
<ClInclude Include="..\test\src\test_vec4.h">
<Filter>src</Filter>
</ClInclude>
<ClInclude Include="..\test\src\test_affine.h">
<Filter>src</Filter>
</ClInclude>
<ClInclude Include="..\test\src\test_affine_mat.h">
<Filter>src</Filter>
</ClInclude>
<ClInclude Include="..\test\src\test_mat2.h">
<Filter>src</Filter>
</ClInclude>
<ClInclude Include="..\test\src\test_plane.h">
<Filter>src</Filter>
</ClInclude>
<ClInclude Include="..\test\src\test_vec2.h">
<Filter>src</Filter>
</ClInclude>
</ItemGroup>
</Project>

11
win/cglm.vcxproj
View File

@@ -28,18 +28,21 @@
<ClCompile Include="..\src\euler.c" />
<ClCompile Include="..\src\frustum.c" />
<ClCompile Include="..\src\io.c" />
<ClCompile Include="..\src\mat2.c" />
<ClCompile Include="..\src\mat3.c" />
<ClCompile Include="..\src\mat4.c" />
<ClCompile Include="..\src\plane.c" />
<ClCompile Include="..\src\project.c" />
<ClCompile Include="..\src\quat.c" />
<ClCompile Include="..\src\sphere.c" />
<ClCompile Include="..\src\vec2.c" />
<ClCompile Include="..\src\vec3.c" />
<ClCompile Include="..\src\vec4.c" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\include\cglm\affine-mat.h" />
<ClInclude Include="..\include\cglm\affine.h" />
<ClInclude Include="..\include\cglm\applesimd.h" />
<ClInclude Include="..\include\cglm\bezier.h" />
<ClInclude Include="..\include\cglm\box.h" />
<ClInclude Include="..\include\cglm\call.h" />
@@ -52,12 +55,14 @@
<ClInclude Include="..\include\cglm\call\euler.h" />
<ClInclude Include="..\include\cglm\call\frustum.h" />
<ClInclude Include="..\include\cglm\call\io.h" />
<ClInclude Include="..\include\cglm\call\mat2.h" />
<ClInclude Include="..\include\cglm\call\mat3.h" />
<ClInclude Include="..\include\cglm\call\mat4.h" />
<ClInclude Include="..\include\cglm\call\plane.h" />
<ClInclude Include="..\include\cglm\call\project.h" />
<ClInclude Include="..\include\cglm\call\quat.h" />
<ClInclude Include="..\include\cglm\call\sphere.h" />
<ClInclude Include="..\include\cglm\call\vec2.h" />
<ClInclude Include="..\include\cglm\call\vec3.h" />
<ClInclude Include="..\include\cglm\call\vec4.h" />
<ClInclude Include="..\include\cglm\cam.h" />
@@ -69,6 +74,7 @@
<ClInclude Include="..\include\cglm\euler.h" />
<ClInclude Include="..\include\cglm\frustum.h" />
<ClInclude Include="..\include\cglm\io.h" />
<ClInclude Include="..\include\cglm\mat2.h" />
<ClInclude Include="..\include\cglm\mat3.h" />
<ClInclude Include="..\include\cglm\mat4.h" />
<ClInclude Include="..\include\cglm\plane.h" />
@@ -94,12 +100,15 @@
<ClInclude Include="..\include\cglm\struct\euler.h" />
<ClInclude Include="..\include\cglm\struct\frustum.h" />
<ClInclude Include="..\include\cglm\struct\io.h" />
<ClInclude Include="..\include\cglm\struct\mat2.h" />
<ClInclude Include="..\include\cglm\struct\mat3.h" />
<ClInclude Include="..\include\cglm\struct\mat4.h" />
<ClInclude Include="..\include\cglm\struct\plane.h" />
<ClInclude Include="..\include\cglm\struct\project.h" />
<ClInclude Include="..\include\cglm\struct\quat.h" />
<ClInclude Include="..\include\cglm\struct\sphere.h" />
<ClInclude Include="..\include\cglm\struct\vec2-ext.h" />
<ClInclude Include="..\include\cglm\struct\vec2.h" />
<ClInclude Include="..\include\cglm\struct\vec3-ext.h" />
<ClInclude Include="..\include\cglm\struct\vec3.h" />
<ClInclude Include="..\include\cglm\struct\vec4-ext.h" />
@@ -107,6 +116,8 @@
<ClInclude Include="..\include\cglm\types-struct.h" />
<ClInclude Include="..\include\cglm\types.h" />
<ClInclude Include="..\include\cglm\util.h" />
<ClInclude Include="..\include\cglm\vec2-ext.h" />
<ClInclude Include="..\include\cglm\vec2.h" />
<ClInclude Include="..\include\cglm\vec3-ext.h" />
<ClInclude Include="..\include\cglm\vec3.h" />
<ClInclude Include="..\include\cglm\vec4-ext.h" />

35
win/cglm.vcxproj.filters
View File

@@ -1,4 +1,4 @@
<?xml version="1.0" encoding="utf-8"?>
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="Header Files">
@@ -86,6 +86,12 @@
<ClCompile Include="..\src\bezier.c">
<Filter>src</Filter>
</ClCompile>
<ClCompile Include="..\src\mat2.c">
<Filter>src</Filter>
</ClCompile>
<ClCompile Include="..\src\vec2.c">
<Filter>src</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\src\config.h">
@@ -253,6 +259,9 @@
<ClInclude Include="..\include\cglm\call\bezier.h">
<Filter>include\cglm\call</Filter>
</ClInclude>
<ClInclude Include="..\include\cglm\vec2.h">
<Filter>include\cglm</Filter>
</ClInclude>
<ClInclude Include="..\include\cglm\struct\affine.h">
<Filter>include\cglm\struct</Filter>
</ClInclude>
@@ -313,5 +322,29 @@
<ClInclude Include="..\include\cglm\types-struct.h">
<Filter>include\cglm</Filter>
</ClInclude>
<ClInclude Include="..\include\cglm\call\mat2.h">
<Filter>include\cglm\call</Filter>
</ClInclude>
<ClInclude Include="..\include\cglm\call\vec2.h">
<Filter>include\cglm\call</Filter>
</ClInclude>
<ClInclude Include="..\include\cglm\struct\mat2.h">
<Filter>include\cglm\struct</Filter>
</ClInclude>
<ClInclude Include="..\include\cglm\applesimd.h">
<Filter>include\cglm</Filter>
</ClInclude>
<ClInclude Include="..\include\cglm\mat2.h">
<Filter>include\cglm</Filter>
</ClInclude>
<ClInclude Include="..\include\cglm\vec2-ext.h">
<Filter>include\cglm</Filter>
</ClInclude>
<ClInclude Include="..\include\cglm\struct\vec2.h">
<Filter>include\cglm\struct</Filter>
</ClInclude>
<ClInclude Include="..\include\cglm\struct\vec2-ext.h">
<Filter>include\cglm\struct</Filter>
</ClInclude>
</ItemGroup>
</Project>