update version

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

include/cglm/call/vec3.h

@@ -96,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

@@ -77,6 +77,14 @@ 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,29 +11,29 @@
                                 float right,
                                 float bottom,
                                 float top,
-                                float near,
-                                float far,
+                                float nearVal,
+                                float farVal,
                                 mat4  dest);
    CGLM_INLINE void glm_ortho(float left,
                               float right,
                               float bottom,
                               float top,
-                              float near,
-                              float far,
+                              float nearVal,
+                              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 far,
+                                    float nearVal,
+                                    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 near,
-                                     float * __restrict far,
+                                     float * __restrict nearVal,
+                                     float * __restrict farVal,
                                      float * __restrict top,
                                      float * __restrict bottom,
                                      float * __restrict left,
@@ -46,10 +46,10 @@
                                        float * __restrict top,
                                        float * __restrict bottom);
    CGLM_INLINE void glm_persp_decomp_z(mat4 proj,
-                                       float * __restrict near,
-                                       float * __restrict far);
-   CGLM_INLINE void glm_persp_decomp_far(mat4 proj, float * __restrict far);
-   CGLM_INLINE void glm_persp_decomp_near(mat4 proj, float * __restrict near);
+                                       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
@@ -303,29 +303,29 @@ glm_lookat(vec3 eye,
 /*!
  * @brief decomposes frustum values of perspective projection.
  *
- * @param[in]  proj   perspective projection matrix
- * @param[out] near   near
- * @param[out] far    far
- * @param[out] top    top
- * @param[out] bottom bottom
- * @param[out] left   left
- * @param[out] right  right
+ * @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 near,
-                 float * __restrict far,
+                 float * __restrict nearVal,
+                 float * __restrict farVal,
                  float * __restrict top,
                  float * __restrict bottom,
                  float * __restrict left,
                  float * __restrict right) {
-  *near   = proj[3][2] / (proj[2][2] - 1);
-  *far    = proj[3][2] / (proj[2][2] + 1);
-  *bottom = *near * (proj[2][1] - 1) / proj[1][1];
-  *top    = *near * (proj[2][1] + 1) / proj[1][1];
-  *left   = *near * (proj[2][0] - 1) / proj[0][0];
-  *right  = *near * (proj[2][0] + 1) / proj[0][0];
+  *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];
 }
 
 /*!
@@ -337,7 +337,7 @@ glm_persp_decomp(mat4 proj,
  */
 CGLM_INLINE
 void
-glm_persp_decompv(mat4  proj, float dest[6]) {
+glm_persp_decompv(mat4 proj, float dest[6]) {
   glm_persp_decomp(proj, &dest[0], &dest[1], &dest[2],
                          &dest[3], &dest[4], &dest[5]);
 }
@@ -355,11 +355,11 @@ void
 glm_persp_decomp_x(mat4 proj,
                    float * __restrict left,
                    float * __restrict right) {
-  float near;
+  float nearVal;
 
-  near    = proj[3][2] / (proj[3][3] - 1);
-  *left   = near * (proj[2][0] - 1) / proj[0][0];
-  *right  = near * (proj[2][0] + 1) / proj[0][0];
+  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];
 }
 
 /*!
@@ -375,51 +375,51 @@ void
 glm_persp_decomp_y(mat4 proj,
                    float * __restrict top,
                    float * __restrict bottom) {
-  float near;
+  float nearVal;
 
-  near    = proj[3][2] / (proj[3][3] - 1);
-  *bottom = near * (proj[2][1] - 1) / proj[1][1];
-  *top    = near * (proj[2][1] + 1) / proj[1][1];
+  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] near near
- * @param[out] far  far
+ * @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 near,
-                   float * __restrict far) {
-  *near = proj[3][2] / (proj[2][2] - 1);
-  *far  = proj[3][2] / (proj[2][2] + 1);
+                   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] far  far
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] farVal far
  */
 CGLM_INLINE
 void
-glm_persp_decomp_far(mat4 proj, float * __restrict far) {
-  *far = proj[3][2] / (proj[2][2] + 1);
+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] near near
+ * @param[in]  proj    perspective projection matrix
+ * @param[out] nearVal near
  */
 CGLM_INLINE
 void
-glm_persp_decomp_near(mat4 proj, float * __restrict near) {
-  *near = proj[3][2] / (proj[2][2] - 1);
+glm_persp_decomp_near(mat4 proj, float * __restrict nearVal) {
+  *nearVal = proj[3][2] / (proj[2][2] - 1);
 }
 #endif /* cglm_vcam_h */

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       (versor){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){1.0f, 0.0f, 0.0f, 0.0f}
 
 CGLM_INLINE
 void

include/cglm/vec3.h

@@ -40,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
@@ -402,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

@@ -35,6 +35,8 @@
    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
@@ -318,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

@@ -10,6 +10,6 @@
 
 #define CGLM_VERSION_MAJOR 0
 #define CGLM_VERSION_MINOR 3
-#define CGLM_VERSION_PATCH 1
+#define CGLM_VERSION_PATCH 3
 
 #endif /* cglm_version_h */

src/vec3.c

@@ -127,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

@@ -97,3 +97,15 @@ 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);
+}