update version

Fixed GLM_QUAT_IDENTITY_INIT (wxyz) instead of (xyzw). Addresses #10.

.gitignore

@@ -56,4 +56,7 @@ test/.libs/*
 test/tests
 cglm_arm/*
 cglm_test_ios/*
-cglm_test_iosTests/*
+cglm_test_iosTests/*
+docs/build/*
+win/cglm_test_*
+* copy.*

.travis.yml

@@ -36,9 +36,6 @@ branches:
   only:
     - master
 
-before_install:
-  - pip install --user cpp-coveralls
-
 script:
   - sh ./build-deps.sh
   - sh ./autogen.sh
@@ -52,6 +49,7 @@ script:
 
 after_success:
   - if [[ "$CC" == "gcc" && "$CODE_COVERAGE" == "ON" ]]; then
+      pip install --user cpp-coveralls
       coveralls
         --build-root .
         --exclude lib

README.md

@@ -58,8 +58,8 @@ Almost all functions are marked inline (always_inline) so compiler probably will
 To call pre-compiled version, just use `glmc_` (c stands for 'call') instead of `glm_`.
 
 ```C
-  #include <cglm.h>        /* for inline */
+  #include <cglm/cglm.h>   /* for inline */
-  #include <cglm-call.h>   /* for library call (this also includes cglm.h) */
+  #include <cglm/call.h>   /* for library call (this also includes cglm.h) */
 
   mat4 rot, trans, rt;
   /* ... */
@@ -125,7 +125,7 @@ $ devenv cglm.sln /Build Release
 ## How to use
 If you want to use inline versions of funcstions then; include main header
 ```C
-#include <cglm.h>
+#include <cglm/cglm.h>
 ```
 the haeder will include all headers. Then call func you want e.g. rotate vector by axis:
 ```C
@@ -144,7 +144,7 @@ like this function you may see `_to` postfix, this functions store results to an
 
 to call pre-compiled versions include header with `c` postfix, c means call. Pre-compiled versions are just wrappers.
 ```C
-#include <cglm-call.h>
+#include <cglm/call.h>
 ```
 this header will include all heaers with c postfix. You need to call functions with c posfix:
 ```C
@@ -158,9 +158,9 @@ Function usage and parameters are documented inside related headers.
 - If headers are not working properly with your compiler, IDE please open an issue, because I'm using GCC and clang to test it maybe sometimes MSVC
 
 **TODO:**
-- [ ] Unit tests
+- [ ] Unit tests (In Progress)
 - [ ] Unit tests for comparing cglm with glm results
 - [x] Add version info
 - [ ] Unaligned operations (e.g. `glm_umat4_mul`)
 - [ ] Extra documentation
-- [ ] ARM Neon Arch
+- [ ] ARM Neon Arch (In Progress)

include/cglm/call/vec3.h

@@ -64,6 +64,14 @@ CGLM_EXPORT
 void
 glmc_vec_flipsign(vec3 v);
 
+CGLM_EXPORT
+void
+glmc_vec_inv(vec3 v);
+
+CGLM_EXPORT
+void
+glmc_vec_inv_to(vec3 v, vec3 dest);
+  
 CGLM_EXPORT
 float
 glmc_vec_angle(vec3 v1, vec3 v2);
@@ -88,6 +96,14 @@ CGLM_EXPORT
 float
 glmc_vec_distance(vec3 v1, vec3 v2);
 
+CGLM_EXPORT
+void
+glmc_vec_maxv(vec3 v1, vec3 v2, vec3 dest);
+
+CGLM_EXPORT
+void
+glmc_vec_minv(vec3 v1, vec3 v2, vec3 dest);
+
 #ifdef __cplusplus
 }
 #endif

include/cglm/call/vec4.h

@@ -65,10 +65,26 @@ CGLM_EXPORT
 void
 glmc_vec4_flipsign(vec4 v);
 
+CGLM_EXPORT
+void
+glmc_vec4_inv(vec4 v);
+
+CGLM_EXPORT
+void
+glmc_vec4_inv_to(vec4 v, vec4 dest);
+
 CGLM_EXPORT
 float
 glmc_vec4_distance(vec4 v1, vec4 v2);
 
+CGLM_EXPORT
+void
+glmc_vec4_maxv(vec4 v1, vec4 v2, vec4 dest);
+
+CGLM_EXPORT
+void
+glmc_vec4_minv(vec4 v1, vec4 v2, vec4 dest);
+
 #ifdef __cplusplus
 }
 #endif

include/cglm/cam.h

@@ -11,26 +11,45 @@
                                 float right,
                                 float bottom,
                                 float top,
-                                float near,
+                                float nearVal,
-                                float far,
+                                float farVal,
                                 mat4  dest);
    CGLM_INLINE void glm_ortho(float left,
                               float right,
                               float bottom,
                               float top,
-                              float near,
+                              float nearVal,
-                              float far,
+                              float farVal,
                               mat4  dest);
    CGLM_INLINE void glm_ortho_default(float aspect, mat4  dest);
    CGLM_INLINE void glm_ortho_default_s(float aspect, float size, mat4  dest);
    CGLM_INLINE void glm_perspective(float fovy,
                                     float aspect,
-                                    float near,
+                                    float nearVal,
-                                    float far,
+                                    float farVal,
                                     mat4  dest);
    CGLM_INLINE void glm_perspective_default(float aspect, mat4  dest);
    CGLM_INLINE void glm_perspective_resize(float aspect, mat4  proj);
    CGLM_INLINE void glm_lookat(vec3 eye, vec3 center, vec3 up, mat4 dest);
+   CGLM_INLINE void glm_persp_decomp(mat4 proj,
+                                     float * __restrict nearVal,
+                                     float * __restrict farVal,
+                                     float * __restrict top,
+                                     float * __restrict bottom,
+                                     float * __restrict left,
+                                     float * __restrict right);
+   CGLM_INLINE void glm_persp_decompv(mat4  proj, float dest[6]);
+   CGLM_INLINE void glm_persp_decomp_x(mat4 proj,
+                                       float * __restrict left,
+                                       float * __restrict right);
+   CGLM_INLINE void glm_persp_decomp_y(mat4 proj,
+                                       float * __restrict top,
+                                       float * __restrict bottom);
+   CGLM_INLINE void glm_persp_decomp_z(mat4 proj,
+                                       float * __restrict nearVal,
+                                       float * __restrict farVal);
+   CGLM_INLINE void glm_persp_decomp_far(mat4 proj, float * __restrict farVal);
+   CGLM_INLINE void glm_persp_decomp_near(mat4 proj, float *__restrict nearVal);
  */
 
 #ifndef cglm_vcam_h
@@ -281,4 +300,126 @@ glm_lookat(vec3 eye,
   dest[3][3] = 1.0f;
 }
 
+/*!
+ * @brief decomposes frustum values of perspective projection.
+ *
+ * @param[in]  proj    perspective projection matrix
+ * @param[out] nearVal near
+ * @param[out] farVal  far
+ * @param[out] top     top
+ * @param[out] bottom  bottom
+ * @param[out] left    left
+ * @param[out] right   right
+ */
+CGLM_INLINE
+void
+glm_persp_decomp(mat4 proj,
+                 float * __restrict nearVal,
+                 float * __restrict farVal,
+                 float * __restrict top,
+                 float * __restrict bottom,
+                 float * __restrict left,
+                 float * __restrict right) {
+  *nearVal = proj[3][2] / (proj[2][2] - 1);
+  *farVal  = proj[3][2] / (proj[2][2] + 1);
+  *bottom  = *nearVal * (proj[2][1] - 1) / proj[1][1];
+  *top     = *nearVal * (proj[2][1] + 1) / proj[1][1];
+  *left    = *nearVal * (proj[2][0] - 1) / proj[0][0];
+  *right   = *nearVal * (proj[2][0] + 1) / proj[0][0];
+}
+
+/*!
+ * @brief decomposes frustum values of perspective projection.
+ *        this makes easy to get all values at once
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] dest   array
+ */
+CGLM_INLINE
+void
+glm_persp_decompv(mat4 proj, float dest[6]) {
+  glm_persp_decomp(proj, &dest[0], &dest[1], &dest[2],
+                         &dest[3], &dest[4], &dest[5]);
+}
+
+/*!
+ * @brief decomposes left and right values of perspective projection.
+ *        x stands for x axis (left / right axis)
+ *
+ * @param[in]  proj perspective projection matrix
+ * @param[out] left  left
+ * @param[out] right right
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_x(mat4 proj,
+                   float * __restrict left,
+                   float * __restrict right) {
+  float nearVal;
+
+  nearVal = proj[3][2] / (proj[3][3] - 1);
+  *left   = nearVal * (proj[2][0] - 1) / proj[0][0];
+  *right  = nearVal * (proj[2][0] + 1) / proj[0][0];
+}
+
+/*!
+ * @brief decomposes top and bottom values of perspective projection.
+ *        y stands for y axis (top / botom axis)
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] top    top
+ * @param[out] bottom bottom
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_y(mat4 proj,
+                   float * __restrict top,
+                   float * __restrict bottom) {
+  float nearVal;
+
+  nearVal = proj[3][2] / (proj[3][3] - 1);
+  *bottom = nearVal * (proj[2][1] - 1) / proj[1][1];
+  *top    = nearVal * (proj[2][1] + 1) / proj[1][1];
+}
+
+/*!
+ * @brief decomposes near and far values of perspective projection.
+ *        z stands for z axis (near / far axis)
+ *
+ * @param[in]  proj    perspective projection matrix
+ * @param[out] nearVal near
+ * @param[out] farVal  far
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_z(mat4 proj,
+                   float * __restrict nearVal,
+                   float * __restrict farVal) {
+  *nearVal = proj[3][2] / (proj[2][2] - 1);
+  *farVal  = proj[3][2] / (proj[2][2] + 1);
+}
+
+/*!
+ * @brief decomposes far value of perspective projection.
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] farVal far
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_far(mat4 proj, float * __restrict farVal) {
+  *farVal = proj[3][2] / (proj[2][2] + 1);
+}
+
+/*!
+ * @brief decomposes near value of perspective projection.
+ *
+ * @param[in]  proj    perspective projection matrix
+ * @param[out] nearVal near
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_near(mat4 proj, float * __restrict nearVal) {
+  *nearVal = proj[3][2] / (proj[2][2] - 1);
+}
 #endif /* cglm_vcam_h */

include/cglm/mat4.h

@@ -36,7 +36,7 @@
    CGLM_INLINE void  glm_mat4_scale(mat4 m, float s);
    CGLM_INLINE float glm_mat4_det(mat4 mat);
    CGLM_INLINE void  glm_mat4_inv(mat4 mat, mat4 dest);
-   CGLM_INLINE void  glm_mat4_inv_precise(mat4 mat, mat4 dest);
+   CGLM_INLINE void  glm_mat4_inv_fast(mat4 mat, mat4 dest);
    CGLM_INLINE void  glm_mat4_swap_col(mat4 mat, int col1, int col2);
    CGLM_INLINE void  glm_mat4_swap_row(mat4 mat, int row1, int row2);
  */
@@ -78,6 +78,9 @@
 #define glm_mat4_udup(mat, dest) glm_mat4_ucopy(mat, dest)
 #define glm_mat4_dup(mat, dest)  glm_mat4_copy(mat, dest)
 
+/* DEPRECATED! default is precise now. */
+#define glm_mat4_inv_precise(mat, dest) glm_mat4_inv(mat, dest)
+
 /*!
  * @brief copy all members of [mat] to [dest]
  *
@@ -448,10 +451,6 @@ glm_mat4_det(mat4 mat) {
 /*!
  * @brief inverse mat4 and store in dest
  *
- * this func uses reciprocal approximation without extra corrections 
- * e.g Newton-Raphson. this should work faster than _precise, 
- * to get precise value use _precise version
- *
  * @param[in]  mat  matrix
  * @param[out] dest inverse matrix
  */
@@ -504,22 +503,23 @@ glm_mat4_inv(mat4 mat, mat4 dest) {
 #endif
 }
 
-
 /*!
- * @brief inverse mat4 precisely and store in dest
+ * @brief inverse mat4 and store in dest
  *
- * this do same thing as glm_mat4_inv did. the only diff is this func uses
+ * this func uses reciprocal approximation without extra corrections
- * division instead of reciprocal approximation. Due to division this might
+ * e.g Newton-Raphson. this should work faster than normal,
- * work slower than glm_mat4_inv
+ * to get more precise use glm_mat4_inv version.
+ *
+ * NOTE: You will lose precision, glm_mat4_inv is more accurate
  *
  * @param[in]  mat  matrix
  * @param[out] dest inverse matrix
  */
 CGLM_INLINE
 void
-glm_mat4_inv_precise(mat4 mat, mat4 dest) {
+glm_mat4_inv_fast(mat4 mat, mat4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
-  glm_mat4_inv_precise_sse2(mat, dest);
+  glm_mat4_inv_fast_sse2(mat, dest);
 #else
   glm_mat4_inv(mat, dest);
 #endif

include/cglm/quat.h

@@ -32,8 +32,8 @@
 #  include "simd/sse2/quat.h"
 #endif
 
-#define GLM_QUAT_IDENTITY_INIT  {0.0f, 0.0f, 0.0f, 1.0f}
+#define GLM_QUAT_IDENTITY_INIT  {1.0f, 0.0f, 0.0f, 0.0f}
-#define GLM_QUAT_IDENTITY       (versor){0.0f, 0.0f, 0.0f, 1.0f}
+#define GLM_QUAT_IDENTITY       (versor){1.0f, 0.0f, 0.0f, 0.0f}
 
 CGLM_INLINE
 void

include/cglm/simd/sse2/mat4.h

@@ -12,6 +12,8 @@
 #include "../../common.h"
 #include "../intrin.h"
 
+#define glm_mat4_inv_precise_sse2(mat, dest) glm_mat4_inv_sse2(mat, dest)
+
 CGLM_INLINE
 void
 glm_mat4_scale_sse2(mat4 m, float s){
@@ -157,7 +159,7 @@ glm_mat4_det_sse2(mat4 mat) {
 
 CGLM_INLINE
 void
-glm_mat4_inv_sse2(mat4 mat, mat4 dest) {
+glm_mat4_inv_fast_sse2(mat4 mat, mat4 dest) {
   __m128 r0, r1, r2, r3,
          v0, v1, v2, v3,
          t0, t1, t2, t3, t4, t5,
@@ -281,7 +283,7 @@ glm_mat4_inv_sse2(mat4 mat, mat4 dest) {
 
 CGLM_INLINE
 void
-glm_mat4_inv_precise_sse2(mat4 mat, mat4 dest) {
+glm_mat4_inv_sse2(mat4 mat, mat4 dest) {
   __m128 r0, r1, r2, r3,
          v0, v1, v2, v3,
          t0, t1, t2, t3, t4, t5,

include/cglm/types.h

@@ -8,7 +8,7 @@
 #ifndef cglm_types_h
 #define cglm_types_h
 
-#if defined(_WIN32)
+#if defined(_MSC_VER)
 #  define CGLM_ALIGN(X) /* __declspec(align(X)) */
 #else
 #  define CGLM_ALIGN(X) __attribute((aligned(X)))

include/cglm/vec3.h

@@ -13,6 +13,11 @@
 /*
  Macros:
    glm_vec_dup(v, dest)
+   GLM_VEC3_ONE_INIT
+   GLM_VEC3_ONE
+   GLM_YUP
+   GLM_ZUP
+   GLM_XUP
 
  Functions:
    CGLM_INLINE void  glm_vec_copy(vec3 a, vec3 dest);
@@ -25,6 +30,8 @@
    CGLM_INLINE void  glm_vec_scale(vec3 v, float s, vec3 dest);
    CGLM_INLINE void  glm_vec_scale_as(vec3 v, float s, vec3 dest);
    CGLM_INLINE void  glm_vec_flipsign(vec3 v);
+   CGLM_INLINE void  glm_vec_inv(vec3 v);
+   CGLM_INLINE void  glm_vec_inv_to(vec3 v, vec3 dest);
    CGLM_INLINE void  glm_vec_normalize(vec3 v);
    CGLM_INLINE void  glm_vec_normalize_to(vec3 vec, vec3 dest);
    CGLM_INLINE float glm_vec_distance(vec3 v1, vec3 v2);
@@ -33,6 +40,8 @@
    CGLM_INLINE void  glm_vec_rotate_m4(mat4 m, vec3 v, vec3 dest);
    CGLM_INLINE void  glm_vec_proj(vec3 a, vec3 b, vec3 dest);
    CGLM_INLINE void  glm_vec_center(vec3 v1, vec3 v2, vec3 dest);
+   CGLM_INLINE void  glm_vec_maxv(vec3 v1, vec3 v2, vec3 dest);
+   CGLM_INLINE void  glm_vec_minv(vec3 v1, vec3 v2, vec3 dest);
  */
 
 #ifndef cglm_vec3_h
@@ -45,6 +54,13 @@
 /* DEPRECATED! use _copy, _ucopy versions */
 #define glm_vec_dup(v, dest) glm_vec_copy(v, dest)
 
+#define GLM_VEC3_ONE_INIT  {1.0f, 1.0f, 1.0f}
+#define GLM_VEC3_ONE  (vec3)GLM_VEC3_ONE_INIT
+
+#define GLM_YUP  (vec3){0.0f, 1.0f, 0.0f}
+#define GLM_ZUP  (vec3){0.0f, 0.0f, 1.0f}
+#define GLM_XUP  (vec3){1.0f, 0.0f, 0.0f}
+
 /*!
  * @brief copy all members of [a] to [dest]
  *
@@ -198,6 +214,30 @@ glm_vec_flipsign(vec3 v) {
   v[2] = -v[2];
 }
 
+/*!
+ * @brief make vector as inverse/opposite of itself
+ *
+ * @param[in, out]  v  vector
+ */
+CGLM_INLINE
+void
+glm_vec_inv(vec3 v) {
+  glm_vec_flipsign(v);
+}
+
+/*!
+ * @brief inverse/opposite vector
+ *
+ * @param[in]  v    source
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_vec_inv_to(vec3 v, vec3 dest) {
+  glm_vec_copy(v, dest);
+  glm_vec_flipsign(dest);
+}
+
 /*!
  * @brief normalize vec3 and store result in same vec
  *
@@ -364,4 +404,56 @@ glm_vec_distance(vec3 v1, vec3 v2) {
                + glm_pow2(v2[2] - v1[2]));
 }
 
+/*!
+ * @brief max values of vectors
+ *
+ * @param[in]  v1   vector1
+ * @param[in]  v2   vector2
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_vec_maxv(vec3 v1, vec3 v2, vec3 dest) {
+  if (v1[0] > v2[0])
+    dest[0] = v1[0];
+  else
+    dest[0] = v2[0];
+
+  if (v1[1] > v2[1])
+    dest[1] = v1[1];
+  else
+    dest[1] = v2[1];
+
+  if (v1[2] > v2[2])
+    dest[2] = v1[2];
+  else
+    dest[2] = v2[2];
+}
+
+/*!
+ * @brief min values of vectors
+ *
+ * @param[in]  v1   vector1
+ * @param[in]  v2   vector2
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_vec_minv(vec3 v1, vec3 v2, vec3 dest) {
+  if (v1[0] < v2[0])
+    dest[0] = v1[0];
+  else
+    dest[0] = v2[0];
+
+  if (v1[1] < v2[1])
+    dest[1] = v1[1];
+  else
+    dest[1] = v2[1];
+
+  if (v1[2] < v2[2])
+    dest[2] = v1[2];
+  else
+    dest[2] = v2[2];
+}
+
 #endif /* cglm_vec3_h */

include/cglm/vec4-ext.h

@@ -26,6 +26,7 @@
 #define cglm_vec4_ext_h
 
 #include "common.h"
+#include "vec3-ext.h"
 #include <stdbool.h>
 #include <math.h>
 #include <float.h>

include/cglm/vec4.h

@@ -14,7 +14,11 @@
  Macros:
    glm_vec4_dup3(v, dest)
    glm_vec4_dup(v, dest)
-
+   GLM_VEC4_ONE_INIT
+   GLM_VEC4_BLACK_INIT
+   GLM_VEC4_ONE
+   GLM_VEC4_BLACK
+ 
  Functions:
    CGLM_INLINE void  glm_vec4_copy3(vec4 a, vec3 dest);
    CGLM_INLINE void  glm_vec4_copy(vec4 v, vec4 dest);
@@ -26,9 +30,13 @@
    CGLM_INLINE void  glm_vec4_scale(vec4 v, float s, vec4 dest);
    CGLM_INLINE void  glm_vec4_scale_as(vec4 v, float s, vec4 dest);
    CGLM_INLINE void  glm_vec4_flipsign(vec4 v);
+   CGLM_INLINE void  glm_vec4_inv(vec4 v);
+   CGLM_INLINE void  glm_vec4_inv_to(vec4 v, vec4 dest);
    CGLM_INLINE void  glm_vec4_normalize(vec4 v);
    CGLM_INLINE void  glm_vec4_normalize_to(vec4 vec, vec4 dest);
    CGLM_INLINE float glm_vec4_distance(vec4 v1, vec4 v2);
+   CGLM_INLINE void  glm_vec4_maxv(vec4 v1, vec4 v2, vec4 dest);
+   CGLM_INLINE void  glm_vec4_minv(vec4 v1, vec4 v2, vec4 dest);
  */
 
 #ifndef cglm_vec4_h
@@ -42,6 +50,12 @@
 #define glm_vec4_dup3(v, dest) glm_vec4_copy3(v, dest)
 #define glm_vec4_dup(v, dest)  glm_vec4_copy(v, dest)
 
+#define GLM_VEC4_ONE_INIT   {1.0f, 1.0f, 1.0f, 1.0f}
+#define GLM_VEC4_BLACK_INIT {0.0f, 0.0f, 0.0f, 1.0f}
+
+#define GLM_VEC4_ONE        (vec4)GLM_VEC4_ONE_INIT
+#define GLM_VEC4_BLACK      (vec4)GLM_VEC4_BLACK_INIT
+
 /*!
  * @brief copy first 3 members of [a] to [dest]
  *
@@ -225,6 +239,30 @@ glm_vec4_flipsign(vec4 v) {
 #endif
 }
 
+/*!
+ * @brief make vector as inverse/opposite of itself
+ *
+ * @param[in, out]  v  vector
+ */
+CGLM_INLINE
+void
+glm_vec4_inv(vec4 v) {
+  glm_vec4_flipsign(v);
+}
+
+/*!
+ * @brief inverse/opposite vector
+ *
+ * @param[in]  v    source
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_vec4_inv_to(vec4 v, vec4 dest) {
+  glm_vec4_copy(v, dest);
+  glm_vec4_flipsign(dest);
+}
+
 /*!
  * @brief normalize vec4 and store result in same vec
  *
@@ -282,4 +320,66 @@ glm_vec4_distance(vec4 v1, vec4 v2) {
                + glm_pow2(v2[3] - v1[3]));
 }
 
+/*!
+ * @brief max values of vectors
+ *
+ * @param[in]  v1   vector1
+ * @param[in]  v2   vector2
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_vec4_maxv(vec4 v1, vec4 v2, vec4 dest) {
+  if (v1[0] > v2[0])
+    dest[0] = v1[0];
+  else
+    dest[0] = v2[0];
+
+  if (v1[1] > v2[1])
+    dest[1] = v1[1];
+  else
+    dest[1] = v2[1];
+
+  if (v1[2] > v2[2])
+    dest[2] = v1[2];
+  else
+    dest[2] = v2[2];
+
+  if (v1[3] > v2[3])
+    dest[3] = v1[3];
+  else
+    dest[3] = v2[3];
+}
+
+/*!
+ * @brief min values of vectors
+ *
+ * @param[in]  v1   vector1
+ * @param[in]  v2   vector2
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_vec4_minv(vec4 v1, vec4 v2, vec4 dest) {
+  if (v1[0] < v2[0])
+    dest[0] = v1[0];
+  else
+    dest[0] = v2[0];
+
+  if (v1[1] < v2[1])
+    dest[1] = v1[1];
+  else
+    dest[1] = v2[1];
+
+  if (v1[2] < v2[2])
+    dest[2] = v1[2];
+  else
+    dest[2] = v2[2];
+
+  if (v1[3] < v2[3])
+    dest[3] = v1[3];
+  else
+    dest[3] = v2[3];
+}
+
 #endif /* cglm_vec4_h */

include/cglm/version.h

@@ -9,7 +9,7 @@
 #define cglm_version_h
 
 #define CGLM_VERSION_MAJOR 0
-#define CGLM_VERSION_MINOR 2
+#define CGLM_VERSION_MINOR 3
-#define CGLM_VERSION_PATCH 1
+#define CGLM_VERSION_PATCH 3
 
 #endif /* cglm_version_h */

src/vec3.c

@@ -80,6 +80,18 @@ glmc_vec_flipsign(vec3 v) {
   glm_vec_flipsign(v);
 }
 
+CGLM_EXPORT
+void
+glmc_vec_inv(vec3 v) {
+  glm_vec_inv(v);
+}
+
+CGLM_EXPORT
+void
+glmc_vec_inv_to(vec3 v, vec3 dest) {
+  glm_vec_inv_to(v, dest);
+}
+
 CGLM_EXPORT
 float
 glmc_vec_angle(vec3 v1, vec3 v2) {
@@ -115,3 +127,15 @@ float
 glmc_vec_distance(vec3 v1, vec3 v2) {
   return glm_vec_distance(v1, v2);
 }
+
+CGLM_EXPORT
+void
+glmc_vec_maxv(vec3 v1, vec3 v2, vec3 dest) {
+  glm_vec_minv(v1, v2, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec_minv(vec3 v1, vec3 v2, vec3 dest) {
+  glm_vec_maxv(v1, v2, dest);
+}

src/vec4.c

@@ -80,8 +80,32 @@ glmc_vec4_flipsign(vec4 v) {
   glm_vec4_flipsign(v);
 }
 
+CGLM_EXPORT
+void
+glmc_vec4_inv(vec4 v) {
+  glm_vec4_inv(v);
+}
+
+CGLM_EXPORT
+void
+glmc_vec4_inv_to(vec4 v, vec4 dest) {
+  glm_vec4_inv_to(v, dest);
+}
+
 CGLM_EXPORT
 float
 glmc_vec4_distance(vec4 v1, vec4 v2) {
   return glm_vec4_distance(v1, v2);
 }
+
+CGLM_EXPORT
+void
+glmc_vec4_maxv(vec4 v1, vec4 v2, vec4 dest) {
+  glm_vec4_minv(v1, v2, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec4_minv(vec4 v1, vec4 v2, vec4 dest) {
+  glm_vec4_maxv(v1, v2, dest);
+}

test/src/test_common.c

@@ -6,31 +6,47 @@
 #include "test_common.h"
 #include <stdlib.h>
 
+#define m 4
+#define n 4
+
 void
 test_rand_mat4(mat4 dest) {
-  int i, j;
+  glm_mat4_copy(GLM_MAT4_IDENTITY, dest);
-
+  
   srand((unsigned int)time(NULL));
-  for (i = 0; i < 4; i++) {
+
-    for (j = 0; j < 4; j++) {
+  /* random position */
-      dest[i][j] = drand48();
+  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()}); */
 }
 
 void
 test_assert_mat4_eq(mat4 m1, mat4 m2) {
   int i, j, k;
 
-#define m 4
-#define n 4
   for (i = 0; i < m; i++) {
     for (j = 0; j < n; j++) {
       for (k = 0; k < m; k++)
-        assert_true(fabsf(m1[i][j] - m2[i][j]) <= FLT_EPSILON);
+        assert_true(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009);
     }
   }
-#undef m
-#undef n
 }
 
+void
+test_assert_mat4_eq2(mat4 m1, mat4 m2, float eps) {
+  int i, j, k;
+  
+  for (i = 0; i < m; i++) {
+    for (j = 0; j < n; j++) {
+      for (k = 0; k < m; k++)
+        assert_true(fabsf(m1[i][j] - m2[i][j]) <= eps);
+    }
+  }
+}

test/src/test_common.h

@@ -28,4 +28,7 @@ test_rand_mat4(mat4 dest);
 void
 test_assert_mat4_eq(mat4 m1, mat4 m2);
 
+void
+test_assert_mat4_eq2(mat4 m1, mat4 m2, float eps);
+
 #endif /* test_common_h */

test/src/test_mat4.c

@@ -16,6 +16,7 @@ test_mat4(void **state) {
   mat4  m2 = GLM_MAT4_IDENTITY_INIT;
   mat4  m3;
   mat4  m4 = GLM_MAT4_ZERO_INIT;
+  mat4  m5;
   int   i, j, k;
 
   /* test identity matrix multiplication */
@@ -48,4 +49,46 @@ test_mat4(void **state) {
   /* test pre compiled */
   glmc_mat4_mul(m1, m2, m3);
   test_assert_mat4_eq(m3, m4);
+
+  for (i = 0; i < 100000; i++) {
+    test_rand_mat4(m3);
+    test_rand_mat4(m4);
+    
+    /* test inverse precise */
+    glm_mat4_inv_precise(m3, m4);
+    glm_mat4_inv_precise(m4, m5);
+    test_assert_mat4_eq(m3, m5);
+    
+    test_rand_mat4(m3);
+    test_rand_mat4(m4);
+
+    glmc_mat4_inv_precise(m3, m4);
+    glmc_mat4_inv_precise(m4, m5);
+    test_assert_mat4_eq(m3, m5);
+    
+    /* test inverse rcp */
+    test_rand_mat4(m3);
+    test_rand_mat4(m4);
+    
+    glm_mat4_inv_fast(m3, m4);
+    glm_mat4_inv_fast(m4, m5);
+    test_assert_mat4_eq2(m3, m5, 0.0009f);
+    
+    test_rand_mat4(m3);
+    test_rand_mat4(m4);
+    
+    glmc_mat4_inv(m3, m4);
+    glmc_mat4_inv(m4, m5);
+    test_assert_mat4_eq2(m3, m5, 0.0009f);
+  }
+
+  /* print */
+  glm_mat4_print(m3, stderr);
+  glm_mat4_print(m4, stderr);
+
+  /* test determinant */
+  assert_int_equal(glm_mat4_det(m1), glmc_mat4_det(m1));
+#if defined( __SSE2__ )
+  assert_int_equal(glmc_mat4_det(m1), glm_mat4_det_sse2(m1));
+#endif
 }