Merge branch 'master' into interpolation

* two value may be same, in this case now returns 1.
* to must be >= from and current <= to && current >= from

CREDITS

@@ -1,7 +1,7 @@
 This library [initially] used some [piece of] implementations
 (may include codes) from these open source projects/resources:
 
-1. Affine Transforms
+1. Initial Affine Transforms
 The original glm repo (g-truc), url: https://github.com/g-truc/glm
 
 LICENSE[S]:
@@ -11,7 +11,7 @@ LICENSE[S]:
 
 FULL LICENSE: https://github.com/g-truc/glm/blob/master/copying.txt
 
-2. Quaternions
+2. Initial Quaternions
 Anton's OpenGL 4 Tutorials book source code:
 
 LICENSE:
@@ -47,6 +47,8 @@ http://old.cescg.org/CESCG-2002/DSykoraJJelinek/
 7. Quaternions
 Initial mat4_quat is borrowed from Apple's simd library
 
-
 8. Vector Rotation using Quaternion
 https://gamedev.stackexchange.com/questions/28395/rotating-vector3-by-a-quaternion
+
+9. Sphere AABB intersect
+https://github.com/erich666/GraphicsGems/blob/master/gems/BoxSphere.c

cglm.podspec

@@ -2,7 +2,7 @@ Pod::Spec.new do |s|
 
   # Description
   s.name         = "cglm"
-  s.version      = "0.4.4"
+  s.version      = "0.4.6"
   s.summary      = "📽 Optimized OpenGL/Graphics Math (glm) for C"
   s.description  = <<-DESC
 cglm is math library for graphics programming for C. It is similar to original glm but it is written for C instead of C++ (you can use here too). See the documentation or README for all features.

configure.ac

@@ -7,7 +7,7 @@
 #*****************************************************************************
 
 AC_PREREQ([2.69])
-AC_INIT([cglm], [0.4.5], [info@recp.me])
+AC_INIT([cglm], [0.4.8], [info@recp.me])
 AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects])
 
 AC_CONFIG_MACRO_DIR([m4])

docs/source/api.rst

@@ -45,3 +45,4 @@ Follow the :doc:`build` documentation for this
    util
    io
    call
+   sphere

docs/source/box.rst

@@ -28,6 +28,11 @@ Functions:
 #. :c:func:`glm_aabb_isvalid`
 #. :c:func:`glm_aabb_size`
 #. :c:func:`glm_aabb_radius`
+#. :c:func:`glm_aabb_center`
+#. :c:func:`glm_aabb_aabb`
+#. :c:func:`glm_aabb_sphere`
+#. :c:func:`glm_aabb_point`
+#. :c:func:`glm_aabb_contains`
 
 Functions documentation
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -131,3 +136,46 @@ Functions documentation
 
     Parameters:
       | *[in]*   **box**     bounding box
+
+.. c:function:: void  glm_aabb_center(vec3 box[2], vec3 dest)
+
+    | computes center point of AABB
+
+    Parameters:
+      | *[in]*    **box**      bounding box
+      | *[out]*   **dest**     center of bounding box
+
+.. c:function:: bool  glm_aabb_aabb(vec3 box[2], vec3 other[2])
+
+    | check if two AABB intersects
+
+    Parameters:
+      | *[in]*    **box**     bounding box
+      | *[out]*   **other**   other bounding box
+
+.. c:function:: bool  glm_aabb_sphere(vec3 box[2], vec4 s)
+
+    | check if AABB intersects with sphere
+
+    | https://github.com/erich666/GraphicsGems/blob/master/gems/BoxSphere.c
+    | Solid Box - Solid Sphere test.
+
+    Parameters:
+      | *[in]*    **box**     solid bounding box
+      | *[out]*   **s**       solid sphere
+
+.. c:function:: bool  glm_aabb_point(vec3 box[2], vec3 point)
+
+    | check if point is inside of AABB
+
+    Parameters:
+      | *[in]*    **box**     bounding box
+      | *[out]*   **point**   point
+
+.. c:function:: bool  glm_aabb_contains(vec3 box[2], vec3 other[2])
+
+    | check if AABB contains other AABB
+
+    Parameters:
+      | *[in]*    **box**     bounding box
+      | *[out]*   **other**   other bounding box

docs/source/cam.rst

@@ -167,11 +167,13 @@ Functions documentation
 
     | set up view matrix
 
+    **NOTE:** The UP vector must not be parallel to the line of sight from the eye point to the reference point.
+
     Parameters:
-    | *[in]*  **eye**     eye vector
-    | *[in]*  **center**  center vector
-    | *[in]*  **up**      up vector
-    | *[out]* **dest**    result matrix
+      | *[in]*  **eye**     eye vector
+      | *[in]*  **center**  center vector
+      | *[in]*  **up**      up vector
+      | *[out]* **dest**    result matrix
 
 .. c:function:: void  glm_look(vec3 eye, vec3 dir, vec3 up, mat4 dest)
 
@@ -181,6 +183,8 @@ Functions documentation
     target self then this might be useful. Because you need to get target
     from direction.
 
+    **NOTE:** The UP vector must not be parallel to the line of sight from the eye point to the reference point.
+
     Parameters:
       | *[in]*  **eye**     eye vector
       | *[in]*  **center**  direction vector

docs/source/conf.py

@@ -62,9 +62,9 @@ author = u'Recep Aslantas'
 # built documents.
 #
 # The short X.Y version.
-version = u'0.4.5'
+version = u'0.4.8'
 # The full version, including alpha/beta/rc tags.
-release = u'0.4.5'
+release = u'0.4.8'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.

docs/source/mat3.rst

@@ -24,6 +24,7 @@ Functions:
 #. :c:func:`glm_mat3_transpose_to`
 #. :c:func:`glm_mat3_transpose`
 #. :c:func:`glm_mat3_mulv`
+#. :c:func:`glm_mat3_quat`
 #. :c:func:`glm_mat3_scale`
 #. :c:func:`glm_mat3_det`
 #. :c:func:`glm_mat3_inv`
@@ -89,6 +90,14 @@ Functions documentation
       | *[in]*  **v**     vec3 (right, column vector)
       | *[out]* **dest**  destination (result, column vector)
 
+.. c:function:: void  glm_mat3_quat(mat3 m, versor dest)
+
+    convert mat3 to quaternion
+
+    Parameters:
+      | *[in]*  **m**     rotation matrix
+      | *[out]* **dest**  destination quaternion
+
 .. c:function:: void  glm_mat3_scale(mat3 m, float s)
 
     multiply matrix with scalar

docs/source/mat4.rst

@@ -32,6 +32,7 @@ Functions:
 #. :c:func:`glm_mat4_mulN`
 #. :c:func:`glm_mat4_mulv`
 #. :c:func:`glm_mat4_mulv3`
+#. :c:func:`glm_mat4_quat`
 #. :c:func:`glm_mat4_transpose_to`
 #. :c:func:`glm_mat4_transpose`
 #. :c:func:`glm_mat4_scale_p`
@@ -146,6 +147,14 @@ Functions documentation
     | *[in]*  **v**     vec3 (right, column vector)
     | *[out]* **dest**  vec3 (result, column vector)
 
+.. c:function:: void  glm_mat4_quat(mat4 m, versor dest)
+
+    convert mat4's rotation part to quaternion
+
+    Parameters:
+    | *[in]*  **m**     affine matrix
+    | *[out]* **dest**  destination quaternion
+
 .. c:function:: void  glm_mat4_transpose_to(mat4 m, mat4 dest)
 
     transpose mat4 and store in dest

docs/source/sphere.rst

@@ -0,0 +1,74 @@
+.. default-domain:: C
+
+Sphere
+================================================================================
+
+Header: cglm/sphere.h
+
+**Definition of sphere:**
+
+Sphere Representation in cglm is *vec4*: **[center.x, center.y, center.z, radii]**
+
+You can call any vec3 function by pasing sphere. Because first three elements
+defines center of sphere.
+
+Table of contents (click to go):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Functions:
+
+1. :c:func:`glm_sphere_radii`
+#. :c:func:`glm_sphere_transform`
+#. :c:func:`glm_sphere_merge`
+#. :c:func:`glm_sphere_sphere`
+#. :c:func:`glm_sphere_point`
+
+Functions documentation
+~~~~~~~~~~~~~~~~~~~~~~~
+
+.. c:function:: float  glm_sphere_radii(vec4 s)
+
+    | helper for getting sphere radius
+
+    Parameters:
+      | *[in]*  **s**   sphere
+
+    Returns:
+       returns radii
+
+.. c:function:: void  glm_sphere_transform(vec4 s, mat4 m, vec4 dest)
+
+    | apply transform to sphere, it is just wrapper for glm_mat4_mulv3
+
+    Parameters:
+      | *[in]*  **s**    sphere
+      | *[in]*  **m**    transform matrix
+      | *[out]* **dest** transformed sphere
+
+.. c:function:: void  glm_sphere_merge(vec4 s1, vec4 s2, vec4 dest)
+
+    | merges two spheres and creates a new one
+
+    two sphere must be in same space, for instance if one in world space then
+    the other must be in world space too, not in local space.
+
+    Parameters:
+      | *[in]*  **s1**      sphere 1
+      | *[in]*  **s2**      sphere 2
+      | *[out]* **dest**    merged/extended sphere
+
+.. c:function:: bool  glm_sphere_sphere(vec4 s1, vec4 s2)
+
+    | check if two sphere intersects
+
+    Parameters:
+      | *[in]*  **s1**      sphere
+      | *[in]*  **s2**      other sphere
+
+.. c:function:: bool  glm_sphere_point(vec4 s, vec3 point)
+
+    | check if sphere intersects with point
+
+    Parameters:
+      | *[in]*  **s**       sphere
+      | *[in]*  **point**   point

docs/source/util.rst

@@ -136,3 +136,38 @@ Functions documentation
 
     Returns:
        interpolated value
+
+.. c:function:: bool glm_eq(float a, float b)
+
+    check if two float equal with using EPSILON
+
+    Parameters:
+      | *[in]*  **a**   a
+      | *[in]*  **b**   b
+
+    Returns:
+       true if a and b equals
+
+.. c:function:: float glm_percent(float from, float to, float current)
+
+    percentage of current value between start and end value
+
+    Parameters:
+      | *[in]*  **from**   from value
+      | *[in]*  **to**     to value
+      | *[in]*  **current**   value between from and to values
+
+    Returns:
+       clamped normalized percent (0-100 in 0-1)
+
+.. c:function:: float glm_percentc(float from, float to, float current)
+
+    clamped percentage of current value between start and end value
+
+    Parameters:
+      | *[in]*  **from**      from value
+      | *[in]*  **to**        to value
+      | *[in]*  **current**   value between from and to values
+
+    Returns:
+       clamped normalized percent (0-100 in 0-1)

docs/source/vec3.rst

@@ -56,6 +56,7 @@ Functions:
 #. :c:func:`glm_vec_inv_to`
 #. :c:func:`glm_vec_normalize`
 #. :c:func:`glm_vec_normalize_to`
+#. :c:func:`glm_vec_distance2`
 #. :c:func:`glm_vec_distance`
 #. :c:func:`glm_vec_angle`
 #. :c:func:`glm_vec_rotate`
@@ -366,6 +367,17 @@ Functions documentation
       | *[in]*  **v2**    vector2
       | *[out]* **dest**  center point
 
+.. c:function:: float  glm_vec_distance2(vec3 v1, vec3 v2)
+
+    squared distance between two vectors
+
+    Parameters:
+      | *[in]*  **mat**   vector1
+      | *[in]*  **row1**  vector2
+
+    Returns:
+      | squared distance (distance * distance)
+
 .. c:function:: float  glm_vec_distance(vec3 v1, vec3 v2)
 
     distance between two vectors

docs/source/vec4.rst

@@ -24,6 +24,7 @@ Functions:
 1. :c:func:`glm_vec4`
 #. :c:func:`glm_vec4_copy3`
 #. :c:func:`glm_vec4_copy`
+#. :c:func:`glm_vec4_ucopy`
 #. :c:func:`glm_vec4_zero`
 #. :c:func:`glm_vec4_one`
 #. :c:func:`glm_vec4_dot`
@@ -89,6 +90,16 @@ Functions documentation
       | *[in]*  **v**     source
       | *[in]*  **dest**  destination
 
+.. c:function:: void  glm_vec4_ucopy(vec4 v, vec4 dest)
+
+    copy all members of [a] to [dest]
+
+    | alignment is not required
+
+    Parameters:
+      | *[in]*  **v**     source
+      | *[in]*  **dest**  destination
+
 .. c:function:: void  glm_vec4_zero(vec4 v)
 
     makes all members zero

include/cglm/affine.h

@@ -44,48 +44,6 @@ CGLM_INLINE
 void
 glm_mat4_mul(mat4 m1, mat4 m2, mat4 dest);
 
-/*!
- * @brief translate existing transform matrix by v vector
- *        and store result in dest
- *
- * @param[in]  m    affine transfrom
- * @param[in]  v    translate vector [x, y, z]
- * @param[out] dest translated matrix
- */
-CGLM_INLINE
-void
-glm_translate_to(mat4 m, vec3 v, mat4 dest) {
-  mat4 t = GLM_MAT4_IDENTITY_INIT;
-
-#if defined( __SSE__ ) || defined( __SSE2__ )
-  glmm_store(dest[3],
-             _mm_add_ps(_mm_add_ps(_mm_mul_ps(glmm_load(t[0]),
-                                              _mm_set1_ps(v[0])),
-                                   _mm_mul_ps(glmm_load(t[1]),
-                                              _mm_set1_ps(v[1]))),
-                        _mm_add_ps(_mm_mul_ps(glmm_load(t[2]),
-                                              _mm_set1_ps(v[2])),
-                                   glmm_load(t[3]))))
-  ;
-
-  glmm_store(dest[0], glmm_load(m[0]));
-  glmm_store(dest[1], glmm_load(m[1]));
-  glmm_store(dest[2], glmm_load(m[2]));
-#else
-  vec4 v1, v2, v3;
-
-  glm_vec4_scale(t[0], v[0], v1);
-  glm_vec4_scale(t[1], v[1], v2);
-  glm_vec4_scale(t[2], v[2], v3);
-
-  glm_vec4_add(v1, t[3], t[3]);
-  glm_vec4_add(v2, t[3], t[3]);
-  glm_vec4_add(v3, t[3], t[3]);
-
-  glm__memcpy(float, dest, t, sizeof(mat4));
-#endif
-}
-
 /*!
  * @brief translate existing transform matrix by v vector
  *        and stores result in same matrix
@@ -119,6 +77,23 @@ glm_translate(mat4 m, vec3 v) {
 #endif
 }
 
+/*!
+ * @brief translate existing transform matrix by v vector
+ *        and store result in dest
+ *
+ * source matrix will remain same
+ *
+ * @param[in]  m    affine transfrom
+ * @param[in]  v    translate vector [x, y, z]
+ * @param[out] dest translated matrix
+ */
+CGLM_INLINE
+void
+glm_translate_to(mat4 m, vec3 v, mat4 dest) {
+  glm_mat4_copy(m, dest);
+  glm_translate(dest, v);
+}
+
 /*!
  * @brief translate existing transform matrix by x factor
  *
@@ -194,8 +169,8 @@ glm_translate_z(mat4 m, float z) {
 CGLM_INLINE
 void
 glm_translate_make(mat4 m, vec3 v) {
-  mat4 t = GLM_MAT4_IDENTITY_INIT;
-  glm_translate_to(t, v, m);
+  glm_mat4_identity(m);
+  glm_vec_copy(v, m[3]);
 }
 
 /*!
@@ -225,8 +200,10 @@ glm_scale_to(mat4 m, vec3 v, mat4 dest) {
 CGLM_INLINE
 void
 glm_scale_make(mat4 m, vec3 v) {
-  mat4 t = GLM_MAT4_IDENTITY_INIT;
-  glm_scale_to(t, v, m);
+  glm_mat4_identity(m);
+  m[0][0] = v[0];
+  m[1][1] = v[1];
+  m[2][2] = v[2];
 }
 
 /*!
@@ -252,7 +229,7 @@ glm_scale(mat4 m, vec3 v) {
 CGLM_INLINE
 void
 glm_scale_uni(mat4 m, float s) {
-  vec3 v = { s, s, s };
+  CGLM_ALIGN(8) vec3 v = { s, s, s };
   glm_scale_to(m, v, m);
 }
 
@@ -267,7 +244,7 @@ glm_scale_uni(mat4 m, float s) {
 CGLM_INLINE
 void
 glm_rotate_x(mat4 m, float angle, mat4 dest) {
-  mat4  t = GLM_MAT4_IDENTITY_INIT;
+  CGLM_ALIGN(16) mat4 t = GLM_MAT4_IDENTITY_INIT;
   float c, s;
 
   c = cosf(angle);
@@ -292,7 +269,7 @@ glm_rotate_x(mat4 m, float angle, mat4 dest) {
 CGLM_INLINE
 void
 glm_rotate_y(mat4 m, float angle, mat4 dest) {
-  mat4  t = GLM_MAT4_IDENTITY_INIT;
+  CGLM_ALIGN(16) mat4 t = GLM_MAT4_IDENTITY_INIT;
   float c, s;
 
   c = cosf(angle);
@@ -317,7 +294,7 @@ glm_rotate_y(mat4 m, float angle, mat4 dest) {
 CGLM_INLINE
 void
 glm_rotate_z(mat4 m, float angle, mat4 dest) {
-  mat4  t = GLM_MAT4_IDENTITY_INIT;
+  CGLM_ALIGN(16) mat4 t = GLM_MAT4_IDENTITY_INIT;
   float c, s;
 
   c = cosf(angle);
@@ -343,7 +320,7 @@ glm_rotate_z(mat4 m, float angle, mat4 dest) {
 CGLM_INLINE
 void
 glm_rotate_make(mat4 m, float angle, vec3 axis) {
-  vec3  axisn, v, vs;
+  CGLM_ALIGN(8) vec3 axisn, v, vs;
   float c;
 
   c = cosf(angle);
@@ -374,7 +351,7 @@ glm_rotate_make(mat4 m, float angle, vec3 axis) {
 CGLM_INLINE
 void
 glm_rotate(mat4 m, float angle, vec3 axis) {
-  mat4 rot;
+  CGLM_ALIGN(16) mat4 rot;
   glm_rotate_make(rot, angle, axis);
   glm_mul_rot(m, rot, m);
 }
@@ -391,7 +368,7 @@ glm_rotate(mat4 m, float angle, vec3 axis) {
 CGLM_INLINE
 void
 glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis) {
-  vec3 pivotInv;
+  CGLM_ALIGN(8) vec3 pivotInv;
 
   glm_vec_inv_to(pivot, pivotInv);
 
@@ -416,12 +393,11 @@ glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis) {
 CGLM_INLINE
 void
 glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis) {
-  vec3 pivotInv;
+  CGLM_ALIGN(8) vec3 pivotInv;
 
   glm_vec_inv_to(pivot, pivotInv);
 
-  glm_mat4_identity(m);
-  glm_vec_copy(pivot, m[3]);
+  glm_translate_make(m, pivot);
   glm_rotate(m, angle, axis);
   glm_translate(m, pivotInv);
 }
@@ -451,9 +427,8 @@ glm_decompose_scalev(mat4 m, vec3 s) {
 CGLM_INLINE
 bool
 glm_uniscaled(mat4 m) {
-  vec3 s;
+  CGLM_ALIGN(8) vec3 s;
   glm_decompose_scalev(m, s);
-
   return glm_vec_eq_all(s);
 }
 
@@ -468,8 +443,8 @@ glm_uniscaled(mat4 m) {
 CGLM_INLINE
 void
 glm_decompose_rs(mat4 m, mat4 r, vec3 s) {
-  vec4 t = {0.0f, 0.0f, 0.0f, 1.0f};
-  vec3 v;
+  CGLM_ALIGN(16) vec4 t = {0.0f, 0.0f, 0.0f, 1.0f};
+  CGLM_ALIGN(8)  vec3 v;
 
   glm_vec4_copy(m[0], r[0]);
   glm_vec4_copy(m[1], r[1]);

include/cglm/bezier.h

@@ -0,0 +1,124 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglm_bezier_h
+#define cglm_bezier_h
+
+#include "common.h"
+
+/*!
+ * @brief cubic bezier interpolation
+ *
+ * @param[in]  t    time between 0 and 1
+ * @param[in]  p0   begin point
+ * @param[in]  c0   control point 1
+ * @param[in]  c1   control point 2
+ * @param[in]  p1   end point
+ *
+ * @return B(s)
+ */
+CGLM_INLINE
+float
+glm_bezier_cubic(float t, float p0, float c0, float c1, float p1) {
+  float s, ss, tt;
+
+  s  = 1.0f - t;
+  ss = s * s;
+  tt = t * t;
+
+  return p0 * ss * s + 3.0f * c0 * t * ss + 3.0f * c1 * tt * s + p1 * tt * t;
+}
+
+/*!
+ * @brief cubic bezier interpolation for vec3
+ *
+ * @param[in]  t    time between 0 and 1
+ * @param[in]  p0   begin point
+ * @param[in]  c0   control point 1
+ * @param[in]  c1   control point 2
+ * @param[in]  p1   end point
+ * @param[in]  dest destination
+ */
+CGLM_INLINE
+void
+glm_bezier_cubicv3(float t, vec3 p0, vec3 c0, vec3 c1, vec3 p1, vec3 dest) {
+  vec3  Bs, tmp0, tmp1, tmp2;
+  float s, ss, tt;
+
+  s  = 1.0f - t;
+  ss = s * s;
+  tt = t * t;
+
+  glm_vec_scale(p0, ss * s, Bs);
+  glm_vec_scale(c0, 3.0f * t * ss, tmp0);
+  glm_vec_scale(c1, 3.0f * tt * s, tmp1);
+  glm_vec_scale(p1, tt * t, tmp2);
+
+  glm_vec_add(Bs, tmp0, Bs);
+  glm_vec_add(Bs, tmp1, Bs);
+  glm_vec_add(Bs, tmp2, Bs);
+
+  glm_vec_copy(Bs, dest);
+}
+
+/*!
+ * @brief cubic hermite interpolation
+ *
+ * @param[in]  t    time between 0 and 1
+ * @param[in]  p0   begin point
+ * @param[in]  t0   tangent 1
+ * @param[in]  t1   tangent 2
+ * @param[in]  p1   end point
+ *
+ * @return B(s)
+ */
+CGLM_INLINE
+float
+glm_hermite_cubic(float t, float p0, float t0, float t1, float p1) {
+  float tt, ttt;
+
+  tt  = t * t;
+  ttt = tt * t;
+
+  return p0 * (2.0f * ttt - 3.0f * tt + 1)
+          + t0 * (ttt - 2.0f * tt + t)
+          + p1 * (3.0f * tt - 2.0f * ttt)
+          - t1 * (ttt - tt);
+}
+
+/*!
+ * @brief cubic hermite interpolation for vec3
+ *
+ * @param[in]  t    time between 0 and 1
+ * @param[in]  p0   begin point
+ * @param[in]  t0   tangent 1
+ * @param[in]  t1   tangent 2
+ * @param[in]  p1   end point
+ * @param[in]  dest destination
+ */
+CGLM_INLINE
+void
+glm_hermite_cubicv3(float t, vec3 p0, vec3 t0, vec3 t1, vec3 p1, vec3 dest) {
+  vec3  Hs, tmp0, tmp1, tmp2;
+  float tt, ttt;
+
+  tt  = t * t;
+  ttt = tt * t;
+
+  glm_vec_scale(p0, 2.0f * ttt - 3.0f * tt + 1, Hs);
+  glm_vec_scale(t0, ttt - 2.0f * tt + t, tmp0);
+  glm_vec_scale(p1, 3.0f * tt - 2.0f * ttt, tmp1);
+  glm_vec_scale(t1, ttt - tt, tmp2);
+
+  glm_vec_add(Hs, tmp0, Hs);
+  glm_vec_add(Hs, tmp1, Hs);
+  glm_vec_add(Hs, tmp2, Hs);
+
+  glm_vec_copy(Hs, dest);
+}
+
+#endif /* cglm_bezier_h */

include/cglm/box.h

@@ -200,4 +200,84 @@ glm_aabb_radius(vec3 box[2]) {
   return glm_aabb_size(box) * 0.5f;
 }
 
+/*!
+ * @brief computes center point of AABB
+ *
+ * @param[in]   box  bounding box
+ * @param[out]  dest center of bounding box
+ */
+CGLM_INLINE
+void
+glm_aabb_center(vec3 box[2], vec3 dest) {
+  glm_vec_center(box[0], box[1], dest);
+}
+
+/*!
+ * @brief check if two AABB intersects
+ *
+ * @param[in]   box    bounding box
+ * @param[in]   other  other bounding box
+ */
+CGLM_INLINE
+bool
+glm_aabb_aabb(vec3 box[2], vec3 other[2]) {
+  return (box[0][0] <= other[1][0] && box[1][0] >= other[0][0])
+      && (box[0][1] <= other[1][1] && box[1][1] >= other[0][1])
+      && (box[0][2] <= other[1][2] && box[1][2] >= other[0][2]);
+}
+
+/*!
+ * @brief check if AABB intersects with sphere
+ *
+ * https://github.com/erich666/GraphicsGems/blob/master/gems/BoxSphere.c
+ * Solid Box - Solid Sphere test.
+ *
+ * @param[in]   box    solid bounding box
+ * @param[in]   s      solid sphere
+ */
+CGLM_INLINE
+bool
+glm_aabb_sphere(vec3 box[2], vec4 s) {
+  float dmin;
+  int   a, b, c;
+
+  a = s[0] >= box[0][0];
+  b = s[1] >= box[0][1];
+  c = s[2] >= box[0][2];
+
+  dmin  = glm_pow2(s[0] - box[a][0])
+        + glm_pow2(s[1] - box[b][1])
+        + glm_pow2(s[2] - box[c][2]);
+
+  return dmin <= glm_pow2(s[3]);
+}
+
+/*!
+ * @brief check if point is inside of AABB
+ *
+ * @param[in]   box    bounding box
+ * @param[in]   point  point
+ */
+CGLM_INLINE
+bool
+glm_aabb_point(vec3 box[2], vec3 point) {
+  return (point[0] >= box[0][0] && point[0] <= box[1][0])
+      && (point[1] >= box[0][1] && point[1] <= box[1][1])
+      && (point[2] >= box[0][2] && point[2] <= box[1][2]);
+}
+
+/*!
+ * @brief check if AABB contains other AABB
+ *
+ * @param[in]   box    bounding box
+ * @param[in]   other  other bounding box
+ */
+CGLM_INLINE
+bool
+glm_aabb_contains(vec3 box[2], vec3 other[2]) {
+  return (box[0][0] <= other[0][0] && box[1][0] >= other[1][0])
+      && (box[0][1] <= other[0][1] && box[1][1] >= other[1][1])
+      && (box[0][2] <= other[0][2] && box[1][2] >= other[1][2]);
+}
+
 #endif /* cglm_box_h */

include/cglm/call.h

@@ -25,6 +25,8 @@ extern "C" {
 #include "call/box.h"
 #include "call/io.h"
 #include "call/project.h"
+#include "call/sphere.h"
+#include "call/ease.h"
 
 #ifdef __cplusplus
 }

include/cglm/call/affine.h

@@ -97,6 +97,20 @@ CGLM_EXPORT
 void
 glmc_decompose(mat4 m, vec4 t, mat4 r, vec3 s);
 
+/* affine-mat */
+
+CGLM_EXPORT
+void
+glmc_mul(mat4 m1, mat4 m2, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_mul_rot(mat4 m1, mat4 m2, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_inv_tr(mat4 mat);
+
 #ifdef __cplusplus
 }
 #endif

include/cglm/call/box.h

@@ -32,6 +32,46 @@ glmc_aabb_crop_until(vec3 box[2],
                      vec3 clampBox[2],
                      vec3 dest[2]);
 
+CGLM_EXPORT
+bool
+glmc_aabb_frustum(vec3 box[2], vec4 planes[6]);
+
+CGLM_EXPORT
+void
+glmc_aabb_invalidate(vec3 box[2]);
+
+CGLM_EXPORT
+bool
+glmc_aabb_isvalid(vec3 box[2]);
+
+CGLM_EXPORT
+float
+glmc_aabb_size(vec3 box[2]);
+
+CGLM_EXPORT
+float
+glmc_aabb_radius(vec3 box[2]);
+
+CGLM_EXPORT
+void
+glmc_aabb_center(vec3 box[2], vec3 dest);
+
+CGLM_EXPORT
+bool
+glmc_aabb_aabb(vec3 box[2], vec3 other[2]);
+
+CGLM_EXPORT
+bool
+glmc_aabb_point(vec3 box[2], vec3 point);
+
+CGLM_EXPORT
+bool
+glmc_aabb_contains(vec3 box[2], vec3 other[2]);
+
+CGLM_EXPORT
+bool
+glmc_aabb_sphere(vec3 box[2], vec4 s);
+
 #ifdef __cplusplus
 }
 #endif

include/cglm/call/cam.h

@@ -33,6 +33,26 @@ glmc_ortho(float left,
            float farVal,
            mat4 dest);
 
+CGLM_EXPORT
+void
+glmc_ortho_aabb(vec3 box[2], mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_ortho_aabb_p(vec3 box[2], float padding, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_ortho_aabb_pz(vec3 box[2], float padding, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_ortho_default(float aspect, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_ortho_default_s(float aspect, float size, mat4 dest);
+
 CGLM_EXPORT
 void
 glmc_perspective(float fovy,
@@ -41,6 +61,14 @@ glmc_perspective(float fovy,
                  float farVal,
                  mat4 dest);
 
+CGLM_EXPORT
+void
+glmc_perspective_default(float aspect, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_perspective_resize(float aspect, mat4 proj);
+
 CGLM_EXPORT
 void
 glmc_lookat(vec3 eye, vec3 center, vec3 up, mat4 dest);
@@ -53,6 +81,58 @@ CGLM_EXPORT
 void
 glmc_look_anyup(vec3 eye, vec3 dir, mat4 dest);
 
+CGLM_EXPORT
+void
+glmc_persp_decomp(mat4 proj,
+                  float * __restrict nearVal,
+                  float * __restrict farVal,
+                  float * __restrict top,
+                  float * __restrict bottom,
+                  float * __restrict left,
+                  float * __restrict right);
+
+CGLM_EXPORT
+void
+glmc_persp_decompv(mat4 proj, float dest[6]);
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_x(mat4 proj,
+                    float * __restrict left,
+                    float * __restrict right);
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_y(mat4 proj,
+                    float * __restrict top,
+                    float * __restrict bottom);
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_z(mat4 proj,
+                    float * __restrict nearVal,
+                    float * __restrict farVal);
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_far(mat4 proj, float * __restrict farVal);
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_near(mat4 proj, float * __restrict nearVal);
+
+CGLM_EXPORT
+float
+glmc_persp_fovy(mat4 proj);
+
+CGLM_EXPORT
+float
+glmc_persp_aspect(mat4 proj);
+
+CGLM_EXPORT
+void
+glmc_persp_sizes(mat4 proj, float fovy, vec4 dest);
+
 #ifdef __cplusplus
 }
 #endif

include/cglm/call/ease.h

@@ -0,0 +1,140 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_ease_h
+#define cglmc_ease_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+float
+glmc_ease_linear(float t);
+
+CGLM_EXPORT
+float
+glmc_ease_sine_in(float t);
+
+CGLM_EXPORT
+float
+glmc_ease_sine_out(float t);
+
+CGLM_EXPORT
+float
+glmc_ease_sine_inout(float t);
+
+CGLM_EXPORT
+float
+glmc_ease_quad_in(float t);
+
+CGLM_EXPORT
+float
+glmc_ease_quad_out(float t);
+
+CGLM_EXPORT
+float
+glmc_ease_quad_inout(float t);
+
+CGLM_EXPORT
+float
+glmc_ease_cubic_in(float t);
+
+CGLM_EXPORT
+float
+glmc_ease_cubic_out(float t);
+
+CGLM_EXPORT
+float
+glmc_ease_cubic_inout(float t);
+
+CGLM_EXPORT
+float
+glmc_ease_quart_in(float t);
+
+CGLM_EXPORT
+float
+glmc_ease_quart_out(float t);
+
+CGLM_EXPORT
+float
+glmc_ease_quart_inout(float t);
+
+CGLM_EXPORT
+float
+glmc_ease_quint_in(float t);
+
+CGLM_EXPORT
+float
+glmc_ease_quint_out(float t);
+
+CGLM_EXPORT
+float
+glmc_ease_quint_inout(float t);
+
+CGLM_EXPORT
+float
+glmc_ease_exp_in(float t);
+
+CGLM_EXPORT
+float
+glmc_ease_exp_out(float t);
+
+CGLM_EXPORT
+float
+glmc_ease_exp_inout(float t);
+
+CGLM_EXPORT
+float
+glmc_ease_circ_in(float t);
+
+CGLM_EXPORT
+float
+glmc_ease_circ_out(float t);
+
+CGLM_EXPORT
+float
+glmc_ease_circ_inout(float t);
+
+CGLM_EXPORT
+float
+glmc_ease_back_in(float t);
+
+CGLM_EXPORT
+float
+glmc_ease_back_out(float t);
+
+CGLM_EXPORT
+float
+glmc_ease_back_inout(float t);
+
+CGLM_EXPORT
+float
+glmc_ease_elast_in(float t);
+
+CGLM_EXPORT
+float
+glmc_ease_elast_out(float t);
+
+CGLM_EXPORT
+float
+glmc_ease_elast_inout(float t);
+
+CGLM_EXPORT
+float
+glmc_ease_bounce_out(float t);
+
+CGLM_EXPORT
+float
+glmc_ease_bounce_in(float t);
+
+CGLM_EXPORT
+float
+glmc_ease_bounce_inout(float t);
+
+#endif /* cglmc_ease_h */

include/cglm/call/mat3.h

@@ -40,6 +40,10 @@ CGLM_EXPORT
 void
 glmc_mat3_mulv(mat3 m, vec3 v, vec3 dest);
 
+CGLM_EXPORT
+void
+glmc_mat3_quat(mat3 m, versor dest);
+
 CGLM_EXPORT
 void
 glmc_mat3_scale(mat3 m, float s);

include/cglm/call/mat4.h

@@ -53,6 +53,10 @@ CGLM_EXPORT
 void
 glmc_mat4_mulv(mat4 m, vec4 v, vec4 dest);
 
+CGLM_EXPORT
+void
+glmc_mat4_mulv3(mat4 m, vec3 v, float last, vec3 dest);
+
 CGLM_EXPORT
 void
 glmc_mat4_quat(mat4 m, versor dest);
@@ -85,6 +89,10 @@ CGLM_EXPORT
 void
 glmc_mat4_inv_precise(mat4 mat, mat4 dest);
 
+CGLM_EXPORT
+void
+glmc_mat4_inv_fast(mat4 mat, mat4 dest);
+
 CGLM_EXPORT
 void
 glmc_mat4_swap_col(mat4 mat, int col1, int col2);

include/cglm/call/sphere.h

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_sphere_h
+#define cglmc_sphere_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+float
+glmc_sphere_radii(vec4 s);
+
+CGLM_EXPORT
+void
+glmc_sphere_transform(vec4 s, mat4 m, vec4 dest);
+
+CGLM_EXPORT
+void
+glmc_sphere_merge(vec4 s1, vec4 s2, vec4 dest);
+
+CGLM_EXPORT
+bool
+glmc_sphere_sphere(vec4 s1, vec4 s2);
+
+CGLM_EXPORT
+bool
+glmc_sphere_point(vec4 s, vec3 point);
+
+#endif /* cglmc_sphere_h */

include/cglm/call/vec3.h

@@ -136,6 +136,10 @@ CGLM_EXPORT
 void
 glmc_vec_rotate_m4(mat4 m, vec3 v, vec3 dest);
 
+CGLM_EXPORT
+void
+glmc_vec_rotate_m3(mat3 m, vec3 v, vec3 dest);
+
 CGLM_EXPORT
 void
 glmc_vec_proj(vec3 a, vec3 b, vec3 dest);
@@ -144,6 +148,10 @@ CGLM_EXPORT
 void
 glmc_vec_center(vec3 v1, vec3 v2, vec3 dest);
 
+CGLM_EXPORT
+float
+glmc_vec_distance2(vec3 v1, vec3 v2);
+
 CGLM_EXPORT
 float
 glmc_vec_distance(vec3 v1, vec3 v2);

include/cglm/call/vec4.h

@@ -37,6 +37,10 @@ CGLM_EXPORT
 void
 glmc_vec4_copy(vec4 v, vec4 dest);
 
+CGLM_EXPORT
+void
+glmc_vec4_ucopy(vec4 v, vec4 dest);
+
 CGLM_EXPORT
 float
 glmc_vec4_dot(vec4 a, vec4 b);

include/cglm/cam.h

@@ -321,6 +321,9 @@ glm_perspective_resize(float aspect,
 /*!
  * @brief set up view matrix
  *
+ * NOTE: The UP vector must not be parallel to the line of sight from
+ *       the eye point to the reference point
+ *
  * @param[in]  eye    eye vector
  * @param[in]  center center vector
  * @param[in]  up     up vector
@@ -332,7 +335,7 @@ glm_lookat(vec3 eye,
            vec3 center,
            vec3 up,
            mat4 dest) {
-  vec3 f, u, s;
+  CGLM_ALIGN(8) vec3 f, u, s;
 
   glm_vec_sub(center, eye, f);
   glm_vec_normalize(f);
@@ -364,6 +367,9 @@ glm_lookat(vec3 eye,
  * convenient wrapper for lookat: if you only have direction not target self
  * then this might be useful. Because you need to get target from direction.
  *
+ * NOTE: The UP vector must not be parallel to the line of sight from
+ *       the eye point to the reference point
+ *
  * @param[in]  eye    eye vector
  * @param[in]  dir    direction vector
  * @param[in]  up     up vector
@@ -372,7 +378,7 @@ glm_lookat(vec3 eye,
 CGLM_INLINE
 void
 glm_look(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
-  vec3 target;
+  CGLM_ALIGN(8) vec3 target;
   glm_vec_add(eye, dir, target);
   glm_lookat(eye, target, up, dest);
 }
@@ -390,7 +396,7 @@ glm_look(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
 CGLM_INLINE
 void
 glm_look_anyup(vec3 eye, vec3 dir, mat4 dest) {
-  vec3 up;
+  CGLM_ALIGN(8) vec3 up;
   glm_vec_ortho(dir, up);
   glm_look(eye, dir, up, dest);
 }

include/cglm/cglm.h

@@ -24,5 +24,8 @@
 #include "util.h"
 #include "io.h"
 #include "project.h"
+#include "sphere.h"
+#include "ease.h"
+#include "bezier.h"
 
 #endif /* cglm_h */

include/cglm/ease.h

@@ -0,0 +1,317 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglm_ease_h
+#define cglm_ease_h
+
+#include "common.h"
+
+CGLM_INLINE
+float
+glm_ease_linear(float t) {
+  return t;
+}
+
+CGLM_INLINE
+float
+glm_ease_sine_in(float t) {
+  return sinf((t - 1.0f) * CGLM_PI_2) + 1.0f;
+}
+
+CGLM_INLINE
+float
+glm_ease_sine_out(float t) {
+  return sinf(t * CGLM_PI_2);
+}
+
+CGLM_INLINE
+float
+glm_ease_sine_inout(float t) {
+  return 0.5f * (1.0f - cosf(t * CGLM_PI));
+}
+
+CGLM_INLINE
+float
+glm_ease_quad_in(float t) {
+  return t * t;
+}
+
+CGLM_INLINE
+float
+glm_ease_quad_out(float t) {
+  return -(t * (t - 2.0f));
+}
+
+CGLM_INLINE
+float
+glm_ease_quad_inout(float t) {
+  float tt;
+
+  tt = t * t;
+  if (t < 0.5f)
+    return 2.0f * tt;
+
+  return (-2.0f * tt) + (4.0f * t) - 1.0f;
+}
+
+CGLM_INLINE
+float
+glm_ease_cubic_in(float t) {
+  return t * t * t;
+}
+
+CGLM_INLINE
+float
+glm_ease_cubic_out(float t) {
+  float f;
+  f = t - 1.0f;
+  return f * f * f + 1.0f;
+}
+
+CGLM_INLINE
+float
+glm_ease_cubic_inout(float t) {
+  float f;
+
+  if (t < 0.5f)
+    return 4.0f * t * t * t;
+
+  f = 2.0f * t - 2.0f;
+
+  return 0.5f * f * f * f + 1.0f;
+}
+
+CGLM_INLINE
+float
+glm_ease_quart_in(float t) {
+  float f;
+  f = t * t;
+  return f * f;
+}
+
+CGLM_INLINE
+float
+glm_ease_quart_out(float t) {
+  float f;
+
+  f = t - 1.0f;
+
+  return f * f * f * (1.0f - t) + 1.0f;
+}
+
+CGLM_INLINE
+float
+glm_ease_quart_inout(float t) {
+  float f, g;
+
+  if (t < 0.5f) {
+    f = t * t;
+    return 8.0f * f * f;
+  }
+
+  f = t - 1.0f;
+  g = f * f;
+
+  return -8.0f * g * g + 1.0f;
+}
+
+CGLM_INLINE
+float
+glm_ease_quint_in(float t) {
+  float f;
+  f = t * t;
+  return f * f * t;
+}
+
+CGLM_INLINE
+float
+glm_ease_quint_out(float t) {
+  float f, g;
+
+  f = t - 1.0f;
+  g = f * f;
+
+  return g * g * f + 1.0f;
+}
+
+CGLM_INLINE
+float
+glm_ease_quint_inout(float t) {
+  float f, g;
+
+  if (t < 0.5f) {
+    f = t * t;
+    return 16.0f * f * f * t;
+  }
+
+  f = 2.0f * t - 2.0f;
+  g = f * f;
+
+  return 0.5f * g * g * f + 1.0f;
+}
+
+CGLM_INLINE
+float
+glm_ease_exp_in(float t) {
+  if (t == 0.0f)
+    return t;
+
+  return powf(2.0f,  10.0f * (t - 1.0f));
+}
+
+CGLM_INLINE
+float
+glm_ease_exp_out(float t) {
+  if (t == 1.0f)
+    return t;
+
+  return 1.0f - powf(2.0f, -10.0f * t);
+}
+
+CGLM_INLINE
+float
+glm_ease_exp_inout(float t) {
+  if (t == 0.0f || t == 1.0f)
+    return t;
+
+  if (t < 0.5f)
+    return 0.5f * powf(2.0f, (20.0f * t) - 10.0f);
+
+  return -0.5f * powf(2.0f, (-20.0f * t) + 10.0f) + 1.0f;
+}
+
+CGLM_INLINE
+float
+glm_ease_circ_in(float t) {
+  return 1.0f - sqrtf(1.0f - (t * t));
+}
+
+CGLM_INLINE
+float
+glm_ease_circ_out(float t) {
+  return sqrtf((2.0f - t) * t);
+}
+
+CGLM_INLINE
+float
+glm_ease_circ_inout(float t) {
+  if (t < 0.5f)
+    return 0.5f * (1.0f - sqrtf(1.0f - 4.0f * (t * t)));
+
+  return 0.5f * (sqrtf(-((2.0f * t) - 3.0f) * ((2.0f * t) - 1.0f)) + 1.0f);
+}
+
+CGLM_INLINE
+float
+glm_ease_back_in(float t) {
+  float o, z;
+
+  o = 1.70158f;
+  z = ((o + 1.0f) * t) - o;
+
+  return t * t * z;
+}
+
+CGLM_INLINE
+float
+glm_ease_back_out(float t) {
+  float o, z, n;
+
+  o = 1.70158f;
+  n = t - 1.0f;
+  z = (o + 1.0f) * n + o;
+
+  return n * n * z + 1.0f;
+}
+
+CGLM_INLINE
+float
+glm_ease_back_inout(float t) {
+  float o, z, n, m, s, x;
+
+  o = 1.70158f;
+  s = o * 1.525f;
+  x = 0.5;
+  n = t / 0.5f;
+
+  if (n < 1.0f) {
+    z = (s + 1) * n - s;
+    m = n * n * z;
+    return x * m;
+  }
+
+  n -= 2.0f;
+  z  = (s + 1.0f) * n + s;
+  m  = (n * n * z) + 2;
+
+  return x * m;
+}
+
+CGLM_INLINE
+float
+glm_ease_elast_in(float t) {
+  return sinf(13.0f * CGLM_PI_2 * t) * powf(2.0f, 10.0f * (t - 1.0f));
+}
+
+CGLM_INLINE
+float
+glm_ease_elast_out(float t) {
+  return sinf(-13.0f * CGLM_PI_2 * (t + 1.0f)) * powf(2.0f, -10.0f * t) + 1.0f;
+}
+
+CGLM_INLINE
+float
+glm_ease_elast_inout(float t) {
+  float a;
+
+  a = 2.0f * t;
+
+  if (t < 0.5f)
+    return 0.5f * sinf(13.0f * CGLM_PI_2 * a)
+                * powf(2.0f, 10.0f * (a - 1.0f));
+
+  return 0.5f * (sinf(-13.0f * CGLM_PI_2 * a)
+                 * powf(2.0f, -10.0f * (a - 1.0f)) + 2.0f);
+}
+
+CGLM_INLINE
+float
+glm_ease_bounce_out(float t) {
+  float tt;
+
+  tt = t * t;
+
+  if (t < (4.0f / 11.0f))
+    return (121.0f * tt) / 16.0f;
+
+  if (t < 8.0f / 11.0f)
+    return ((363.0f / 40.0f) * tt) - ((99.0f / 10.0f) * t) + (17.0f / 5.0f);
+
+  if (t < (9.0f / 10.0f))
+    return (4356.0f / 361.0f) * tt
+            - (35442.0f / 1805.0f) * t
+            + (16061.0f / 1805.0f);
+
+  return ((54.0f / 5.0f) * tt) - ((513.0f / 25.0f) * t) + (268.0f / 25.0f);
+}
+
+CGLM_INLINE
+float
+glm_ease_bounce_in(float t) {
+  return 1.0f - glm_ease_bounce_out(1.0f - t);
+}
+
+CGLM_INLINE
+float
+glm_ease_bounce_inout(float t) {
+  if (t < 0.5f)
+    return 0.5f * (1.0f - glm_ease_bounce_out(t * 2.0f));
+
+  return 0.5f * glm_ease_bounce_out(t * 2.0f - 1.0f) + 0.5f;
+}
+
+#endif /* cglm_ease_h */

include/cglm/mat3.h

@@ -81,7 +81,7 @@ glm_mat3_copy(mat3 mat, mat3 dest) {
 CGLM_INLINE
 void
 glm_mat3_identity(mat3 mat) {
-  mat3 t = GLM_MAT3_IDENTITY_INIT;
+  CGLM_ALIGN(16) mat3 t = GLM_MAT3_IDENTITY_INIT;
   glm_mat3_copy(t, mat);
 }
 
@@ -155,7 +155,7 @@ glm_mat3_transpose_to(mat3 m, mat3 dest) {
 CGLM_INLINE
 void
 glm_mat3_transpose(mat3 m) {
-  mat3 tmp;
+  CGLM_ALIGN(16) mat3 tmp;
 
   tmp[0][1] = m[1][0];
   tmp[0][2] = m[2][0];
@@ -189,9 +189,9 @@ glm_mat3_mulv(mat3 m, vec3 v, vec3 dest) {
 
 
 /*!
- * @brief convert mat4's rotation part to quaternion
+ * @brief convert mat3 to quaternion
  *
- * @param[in]  m    left matrix
+ * @param[in]  m    rotation matrix
  * @param[out] dest destination quaternion
  */
 CGLM_INLINE

include/cglm/mat4.h

@@ -139,7 +139,7 @@ glm_mat4_copy(mat4 mat, mat4 dest) {
 CGLM_INLINE
 void
 glm_mat4_identity(mat4 mat) {
-  mat4 t = GLM_MAT4_IDENTITY_INIT;
+  CGLM_ALIGN(16) mat4 t = GLM_MAT4_IDENTITY_INIT;
   glm_mat4_copy(t, mat);
 }
 
@@ -323,7 +323,7 @@ glm_mat4_mulv(mat4 m, vec4 v, vec4 dest) {
 /*!
  * @brief convert mat4's rotation part to quaternion
  *
- * @param[in]  m    left matrix
+ * @param[in]  m    affine matrix
  * @param[out] dest destination quaternion
  */
 CGLM_INLINE
@@ -370,20 +370,20 @@ glm_mat4_quat(mat4 m, versor dest) {
 }
 
 /*!
- * @brief multiply vector with mat4's mat3 part(rotation)
+ * @brief multiply vector with mat4
  *
  * @param[in]  m    mat4(affine transform)
  * @param[in]  v    vec3
- * @param[out] dest vec3
+ * @param[in]  last 4th item to make it vec4
+ * @param[out] dest result vector (vec3)
  */
 CGLM_INLINE
 void
-glm_mat4_mulv3(mat4 m, vec3 v, vec3 dest) {
-  vec3 res;
-  res[0] = m[0][0] * v[0] + m[1][0] * v[1] + m[2][0] * v[2];
-  res[1] = m[0][1] * v[0] + m[1][1] * v[1] + m[2][1] * v[2];
-  res[2] = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2];
-  glm_vec_copy(res, dest);
+glm_mat4_mulv3(mat4 m, vec3 v, float last, vec3 dest) {
+  vec4 res;
+  glm_vec4(v, last, res);
+  glm_mat4_mulv(m, res, res);
+  glm_vec3(res, dest);
 }
 
 /*!
@@ -586,7 +586,7 @@ glm_mat4_inv_fast(mat4 mat, mat4 dest) {
 CGLM_INLINE
 void
 glm_mat4_swap_col(mat4 mat, int col1, int col2) {
-  vec4 tmp;
+  CGLM_ALIGN(16) vec4 tmp;
   glm_vec4_copy(mat[col1], tmp);
   glm_vec4_copy(mat[col2], mat[col1]);
   glm_vec4_copy(tmp, mat[col2]);
@@ -602,7 +602,7 @@ glm_mat4_swap_col(mat4 mat, int col1, int col2) {
 CGLM_INLINE
 void
 glm_mat4_swap_row(mat4 mat, int row1, int row2) {
-  vec4 tmp;
+  CGLM_ALIGN(16) vec4 tmp;
   tmp[0] = mat[0][row1];
   tmp[1] = mat[1][row1];
   tmp[2] = mat[2][row1];

include/cglm/project.h

@@ -100,7 +100,7 @@ glm_unproject(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
 CGLM_INLINE
 void
 glm_project(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
-  vec4 pos4, vone = GLM_VEC4_ONE_INIT;
+  CGLM_ALIGN(16) vec4 pos4, vone = GLM_VEC4_ONE_INIT;
 
   glm_vec4(pos, 1.0f, pos4);
 

include/cglm/quat.h

@@ -99,7 +99,7 @@ glm_translate(mat4 m, vec3 v);
 CGLM_INLINE
 void
 glm_quat_identity(versor q) {
-  versor v = GLM_QUAT_IDENTITY_INIT;
+  CGLM_ALIGN(16) versor v = GLM_QUAT_IDENTITY_INIT;
   glm_vec4_copy(v, q);
 }
 
@@ -131,7 +131,7 @@ glm_quat_init(versor q, float x, float y, float z, float w) {
 CGLM_INLINE
 void
 glm_quatv(versor q, float angle, vec3 axis) {
-  vec3  k;
+  CGLM_ALIGN(8) vec3 k;
   float a, c, s;
 
   a = angle * 0.5f;
@@ -158,7 +158,7 @@ glm_quatv(versor q, float angle, vec3 axis) {
 CGLM_INLINE
 void
 glm_quat(versor q, float angle, float x, float y, float z) {
-  vec3 axis = {x, y, z};
+  CGLM_ALIGN(8) vec3 axis = {x, y, z};
   glm_quatv(q, angle, axis);
 }
 
@@ -267,7 +267,7 @@ glm_quat_conjugate(versor q, versor dest) {
 CGLM_INLINE
 void
 glm_quat_inv(versor q, versor dest) {
-  versor conj;
+  CGLM_ALIGN(8) versor conj;
   glm_quat_conjugate(q, conj);
   glm_vec4_scale(conj, 1.0f / glm_vec4_norm2(q), dest);
 }
@@ -603,7 +603,7 @@ glm_quat_lerp(versor from, versor to, float t, versor dest) {
 CGLM_INLINE
 void
 glm_quat_slerp(versor from, versor to, float t, versor dest) {
-  vec4  q1, q2;
+  CGLM_ALIGN(16) vec4 q1, q2;
   float cosTheta, sinTheta, angle;
 
   cosTheta = glm_quat_dot(from, to);
@@ -646,15 +646,12 @@ glm_quat_slerp(versor from, versor to, float t, versor dest) {
 CGLM_INLINE
 void
 glm_quat_look(vec3 eye, versor ori, mat4 dest) {
-  vec4 t;
-
   /* orientation */
   glm_quat_mat4t(ori, dest);
 
   /* translate */
-  glm_vec4(eye, 1.0f, t);
-  glm_mat4_mulv(dest, t, t);
-  glm_vec_flipsign_to(t, dest[3]);
+  glm_mat4_mulv3(dest, eye, 1.0f, dest[3]);
+  glm_vec_flipsign(dest[3]);
 }
 
 /*!
@@ -668,7 +665,7 @@ glm_quat_look(vec3 eye, versor ori, mat4 dest) {
 CGLM_INLINE
 void
 glm_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest) {
-  vec3  axis;
+  CGLM_ALIGN(8) vec3 axis;
   float dot, angle;
 
   dot = glm_vec_dot(dir, fwd);
@@ -702,7 +699,7 @@ glm_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest) {
 CGLM_INLINE
 void
 glm_quat_forp(vec3 from, vec3 to, vec3 fwd, vec3 up, versor dest) {
-  vec3 dir;
+  CGLM_ALIGN(8) vec3 dir;
   glm_vec_sub(to, from, dir);
   glm_quat_for(dir, fwd, up, dest);
 }
@@ -717,9 +714,9 @@ glm_quat_forp(vec3 from, vec3 to, vec3 fwd, vec3 up, versor dest) {
 CGLM_INLINE
 void
 glm_quat_rotatev(versor q, vec3 v, vec3 dest) {
-  versor p;
-  vec3   u, v1, v2;
-  float  s;
+  CGLM_ALIGN(16) versor p;
+  CGLM_ALIGN(8)  vec3   u, v1, v2;
+  float s;
 
   glm_quat_normalize_to(q, p);
   glm_quat_imag(p, u);
@@ -745,7 +742,7 @@ glm_quat_rotatev(versor q, vec3 v, vec3 dest) {
 CGLM_INLINE
 void
 glm_quat_rotate(mat4 m, versor q, mat4 dest) {
-  mat4 rot;
+  CGLM_ALIGN(16) mat4 rot;
   glm_quat_mat4(q, rot);
   glm_mul_rot(m, rot, dest);
 }
@@ -760,7 +757,7 @@ glm_quat_rotate(mat4 m, versor q, mat4 dest) {
 CGLM_INLINE
 void
 glm_quat_rotate_at(mat4 m, versor q, vec3 pivot) {
-  vec3 pivotInv;
+  CGLM_ALIGN(8) vec3 pivotInv;
 
   glm_vec_inv_to(pivot, pivotInv);
 
@@ -784,12 +781,11 @@ glm_quat_rotate_at(mat4 m, versor q, vec3 pivot) {
 CGLM_INLINE
 void
 glm_quat_rotate_atm(mat4 m, versor q, vec3 pivot) {
-  vec3 pivotInv;
+  CGLM_ALIGN(8) vec3 pivotInv;
 
   glm_vec_inv_to(pivot, pivotInv);
 
-  glm_mat4_identity(m);
-  glm_vec_copy(pivot, m[3]);
+  glm_translate_make(m, pivot);
   glm_quat_rotate(m, q, m);
   glm_translate(m, pivotInv);
 }

include/cglm/sphere.h

@@ -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
+ */
+
+#ifndef cglm_sphere_h
+#define cglm_sphere_h
+
+#include "common.h"
+#include "mat4.h"
+
+/*
+  Sphere Representation in cglm: [center.x, center.y, center.z, radii]
+
+  You could use this representation or you can convert it to vec4 before call
+  any function
+ */
+
+/*!
+ * @brief helper for getting sphere radius
+ *
+ * @param[in]   s  sphere
+ *
+ * @return returns radii
+ */
+CGLM_INLINE
+float
+glm_sphere_radii(vec4 s) {
+  return s[3];
+}
+
+/*!
+ * @brief apply transform to sphere, it is just wrapper for glm_mat4_mulv3
+ *
+ * @param[in]  s    sphere
+ * @param[in]  m    transform matrix
+ * @param[out] dest transformed sphere
+ */
+CGLM_INLINE
+void
+glm_sphere_transform(vec4 s, mat4 m, vec4 dest) {
+  glm_mat4_mulv3(m, s, 1.0f, dest);
+  dest[3] = s[3];
+}
+
+/*!
+ * @brief merges two spheres and creates a new one
+ *
+ * two sphere must be in same space, for instance if one in world space then
+ * the other must be in world space too, not in local space.
+ *
+ * @param[in]  s1   sphere 1
+ * @param[in]  s2   sphere 2
+ * @param[out] dest merged/extended sphere
+ */
+CGLM_INLINE
+void
+glm_sphere_merge(vec4 s1, vec4 s2, vec4 dest) {
+  float dist, radii;
+
+  dist  = glm_vec_distance(s1, s2);
+  radii = dist + s1[3] + s2[3];
+
+  radii = glm_max(radii, s1[3]);
+  radii = glm_max(radii, s2[3]);
+
+  glm_vec_center(s1, s2, dest);
+  dest[3] = radii;
+}
+
+/*!
+ * @brief check if two sphere intersects
+ *
+ * @param[in]   s1  sphere
+ * @param[in]   s2  other sphere
+ */
+CGLM_INLINE
+bool
+glm_sphere_sphere(vec4 s1, vec4 s2) {
+  return glm_vec_distance2(s1, s2) <= glm_pow2(s1[3] + s2[3]);
+}
+
+/*!
+ * @brief check if sphere intersects with point
+ *
+ * @param[in]   s      sphere
+ * @param[in]   point  point
+ */
+CGLM_INLINE
+bool
+glm_sphere_point(vec4 s, vec3 point) {
+  float rr;
+  rr = s[3] * s[3];
+  return glm_vec_distance2(point, s) <= rr;
+}
+
+#endif /* cglm_sphere_h */

include/cglm/util.h

@@ -19,6 +19,10 @@
 #define cglm_util_h
 
 #include "common.h"
+#include <stdbool.h>
+
+#define GLM_MIN(X, Y) (((X) < (Y)) ? (X) : (Y))
+#define GLM_MAX(X, Y) (((X) > (Y)) ? (X) : (Y))
 
 /*!
  * @brief get sign of 32 bit integer as +1, -1, 0
@@ -98,7 +102,6 @@ glm_make_deg(float *rad) {
 CGLM_INLINE
 float
 glm_pow2(float x) {
-
   return x * x;
 }
 
@@ -143,6 +146,17 @@ glm_clamp(float val, float minVal, float maxVal) {
   return glm_min(glm_max(val, minVal), maxVal);
 }
 
+/*!
+ * @brief clamp a number to zero and one
+ *
+ * @param[in] val value to clamp
+ */
+CGLM_INLINE
+float
+glm_clamp_zo(float val) {
+  return glm_clamp(val, 0.0f, 1.0f);
+}
+
 /*!
  * @brief linear interpolation between two number
  *
@@ -155,7 +169,52 @@ glm_clamp(float val, float minVal, float maxVal) {
 CGLM_INLINE
 float
 glm_lerp(float from, float to, float t) {
-  return from + glm_clamp(t, 0.0f, 1.0f) * (to - from);
+  return from + glm_clamp_zo(t) * (to - from);
+}
+
+/*!
+ * @brief check if two float equal with using EPSILON
+ *
+ * @param[in]   a   a
+ * @param[in]   b   b
+ */
+CGLM_INLINE
+bool
+glm_eq(float a, float b) {
+  return fabsf(a - b) <= FLT_EPSILON;
+}
+
+/*!
+ * @brief percentage of current value between start and end value
+ *
+ * maybe fraction could be alternative name.
+ *
+ * @param[in]   from    from value
+ * @param[in]   to      to value
+ * @param[in]   current current value
+ */
+CGLM_INLINE
+float
+glm_percent(float from, float to, float current) {
+  float t;
+
+  if ((t = to - from) == 0.0f)
+    return 1.0f;
+
+  return (current - from) / t;
+}
+
+/*!
+ * @brief clamped percentage of current value between start and end value
+ *
+ * @param[in]   from    from value
+ * @param[in]   to      to value
+ * @param[in]   current current value
+ */
+CGLM_INLINE
+float
+glm_percentc(float from, float to, float current) {
+  return glm_clamp(glm_percent(from, to, current), 0.0f, 1.0f);
 }
 
 #endif /* cglm_util_h */

include/cglm/vec3.h

@@ -454,8 +454,7 @@ glm_vec_inv(vec3 v) {
 CGLM_INLINE
 void
 glm_vec_inv_to(vec3 v, vec3 dest) {
-  glm_vec_copy(v, dest);
-  glm_vec_flipsign(dest);
+  glm_vec_flipsign_to(v, dest);
 }
 
 /*!
@@ -634,6 +633,21 @@ glm_vec_center(vec3 v1, vec3 v2, vec3 dest) {
   glm_vec_scale(dest, 0.5f, dest);
 }
 
+/**
+ * @brief squared distance between two vectors
+ *
+ * @param[in] v1 vector1
+ * @param[in] v2 vector2
+ * @return returns squared distance (distance * distance)
+ */
+CGLM_INLINE
+float
+glm_vec_distance2(vec3 v1, vec3 v2) {
+  return glm_pow2(v2[0] - v1[0])
+       + glm_pow2(v2[1] - v1[1])
+       + glm_pow2(v2[2] - v1[2]);
+}
+
 /**
  * @brief distance between two vectors
  *
@@ -644,9 +658,7 @@ glm_vec_center(vec3 v1, vec3 v2, vec3 dest) {
 CGLM_INLINE
 float
 glm_vec_distance(vec3 v1, vec3 v2) {
-  return sqrtf(glm_pow2(v2[0] - v1[0])
-             + glm_pow2(v2[1] - v1[1])
-             + glm_pow2(v2[2] - v1[2]));
+  return sqrtf(glm_vec_distance2(v1, v2));
 }
 
 /*!
@@ -724,7 +736,7 @@ glm_vec_lerp(vec3 from, vec3 to, float t, vec3 dest) {
   vec3 s, v;
 
   /* from + s * (to - from) */
-  glm_vec_broadcast(glm_clamp(t, 0.0f, 1.0f), s);
+  glm_vec_broadcast(glm_clamp_zo(t), s);
   glm_vec_sub(to, from, v);
   glm_vec_mulv(s, v, v);
   glm_vec_add(from, v, dest);

include/cglm/vec4.h

@@ -25,6 +25,7 @@
    CGLM_INLINE void  glm_vec4(vec3 v3, float last, vec4 dest);
    CGLM_INLINE void  glm_vec4_copy3(vec4 a, vec3 dest);
    CGLM_INLINE void  glm_vec4_copy(vec4 v, vec4 dest);
+   CGLM_INLINE void  glm_vec4_ucopy(vec4 v, vec4 dest);
    CGLM_INLINE float glm_vec4_dot(vec4 a, vec4 b);
    CGLM_INLINE float glm_vec4_norm2(vec4 v);
    CGLM_INLINE float glm_vec4_norm(vec4 vec);
@@ -120,6 +121,23 @@ glm_vec4_copy(vec4 v, vec4 dest) {
 #endif
 }
 
+/*!
+ * @brief copy all members of [a] to [dest]
+ *
+ * alignment is not required
+ *
+ * @param[in]  v    source
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_vec4_ucopy(vec4 v, vec4 dest) {
+  dest[0] = v[0];
+  dest[1] = v[1];
+  dest[2] = v[2];
+  dest[3] = v[3];
+}
+
 /*!
  * @brief make vector zero
  *
@@ -698,7 +716,7 @@ glm_vec4_lerp(vec4 from, vec4 to, float t, vec4 dest) {
   vec4 s, v;
 
   /* from + s * (to - from) */
-  glm_vec4_broadcast(glm_clamp(t, 0.0f, 1.0f), s);
+  glm_vec4_broadcast(glm_clamp_zo(t), s);
   glm_vec4_sub(to, from, v);
   glm_vec4_mulv(s, v, v);
   glm_vec4_add(from, v, dest);

include/cglm/version.h

@@ -10,6 +10,6 @@
 
 #define CGLM_VERSION_MAJOR 0
 #define CGLM_VERSION_MINOR 4
-#define CGLM_VERSION_PATCH 5
+#define CGLM_VERSION_PATCH 8
 
 #endif /* cglm_version_h */

makefile.am

@@ -55,7 +55,9 @@ cglm_HEADERS = include/cglm/version.h \
                   include/cglm/frustum.h \
                   include/cglm/box.h \
                   include/cglm/color.h \
-                  include/cglm/project.h
+                  include/cglm/project.h \
+                  include/cglm/sphere.h \
+                  include/cglm/ease.h
 
 cglm_calldir=$(includedir)/cglm/call
 cglm_call_HEADERS = include/cglm/call/mat4.h \
@@ -70,7 +72,9 @@ cglm_call_HEADERS = include/cglm/call/mat4.h \
                     include/cglm/call/plane.h \
                     include/cglm/call/frustum.h \
                     include/cglm/call/box.h \
-                    include/cglm/call/project.h
+                    include/cglm/call/project.h \
+                    include/cglm/call/sphere.h \
+                    include/cglm/call/ease.h
 
 cglm_simddir=$(includedir)/cglm/simd
 cglm_simd_HEADERS = include/cglm/simd/intrin.h
@@ -101,7 +105,9 @@ libcglm_la_SOURCES=\
     src/plane.c \
     src/frustum.c \
     src/box.c \
-    src/project.c
+    src/project.c \
+    src/sphere.c \
+    src/ease.c
 
 test_tests_SOURCES=\
     test/src/test_common.c \

src/affine.c

@@ -133,3 +133,21 @@ void
 glmc_decompose(mat4 m, vec4 t, mat4 r, vec3 s) {
   glm_decompose(m, t, r, s);
 }
+
+CGLM_EXPORT
+void
+glmc_mul(mat4 m1, mat4 m2, mat4 dest) {
+  glm_mul(m1, m2, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mul_rot(mat4 m1, mat4 m2, mat4 dest) {
+  glm_mul_rot(m1, m2, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_inv_tr(mat4 mat) {
+  glm_inv_tr(mat);
+}

src/box.c

@@ -34,3 +34,63 @@ glmc_aabb_crop_until(vec3 box[2],
                      vec3 dest[2]) {
   glm_aabb_crop_until(box, cropBox, clampBox, dest);
 }
+
+CGLM_EXPORT
+bool
+glmc_aabb_frustum(vec3 box[2], vec4 planes[6]) {
+  return glm_aabb_frustum(box, planes);
+}
+
+CGLM_EXPORT
+void
+glmc_aabb_invalidate(vec3 box[2]) {
+  glm_aabb_invalidate(box);
+}
+
+CGLM_EXPORT
+bool
+glmc_aabb_isvalid(vec3 box[2]) {
+  return glm_aabb_isvalid(box);
+}
+
+CGLM_EXPORT
+float
+glmc_aabb_size(vec3 box[2]) {
+  return glm_aabb_size(box);
+}
+
+CGLM_EXPORT
+float
+glmc_aabb_radius(vec3 box[2]) {
+  return glm_aabb_radius(box);
+}
+
+CGLM_EXPORT
+void
+glmc_aabb_center(vec3 box[2], vec3 dest) {
+  glm_aabb_center(box, dest);
+}
+
+CGLM_EXPORT
+bool
+glmc_aabb_aabb(vec3 box[2], vec3 other[2]) {
+  return glm_aabb_aabb(box, other);
+}
+
+CGLM_EXPORT
+bool
+glmc_aabb_point(vec3 box[2], vec3 point) {
+  return glm_aabb_point(box, point);
+}
+
+CGLM_EXPORT
+bool
+glmc_aabb_contains(vec3 box[2], vec3 other[2]) {
+  return glm_aabb_contains(box, other);
+}
+
+CGLM_EXPORT
+bool
+glmc_aabb_sphere(vec3 box[2], vec4 s) {
+  return glm_aabb_sphere(box, s);
+}

src/cam.c

@@ -44,6 +44,36 @@ glmc_ortho(float left,
             dest);
 }
 
+CGLM_EXPORT
+void
+glmc_ortho_aabb(vec3 box[2], mat4 dest) {
+  glm_ortho_aabb(box, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_ortho_aabb_p(vec3 box[2], float padding, mat4 dest) {
+  glm_ortho_aabb_p(box, padding, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_ortho_aabb_pz(vec3 box[2], float padding, mat4 dest) {
+  glm_ortho_aabb_pz(box, padding, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_ortho_default(float aspect, mat4 dest) {
+  glm_ortho_default(aspect, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_ortho_default_s(float aspect, float size, mat4 dest) {
+  glm_ortho_default_s(aspect, size, dest);
+}
+
 CGLM_EXPORT
 void
 glmc_perspective(float fovy,
@@ -58,6 +88,18 @@ glmc_perspective(float fovy,
                   dest);
 }
 
+CGLM_EXPORT
+void
+glmc_perspective_default(float aspect, mat4 dest) {
+  glm_perspective_default(aspect, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_perspective_resize(float aspect, mat4 proj) {
+  glm_perspective_resize(aspect, proj);
+}
+
 CGLM_EXPORT
 void
 glmc_lookat(vec3 eye,
@@ -78,3 +120,75 @@ void
 glmc_look_anyup(vec3 eye, vec3 dir, mat4 dest) {
   glm_look_anyup(eye, dir, dest);
 }
+
+CGLM_EXPORT
+void
+glmc_persp_decomp(mat4 proj,
+                  float * __restrict nearVal,
+                  float * __restrict farVal,
+                  float * __restrict top,
+                  float * __restrict bottom,
+                  float * __restrict left,
+                  float * __restrict right) {
+  glm_persp_decomp(proj, nearVal, farVal, top, bottom, left, right);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decompv(mat4 proj, float dest[6]) {
+  glm_persp_decompv(proj, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_x(mat4 proj,
+                    float * __restrict left,
+                    float * __restrict right) {
+  glm_persp_decomp_x(proj, left, right);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_y(mat4 proj,
+                    float * __restrict top,
+                    float * __restrict bottom) {
+  glm_persp_decomp_y(proj, top, bottom);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_z(mat4 proj,
+                    float * __restrict nearVal,
+                    float * __restrict farVal) {
+  glm_persp_decomp_z(proj, nearVal, farVal);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_far(mat4 proj, float * __restrict farVal) {
+  glm_persp_decomp_far(proj, farVal);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_near(mat4 proj, float * __restrict nearVal) {
+  glm_persp_decomp_near(proj, nearVal);
+}
+
+CGLM_EXPORT
+float
+glmc_persp_fovy(mat4 proj) {
+  return glm_persp_fovy(proj);
+}
+
+CGLM_EXPORT
+float
+glmc_persp_aspect(mat4 proj) {
+  return glm_persp_aspect(proj);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_sizes(mat4 proj, float fovy, vec4 dest) {
+  glm_persp_sizes(proj, fovy, dest);
+}

src/ease.c

@@ -0,0 +1,195 @@
+/*
+ * 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
+float
+glmc_ease_linear(float t) {
+  return glm_ease_linear(t);
+}
+
+CGLM_EXPORT
+float
+glmc_ease_sine_in(float t) {
+  return glm_ease_sine_in(t);
+}
+
+CGLM_EXPORT
+float
+glmc_ease_sine_out(float t) {
+  return glm_ease_sine_out(t);
+}
+
+CGLM_EXPORT
+float
+glmc_ease_sine_inout(float t) {
+  return glm_ease_sine_inout(t);
+}
+
+CGLM_EXPORT
+float
+glmc_ease_quad_in(float t) {
+  return glm_ease_quad_in(t);
+}
+
+CGLM_EXPORT
+float
+glmc_ease_quad_out(float t) {
+  return glm_ease_quad_out(t);
+}
+
+CGLM_EXPORT
+float
+glmc_ease_quad_inout(float t) {
+  return glm_ease_quad_inout(t);
+}
+
+CGLM_EXPORT
+float
+glmc_ease_cubic_in(float t) {
+  return glm_ease_cubic_in(t);
+}
+
+CGLM_EXPORT
+float
+glmc_ease_cubic_out(float t) {
+  return glm_ease_cubic_out(t);
+}
+
+CGLM_EXPORT
+float
+glmc_ease_cubic_inout(float t) {
+  return glm_ease_cubic_inout(t);
+}
+
+CGLM_EXPORT
+float
+glmc_ease_quart_in(float t) {
+  return glm_ease_quart_in(t);
+}
+
+CGLM_EXPORT
+float
+glmc_ease_quart_out(float t) {
+  return glm_ease_quart_out(t);
+}
+
+CGLM_EXPORT
+float
+glmc_ease_quart_inout(float t) {
+  return glm_ease_quart_inout(t);
+}
+
+CGLM_EXPORT
+float
+glmc_ease_quint_in(float t) {
+  return glm_ease_quint_in(t);
+}
+
+CGLM_EXPORT
+float
+glmc_ease_quint_out(float t) {
+  return glm_ease_quint_out(t);
+}
+
+CGLM_EXPORT
+float
+glmc_ease_quint_inout(float t) {
+  return glm_ease_quint_inout(t);
+}
+
+CGLM_EXPORT
+float
+glmc_ease_exp_in(float t) {
+  return glm_ease_exp_in(t);
+}
+
+CGLM_EXPORT
+float
+glmc_ease_exp_out(float t) {
+  return glm_ease_exp_out(t);
+}
+
+CGLM_EXPORT
+float
+glmc_ease_exp_inout(float t) {
+  return glm_ease_exp_inout(t);
+}
+
+CGLM_EXPORT
+float
+glmc_ease_circ_in(float t) {
+  return glm_ease_circ_in(t);
+}
+
+CGLM_EXPORT
+float
+glmc_ease_circ_out(float t) {
+  return glm_ease_circ_out(t);
+}
+
+CGLM_EXPORT
+float
+glmc_ease_circ_inout(float t) {
+  return glm_ease_circ_inout(t);
+}
+
+CGLM_EXPORT
+float
+glmc_ease_back_in(float t) {
+  return glm_ease_back_in(t);
+}
+
+CGLM_EXPORT
+float
+glmc_ease_back_out(float t) {
+  return glm_ease_back_out(t);
+}
+
+CGLM_EXPORT
+float
+glmc_ease_back_inout(float t) {
+  return glm_ease_back_inout(t);
+}
+
+CGLM_EXPORT
+float
+glmc_ease_elast_in(float t) {
+  return glm_ease_elast_in(t);
+}
+
+CGLM_EXPORT
+float
+glmc_ease_elast_out(float t) {
+  return glm_ease_elast_out(t);
+}
+
+CGLM_EXPORT
+float
+glmc_ease_elast_inout(float t) {
+  return glm_ease_elast_inout(t);
+}
+
+CGLM_EXPORT
+float
+glmc_ease_bounce_out(float t) {
+  return glm_ease_bounce_out(t);
+}
+
+CGLM_EXPORT
+float
+glmc_ease_bounce_in(float t) {
+  return glm_ease_bounce_in(t);
+}
+
+CGLM_EXPORT
+float
+glmc_ease_bounce_inout(float t) {
+  return glm_ease_bounce_inout(t);
+}

src/mat3.c

@@ -44,6 +44,12 @@ glmc_mat3_mulv(mat3 m, vec3 v, vec3 dest) {
   glm_mat3_mulv(m, v, dest);
 }
 
+CGLM_EXPORT
+void
+glmc_mat3_quat(mat3 m, versor dest) {
+  glm_mat3_quat(m, dest);
+}
+
 CGLM_EXPORT
 void
 glmc_mat3_scale(mat3 m, float s) {

src/mat4.c

@@ -62,6 +62,12 @@ glmc_mat4_mulv(mat4 m, vec4 v, vec4 dest) {
   glm_mat4_mulv(m, v, dest);
 }
 
+CGLM_EXPORT
+void
+glmc_mat4_mulv3(mat4 m, vec3 v, float last, vec3 dest) {
+  glm_mat4_mulv3(m, v, last, dest);
+}
+
 CGLM_EXPORT
 void
 glmc_mat4_quat(mat4 m, versor dest) {
@@ -110,6 +116,12 @@ glmc_mat4_inv_precise(mat4 mat, mat4 dest) {
   glm_mat4_inv_precise(mat, dest);
 }
 
+CGLM_EXPORT
+void
+glmc_mat4_inv_fast(mat4 mat, mat4 dest) {
+  glm_mat4_inv_fast(mat, dest);
+}
+
 CGLM_EXPORT
 void
 glmc_mat4_swap_col(mat4 mat, int col1, int col2) {

src/sphere.c

@@ -0,0 +1,39 @@
+/*
+ * 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
+float
+glmc_sphere_radii(vec4 s) {
+  return glm_sphere_radii(s);
+}
+
+CGLM_EXPORT
+void
+glmc_sphere_transform(vec4 s, mat4 m, vec4 dest) {
+  glm_sphere_transform(s, m, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_sphere_merge(vec4 s1, vec4 s2, vec4 dest) {
+  glm_sphere_merge(s1, s2, dest);
+}
+
+CGLM_EXPORT
+bool
+glmc_sphere_sphere(vec4 s1, vec4 s2) {
+  return glm_sphere_sphere(s1, s2);
+}
+
+CGLM_EXPORT
+bool
+glmc_sphere_point(vec4 s, vec3 point) {
+  return glm_sphere_point(s, point);
+}

src/vec3.c

@@ -188,6 +188,12 @@ glmc_vec_rotate_m4(mat4 m, vec3 v, vec3 dest) {
   glm_vec_rotate_m4(m, v, dest);
 }
 
+CGLM_EXPORT
+void
+glmc_vec_rotate_m3(mat3 m, vec3 v, vec3 dest) {
+  glm_vec_rotate_m3(m, v, dest);
+}
+
 CGLM_EXPORT
 void
 glmc_vec_proj(vec3 a, vec3 b, vec3 dest) {
@@ -200,6 +206,12 @@ glmc_vec_center(vec3 v1, vec3 v2, vec3 dest) {
   glm_vec_center(v1, v2, dest);
 }
 
+CGLM_EXPORT
+float
+glmc_vec_distance2(vec3 v1, vec3 v2) {
+  return glm_vec_distance2(v1, v2);
+}
+
 CGLM_EXPORT
 float
 glmc_vec_distance(vec3 v1, vec3 v2) {

src/vec4.c

@@ -38,6 +38,12 @@ glmc_vec4_copy(vec4 v, vec4 dest) {
   glm_vec4_copy(v, dest);
 }
 
+CGLM_EXPORT
+void
+glmc_vec4_ucopy(vec4 v, vec4 dest) {
+  glm_vec4_ucopy(v, dest);
+}
+
 CGLM_EXPORT
 float
 glmc_vec4_dot(vec4 a, vec4 b) {

win/cglm.vcxproj

@@ -23,6 +23,7 @@
     <ClCompile Include="..\src\box.c" />
     <ClCompile Include="..\src\cam.c" />
     <ClCompile Include="..\src\dllmain.c" />
+    <ClCompile Include="..\src\ease.c" />
     <ClCompile Include="..\src\euler.c" />
     <ClCompile Include="..\src\frustum.c" />
     <ClCompile Include="..\src\io.c" />
@@ -31,6 +32,7 @@
     <ClCompile Include="..\src\plane.c" />
     <ClCompile Include="..\src\project.c" />
     <ClCompile Include="..\src\quat.c" />
+    <ClCompile Include="..\src\sphere.c" />
     <ClCompile Include="..\src\vec3.c" />
     <ClCompile Include="..\src\vec4.c" />
   </ItemGroup>
@@ -42,6 +44,7 @@
     <ClInclude Include="..\include\cglm\call\affine.h" />
     <ClInclude Include="..\include\cglm\call\box.h" />
     <ClInclude Include="..\include\cglm\call\cam.h" />
+    <ClInclude Include="..\include\cglm\call\ease.h" />
     <ClInclude Include="..\include\cglm\call\euler.h" />
     <ClInclude Include="..\include\cglm\call\frustum.h" />
     <ClInclude Include="..\include\cglm\call\io.h" />
@@ -50,12 +53,14 @@
     <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\vec3.h" />
     <ClInclude Include="..\include\cglm\call\vec4.h" />
     <ClInclude Include="..\include\cglm\cam.h" />
     <ClInclude Include="..\include\cglm\cglm.h" />
     <ClInclude Include="..\include\cglm\color.h" />
     <ClInclude Include="..\include\cglm\common.h" />
+    <ClInclude Include="..\include\cglm\ease.h" />
     <ClInclude Include="..\include\cglm\euler.h" />
     <ClInclude Include="..\include\cglm\frustum.h" />
     <ClInclude Include="..\include\cglm\io.h" />
@@ -72,6 +77,7 @@
     <ClInclude Include="..\include\cglm\simd\sse2\mat3.h" />
     <ClInclude Include="..\include\cglm\simd\sse2\mat4.h" />
     <ClInclude Include="..\include\cglm\simd\sse2\quat.h" />
+    <ClInclude Include="..\include\cglm\sphere.h" />
     <ClInclude Include="..\include\cglm\types.h" />
     <ClInclude Include="..\include\cglm\util.h" />
     <ClInclude Include="..\include\cglm\vec3-ext.h" />

win/cglm.vcxproj.filters

@@ -78,6 +78,12 @@
     <ClCompile Include="..\src\project.c">
       <Filter>src</Filter>
     </ClCompile>
+    <ClCompile Include="..\src\sphere.c">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\ease.c">
+      <Filter>src</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\src\config.h">
@@ -215,5 +221,17 @@
     <ClInclude Include="..\include\cglm\call\project.h">
       <Filter>include\cglm\call</Filter>
     </ClInclude>
+    <ClInclude Include="..\include\cglm\call\sphere.h">
+      <Filter>include\cglm\call</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\sphere.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\call\ease.h">
+      <Filter>include\cglm\call</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\ease.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>