Merge branch 'master' into const

Resolve vec4 : glm_vec4_distance() to satisfy compiling on armv7

.gitignore

@@ -69,3 +69,4 @@ win/cglm_test_*
 win/x64
 win/x85
 win/Debug
+cglm-test-ios*

.travis.yml

@@ -57,3 +57,6 @@ after_success:
         --gcov-options '\-lp'
         --verbose;
     fi
+
+after_failure:
+  - cat ./test-suite.log

CREDITS

@@ -52,3 +52,12 @@ https://gamedev.stackexchange.com/questions/28395/rotating-vector3-by-a-quaterni
 
 9. Sphere AABB intersect
 https://github.com/erich666/GraphicsGems/blob/master/gems/BoxSphere.c
+
+10. Horizontal add
+https://stackoverflow.com/questions/6996764/fastest-way-to-do-horizontal-float-vector-sum-on-x86
+
+11. de casteljau implementation and comments
+https://forums.khronos.org/showthread.php/10264-Animations-in-1-4-1-release-notes-revision-A/page2?highlight=bezier
+https://forums.khronos.org/showthread.php/10644-Animation-Bezier-interpolation
+https://forums.khronos.org/showthread.php/10387-2D-Tangents-in-Bezier-Splines?p=34164&viewfull=1#post34164
+https://forums.khronos.org/showthread.php/10651-Animation-TCB-Spline-Interpolation-in-COLLADA?highlight=bezier

README.md

@@ -82,7 +82,11 @@ Currently *cglm* uses default clip space configuration (-1, 1) for camera functi
 - inline or pre-compiled function call
 - frustum (extract view frustum planes, corners...)
 - bounding box  (AABB in Frustum (culling), crop, merge...)
+- bounding sphere
 - project, unproject
+- easing functions
+- curves
+- curve interpolation helpers (S*M*C, deCasteljau...)
 - and other...
 
 <hr />

cglm.podspec

@@ -2,7 +2,7 @@ Pod::Spec.new do |s|
 
   # Description
   s.name         = "cglm"
-  s.version      = "0.4.6"
+  s.version      = "0.5.1"
   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.5.1], [info@recp.me])
+AC_INIT([cglm], [0.5.4], [info@recp.me])
 AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects])
 
 AC_CONFIG_MACRO_DIR([m4])
@@ -29,6 +29,7 @@ LT_INIT
 # Checks for libraries.
 AC_CHECK_LIB([m], [floor])
 
+m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
 AC_SYS_LARGEFILE
 
 # Checks for header files.

docs/source/api.rst

@@ -46,3 +46,5 @@ Follow the :doc:`build` documentation for this
    io
    call
    sphere
+   curve
+   bezier

docs/source/bezier.rst

@@ -0,0 +1,89 @@
+.. default-domain:: C
+
+Bezier
+================================================================================
+
+Header: cglm/bezier.h
+
+Common helpers for cubic bezier and similar curves.
+
+Table of contents (click to go):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Functions:
+
+1. :c:func:`glm_bezier`
+2. :c:func:`glm_hermite`
+3. :c:func:`glm_decasteljau`
+
+Functions documentation
+~~~~~~~~~~~~~~~~~~~~~~~
+
+.. c:function:: float glm_bezier(float s, float p0, float c0, float c1, float p1)
+
+    | cubic bezier interpolation
+    | formula:
+
+    .. code-block:: text
+
+      B(s) = P0*(1-s)^3 + 3*C0*s*(1-s)^2 + 3*C1*s^2*(1-s) + P1*s^3
+
+    | similar result using matrix:
+
+    .. code-block:: text
+
+      B(s) = glm_smc(t, GLM_BEZIER_MAT, (vec4){p0, c0, c1, p1})
+
+    | glm_eq(glm_smc(...), glm_bezier(...)) should return TRUE
+
+    Parameters:
+      | *[in]*  **s**   parameter between 0 and 1
+      | *[in]*  **p0**  begin point
+      | *[in]*  **c0**  control point 1
+      | *[in]*  **c1**  control point 2
+      | *[in]*  **p1**  end point
+
+    Returns:
+        B(s)
+
+.. c:function:: float glm_hermite(float s, float p0, float t0, float t1, float p1)
+
+    | cubic hermite interpolation
+    | formula:
+
+    .. code-block:: text
+
+      H(s) = P0*(2*s^3 - 3*s^2 + 1) + T0*(s^3 - 2*s^2 + s) + P1*(-2*s^3 + 3*s^2) + T1*(s^3 - s^2)
+
+    | similar result using matrix:
+
+    .. code-block:: text
+
+      H(s) = glm_smc(t, GLM_HERMITE_MAT, (vec4){p0, p1, c0, c1})
+
+    | glm_eq(glm_smc(...), glm_hermite(...)) should return TRUE
+
+
+    Parameters:
+      | *[in]*  **s**   parameter between 0 and 1
+      | *[in]*  **p0**  begin point
+      | *[in]*  **t0**  tangent 1
+      | *[in]*  **t1**  tangent 2
+      | *[in]*  **p1**  end point
+
+    Returns:
+        B(s)
+
+.. c:function:: float glm_decasteljau(float prm, float p0, float c0, float c1, float p1)
+
+    | iterative way to solve cubic equation
+
+    Parameters:
+      | *[in]*  **prm** parameter between 0 and 1
+      | *[in]*  **p0**  begin point
+      | *[in]*  **c0**  control point 1
+      | *[in]*  **c1**  control point 2
+      | *[in]*  **p1**  end point
+
+    Returns:
+        parameter to use in cubic equation

docs/source/build.rst

@@ -1,9 +1,7 @@
-Building cglm
+Build cglm
 ================================
 
-| **cglm** does not have external dependencies except for unit testing.
-| When you pulled cglm repo with submodules all dependencies will be pulled too.
-| `build-deps.sh` will pull all dependencies/submodules and build for you.
+| **cglm** does not have external dependencies except for unit testing. When you pulled **cglm** repo with submodules all dependencies will be pulled too. `build-deps.sh` will pull all dependencies/submodules and build for you.
 
 External dependencies:
   * cmocka - for unit testing
@@ -12,7 +10,8 @@ External dependencies:
 If you only need to inline versions, you don't need to build **cglm**, you don't need to link it to your program.
 Just import cglm to your project as dependency / external lib by copy-paste then use it as usual
 
-**Unix (Autotools):**
+Unix (Autotools):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 .. code-block:: bash
   :linenos:
@@ -26,11 +25,12 @@ Just import cglm to your project as dependency / external lib by copy-paste then
   $ [sudo] make install   # install to system (optional)
 
 **make** will build cglm to **.libs** sub folder in project folder.
-If you don't want to install cglm to your system's folder you can get static and dynamic libs in this folder.
+If you don't want to install **cglm** to your system's folder you can get static and dynamic libs in this folder.
 
-**Build dependencies (windows):**
+Windows (MSBuild):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Windows related build files, project files are located in win folder,
+Windows related build files, project files are located in `win` folder,
 make sure you are inside in cglm/win folder.
 
 Code Analysis are enabled, it may take awhile to build.
@@ -50,3 +50,19 @@ then try to build with *devenv*:
   $ devenv cglm.sln /Build Release
 
 Currently tests are not available on Windows.
+
+Documentation (Sphinx):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+**cglm** uses sphinx framework for documentation, it allows lot of formats for documentation. To see all options see sphinx build page:
+
+https://www.sphinx-doc.org/en/master/man/sphinx-build.html
+
+Example build:
+
+.. code-block:: bash
+  :linenos:
+
+  $ cd cglm/docs
+  $ sphinx-build source build
+

docs/source/cam.rst

@@ -36,6 +36,7 @@ Functions:
 #. :c:func:`glm_ortho_default`
 #. :c:func:`glm_ortho_default_s`
 #. :c:func:`glm_perspective`
+#. :c:func:`glm_persp_move_far`
 #. :c:func:`glm_perspective_default`
 #. :c:func:`glm_perspective_resize`
 #. :c:func:`glm_lookat`
@@ -145,6 +146,16 @@ Functions documentation
       | *[in]*  **farVal**  far clipping planes
       | *[out]* **dest**    result matrix
 
+.. c:function:: void  glm_persp_move_far(mat4 proj, float deltaFar)
+
+    | extend perspective projection matrix's far distance
+
+    | this function does not guarantee far >= near, be aware of that!
+
+    Parameters:
+      | *[in, out]*  **proj**      projection matrix to extend
+      | *[in]*       **deltaFar**  distance from existing far (negative to shink)
+
 .. c:function:: void glm_perspective_default(float aspect, mat4 dest)
 
      | set up perspective projection matrix with default near/far

docs/source/conf.py

@@ -62,9 +62,9 @@ author = u'Recep Aslantas'
 # built documents.
 #
 # The short X.Y version.
-version = u'0.5.1'
+version = u'0.5.4'
 # The full version, including alpha/beta/rc tags.
-release = u'0.5.1'
+release = u'0.5.4'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
@@ -90,7 +90,7 @@ todo_include_todos = False
 # The theme to use for HTML and HTML Help pages.  See the documentation for
 # a list of builtin themes.
 #
-html_theme = 'alabaster'
+html_theme = 'sphinx_rtd_theme'
 
 # Theme options are theme-specific and customize the look and feel of a theme
 # further.  For a list of options available for each theme, see the
@@ -99,13 +99,13 @@ html_theme = 'alabaster'
 # html_theme_options = {}
 
 html_theme_options = {
-    'github_banner': 'true',
-    'github_button': 'true',
-    'github_user': 'recp',
-    'github_repo': 'cglm',
-    'travis_button': 'true',
-    'show_related': 'true',
-    'fixed_sidebar': 'true'
+    # 'github_banner': 'true',
+    # 'github_button': 'true',
+    # 'github_user': 'recp',
+    # 'github_repo': 'cglm',
+    # 'travis_button': 'true',
+    # 'show_related': 'true',
+    # 'fixed_sidebar': 'true'
 }
 
 # Add any paths that contain custom static files (such as style sheets) here,

docs/source/curve.rst

@@ -0,0 +1,41 @@
+.. default-domain:: C
+
+Curve
+================================================================================
+
+Header: cglm/curve.h
+
+Common helpers for common curves. For specific curve see its header/doc
+e.g bezier
+
+Table of contents (click to go):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Functions:
+
+1. :c:func:`glm_smc`
+
+Functions documentation
+~~~~~~~~~~~~~~~~~~~~~~~
+
+.. c:function:: float  glm_smc(float s, mat4 m, vec4 c)
+
+    | helper function to calculate **S** * **M** * **C** multiplication for curves
+
+    | this function does not encourage you to use SMC, instead it is a helper if you use SMC.
+
+    | if you want to specify S as vector then use more generic glm_mat4_rmc() func.
+
+    | Example usage:
+
+    .. code-block:: c
+
+       Bs = glm_smc(s, GLM_BEZIER_MAT, (vec4){p0, c0, c1, p1})
+
+    Parameters:
+      | *[in]*  **s**  parameter between 0 and 1 (this will be [s3, s2, s, 1])
+      | *[in]*  **m**  basis matrix
+      | *[out]* **c**  position/control vector
+
+    Returns:
+        scalar value e.g. Bs

docs/source/features.rst

@@ -0,0 +1,23 @@
+Features
+================================================================================
+
+* general purpose matrix operations (mat4, mat3)
+* chain matrix multiplication (square only)
+* general purpose vector operations (cross, dot, rotate, proj, angle...)
+* affine transforms
+* matrix decomposition (extract rotation, scaling factor)
+* optimized affine transform matrices (mul, rigid-body inverse)
+* camera (lookat)
+* projections (ortho, perspective)
+* quaternions
+* euler angles / yaw-pitch-roll to matrix
+* extract euler angles
+* inline or pre-compiled function call
+* frustum (extract view frustum planes, corners...)
+* bounding box (AABB in Frustum (culling), crop, merge...)
+* bounding sphere
+* project, unproject
+* easing functions
+* curves
+* curve interpolation helpers (SMC, deCasteljau...)
+* and other...

docs/source/getting_started.rst

@@ -9,23 +9,26 @@ Types:
 .. code-block:: c
   :linenos:
 
+  typedef float                   vec2[2];
   typedef float                   vec3[3];
   typedef int                    ivec3[3];
-   typedef CGLM_ALIGN(16) float vec4[4];
-
-   typedef vec3 mat3[3];
-   typedef vec4 mat4[4];
-
+  typedef CGLM_ALIGN_IF(16) float vec4[4];
   typedef vec4                    versor;
+  typedef vec3                    mat3[3];
+
+  #ifdef __AVX__
+  typedef CGLM_ALIGN_IF(32) vec4  mat4[4];
+  #else
+  typedef CGLM_ALIGN_IF(16) vec4  mat4[4];
+  #endif
 
 As you can see types don't store extra informations in favor of space.
 You can send these values e.g. matrix to OpenGL directly without casting or calling a function like *value_ptr*
 
-Alignment is Required:
+Alignment Is Required:
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-**vec4** and **mat4** requires 16 byte alignment because vec4 and mat4 operations are
-vectorized by SIMD instructions (SSE/AVX).
+**vec4** and **mat4** requires 16 (32 for **mat4** if AVX is enabled) byte alignment because **vec4** and **mat4** operations are vectorized by SIMD instructions (SSE/AVX/NEON).
 
 **UPDATE:**
   By starting v0.4.5 cglm provides an option to disable alignment requirement, it is enabled as default
@@ -37,10 +40,9 @@ vectorized by SIMD instructions (SSE/AVX).
 Allocations:
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *cglm* doesn't alloc any memory on heap. So it doesn't provide any allocator.
-You must allocate memory yourself. You should alloc memory for out parameters too if you pass pointer of memory location.
-When allocating memory don't forget that **vec4** and **mat4** requires alignment.
+You must allocate memory yourself. You should alloc memory for out parameters too if you pass pointer of memory location. When allocating memory, don't forget that **vec4** and **mat4** require alignment.
 
-**NOTE:** Unaligned vec4 and unaligned mat4 operations will be supported in the future. Check todo list.
+**NOTE:** Unaligned **vec4** and unaligned **mat4** operations will be supported in the future. Check todo list.
 Because you may want to multiply a CGLM matrix with external matrix.
 There is no guarantee that non-CGLM matrix is aligned. Unaligned types will have *u* prefix e.g. **umat4**
 

docs/source/index.rst

@@ -3,7 +3,7 @@
    You can adapt this file completely to your liking, but it should at least
    contain the root `toctree` directive.
 
-Welcome to cglm's documentation!
+cglm Documentation
 ================================
 
 **cglm** is optimized 3D math library written in C99 (compatible with C89).
@@ -14,33 +14,36 @@ is considered to be supported as optional.
 
 Also currently only **float** type is supported for most operations.
 
-**Features**
-
-* general purpose matrix operations (mat4, mat3)
-* chain matrix multiplication (square only)
-* general purpose vector operations (cross, dot, rotate, proj, angle...)
-* affine transforms
-* matrix decomposition (extract rotation, scaling factor)
-* optimized affine transform matrices (mul, rigid-body inverse)
-* camera (lookat)
-* projections (ortho, perspective)
-* quaternions
-* euler angles / yaw-pitch-roll to matrix
-* extract euler angles
-* inline or pre-compiled function call
-* frustum (extract view frustum planes, corners...)
-* bounding box (AABB in Frustum (culling), crop, merge...)
-
-
 .. toctree::
-   :maxdepth: 1
-   :caption: Table Of Contents:
+   :maxdepth: 2
+   :caption: Getting Started:
 
+   features
    build
    getting_started
+
+.. toctree::
+   :maxdepth: 2
+   :caption: How To:
+
    opengl
+
+.. toctree::
+   :maxdepth: 2
+   :caption: API:
+
    api
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Options:
+
    opt
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Troubleshooting:
+
    troubleshooting
 
 Indices and tables

docs/source/mat3.rst

@@ -21,6 +21,7 @@ Functions:
 1. :c:func:`glm_mat3_copy`
 #. :c:func:`glm_mat3_identity`
 #. :c:func:`glm_mat3_identity_array`
+#. :c:func:`glm_mat3_zero`
 #. :c:func:`glm_mat3_mul`
 #. :c:func:`glm_mat3_transpose_to`
 #. :c:func:`glm_mat3_transpose`
@@ -32,6 +33,7 @@ Functions:
 #. :c:func:`glm_mat3_trace`
 #. :c:func:`glm_mat3_swap_col`
 #. :c:func:`glm_mat3_swap_row`
+#. :c:func:`glm_mat3_rmc`
 
 Functions documentation
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -59,6 +61,13 @@ Functions documentation
       | *[in,out]* **mat**  matrix array (must be aligned (16/32) if alignment is not disabled)
       | *[in]* **count**  count of matrices
 
+.. c:function:: void  glm_mat3_zero(mat3 mat)
+
+    make given matrix zero
+
+    Parameters:
+      | *[in,out]* **mat**  matrix to
+
 .. c:function:: void  glm_mat3_mul(mat3 m1, mat3 m2, mat3 dest)
 
     multiply m1 and m2 to dest
@@ -161,3 +170,20 @@ Functions documentation
       | *[in, out]*  **mat**   matrix
       | *[in]*       **row1**  row1
       | *[in]*       **row2**  row2
+
+.. c:function:: float  glm_mat3_rmc(vec3 r, mat3 m, vec3 c)
+
+    | **rmc** stands for **Row** * **Matrix** * **Column**
+
+    | helper for  R (row vector) * M (matrix) * C (column vector)
+
+    | the result is scalar because R * M = Matrix1x3 (row vector),
+    | then Matrix1x3 * Vec3 (column vector) = Matrix1x1 (Scalar)
+
+    Parameters:
+      | *[in]*  **r**  row vector or matrix1x3
+      | *[in]*  **m**  matrix3x3
+      | *[in]*  **c**  column vector or matrix3x1
+
+    Returns:
+        scalar value e.g. Matrix1x1

docs/source/mat4.rst

@@ -26,6 +26,7 @@ Functions:
 #. :c:func:`glm_mat4_copy`
 #. :c:func:`glm_mat4_identity`
 #. :c:func:`glm_mat4_identity_array`
+#. :c:func:`glm_mat4_zero`
 #. :c:func:`glm_mat4_pick3`
 #. :c:func:`glm_mat4_pick3t`
 #. :c:func:`glm_mat4_ins3`
@@ -45,6 +46,7 @@ Functions:
 #. :c:func:`glm_mat4_inv_fast`
 #. :c:func:`glm_mat4_swap_col`
 #. :c:func:`glm_mat4_swap_row`
+#. :c:func:`glm_mat4_rmc`
 
 Functions documentation
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -80,6 +82,13 @@ Functions documentation
       | *[in,out]* **mat**  matrix array (must be aligned (16/32) if alignment is not disabled)
       | *[in]* **count**  count of matrices
 
+.. c:function:: void  glm_mat4_zero(mat4 mat)
+
+    make given matrix zero
+
+    Parameters:
+      | *[in,out]* **mat**  matrix to
+
 .. c:function:: void  glm_mat4_pick3(mat4 mat, mat3 dest)
 
     copy upper-left of mat4 to mat3
@@ -270,3 +279,20 @@ Functions documentation
       | *[in, out]*  **mat**   matrix
       | *[in]*       **row1**  row1
       | *[in]*       **row2**  row2
+
+.. c:function:: float  glm_mat4_rmc(vec4 r, mat4 m, vec4 c)
+
+    | **rmc** stands for **Row** * **Matrix** * **Column**
+
+    | helper for  R (row vector) * M (matrix) * C (column vector)
+
+    | the result is scalar because R * M = Matrix1x4 (row vector),
+    | then Matrix1x4 * Vec4 (column vector) = Matrix1x1 (Scalar)
+
+    Parameters:
+      | *[in]*  **r**  row vector or matrix1x4
+      | *[in]*  **m**  matrix4x4
+      | *[in]*  **c**  column vector or matrix4x1
+
+    Returns:
+        scalar value e.g. Matrix1x1

docs/source/opengl.rst

@@ -45,7 +45,7 @@ array of matrices:
 
 in this way, passing aray of matrices is same
 
-Passing / Uniforming Vectors to OpenGL:¶
+Passing / Uniforming Vectors to OpenGL:
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 You don't need to do extra thing when passing cglm vectors to OpengL or other APIs.

docs/source/opt.rst

@@ -40,3 +40,13 @@ SSE and SSE2 Shuffle Option
 **_mm_shuffle_ps** generates **shufps** instruction even if registers are same.
 You can force it to generate **pshufd** instruction by defining
 **CGLM_USE_INT_DOMAIN** macro. As default it is not defined.
+
+SSE3 and SSE4 Dot Product Options
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+You have to extra options for dot product: **CGLM_SSE4_DOT** and **CGLM_SSE3_DOT**.
+
+- If **SSE4** is enabled then you can define **CGLM_SSE4_DOT** to force cglm to use **_mm_dp_ps** instruction.
+- If **SSE3** is enabled then you can define **CGLM_SSE3_DOT** to force cglm to use **_mm_hadd_ps** instructions.
+
+otherwise cglm will use custom cglm's hadd functions which are optimized too.

docs/source/vec4.rst

@@ -58,11 +58,7 @@ Functions:
 #. :c:func:`glm_vec4_minv`
 #. :c:func:`glm_vec4_clamp`
 #. :c:func:`glm_vec4_lerp`
-#. :c:func:`glm_vec4_isnan`
-#. :c:func:`glm_vec4_isinf`
-#. :c:func:`glm_vec4_isvalid`
-#. :c:func:`glm_vec4_sign`
-#. :c:func:`glm_vec4_sqrt`
+#. :c:func:`glm_vec4_cubic`
 
 Functions documentation
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -401,3 +397,11 @@ Functions documentation
       | *[in]*  **to**     to value
       | *[in]*  **t**      interpolant (amount) clamped between 0 and 1
       | *[out]* **dest**   destination
+
+.. c:function:: void  glm_vec4_cubic(float s, vec4 dest)
+
+    helper to fill vec4 as [S^3, S^2, S, 1]
+
+    Parameters:
+      | *[in]*  **s**      parameter
+      | *[out]* **dest**   destination

include/cglm/affine-mat.h

@@ -44,7 +44,7 @@
  */
 CGLM_INLINE
 void
-glm_mul(mat4 m1, mat4 m2, mat4 dest) {
+glm_mul(const mat4 m1, const mat4 m2, mat4 dest) {
 #ifdef __AVX__
   glm_mul_avx(m1, m2, dest);
 #elif defined( __SSE__ ) || defined( __SSE2__ )
@@ -100,7 +100,7 @@ glm_mul(mat4 m1, mat4 m2, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_mul_rot(mat4 m1, mat4 m2, mat4 dest) {
+glm_mul_rot(const mat4 m1, const mat4 m2, mat4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glm_mul_rot_sse2(m1, m2, dest);
 #else
@@ -152,7 +152,7 @@ glm_inv_tr(mat4 mat) {
   glm_inv_tr_sse2(mat);
 #else
   CGLM_ALIGN_MAT mat3 r;
-  CGLM_ALIGN(16) vec3 t;
+  CGLM_ALIGN(8)  vec3 t;
 
   /* rotate */
   glm_mat4_pick3t(mat, r);

include/cglm/affine.h

@@ -42,7 +42,7 @@
 
 CGLM_INLINE
 void
-glm_mat4_mul(mat4 m1, mat4 m2, mat4 dest);
+glm_mat4_mul(const mat4 m1, const mat4 m2, mat4 dest);
 
 /*!
  * @brief translate existing transform matrix by v vector
@@ -53,7 +53,7 @@ glm_mat4_mul(mat4 m1, mat4 m2, mat4 dest);
  */
 CGLM_INLINE
 void
-glm_translate(mat4 m, vec3 v) {
+glm_translate(mat4 m, const vec3 v) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(m[3],
              _mm_add_ps(_mm_add_ps(_mm_mul_ps(glmm_load(m[0]),
@@ -89,7 +89,7 @@ glm_translate(mat4 m, vec3 v) {
  */
 CGLM_INLINE
 void
-glm_translate_to(mat4 m, vec3 v, mat4 dest) {
+glm_translate_to(const mat4 m, const vec3 v, mat4 dest) {
   glm_mat4_copy(m, dest);
   glm_translate(dest, v);
 }
@@ -168,7 +168,7 @@ glm_translate_z(mat4 m, float z) {
  */
 CGLM_INLINE
 void
-glm_translate_make(mat4 m, vec3 v) {
+glm_translate_make(mat4 m, const vec3 v) {
   glm_mat4_identity(m);
   glm_vec3_copy(v, m[3]);
 }
@@ -183,7 +183,7 @@ glm_translate_make(mat4 m, vec3 v) {
  */
 CGLM_INLINE
 void
-glm_scale_to(mat4 m, vec3 v, mat4 dest) {
+glm_scale_to(const mat4 m, const vec3 v, mat4 dest) {
   glm_vec4_scale(m[0], v[0], dest[0]);
   glm_vec4_scale(m[1], v[1], dest[1]);
   glm_vec4_scale(m[2], v[2], dest[2]);
@@ -199,7 +199,7 @@ glm_scale_to(mat4 m, vec3 v, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_scale_make(mat4 m, vec3 v) {
+glm_scale_make(mat4 m, const vec3 v) {
   glm_mat4_identity(m);
   m[0][0] = v[0];
   m[1][1] = v[1];
@@ -215,7 +215,7 @@ glm_scale_make(mat4 m, vec3 v) {
  */
 CGLM_INLINE
 void
-glm_scale(mat4 m, vec3 v) {
+glm_scale(mat4 m, const vec3 v) {
   glm_scale_to(m, v, m);
 }
 
@@ -243,7 +243,7 @@ glm_scale_uni(mat4 m, float s) {
  */
 CGLM_INLINE
 void
-glm_rotate_x(mat4 m, float angle, mat4 dest) {
+glm_rotate_x(const mat4 m, float angle, mat4 dest) {
   CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
   float c, s;
 
@@ -268,7 +268,7 @@ glm_rotate_x(mat4 m, float angle, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_rotate_y(mat4 m, float angle, mat4 dest) {
+glm_rotate_y(const mat4 m, float angle, mat4 dest) {
   CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
   float c, s;
 
@@ -293,7 +293,7 @@ glm_rotate_y(mat4 m, float angle, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_rotate_z(mat4 m, float angle, mat4 dest) {
+glm_rotate_z(const mat4 m, float angle, mat4 dest) {
   CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
   float c, s;
 
@@ -319,7 +319,7 @@ glm_rotate_z(mat4 m, float angle, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_rotate_make(mat4 m, float angle, vec3 axis) {
+glm_rotate_make(mat4 m, float angle, const vec3 axis) {
   CGLM_ALIGN(8) vec3 axisn, v, vs;
   float c;
 
@@ -350,7 +350,7 @@ glm_rotate_make(mat4 m, float angle, vec3 axis) {
  */
 CGLM_INLINE
 void
-glm_rotate(mat4 m, float angle, vec3 axis) {
+glm_rotate(mat4 m, float angle, const vec3 axis) {
   CGLM_ALIGN_MAT mat4 rot;
   glm_rotate_make(rot, angle, axis);
   glm_mul_rot(m, rot, m);
@@ -367,7 +367,7 @@ glm_rotate(mat4 m, float angle, vec3 axis) {
  */
 CGLM_INLINE
 void
-glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis) {
+glm_rotate_at(mat4 m, const vec3 pivot, float angle, const vec3 axis) {
   CGLM_ALIGN(8) vec3 pivotInv;
 
   glm_vec3_negate_to(pivot, pivotInv);
@@ -392,7 +392,7 @@ 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) {
+glm_rotate_atm(mat4 m, const vec3 pivot, float angle, const vec3 axis) {
   CGLM_ALIGN(8) vec3 pivotInv;
 
   glm_vec3_negate_to(pivot, pivotInv);
@@ -410,7 +410,7 @@ glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis) {
  */
 CGLM_INLINE
 void
-glm_decompose_scalev(mat4 m, vec3 s) {
+glm_decompose_scalev(const mat4 m, vec3 s) {
   s[0] = glm_vec3_norm(m[0]);
   s[1] = glm_vec3_norm(m[1]);
   s[2] = glm_vec3_norm(m[2]);
@@ -426,7 +426,7 @@ glm_decompose_scalev(mat4 m, vec3 s) {
  */
 CGLM_INLINE
 bool
-glm_uniscaled(mat4 m) {
+glm_uniscaled(const mat4 m) {
   CGLM_ALIGN(8) vec3 s;
   glm_decompose_scalev(m, s);
   return glm_vec3_eq_all(s);
@@ -442,7 +442,7 @@ glm_uniscaled(mat4 m) {
  */
 CGLM_INLINE
 void
-glm_decompose_rs(mat4 m, mat4 r, vec3 s) {
+glm_decompose_rs(const mat4 m, mat4 r, vec3 s) {
   CGLM_ALIGN(16) vec4 t = {0.0f, 0.0f, 0.0f, 1.0f};
   CGLM_ALIGN(8)  vec3 v;
 
@@ -482,7 +482,7 @@ glm_decompose_rs(mat4 m, mat4 r, vec3 s) {
  */
 CGLM_INLINE
 void
-glm_decompose(mat4 m, vec4 t, mat4 r, vec3 s) {
+glm_decompose(const mat4 m, vec4 t, mat4 r, vec3 s) {
   glm_vec4_copy(m[3], t);
   glm_decompose_rs(m, r, s);
 }

include/cglm/bezier.h

@@ -0,0 +1,154 @@
+/*
+ * 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"
+
+#define GLM_BEZIER_MAT_INIT  {{-1.0f,  3.0f, -3.0f,  1.0f},                   \
+                              { 3.0f, -6.0f,  3.0f,  0.0f},                   \
+                              {-3.0f,  3.0f,  0.0f,  0.0f},                   \
+                              { 1.0f,  0.0f,  0.0f,  0.0f}}
+#define GLM_HERMITE_MAT_INIT {{ 2.0f, -3.0f,  0.0f,  1.0f},                   \
+                              {-2.0f,  3.0f,  0.0f,  0.0f},                   \
+                              { 1.0f, -2.0f,  1.0f,  0.0f},                   \
+                              { 1.0f, -1.0f,  0.0f,  0.0f}}
+/* for C only */
+#define GLM_BEZIER_MAT  ((mat4)GLM_BEZIER_MAT_INIT)
+#define GLM_HERMITE_MAT ((mat4)GLM_HERMITE_MAT_INIT)
+
+#define CGLM_DECASTEL_EPS   1e-9
+#define CGLM_DECASTEL_MAX   1000
+#define CGLM_DECASTEL_SMALL 1e-20
+
+/*!
+ * @brief cubic bezier interpolation
+ *
+ * Formula:
+ *  B(s) = P0*(1-s)^3 + 3*C0*s*(1-s)^2 + 3*C1*s^2*(1-s) + P1*s^3
+ *
+ * similar result using matrix:
+ *  B(s) = glm_smc(t, GLM_BEZIER_MAT, (vec4){p0, c0, c1, p1})
+ *
+ * glm_eq(glm_smc(...), glm_bezier(...)) should return TRUE
+ *
+ * @param[in]  s    parameter 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(float s, float p0, float c0, float c1, float p1) {
+  float x, xx, ss, xs3, a;
+
+  x   = 1.0f - s;
+  xx  = x * x;
+  ss  = s * s;
+  xs3 = (s - ss) * 3.0f;
+  a   = p0 * xx + c0 * xs3;
+
+  return a + s * (c1 * xs3 + p1 * ss - a);
+}
+
+/*!
+ * @brief cubic hermite interpolation
+ *
+ * Formula:
+ *  H(s) = P0*(2*s^3 - 3*s^2 + 1) + T0*(s^3 - 2*s^2 + s)
+ *            + P1*(-2*s^3 + 3*s^2) + T1*(s^3 - s^2)
+ *
+ * similar result using matrix:
+ *  H(s) = glm_smc(t, GLM_HERMITE_MAT, (vec4){p0, p1, c0, c1})
+ *
+ * glm_eq(glm_smc(...), glm_hermite(...)) should return TRUE
+ *
+ * @param[in]  s    parameter 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 H(s)
+ */
+CGLM_INLINE
+float
+glm_hermite(float s, float p0, float t0, float t1, float p1) {
+  float ss, d, a, b, c, e, f;
+
+  ss = s  * s;
+  a  = ss + ss;
+  c  = a  + ss;
+  b  = a  * s;
+  d  = s  * ss;
+  f  = d  - ss;
+  e  = b  - c;
+
+  return p0 * (e + 1.0f) + t0 * (f - ss + s) + t1 * f - p1 * e;
+}
+
+/*!
+ * @brief iterative way to solve cubic equation
+ *
+ * @param[in]  prm  parameter 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 parameter to use in cubic equation
+ */
+CGLM_INLINE
+float
+glm_decasteljau(float prm, float p0, float c0, float c1, float p1) {
+  float u, v, a, b, c, d, e, f;
+  int   i;
+
+  if (prm - p0 < CGLM_DECASTEL_SMALL)
+    return 0.0f;
+
+  if (p1 - prm < CGLM_DECASTEL_SMALL)
+    return 1.0f;
+
+  u  = 0.0f;
+  v  = 1.0f;
+
+  for (i = 0; i < CGLM_DECASTEL_MAX; i++) {
+    /* de Casteljau Subdivision */
+    a  = (p0 + c0) * 0.5f;
+    b  = (c0 + c1) * 0.5f;
+    c  = (c1 + p1) * 0.5f;
+    d  = (a  + b)  * 0.5f;
+    e  = (b  + c)  * 0.5f;
+    f  = (d  + e)  * 0.5f; /* this one is on the curve! */
+
+    /* The curve point is close enough to our wanted t */
+    if (fabsf(f - prm) < CGLM_DECASTEL_EPS)
+      return glm_clamp_zo((u  + v) * 0.5f);
+
+    /* dichotomy */
+    if (f < prm) {
+      p0 = f;
+      c0 = e;
+      c1 = c;
+      u  = (u  + v) * 0.5f;
+    } else {
+      c0 = a;
+      c1 = d;
+      p1 = f;
+      v  = (u  + v) * 0.5f;
+    }
+  }
+
+  return glm_clamp_zo((u  + v) * 0.5f);
+}
+
+#endif /* cglm_bezier_h */

include/cglm/box.h

@@ -22,7 +22,7 @@
  */
 CGLM_INLINE
 void
-glm_aabb_transform(vec3 box[2], mat4 m, vec3 dest[2]) {
+glm_aabb_transform(const vec3 box[2], const mat4 m, vec3 dest[2]) {
   vec3 v[2], xa, xb, ya, yb, za, zb;
 
   glm_vec3_scale(m[0], box[0][0], xa);
@@ -62,7 +62,7 @@ glm_aabb_transform(vec3 box[2], mat4 m, vec3 dest[2]) {
  */
 CGLM_INLINE
 void
-glm_aabb_merge(vec3 box1[2], vec3 box2[2], vec3 dest[2]) {
+glm_aabb_merge(const vec3 box1[2], const vec3 box2[2], vec3 dest[2]) {
   dest[0][0] = glm_min(box1[0][0], box2[0][0]);
   dest[0][1] = glm_min(box1[0][1], box2[0][1]);
   dest[0][2] = glm_min(box1[0][2], box2[0][2]);
@@ -85,7 +85,7 @@ glm_aabb_merge(vec3 box1[2], vec3 box2[2], vec3 dest[2]) {
  */
 CGLM_INLINE
 void
-glm_aabb_crop(vec3 box[2], vec3 cropBox[2], vec3 dest[2]) {
+glm_aabb_crop(const vec3 box[2], const vec3 cropBox[2], vec3 dest[2]) {
   dest[0][0] = glm_max(box[0][0], cropBox[0][0]);
   dest[0][1] = glm_max(box[0][1], cropBox[0][1]);
   dest[0][2] = glm_max(box[0][2], cropBox[0][2]);
@@ -109,9 +109,9 @@ glm_aabb_crop(vec3 box[2], vec3 cropBox[2], vec3 dest[2]) {
  */
 CGLM_INLINE
 void
-glm_aabb_crop_until(vec3 box[2],
-                    vec3 cropBox[2],
-                    vec3 clampBox[2],
+glm_aabb_crop_until(const vec3 box[2],
+                    const vec3 cropBox[2],
+                    const vec3 clampBox[2],
                     vec3       dest[2]) {
   glm_aabb_crop(box, cropBox, dest);
   glm_aabb_merge(clampBox, dest, dest);
@@ -133,8 +133,9 @@ glm_aabb_crop_until(vec3 box[2],
  */
 CGLM_INLINE
 bool
-glm_aabb_frustum(vec3 box[2], vec4 planes[6]) {
-  float *p, dp;
+glm_aabb_frustum(const vec3 box[2], const vec4 planes[6]) {
+  const float *p;
+  float       dp;
   int         i;
 
   for (i = 0; i < 6; i++) {
@@ -169,7 +170,7 @@ glm_aabb_invalidate(vec3 box[2]) {
  */
 CGLM_INLINE
 bool
-glm_aabb_isvalid(vec3 box[2]) {
+glm_aabb_isvalid(const vec3 box[2]) {
   return glm_vec3_max(box[0]) != FLT_MAX
          && glm_vec3_min(box[1]) != -FLT_MAX;
 }
@@ -181,7 +182,7 @@ glm_aabb_isvalid(vec3 box[2]) {
  */
 CGLM_INLINE
 float
-glm_aabb_size(vec3 box[2]) {
+glm_aabb_size(const vec3 box[2]) {
   return glm_vec3_distance(box[0], box[1]);
 }
 
@@ -192,7 +193,7 @@ glm_aabb_size(vec3 box[2]) {
  */
 CGLM_INLINE
 float
-glm_aabb_radius(vec3 box[2]) {
+glm_aabb_radius(const vec3 box[2]) {
   return glm_aabb_size(box) * 0.5f;
 }
 
@@ -204,7 +205,7 @@ glm_aabb_radius(vec3 box[2]) {
  */
 CGLM_INLINE
 void
-glm_aabb_center(vec3 box[2], vec3 dest) {
+glm_aabb_center(const vec3 box[2], vec3 dest) {
   glm_vec3_center(box[0], box[1], dest);
 }
 
@@ -216,7 +217,7 @@ glm_aabb_center(vec3 box[2], vec3 dest) {
  */
 CGLM_INLINE
 bool
-glm_aabb_aabb(vec3 box[2], vec3 other[2]) {
+glm_aabb_aabb(const vec3 box[2], const 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]);
@@ -233,7 +234,7 @@ glm_aabb_aabb(vec3 box[2], vec3 other[2]) {
  */
 CGLM_INLINE
 bool
-glm_aabb_sphere(vec3 box[2], vec4 s) {
+glm_aabb_sphere(const vec3 box[2], const vec4 s) {
   float dmin;
   int   a, b, c;
 
@@ -256,7 +257,7 @@ glm_aabb_sphere(vec3 box[2], vec4 s) {
  */
 CGLM_INLINE
 bool
-glm_aabb_point(vec3 box[2], vec3 point) {
+glm_aabb_point(const vec3 box[2], const 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]);
@@ -270,7 +271,7 @@ glm_aabb_point(vec3 box[2], vec3 point) {
  */
 CGLM_INLINE
 bool
-glm_aabb_contains(vec3 box[2], vec3 other[2]) {
+glm_aabb_contains(const vec3 box[2], const 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]);

include/cglm/call.h

@@ -27,6 +27,8 @@ extern "C" {
 #include "call/project.h"
 #include "call/sphere.h"
 #include "call/ease.h"
+#include "call/curve.h"
+#include "call/bezier.h"
 
 #ifdef __cplusplus
 }

include/cglm/call/affine.h

@@ -15,15 +15,15 @@ extern "C" {
 
 CGLM_EXPORT
 void
-glmc_translate_make(mat4 m, vec3 v);
+glmc_translate_make(mat4 m, const vec3 v);
 
 CGLM_EXPORT
 void
-glmc_translate_to(mat4 m, vec3 v, mat4 dest);
+glmc_translate_to(const mat4 m, const vec3 v, mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_translate(mat4 m, vec3 v);
+glmc_translate(mat4 m, const vec3 v);
 
 CGLM_EXPORT
 void
@@ -39,15 +39,15 @@ glmc_translate_z(mat4 m, float to);
 
 CGLM_EXPORT
 void
-glmc_scale_make(mat4 m, vec3 v);
+glmc_scale_make(mat4 m, const vec3 v);
 
 CGLM_EXPORT
 void
-glmc_scale_to(mat4 m, vec3 v, mat4 dest);
+glmc_scale_to(const mat4 m, const vec3 v, mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_scale(mat4 m, vec3 v);
+glmc_scale(mat4 m, const vec3 v);
 
 CGLM_EXPORT
 void
@@ -55,57 +55,57 @@ glmc_scale_uni(mat4 m, float s);
 
 CGLM_EXPORT
 void
-glmc_rotate_x(mat4 m, float rad, mat4 dest);
+glmc_rotate_x(const mat4 m, float rad, mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_rotate_y(mat4 m, float rad, mat4 dest);
+glmc_rotate_y(const mat4 m, float rad, mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_rotate_z(mat4 m, float rad, mat4 dest);
+glmc_rotate_z(const mat4 m, float rad, mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_rotate_make(mat4 m, float angle, vec3 axis);
+glmc_rotate_make(mat4 m, float angle, const vec3 axis);
 
 CGLM_EXPORT
 void
-glmc_rotate(mat4 m, float angle, vec3 axis);
+glmc_rotate(mat4 m, float angle, const vec3 axis);
 
 CGLM_EXPORT
 void
-glmc_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis);
+glmc_rotate_at(mat4 m, const vec3 pivot, float angle, const vec3 axis);
 
 CGLM_EXPORT
 void
-glmc_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis);
+glmc_rotate_atm(mat4 m, const vec3 pivot, float angle, const vec3 axis);
 
 CGLM_EXPORT
 void
-glmc_decompose_scalev(mat4 m, vec3 s);
+glmc_decompose_scalev(const mat4 m, vec3 s);
 
 CGLM_EXPORT
 bool
-glmc_uniscaled(mat4 m);
+glmc_uniscaled(const mat4 m);
 
 CGLM_EXPORT
 void
-glmc_decompose_rs(mat4 m, mat4 r, vec3 s);
+glmc_decompose_rs(const mat4 m, mat4 r, vec3 s);
 
 CGLM_EXPORT
 void
-glmc_decompose(mat4 m, vec4 t, mat4 r, vec3 s);
+glmc_decompose(const mat4 m, vec4 t, mat4 r, vec3 s);
 
 /* affine-mat */
 
 CGLM_EXPORT
 void
-glmc_mul(mat4 m1, mat4 m2, mat4 dest);
+glmc_mul(const mat4 m1, const mat4 m2, mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_mul_rot(mat4 m1, mat4 m2, mat4 dest);
+glmc_mul_rot(const mat4 m1, const mat4 m2, mat4 dest);
 
 CGLM_EXPORT
 void

include/cglm/call/bezier.h

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_bezier_h
+#define cglmc_bezier_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+float
+glmc_bezier(float s, float p0, float c0, float c1, float p1);
+
+CGLM_EXPORT
+float
+glmc_hermite(float s, float p0, float t0, float t1, float p1);
+
+CGLM_EXPORT
+float
+glmc_decasteljau(float prm, float p0, float c0, float c1, float p1);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_bezier_h */

include/cglm/call/box.h

@@ -15,26 +15,26 @@ extern "C" {
 
 CGLM_EXPORT
 void
-glmc_aabb_transform(vec3 box[2], mat4 m, vec3 dest[2]);
+glmc_aabb_transform(const vec3 box[2], const mat4 m, vec3 dest[2]);
 
 CGLM_EXPORT
 void
-glmc_aabb_merge(vec3 box1[2], vec3 box2[2], vec3 dest[2]);
+glmc_aabb_merge(const vec3 box1[2], const vec3 box2[2], vec3 dest[2]);
 
 CGLM_EXPORT
 void
-glmc_aabb_crop(vec3 box[2], vec3 cropBox[2], vec3 dest[2]);
+glmc_aabb_crop(const vec3 box[2], const vec3 cropBox[2], vec3 dest[2]);
 
 CGLM_EXPORT
 void
-glmc_aabb_crop_until(vec3 box[2],
-                     vec3 cropBox[2],
-                     vec3 clampBox[2],
+glmc_aabb_crop_until(const vec3 box[2],
+                     const vec3 cropBox[2],
+                     const vec3 clampBox[2],
                      vec3       dest[2]);
 
 CGLM_EXPORT
 bool
-glmc_aabb_frustum(vec3 box[2], vec4 planes[6]);
+glmc_aabb_frustum(const vec3 box[2], vec4 planes[6]);
 
 CGLM_EXPORT
 void
@@ -42,35 +42,35 @@ glmc_aabb_invalidate(vec3 box[2]);
 
 CGLM_EXPORT
 bool
-glmc_aabb_isvalid(vec3 box[2]);
+glmc_aabb_isvalid(const vec3 box[2]);
 
 CGLM_EXPORT
 float
-glmc_aabb_size(vec3 box[2]);
+glmc_aabb_size(const vec3 box[2]);
 
 CGLM_EXPORT
 float
-glmc_aabb_radius(vec3 box[2]);
+glmc_aabb_radius(const vec3 box[2]);
 
 CGLM_EXPORT
 void
-glmc_aabb_center(vec3 box[2], vec3 dest);
+glmc_aabb_center(const vec3 box[2], vec3 dest);
 
 CGLM_EXPORT
 bool
-glmc_aabb_aabb(vec3 box[2], vec3 other[2]);
+glmc_aabb_aabb(const vec3 box[2], const vec3 other[2]);
 
 CGLM_EXPORT
 bool
-glmc_aabb_point(vec3 box[2], vec3 point);
+glmc_aabb_point(const vec3 box[2], const vec3 point);
 
 CGLM_EXPORT
 bool
-glmc_aabb_contains(vec3 box[2], vec3 other[2]);
+glmc_aabb_contains(const vec3 box[2], const vec3 other[2]);
 
 CGLM_EXPORT
 bool
-glmc_aabb_sphere(vec3 box[2], vec4 s);
+glmc_aabb_sphere(const vec3 box[2], const vec4 s);
 
 #ifdef __cplusplus
 }

include/cglm/call/cam.h

@@ -35,15 +35,15 @@ glmc_ortho(float left,
 
 CGLM_EXPORT
 void
-glmc_ortho_aabb(vec3 box[2], mat4 dest);
+glmc_ortho_aabb(const vec3 box[2], mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_ortho_aabb_p(vec3 box[2], float padding, mat4 dest);
+glmc_ortho_aabb_p(const vec3 box[2], float padding, mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_ortho_aabb_pz(vec3 box[2], float padding, mat4 dest);
+glmc_ortho_aabb_pz(const vec3 box[2], float padding, mat4 dest);
 
 CGLM_EXPORT
 void
@@ -61,6 +61,10 @@ glmc_perspective(float fovy,
                  float farVal,
                  mat4  dest);
 
+CGLM_EXPORT
+void
+glmc_persp_move_far(mat4 proj, float deltaFar);
+
 CGLM_EXPORT
 void
 glmc_perspective_default(float aspect, mat4 dest);
@@ -71,19 +75,19 @@ glmc_perspective_resize(float aspect, mat4 proj);
 
 CGLM_EXPORT
 void
-glmc_lookat(vec3 eye, vec3 center, vec3 up, mat4 dest);
+glmc_lookat(const vec3 eye, const vec3 center, const vec3 up, mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_look(vec3 eye, vec3 dir, vec3 up, mat4 dest);
+glmc_look(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_look_anyup(vec3 eye, vec3 dir, mat4 dest);
+glmc_look_anyup(const vec3 eye, const vec3 dir, mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_persp_decomp(mat4 proj,
+glmc_persp_decomp(const mat4 proj,
                   float * __restrict nearVal,
                   float * __restrict farVal,
                   float * __restrict top,
@@ -93,45 +97,45 @@ glmc_persp_decomp(mat4 proj,
 
 CGLM_EXPORT
 void
-glmc_persp_decompv(mat4 proj, float dest[6]);
+glmc_persp_decompv(const mat4 proj, float dest[6]);
 
 CGLM_EXPORT
 void
-glmc_persp_decomp_x(mat4 proj,
+glmc_persp_decomp_x(const mat4 proj,
                     float * __restrict left,
                     float * __restrict right);
 
 CGLM_EXPORT
 void
-glmc_persp_decomp_y(mat4 proj,
+glmc_persp_decomp_y(const mat4 proj,
                     float * __restrict top,
                     float * __restrict bottom);
 
 CGLM_EXPORT
 void
-glmc_persp_decomp_z(mat4 proj,
+glmc_persp_decomp_z(const mat4 proj,
                     float * __restrict nearVal,
                     float * __restrict farVal);
 
 CGLM_EXPORT
 void
-glmc_persp_decomp_far(mat4 proj, float * __restrict farVal);
+glmc_persp_decomp_far(const mat4 proj, float * __restrict farVal);
 
 CGLM_EXPORT
 void
-glmc_persp_decomp_near(mat4 proj, float * __restrict nearVal);
+glmc_persp_decomp_near(const mat4 proj, float * __restrict nearVal);
 
 CGLM_EXPORT
 float
-glmc_persp_fovy(mat4 proj);
+glmc_persp_fovy(const mat4 proj);
 
 CGLM_EXPORT
 float
-glmc_persp_aspect(mat4 proj);
+glmc_persp_aspect(const mat4 proj);
 
 CGLM_EXPORT
 void
-glmc_persp_sizes(mat4 proj, float fovy, vec4 dest);
+glmc_persp_sizes(const mat4 proj, float fovy, vec4 dest);
 
 #ifdef __cplusplus
 }

include/cglm/call/curve.h

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_curve_h
+#define cglmc_curve_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+float
+glmc_smc(float s, const mat4 m, const vec4 c);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_curve_h */

include/cglm/call/ease.h

@@ -137,4 +137,7 @@ CGLM_EXPORT
 float
 glmc_ease_bounce_inout(float t);
 
+#ifdef __cplusplus
+}
+#endif
 #endif /* cglmc_ease_h */

include/cglm/call/euler.h

@@ -15,39 +15,39 @@ extern "C" {
 
 CGLM_EXPORT
 void
-glmc_euler_angles(mat4 m, vec3 dest);
+glmc_euler_angles(const mat4 m, vec3 dest);
 
 CGLM_EXPORT
 void
-glmc_euler(vec3 angles, mat4 dest);
+glmc_euler(const vec3 angles, mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_euler_xyz(vec3 angles,  mat4 dest);
+glmc_euler_xyz(const vec3 angles,  mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_euler_zyx(vec3 angles,  mat4 dest);
+glmc_euler_zyx(const vec3 angles,  mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_euler_zxy(vec3 angles, mat4 dest);
+glmc_euler_zxy(const vec3 angles, mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_euler_xzy(vec3 angles, mat4 dest);
+glmc_euler_xzy(const vec3 angles, mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_euler_yzx(vec3 angles, mat4 dest);
+glmc_euler_yzx(const vec3 angles, mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_euler_yxz(vec3 angles, mat4 dest);
+glmc_euler_yxz(const vec3 angles, mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_euler_by_order(vec3 angles, glm_euler_sq axis, mat4 dest);
+glmc_euler_by_order(const vec3 angles, glm_euler_sq axis, mat4 dest);
 
 #ifdef __cplusplus
 }

include/cglm/call/frustum.h

@@ -15,23 +15,23 @@ extern "C" {
 
 CGLM_EXPORT
 void
-glmc_frustum_planes(mat4 m, vec4 dest[6]);
+glmc_frustum_planes(const mat4 m, vec4 dest[6]);
 
 CGLM_EXPORT
 void
-glmc_frustum_corners(mat4 invMat, vec4 dest[8]);
+glmc_frustum_corners(const mat4 invMat, vec4 dest[8]);
 
 CGLM_EXPORT
 void
-glmc_frustum_center(vec4 corners[8], vec4 dest);
+glmc_frustum_center(const vec4 corners[8], vec4 dest);
 
 CGLM_EXPORT
 void
-glmc_frustum_box(vec4 corners[8], mat4 m, vec3 box[2]);
+glmc_frustum_box(const vec4 corners[8], const mat4 m, vec3 box[2]);
 
 CGLM_EXPORT
 void
-glmc_frustum_corners_at(vec4  corners[8],
+glmc_frustum_corners_at(const vec4 corners[8],
                         float      splitDist,
                         float      farDist,
                         vec4       planeCorners[4]);

include/cglm/call/io.h

@@ -15,28 +15,28 @@ extern "C" {
 
 CGLM_EXPORT
 void
-glmc_mat4_print(mat4   matrix,
-                FILE * __restrict ostream);
+glmc_mat4_print(const mat4   matrix,
+                FILE * const __restrict ostream);
 
 CGLM_EXPORT
 void
-glmc_mat3_print(mat3 matrix,
-                FILE * __restrict ostream);
+glmc_mat3_print(const mat3 matrix,
+                FILE * const __restrict ostream);
 
 CGLM_EXPORT
 void
-glmc_vec4_print(vec4 vec,
-                FILE * __restrict ostream);
+glmc_vec4_print(const vec4 vec,
+                FILE * const __restrict ostream);
 
 CGLM_EXPORT
 void
-glmc_vec3_print(vec3 vec,
-                FILE * __restrict ostream);
+glmc_vec3_print(const vec3 vec,
+                FILE * const __restrict ostream);
 
 CGLM_EXPORT
 void
-glmc_versor_print(versor vec,
-                  FILE * __restrict ostream);
+glmc_versor_print(const versor vec,
+                  FILE * const __restrict ostream);
 
 #ifdef __cplusplus
 }

include/cglm/call/mat3.h

@@ -18,7 +18,7 @@ extern "C" {
 
 CGLM_EXPORT
 void
-glmc_mat3_copy(mat3 mat, mat3 dest);
+glmc_mat3_copy(const mat3 mat, mat3 dest);
 
 CGLM_EXPORT
 void
@@ -26,15 +26,15 @@ glmc_mat3_identity(mat3 mat);
 
 CGLM_EXPORT
 void
-glmc_mat3_identity_array(mat3 * __restrict mat, size_t count);
+glmc_mat3_identity_array(mat3 * const __restrict mat, size_t count);
 
 CGLM_EXPORT
 void
-glmc_mat3_mul(mat3 m1, mat3 m2, mat3 dest);
+glmc_mat3_mul(const mat3 m1, const mat3 m2, mat3 dest);
 
 CGLM_EXPORT
 void
-glmc_mat3_transpose_to(mat3 m, mat3 dest);
+glmc_mat3_transpose_to(const mat3 m, mat3 dest);
 
 CGLM_EXPORT
 void
@@ -42,15 +42,15 @@ glmc_mat3_transpose(mat3 m);
 
 CGLM_EXPORT
 void
-glmc_mat3_mulv(mat3 m, vec3 v, vec3 dest);
+glmc_mat3_mulv(const mat3 m, const vec3 v, vec3 dest);
 
 CGLM_EXPORT
 float
-glmc_mat3_trace(mat3 m);
+glmc_mat3_trace(const mat3 m);
 
 CGLM_EXPORT
 void
-glmc_mat3_quat(mat3 m, versor dest);
+glmc_mat3_quat(const mat3 m, versor dest);
 
 CGLM_EXPORT
 void
@@ -58,11 +58,11 @@ glmc_mat3_scale(mat3 m, float s);
 
 CGLM_EXPORT
 float
-glmc_mat3_det(mat3 mat);
+glmc_mat3_det(const mat3 mat);
 
 CGLM_EXPORT
 void
-glmc_mat3_inv(mat3 mat, mat3 dest);
+glmc_mat3_inv(const mat3 mat, mat3 dest);
 
 CGLM_EXPORT
 void
@@ -72,6 +72,10 @@ CGLM_EXPORT
 void
 glmc_mat3_swap_row(mat3 mat, int row1, int row2);
 
+CGLM_EXPORT
+float
+glmc_mat3_rmc(const vec3 r, const mat3 m, const vec3 c);
+
 #ifdef __cplusplus
 }
 #endif

include/cglm/call/mat4.h

@@ -19,11 +19,11 @@ extern "C" {
 
 CGLM_EXPORT
 void
-glmc_mat4_ucopy(mat4 mat, mat4 dest);
+glmc_mat4_ucopy(const mat4 mat, mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_mat4_copy(mat4 mat, mat4 dest);
+glmc_mat4_copy(const mat4 mat, mat4 dest);
 
 CGLM_EXPORT
 void
@@ -31,51 +31,51 @@ glmc_mat4_identity(mat4 mat);
 
 CGLM_EXPORT
 void
-glmc_mat4_identity_array(mat4 * __restrict mat, size_t count);
+glmc_mat4_identity_array(mat4 * const __restrict mat, size_t count);
 
 CGLM_EXPORT
 void
-glmc_mat4_pick3(mat4 mat, mat3 dest);
+glmc_mat4_pick3(const mat4 mat, mat3 dest);
 
 CGLM_EXPORT
 void
-glmc_mat4_pick3t(mat4 mat, mat3 dest);
+glmc_mat4_pick3t(const mat4 mat, mat3 dest);
 
 CGLM_EXPORT
 void
-glmc_mat4_ins3(mat3 mat, mat4 dest);
+glmc_mat4_ins3(const mat3 mat, mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_mat4_mul(mat4 m1, mat4 m2, mat4 dest);
+glmc_mat4_mul(const mat4 m1, const mat4 m2, mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_mat4_mulN(mat4 * __restrict matrices[], uint32_t len, mat4 dest);
+glmc_mat4_mulN(mat4 * const __restrict matrices[], uint32_t len, mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_mat4_mulv(mat4 m, vec4 v, vec4 dest);
+glmc_mat4_mulv(const mat4 m, const vec4 v, vec4 dest);
 
 CGLM_EXPORT
 void
-glmc_mat4_mulv3(mat4 m, vec3 v, float last, vec3 dest);
+glmc_mat4_mulv3(const mat4 m, const vec3 v, float last, vec3 dest);
 
 CGLM_EXPORT
 float
-glmc_mat4_trace(mat4 m);
+glmc_mat4_trace(const mat4 m);
 
 CGLM_EXPORT
 float
-glmc_mat4_trace3(mat4 m);
+glmc_mat4_trace3(const mat4 m);
 
 CGLM_EXPORT
 void
-glmc_mat4_quat(mat4 m, versor dest);
+glmc_mat4_quat(const mat4 m, versor dest);
 
 CGLM_EXPORT
 void
-glmc_mat4_transpose_to(mat4 m, mat4 dest);
+glmc_mat4_transpose_to(const mat4 m, mat4 dest);
 
 CGLM_EXPORT
 void
@@ -91,19 +91,19 @@ glmc_mat4_scale(mat4 m, float s);
 
 CGLM_EXPORT
 float
-glmc_mat4_det(mat4 mat);
+glmc_mat4_det(const mat4 mat);
 
 CGLM_EXPORT
 void
-glmc_mat4_inv(mat4 mat, mat4 dest);
+glmc_mat4_inv(const mat4 mat, mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_mat4_inv_precise(mat4 mat, mat4 dest);
+glmc_mat4_inv_precise(const mat4 mat, mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_mat4_inv_fast(mat4 mat, mat4 dest);
+glmc_mat4_inv_fast(const mat4 mat, mat4 dest);
 
 CGLM_EXPORT
 void
@@ -113,6 +113,10 @@ CGLM_EXPORT
 void
 glmc_mat4_swap_row(mat4 mat, int row1, int row2);
 
+CGLM_EXPORT
+float
+glmc_mat4_rmc(const vec4 r, const mat4 m, const vec4 c);
+
 #ifdef __cplusplus
 }
 #endif

include/cglm/call/project.h

@@ -15,15 +15,15 @@ extern "C" {
 
 CGLM_EXPORT
 void
-glmc_unprojecti(vec3 pos, mat4 invMat, vec4 vp, vec3 dest);
+glmc_unprojecti(const vec3 pos, const mat4 invMat, const vec4 vp, vec3 dest);
 
 CGLM_EXPORT
 void
-glmc_unproject(vec3 pos, mat4 m, vec4 vp, vec3 dest);
+glmc_unproject(const vec3 pos, const mat4 m, const vec4 vp, vec3 dest);
 
 CGLM_EXPORT
 void
-glmc_project(vec3 pos, mat4 m, vec4 vp, vec3 dest);
+glmc_project(const vec3 pos, const mat4 m, const vec4 vp, vec3 dest);
 
 #ifdef __cplusplus
 }

include/cglm/call/quat.h

@@ -19,7 +19,7 @@ glmc_quat_identity(versor q);
 
 CGLM_EXPORT
 void
-glmc_quat_identity_array(versor * __restrict q, size_t count);
+glmc_quat_identity_array(versor * const __restrict q, size_t count);
 
 CGLM_EXPORT
 void
@@ -31,19 +31,19 @@ glmc_quat(versor q, float angle, float x, float y, float z);
 
 CGLM_EXPORT
 void
-glmc_quatv(versor q, float angle, vec3 axis);
+glmc_quatv(versor q, float angle, const vec3 axis);
 
 CGLM_EXPORT
 void
-glmc_quat_copy(versor q, versor dest);
+glmc_quat_copy(const versor q, versor dest);
 
 CGLM_EXPORT
 float
-glmc_quat_norm(versor q);
+glmc_quat_norm(const versor q);
 
 CGLM_EXPORT
 void
-glmc_quat_normalize_to(versor q, versor dest);
+glmc_quat_normalize_to(const versor q, versor dest);
 
 CGLM_EXPORT
 void
@@ -51,103 +51,107 @@ glmc_quat_normalize(versor q);
 
 CGLM_EXPORT
 float
-glmc_quat_dot(versor p, versor q);
+glmc_quat_dot(const versor p, const versor q);
 
 CGLM_EXPORT
 void
-glmc_quat_conjugate(versor q, versor dest);
+glmc_quat_conjugate(const versor q, versor dest);
 
 CGLM_EXPORT
 void
-glmc_quat_inv(versor q, versor dest);
+glmc_quat_inv(const versor q, versor dest);
 
 CGLM_EXPORT
 void
-glmc_quat_add(versor p, versor q, versor dest);
+glmc_quat_add(const versor p, const versor q, versor dest);
 
 CGLM_EXPORT
 void
-glmc_quat_sub(versor p, versor q, versor dest);
+glmc_quat_sub(const versor p, const versor q, versor dest);
 
 CGLM_EXPORT
 float
-glmc_quat_real(versor q);
+glmc_quat_real(const versor q);
 
 CGLM_EXPORT
 void
-glmc_quat_imag(versor q, vec3 dest);
+glmc_quat_imag(const versor q, vec3 dest);
 
 CGLM_EXPORT
 void
-glmc_quat_imagn(versor q, vec3 dest);
+glmc_quat_imagn(const versor q, vec3 dest);
 
 CGLM_EXPORT
 float
-glmc_quat_imaglen(versor q);
+glmc_quat_imaglen(const versor q);
 
 CGLM_EXPORT
 float
-glmc_quat_angle(versor q);
+glmc_quat_angle(const versor q);
 
 CGLM_EXPORT
 void
-glmc_quat_axis(versor q, versor dest);
+glmc_quat_axis(const versor q, versor dest);
 
 CGLM_EXPORT
 void
-glmc_quat_mul(versor p, versor q, versor dest);
+glmc_quat_mul(const versor p, const versor q, versor dest);
 
 CGLM_EXPORT
 void
-glmc_quat_mat4(versor q, mat4 dest);
+glmc_quat_mat4(const versor q, mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_quat_mat4t(versor q, mat4 dest);
+glmc_quat_mat4t(const versor q, mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_quat_mat3(versor q, mat3 dest);
+glmc_quat_mat3(const versor q, mat3 dest);
 
 CGLM_EXPORT
 void
-glmc_quat_mat3t(versor q, mat3 dest);
+glmc_quat_mat3t(const versor q, mat3 dest);
 
 CGLM_EXPORT
 void
-glmc_quat_lerp(versor from, versor to, float t, versor dest);
+glmc_quat_lerp(const versor from, const versor to, float t, versor dest);
 
 CGLM_EXPORT
 void
-glmc_quat_slerp(versor q, versor r, float t, versor dest);
+glmc_quat_slerp(const versor q, const versor r, float t, versor dest);
 
 CGLM_EXPORT
 void
-glmc_quat_look(vec3 eye, versor ori, mat4 dest);
+glmc_quat_look(const vec3 eye, const versor ori, mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest);
+glmc_quat_for(const vec3 dir, const vec3 fwd, const vec3 up, versor dest);
 
 CGLM_EXPORT
 void
-glmc_quat_forp(vec3 from, vec3 to, vec3 fwd, vec3 up, versor dest);
+glmc_quat_forp(const vec3 from,
+               const vec3 to,
+               const vec3 fwd,
+               const vec3 up,
+               versor     dest);
 
 CGLM_EXPORT
 void
-glmc_quat_rotatev(versor from, vec3 to, vec3 dest);
+glmc_quat_rotatev(const versor from, const vec3 to, vec3 dest);
 
 CGLM_EXPORT
 void
-glmc_quat_rotate(mat4 m, versor q, mat4 dest);
+glmc_quat_rotate(const mat4 m, const versor q, mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_quat_rotate_at(mat4 model, versor q, vec3 pivot);
+glmc_quat_rotate_at(mat4 model, const versor q, const vec3 pivot);
 
 CGLM_EXPORT
 void
-glmc_quat_rotate_atm(mat4 m, versor q, vec3 pivot);
+glmc_quat_rotate_atm(mat4 m, const versor q, const vec3 pivot);
 
 #ifdef __cplusplus
 }

include/cglm/call/sphere.h

@@ -15,22 +15,25 @@ extern "C" {
 
 CGLM_EXPORT
 float
-glmc_sphere_radii(vec4 s);
+glmc_sphere_radii(const vec4 s);
 
 CGLM_EXPORT
 void
-glmc_sphere_transform(vec4 s, mat4 m, vec4 dest);
+glmc_sphere_transform(const vec4 s, const mat4 m, vec4 dest);
 
 CGLM_EXPORT
 void
-glmc_sphere_merge(vec4 s1, vec4 s2, vec4 dest);
+glmc_sphere_merge(const vec4 s1, const vec4 s2, vec4 dest);
 
 CGLM_EXPORT
 bool
-glmc_sphere_sphere(vec4 s1, vec4 s2);
+glmc_sphere_sphere(const vec4 s1, const vec4 s2);
 
 CGLM_EXPORT
 bool
-glmc_sphere_point(vec4 s, vec3 point);
+glmc_sphere_point(const vec4 s, const vec3 point);
 
+#ifdef __cplusplus
+}
+#endif
 #endif /* cglmc_sphere_h */

include/cglm/call/vec3.h

@@ -22,11 +22,11 @@ extern "C" {
 
 CGLM_EXPORT
 void
-glmc_vec3(vec4 v4, vec3 dest);
+glmc_vec3(const vec4 v4, vec3 dest);
 
 CGLM_EXPORT
 void
-glmc_vec3_copy(vec3 a, vec3 dest);
+glmc_vec3_copy(const vec3 a, vec3 dest);
 
 CGLM_EXPORT
 void
@@ -38,27 +38,27 @@ glmc_vec3_one(vec3 v);
 
 CGLM_EXPORT
 float
-glmc_vec3_dot(vec3 a, vec3 b);
+glmc_vec3_dot(const vec3 a, const vec3 b);
 
 CGLM_EXPORT
 void
-glmc_vec3_cross(vec3 a, vec3 b, vec3 dest);
+glmc_vec3_cross(const vec3 a, const vec3 b, vec3 dest);
 
 CGLM_EXPORT
 void
-glmc_vec3_crossn(vec3 a, vec3 b, vec3 dest);
+glmc_vec3_crossn(const vec3 a, const vec3 b, vec3 dest);
 
 CGLM_EXPORT
 float
-glmc_vec3_norm(vec3 v);
+glmc_vec3_norm(const vec3 v);
 
 CGLM_EXPORT
 float
-glmc_vec3_norm2(vec3 v);
+glmc_vec3_norm2(const vec3 v);
 
 CGLM_EXPORT
 void
-glmc_vec3_normalize_to(vec3 v, vec3 dest);
+glmc_vec3_normalize_to(const vec3 v, vec3 dest);
 
 CGLM_EXPORT
 void
@@ -66,63 +66,63 @@ glmc_vec3_normalize(vec3 v);
 
 CGLM_EXPORT
 void
-glmc_vec3_add(vec3 a, vec3 b, vec3 dest);
+glmc_vec3_add(const vec3 a, const vec3 b, vec3 dest);
 
 CGLM_EXPORT
 void
-glmc_vec3_adds(vec3 v, float s, vec3 dest);
+glmc_vec3_adds(const vec3 v, float s, vec3 dest);
 
 CGLM_EXPORT
 void
-glmc_vec3_sub(vec3 a, vec3 b, vec3 dest);
+glmc_vec3_sub(const vec3 a, const vec3 b, vec3 dest);
 
 CGLM_EXPORT
 void
-glmc_vec3_subs(vec3 v, float s, vec3 dest);
+glmc_vec3_subs(const vec3 v, float s, vec3 dest);
 
 CGLM_EXPORT
 void
-glmc_vec3_mul(vec3 a, vec3 b, vec3 d);
+glmc_vec3_mul(const vec3 a, const vec3 b, vec3 d);
 
 CGLM_EXPORT
 void
-glmc_vec3_scale(vec3 v, float s, vec3 dest);
+glmc_vec3_scale(const vec3 v, float s, vec3 dest);
 
 CGLM_EXPORT
 void
-glmc_vec3_scale_as(vec3 v, float s, vec3 dest);
+glmc_vec3_scale_as(const vec3 v, float s, vec3 dest);
 
 CGLM_EXPORT
 void
-glmc_vec3_div(vec3 a, vec3 b, vec3 dest);
+glmc_vec3_div(const vec3 a, const vec3 b, vec3 dest);
 
 CGLM_EXPORT
 void
-glmc_vec3_divs(vec3 a, float s, vec3 dest);
+glmc_vec3_divs(const vec3 a, float s, vec3 dest);
 
 CGLM_EXPORT
 void
-glmc_vec3_addadd(vec3 a, vec3 b, vec3 dest);
+glmc_vec3_addadd(const vec3 a, const vec3 b, vec3 dest);
 
 CGLM_EXPORT
 void
-glmc_vec3_subadd(vec3 a, vec3 b, vec3 dest);
+glmc_vec3_subadd(const vec3 a, const vec3 b, vec3 dest);
 
 CGLM_EXPORT
 void
-glmc_vec3_muladd(vec3 a, vec3 b, vec3 dest);
+glmc_vec3_muladd(const vec3 a, const vec3 b, vec3 dest);
 
 CGLM_EXPORT
 void
-glmc_vec3_muladds(vec3 a, float s, vec3 dest);
+glmc_vec3_muladds(const vec3 a, float s, vec3 dest);
 
 CGLM_EXPORT
 void
-glmc_vec3_maxadd(vec3 a, vec3 b, vec3 dest);
+glmc_vec3_maxadd(const vec3 a, const vec3 b, vec3 dest);
 
 CGLM_EXPORT
 void
-glmc_vec3_minadd(vec3 a, vec3 b, vec3 dest);
+glmc_vec3_minadd(const vec3 a, const vec3 b, vec3 dest);
 
 CGLM_EXPORT
 void
@@ -130,47 +130,47 @@ glmc_vec3_negate(vec3 v);
 
 CGLM_EXPORT
 void
-glmc_vec3_negate_to(vec3 v, vec3 dest);
+glmc_vec3_negate_to(const vec3 v, vec3 dest);
 
 CGLM_EXPORT
 float
-glmc_vec3_angle(vec3 a, vec3 b);
+glmc_vec3_angle(const vec3 a, const vec3 b);
 
 CGLM_EXPORT
 void
-glmc_vec3_rotate(vec3 v, float angle, vec3 axis);
+glmc_vec3_rotate(vec3 v, float angle, const vec3 axis);
 
 CGLM_EXPORT
 void
-glmc_vec3_rotate_m4(mat4 m, vec3 v, vec3 dest);
+glmc_vec3_rotate_m4(const mat4 m, const vec3 v, vec3 dest);
 
 CGLM_EXPORT
 void
-glmc_vec3_rotate_m3(mat3 m, vec3 v, vec3 dest);
+glmc_vec3_rotate_m3(const mat3 m, const vec3 v, vec3 dest);
 
 CGLM_EXPORT
 void
-glmc_vec3_proj(vec3 a, vec3 b, vec3 dest);
+glmc_vec3_proj(const vec3 a, const vec3 b, vec3 dest);
 
 CGLM_EXPORT
 void
-glmc_vec3_center(vec3 a, vec3 b, vec3 dest);
+glmc_vec3_center(const vec3 a, const vec3 b, vec3 dest);
 
 CGLM_EXPORT
 float
-glmc_vec3_distance2(vec3 a, vec3 b);
+glmc_vec3_distance2(const vec3 a, const vec3 b);
 
 CGLM_EXPORT
 float
-glmc_vec3_distance(vec3 a, vec3 b);
+glmc_vec3_distance(const vec3 a, const vec3 b);
 
 CGLM_EXPORT
 void
-glmc_vec3_maxv(vec3 a, vec3 b, vec3 dest);
+glmc_vec3_maxv(const vec3 a, const vec3 b, vec3 dest);
 
 CGLM_EXPORT
 void
-glmc_vec3_minv(vec3 a, vec3 b, vec3 dest);
+glmc_vec3_minv(const vec3 a, const vec3 b, vec3 dest);
 
 CGLM_EXPORT
 void
@@ -178,17 +178,17 @@ glmc_vec3_clamp(vec3 v, float minVal, float maxVal);
 
 CGLM_EXPORT
 void
-glmc_vec3_ortho(vec3 v, vec3 dest);
+glmc_vec3_ortho(const vec3 v, vec3 dest);
 
 CGLM_EXPORT
 void
-glmc_vec3_lerp(vec3 from, vec3 to, float t, vec3 dest);
+glmc_vec3_lerp(const vec3 from, const vec3 to, float t, vec3 dest);
 
 /* ext */
 
 CGLM_EXPORT
 void
-glmc_vec3_mulv(vec3 a, vec3 b, vec3 d);
+glmc_vec3_mulv(const vec3 a, const vec3 b, vec3 d);
 
 CGLM_EXPORT
 void
@@ -196,51 +196,51 @@ glmc_vec3_broadcast(float val, vec3 d);
 
 CGLM_EXPORT
 bool
-glmc_vec3_eq(vec3 v, float val);
+glmc_vec3_eq(const vec3 v, float val);
 
 CGLM_EXPORT
 bool
-glmc_vec3_eq_eps(vec3 v, float val);
+glmc_vec3_eq_eps(const vec3 v, float val);
 
 CGLM_EXPORT
 bool
-glmc_vec3_eq_all(vec3 v);
+glmc_vec3_eq_all(const vec3 v);
 
 CGLM_EXPORT
 bool
-glmc_vec3_eqv(vec3 a, vec3 b);
+glmc_vec3_eqv(const vec3 a, const vec3 b);
 
 CGLM_EXPORT
 bool
-glmc_vec3_eqv_eps(vec3 a, vec3 b);
+glmc_vec3_eqv_eps(const vec3 a, const vec3 b);
 
 CGLM_EXPORT
 float
-glmc_vec3_max(vec3 v);
+glmc_vec3_max(const vec3 v);
 
 CGLM_EXPORT
 float
-glmc_vec3_min(vec3 v);
+glmc_vec3_min(const vec3 v);
 
 CGLM_EXPORT
 bool
-glmc_vec3_isnan(vec3 v);
+glmc_vec3_isnan(const vec3 v);
 
 CGLM_EXPORT
 bool
-glmc_vec3_isinf(vec3 v);
+glmc_vec3_isinf(const vec3 v);
 
 CGLM_EXPORT
 bool
-glmc_vec3_isvalid(vec3 v);
+glmc_vec3_isvalid(const vec3 v);
 
 CGLM_EXPORT
 void
-glmc_vec3_sign(vec3 v, vec3 dest);
+glmc_vec3_sign(const vec3 v, vec3 dest);
 
 CGLM_EXPORT
 void
-glmc_vec3_sqrt(vec3 v, vec3 dest);
+glmc_vec3_sqrt(const vec3 v, vec3 dest);
 
 #ifdef __cplusplus
 }

include/cglm/call/vec4.h

@@ -23,7 +23,7 @@ extern "C" {
 
 CGLM_EXPORT
 void
-glmc_vec4(vec3 v3, float last, vec4 dest);
+glmc_vec4(const vec3 v3, float last, vec4 dest);
 
 CGLM_EXPORT
 void
@@ -35,31 +35,31 @@ glmc_vec4_one(vec4 v);
 
 CGLM_EXPORT
 void
-glmc_vec4_copy3(vec4 v, vec3 dest);
+glmc_vec4_copy3(const vec4 v, vec3 dest);
 
 CGLM_EXPORT
 void
-glmc_vec4_copy(vec4 v, vec4 dest);
+glmc_vec4_copy(const vec4 v, vec4 dest);
 
 CGLM_EXPORT
 void
-glmc_vec4_ucopy(vec4 v, vec4 dest);
+glmc_vec4_ucopy(const vec4 v, vec4 dest);
 
 CGLM_EXPORT
 float
-glmc_vec4_dot(vec4 a, vec4 b);
+glmc_vec4_dot(const vec4 a, const vec4 b);
 
 CGLM_EXPORT
 float
-glmc_vec4_norm(vec4 v);
+glmc_vec4_norm(const vec4 v);
 
 CGLM_EXPORT
 float
-glmc_vec4_norm2(vec4 v);
+glmc_vec4_norm2(const vec4 v);
 
 CGLM_EXPORT
 void
-glmc_vec4_normalize_to(vec4 v, vec4 dest);
+glmc_vec4_normalize_to(const vec4 v, vec4 dest);
 
 CGLM_EXPORT
 void
@@ -67,63 +67,63 @@ glmc_vec4_normalize(vec4 v);
 
 CGLM_EXPORT
 void
-glmc_vec4_add(vec4 a, vec4 b, vec4 dest);
+glmc_vec4_add(const vec4 a, const vec4 b, vec4 dest);
 
 CGLM_EXPORT
 void
-glmc_vec4_adds(vec4 v, float s, vec4 dest);
+glmc_vec4_adds(const vec4 v, float s, vec4 dest);
 
 CGLM_EXPORT
 void
-glmc_vec4_sub(vec4 a, vec4 b, vec4 dest);
+glmc_vec4_sub(const vec4 a, const vec4 b, vec4 dest);
 
 CGLM_EXPORT
 void
-glmc_vec4_subs(vec4 v, float s, vec4 dest);
+glmc_vec4_subs(const vec4 v, float s, vec4 dest);
 
 CGLM_EXPORT
 void
-glmc_vec4_mul(vec4 a, vec4 b, vec4 d);
+glmc_vec4_mul(const vec4 a, const vec4 b, vec4 d);
 
 CGLM_EXPORT
 void
-glmc_vec4_scale(vec4 v, float s, vec4 dest);
+glmc_vec4_scale(const vec4 v, float s, vec4 dest);
 
 CGLM_EXPORT
 void
-glmc_vec4_scale_as(vec3 v, float s, vec3 dest);
+glmc_vec4_scale_as(const vec3 v, float s, vec3 dest);
 
 CGLM_EXPORT
 void
-glmc_vec4_div(vec4 a, vec4 b, vec4 dest);
+glmc_vec4_div(const vec4 a, const vec4 b, vec4 dest);
 
 CGLM_EXPORT
 void
-glmc_vec4_divs(vec4 v, float s, vec4 dest);
+glmc_vec4_divs(const vec4 v, float s, vec4 dest);
 
 CGLM_EXPORT
 void
-glmc_vec4_addadd(vec4 a, vec4 b, vec4 dest);
+glmc_vec4_addadd(const vec4 a, const vec4 b, vec4 dest);
 
 CGLM_EXPORT
 void
-glmc_vec4_subadd(vec4 a, vec4 b, vec4 dest);
+glmc_vec4_subadd(const vec4 a, const vec4 b, vec4 dest);
 
 CGLM_EXPORT
 void
-glmc_vec4_muladd(vec4 a, vec4 b, vec4 dest);
+glmc_vec4_muladd(const vec4 a, const vec4 b, vec4 dest);
 
 CGLM_EXPORT
 void
-glmc_vec4_muladds(vec4 a, float s, vec4 dest);
+glmc_vec4_muladds(const vec4 a, float s, vec4 dest);
 
 CGLM_EXPORT
 void
-glmc_vec4_maxadd(vec4 a, vec4 b, vec4 dest);
+glmc_vec4_maxadd(const vec4 a, const vec4 b, vec4 dest);
 
 CGLM_EXPORT
 void
-glmc_vec4_minadd(vec4 a, vec4 b, vec4 dest);
+glmc_vec4_minadd(const vec4 a, const vec4 b, vec4 dest);
 
 CGLM_EXPORT
 void
@@ -131,19 +131,19 @@ glmc_vec4_negate(vec4 v);
 
 CGLM_EXPORT
 void
-glmc_vec4_negate_to(vec4 v, vec4 dest);
+glmc_vec4_negate_to(const vec4 v, vec4 dest);
 
 CGLM_EXPORT
 float
-glmc_vec4_distance(vec4 a, vec4 b);
+glmc_vec4_distance(const vec4 a, const vec4 b);
 
 CGLM_EXPORT
 void
-glmc_vec4_maxv(vec4 a, vec4 b, vec4 dest);
+glmc_vec4_maxv(const vec4 a, const vec4 b, vec4 dest);
 
 CGLM_EXPORT
 void
-glmc_vec4_minv(vec4 a, vec4 b, vec4 dest);
+glmc_vec4_minv(const vec4 a, const vec4 b, vec4 dest);
 
 CGLM_EXPORT
 void
@@ -151,13 +151,17 @@ glmc_vec4_clamp(vec4 v, float minVal, float maxVal);
 
 CGLM_EXPORT
 void
-glmc_vec4_lerp(vec4 from, vec4 to, float t, vec4 dest);
+glmc_vec4_lerp(const vec4 from, const vec4 to, float t, vec4 dest);
+
+CGLM_EXPORT
+void
+glmc_vec4_cubic(float s, vec4 dest);
 
 /* ext */
 
 CGLM_EXPORT
 void
-glmc_vec4_mulv(vec4 a, vec4 b, vec4 d);
+glmc_vec4_mulv(const vec4 a, const vec4 b, vec4 d);
 
 CGLM_EXPORT
 void
@@ -165,51 +169,51 @@ glmc_vec4_broadcast(float val, vec4 d);
 
 CGLM_EXPORT
 bool
-glmc_vec4_eq(vec4 v, float val);
+glmc_vec4_eq(const vec4 v, float val);
 
 CGLM_EXPORT
 bool
-glmc_vec4_eq_eps(vec4 v, float val);
+glmc_vec4_eq_eps(const vec4 v, float val);
 
 CGLM_EXPORT
 bool
-glmc_vec4_eq_all(vec4 v);
+glmc_vec4_eq_all(const vec4 v);
 
 CGLM_EXPORT
 bool
-glmc_vec4_eqv(vec4 a, vec4 b);
+glmc_vec4_eqv(const vec4 a, const vec4 b);
 
 CGLM_EXPORT
 bool
-glmc_vec4_eqv_eps(vec4 a, vec4 b);
+glmc_vec4_eqv_eps(const vec4 a, const vec4 b);
 
 CGLM_EXPORT
 float
-glmc_vec4_max(vec4 v);
+glmc_vec4_max(const vec4 v);
 
 CGLM_EXPORT
 float
-glmc_vec4_min(vec4 v);
+glmc_vec4_min(const vec4 v);
 
 CGLM_EXPORT
 bool
-glmc_vec4_isnan(vec4 v);
+glmc_vec4_isnan(const vec4 v);
 
 CGLM_EXPORT
 bool
-glmc_vec4_isinf(vec4 v);
+glmc_vec4_isinf(const vec4 v);
 
 CGLM_EXPORT
 bool
-glmc_vec4_isvalid(vec4 v);
+glmc_vec4_isvalid(const vec4 v);
 
 CGLM_EXPORT
 void
-glmc_vec4_sign(vec4 v, vec4 dest);
+glmc_vec4_sign(const vec4 v, vec4 dest);
 
 CGLM_EXPORT
 void
-glmc_vec4_sqrt(vec4 v, vec4 dest);
+glmc_vec4_sqrt(const vec4 v, vec4 dest);
 
 #ifdef __cplusplus
 }

include/cglm/cam.h

@@ -84,7 +84,7 @@ glm_frustum(float left,
             mat4  dest) {
   float rl, tb, fn, nv;
 
-  glm__memzero(float, dest, sizeof(mat4));
+  glm_mat4_zero(dest);
 
   rl = 1.0f / (right  - left);
   tb = 1.0f / (top    - bottom);
@@ -122,7 +122,7 @@ glm_ortho(float left,
           mat4  dest) {
   float rl, tb, fn;
 
-  glm__memzero(float, dest, sizeof(mat4));
+  glm_mat4_zero(dest);
 
   rl = 1.0f / (right  - left);
   tb = 1.0f / (top    - bottom);
@@ -147,7 +147,7 @@ glm_ortho(float left,
  */
 CGLM_INLINE
 void
-glm_ortho_aabb(vec3 box[2], mat4 dest) {
+glm_ortho_aabb(const vec3 box[2], mat4 dest) {
   glm_ortho(box[0][0],  box[1][0],
             box[0][1],  box[1][1],
            -box[1][2], -box[0][2],
@@ -165,7 +165,7 @@ glm_ortho_aabb(vec3 box[2], mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_ortho_aabb_p(vec3 box[2], float padding, mat4 dest) {
+glm_ortho_aabb_p(const vec3 box[2], float padding, mat4 dest) {
   glm_ortho(box[0][0] - padding,    box[1][0] + padding,
             box[0][1] - padding,    box[1][1] + padding,
           -(box[1][2] + padding), -(box[0][2] - padding),
@@ -183,7 +183,7 @@ glm_ortho_aabb_p(vec3 box[2], float padding, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_ortho_aabb_pz(vec3 box[2], float padding, mat4 dest) {
+glm_ortho_aabb_pz(const vec3 box[2], float padding, mat4 dest) {
   glm_ortho(box[0][0],              box[1][0],
             box[0][1],              box[1][1],
           -(box[1][2] + padding), -(box[0][2] - padding),
@@ -218,9 +218,7 @@ glm_ortho_default(float aspect, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_ortho_default_s(float aspect,
-                    float size,
-                    mat4  dest) {
+glm_ortho_default_s(float aspect, float size, mat4 dest) {
   if (aspect >= 1.0f) {
     glm_ortho(-size * aspect,
                size * aspect,
@@ -259,7 +257,7 @@ glm_perspective(float fovy,
                 mat4  dest) {
   float f, fn;
 
-  glm__memzero(float, dest, sizeof(mat4));
+  glm_mat4_zero(dest);
 
   f  = 1.0f / tanf(fovy * 0.5f);
   fn = 1.0f / (nearVal - farVal);
@@ -271,6 +269,30 @@ glm_perspective(float fovy,
   dest[3][2] = 2.0f * nearVal * farVal * fn;
 }
 
+/*!
+ * @brief extend perspective projection matrix's far distance
+ *
+ * this function does not guarantee far >= near, be aware of that!
+ *
+ * @param[in, out] proj      projection matrix to extend
+ * @param[in]      deltaFar  distance from existing far (negative to shink)
+ */
+CGLM_INLINE
+void
+glm_persp_move_far(mat4 proj, float deltaFar) {
+  float fn, farVal, nearVal, p22, p32;
+
+  p22        = proj[2][2];
+  p32        = proj[3][2];
+
+  nearVal    = p32 / (p22 - 1.0f);
+  farVal     = p32 / (p22 + 1.0f) + deltaFar;
+  fn         = 1.0f / (nearVal - farVal);
+
+  proj[2][2] = (nearVal + farVal) * fn;
+  proj[3][2] = 2.0f * nearVal * farVal * fn;
+}
+
 /*!
  * @brief set up perspective projection matrix with default near/far
  *        and angle values
@@ -314,9 +336,9 @@ glm_perspective_resize(float aspect, mat4 proj) {
  */
 CGLM_INLINE
 void
-glm_lookat(vec3 eye,
-           vec3 center,
-           vec3 up,
+glm_lookat(const vec3 eye,
+           const vec3 center,
+           const vec3 up,
            mat4       dest) {
   CGLM_ALIGN(8) vec3 f, u, s;
 
@@ -358,7 +380,7 @@ glm_lookat(vec3 eye,
  */
 CGLM_INLINE
 void
-glm_look(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
+glm_look(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest) {
   CGLM_ALIGN(8) vec3 target;
   glm_vec3_add(eye, dir, target);
   glm_lookat(eye, target, up, dest);
@@ -376,7 +398,7 @@ glm_look(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_look_anyup(vec3 eye, vec3 dir, mat4 dest) {
+glm_look_anyup(const vec3 eye, const vec3 dir, mat4 dest) {
   CGLM_ALIGN(8) vec3 up;
   glm_vec3_ortho(dir, up);
   glm_look(eye, dir, up, dest);
@@ -395,7 +417,7 @@ glm_look_anyup(vec3 eye, vec3 dir, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_persp_decomp(mat4 proj,
+glm_persp_decomp(const mat4 proj,
                  float * __restrict nearVal,
                  float * __restrict farVal,
                  float * __restrict top,
@@ -435,7 +457,7 @@ glm_persp_decomp(mat4 proj,
  */
 CGLM_INLINE
 void
-glm_persp_decompv(mat4 proj, float dest[6]) {
+glm_persp_decompv(const mat4 proj, float dest[6]) {
   glm_persp_decomp(proj, &dest[0], &dest[1], &dest[2],
                          &dest[3], &dest[4], &dest[5]);
 }
@@ -450,7 +472,7 @@ glm_persp_decompv(mat4 proj, float dest[6]) {
  */
 CGLM_INLINE
 void
-glm_persp_decomp_x(mat4 proj,
+glm_persp_decomp_x(const mat4 proj,
                    float * __restrict left,
                    float * __restrict right) {
   float nearVal, m20, m00;
@@ -473,7 +495,7 @@ glm_persp_decomp_x(mat4 proj,
  */
 CGLM_INLINE
 void
-glm_persp_decomp_y(mat4 proj,
+glm_persp_decomp_y(const mat4 proj,
                    float * __restrict top,
                    float * __restrict bottom) {
   float nearVal, m21, m11;
@@ -496,7 +518,7 @@ glm_persp_decomp_y(mat4 proj,
  */
 CGLM_INLINE
 void
-glm_persp_decomp_z(mat4 proj,
+glm_persp_decomp_z(const mat4 proj,
                    float * __restrict nearVal,
                    float * __restrict farVal) {
   float m32, m22;
@@ -516,7 +538,7 @@ glm_persp_decomp_z(mat4 proj,
  */
 CGLM_INLINE
 void
-glm_persp_decomp_far(mat4 proj, float * __restrict farVal) {
+glm_persp_decomp_far(const mat4 proj, float * __restrict farVal) {
   *farVal = proj[3][2] / (proj[2][2] + 1.0f);
 }
 
@@ -528,7 +550,7 @@ glm_persp_decomp_far(mat4 proj, float * __restrict farVal) {
  */
 CGLM_INLINE
 void
-glm_persp_decomp_near(mat4 proj, float * __restrict nearVal) {
+glm_persp_decomp_near(const mat4 proj, float * __restrict nearVal) {
   *nearVal = proj[3][2] / (proj[2][2] - 1.0f);
 }
 
@@ -542,7 +564,7 @@ glm_persp_decomp_near(mat4 proj, float * __restrict nearVal) {
  */
 CGLM_INLINE
 float
-glm_persp_fovy(mat4 proj) {
+glm_persp_fovy(const mat4 proj) {
   return 2.0f * atanf(1.0f / proj[1][1]);
 }
 
@@ -553,7 +575,7 @@ glm_persp_fovy(mat4 proj) {
  */
 CGLM_INLINE
 float
-glm_persp_aspect(mat4 proj) {
+glm_persp_aspect(const mat4 proj) {
   return proj[1][1] / proj[0][0];
 }
 
@@ -566,7 +588,7 @@ glm_persp_aspect(mat4 proj) {
  */
 CGLM_INLINE
 void
-glm_persp_sizes(mat4 proj, float fovy, vec4 dest) {
+glm_persp_sizes(const mat4 proj, float fovy, vec4 dest) {
   float t, a, nearVal, farVal;
 
   t = 2.0f * tanf(fovy * 0.5f);

include/cglm/cglm.h

@@ -26,5 +26,7 @@
 #include "project.h"
 #include "sphere.h"
 #include "ease.h"
+#include "curve.h"
+#include "bezier.h"
 
 #endif /* cglm_h */

include/cglm/color.h

@@ -18,7 +18,7 @@
  */
 CGLM_INLINE
 float
-glm_luminance(vec3 rgb) {
+glm_luminance(const vec3 rgb) {
   vec3 l = {0.212671f, 0.715160f, 0.072169f};
   return glm_dot(rgb, l);
 }

include/cglm/common.h

@@ -11,8 +11,10 @@
 #define _USE_MATH_DEFINES /* for windows */
 
 #include <stdint.h>
+#include <stddef.h>
 #include <math.h>
 #include <float.h>
+#include <stdbool.h>
 
 #if defined(_MSC_VER)
 #  ifdef CGLM_DLL
@@ -26,34 +28,6 @@
 #  define CGLM_INLINE static inline __attribute((always_inline))
 #endif
 
-#define glm__memcpy(type, dest, src, size)                                    \
-  do {                                                                        \
-    type *srci;                                                               \
-    type *srci_end;                                                           \
-    type *desti;                                                              \
-                                                                              \
-    srci     = (type *)src;                                                   \
-    srci_end = (type *)((char *)srci + size);                                 \
-    desti    = (type *)dest;                                                  \
-                                                                              \
-    while (srci != srci_end)                                                  \
-      *desti++ = *srci++;                                                     \
-  } while (0)
-
-#define glm__memset(type, dest, size, val)                                    \
-  do {                                                                        \
-    type *desti;                                                              \
-    type *desti_end;                                                          \
-                                                                              \
-    desti     = (type *)dest;                                                 \
-    desti_end = (type *)((char *)desti + size);                               \
-                                                                              \
-    while (desti != desti_end)                                                \
-      *desti++ = val;                                                         \
-  } while (0)
-
-#define glm__memzero(type, dest, size) glm__memset(type, dest, size, 0)
-
 #include "types.h"
 #include "simd/intrin.h"
 

include/cglm/curve.h

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglm_curve_h
+#define cglm_curve_h
+
+#include "common.h"
+#include "vec4.h"
+#include "mat4.h"
+
+/*!
+ * @brief helper function to calculate S*M*C multiplication for curves
+ *
+ * This function does not encourage you to use SMC,
+ * instead it is a helper if you use SMC.
+ *
+ * if you want to specify S as vector then use more generic glm_mat4_rmc() func.
+ *
+ * Example usage:
+ *  B(s) = glm_smc(s, GLM_BEZIER_MAT, (vec4){p0, c0, c1, p1})
+ *
+ * @param[in]  s  parameter between 0 and 1 (this will be [s3, s2, s, 1])
+ * @param[in]  m  basis matrix
+ * @param[in]  c  position/control vector
+ *
+ * @return B(s)
+ */
+CGLM_INLINE
+float
+glm_smc(float s, const mat4 m, const vec4 c) {
+  vec4 vs;
+  glm_vec4_cubic(s, vs);
+  return glm_mat4_rmc(vs, m, c);
+}
+
+#endif /* cglm_curve_h */

include/cglm/euler.h

@@ -57,7 +57,7 @@ typedef enum glm_euler_sq {
 
 CGLM_INLINE
 glm_euler_sq
-glm_euler_order(int ord[3]) {
+glm_euler_order(const int ord[3]) {
   return (glm_euler_sq)(ord[0] << 0 | ord[1] << 2 | ord[2] << 4);
 }
 
@@ -69,7 +69,7 @@ glm_euler_order(int ord[3]) {
  */
 CGLM_INLINE
 void
-glm_euler_angles(mat4 m, vec3 dest) {
+glm_euler_angles(const mat4 m, vec3 dest) {
   float m00, m01, m10, m11, m20, m21, m22;
   float thetaX, thetaY, thetaZ;
 
@@ -107,7 +107,7 @@ glm_euler_angles(mat4 m, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_euler_xyz(vec3 angles, mat4 dest) {
+glm_euler_xyz(const vec3 angles, mat4 dest) {
   float cx, cy, cz,
         sx, sy, sz, czsx, cxcz, sysz;
 
@@ -145,7 +145,7 @@ glm_euler_xyz(vec3 angles, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_euler(vec3 angles, mat4 dest) {
+glm_euler(const vec3 angles, mat4 dest) {
   glm_euler_xyz(angles, dest);
 }
 
@@ -157,7 +157,7 @@ glm_euler(vec3 angles, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_euler_xzy(vec3 angles, mat4 dest) {
+glm_euler_xzy(const vec3 angles, mat4 dest) {
   float cx, cy, cz,
   sx, sy, sz, sxsy, cysx, cxsy, cxcy;
 
@@ -197,7 +197,7 @@ glm_euler_xzy(vec3 angles, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_euler_yxz(vec3 angles, mat4 dest) {
+glm_euler_yxz(const vec3 angles, mat4 dest) {
   float cx, cy, cz,
         sx, sy, sz, cycz, sysz, czsy, cysz;
 
@@ -236,7 +236,7 @@ glm_euler_yxz(vec3 angles, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_euler_yzx(vec3 angles, mat4 dest) {
+glm_euler_yzx(const vec3 angles, mat4 dest) {
   float cx, cy, cz,
         sx, sy, sz, sxsy, cxcy, cysx, cxsy;
 
@@ -275,7 +275,7 @@ glm_euler_yzx(vec3 angles, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_euler_zxy(vec3 angles, mat4 dest) {
+glm_euler_zxy(const vec3 angles, mat4 dest) {
   float cx, cy, cz,
         sx, sy, sz, cycz, sxsy, cysz;
 
@@ -313,7 +313,7 @@ glm_euler_zxy(vec3 angles, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_euler_zyx(vec3 angles, mat4 dest) {
+glm_euler_zyx(const vec3 angles, mat4 dest) {
   float cx, cy, cz,
         sx, sy, sz, czsx, cxcz, sysz;
 
@@ -352,7 +352,7 @@ glm_euler_zyx(vec3 angles, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_euler_by_order(vec3 angles, glm_euler_sq ord, mat4 dest) {
+glm_euler_by_order(const vec3 angles, glm_euler_sq ord, mat4 dest) {
   float cx, cy, cz,
         sx, sy, sz;
 

include/cglm/frustum.h

@@ -69,7 +69,7 @@
  */
 CGLM_INLINE
 void
-glm_frustum_planes(mat4 m, vec4 dest[6]) {
+glm_frustum_planes(const mat4 m, vec4 dest[6]) {
   mat4 t;
 
   glm_mat4_transpose_to(m, t);
@@ -114,7 +114,7 @@ glm_frustum_planes(mat4 m, vec4 dest[6]) {
  */
 CGLM_INLINE
 void
-glm_frustum_corners(mat4 invMat, vec4 dest[8]) {
+glm_frustum_corners(const mat4 invMat, vec4 dest[8]) {
   vec4 c[8];
 
   /* indexOf(nearCoord) = indexOf(farCoord) + 4 */
@@ -157,7 +157,7 @@ glm_frustum_corners(mat4 invMat, vec4 dest[8]) {
  */
 CGLM_INLINE
 void
-glm_frustum_center(vec4 corners[8], vec4 dest) {
+glm_frustum_center(const vec4 corners[8], vec4 dest) {
   vec4 center;
 
   glm_vec4_copy(corners[0], center);
@@ -182,7 +182,7 @@ glm_frustum_center(vec4 corners[8], vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_frustum_box(vec4 corners[8], mat4 m, vec3 box[2]) {
+glm_frustum_box(const vec4 corners[8], const mat4 m, vec3 box[2]) {
   vec4 v;
   vec3 min, max;
   int  i;
@@ -220,7 +220,7 @@ glm_frustum_box(vec4 corners[8], mat4 m, vec3 box[2]) {
  */
 CGLM_INLINE
 void
-glm_frustum_corners_at(vec4  corners[8],
+glm_frustum_corners_at(const vec4 corners[8],
                        float      splitDist,
                        float      farDist,
                        vec4       planeCorners[4]) {

include/cglm/io.h

@@ -25,8 +25,8 @@
 
 CGLM_INLINE
 void
-glm_mat4_print(mat4              matrix,
-               FILE * __restrict ostream) {
+glm_mat4_print(const mat4              matrix,
+               FILE * const __restrict ostream) {
   int i;
   int j;
 
@@ -55,8 +55,8 @@ glm_mat4_print(mat4              matrix,
 
 CGLM_INLINE
 void
-glm_mat3_print(mat3              matrix,
-               FILE * __restrict ostream) {
+glm_mat3_print(const mat3              matrix,
+               FILE * const __restrict ostream) {
   int i;
   int j;
 
@@ -85,8 +85,8 @@ glm_mat3_print(mat3              matrix,
 
 CGLM_INLINE
 void
-glm_vec4_print(vec4              vec,
-               FILE * __restrict ostream) {
+glm_vec4_print(const vec4              vec,
+               FILE * const __restrict ostream) {
   int i;
 
 #define m 4
@@ -107,8 +107,8 @@ glm_vec4_print(vec4              vec,
 
 CGLM_INLINE
 void
-glm_vec3_print(vec3              vec,
-               FILE * __restrict ostream) {
+glm_vec3_print(const vec3              vec,
+               FILE * const __restrict ostream) {
   int i;
 
 #define m 3
@@ -129,8 +129,8 @@ glm_vec3_print(vec3              vec,
 
 CGLM_INLINE
 void
-glm_ivec3_print(ivec3             vec,
-                FILE * __restrict ostream) {
+glm_ivec3_print(const ivec3             vec,
+                FILE * const __restrict ostream) {
   int i;
 
 #define m 3
@@ -151,8 +151,8 @@ glm_ivec3_print(ivec3             vec,
 
 CGLM_INLINE
 void
-glm_versor_print(versor            vec,
-                 FILE * __restrict ostream) {
+glm_versor_print(const versor            vec,
+                 FILE * const __restrict ostream) {
   int i;
 
 #define m 4
@@ -173,9 +173,9 @@ glm_versor_print(versor            vec,
 
 CGLM_INLINE
 void
-glm_aabb_print(vec3                    bbox[2],
+glm_aabb_print(const vec3              bbox[2],
                const char * __restrict tag,
-               FILE       * __restrict ostream) {
+               FILE * const __restrict ostream) {
   int i, j;
 
 #define m 3

include/cglm/mat3.h

@@ -17,16 +17,19 @@
    CGLM_INLINE void  glm_mat3_copy(mat3 mat, mat3 dest);
    CGLM_INLINE void  glm_mat3_identity(mat3 mat);
    CGLM_INLINE void  glm_mat3_identity_array(mat3 * restrict mat, size_t count);
+   CGLM_INLINE void  glm_mat3_zero(mat3 mat);
    CGLM_INLINE void  glm_mat3_mul(mat3 m1, mat3 m2, mat3 dest);
    CGLM_INLINE void  glm_mat3_transpose_to(mat3 m, mat3 dest);
    CGLM_INLINE void  glm_mat3_transpose(mat3 m);
    CGLM_INLINE void  glm_mat3_mulv(mat3 m, vec3 v, vec3 dest);
    CGLM_INLINE float glm_mat3_trace(mat3 m);
+   CGLM_INLINE void  glm_mat3_quat(mat3 m, versor dest);
    CGLM_INLINE void  glm_mat3_scale(mat3 m, float s);
    CGLM_INLINE float glm_mat3_det(mat3 mat);
    CGLM_INLINE void  glm_mat3_inv(mat3 mat, mat3 dest);
    CGLM_INLINE void  glm_mat3_swap_col(mat3 mat, int col1, int col2);
    CGLM_INLINE void  glm_mat3_swap_row(mat3 mat, int row1, int row2);
+   CGLM_INLINE float glm_mat3_rmc(vec3 r, mat3 m, vec3 c);
  */
 
 #ifndef cglm_mat3_h
@@ -62,8 +65,18 @@
  */
 CGLM_INLINE
 void
-glm_mat3_copy(mat3 mat, mat3 dest) {
-  glm__memcpy(float, dest, mat, sizeof(mat3));
+glm_mat3_copy(const mat3 mat, mat3 dest) {
+  dest[0][0] = mat[0][0];
+  dest[0][1] = mat[0][1];
+  dest[0][2] = mat[0][2];
+
+  dest[1][0] = mat[1][0];
+  dest[1][1] = mat[1][1];
+  dest[1][2] = mat[1][2];
+
+  dest[2][0] = mat[2][0];
+  dest[2][1] = mat[2][1];
+  dest[2][2] = mat[2][2];
 }
 
 /*!
@@ -97,7 +110,7 @@ glm_mat3_identity(mat3 mat) {
  */
 CGLM_INLINE
 void
-glm_mat3_identity_array(mat3 * __restrict mat, size_t count) {
+glm_mat3_identity_array(mat3 * const __restrict mat, size_t count) {
   CGLM_ALIGN_MAT mat3 t = GLM_MAT3_IDENTITY_INIT;
   size_t i;
 
@@ -106,6 +119,18 @@ glm_mat3_identity_array(mat3 * __restrict mat, size_t count) {
   }
 }
 
+/*!
+ * @brief make given matrix zero.
+ *
+ * @param[in, out]  mat  matrix
+ */
+CGLM_INLINE
+void
+glm_mat3_zero(mat3 mat) {
+  CGLM_ALIGN_MAT mat3 t = GLM_MAT3_ZERO_INIT;
+  glm_mat3_copy(t, mat);
+}
+
 /*!
  * @brief multiply m1 and m2 to dest
  *
@@ -122,7 +147,7 @@ glm_mat3_identity_array(mat3 * __restrict mat, size_t count) {
  */
 CGLM_INLINE
 void
-glm_mat3_mul(mat3 m1, mat3 m2, mat3 dest) {
+glm_mat3_mul(const mat3 m1, const mat3 m2, mat3 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glm_mat3_mul_sse2(m1, m2, dest);
 #else
@@ -156,7 +181,7 @@ glm_mat3_mul(mat3 m1, mat3 m2, mat3 dest) {
  */
 CGLM_INLINE
 void
-glm_mat3_transpose_to(mat3 m, mat3 dest) {
+glm_mat3_transpose_to(const mat3 m, mat3 dest) {
   dest[0][0] = m[0][0];
   dest[0][1] = m[1][0];
   dest[0][2] = m[2][0];
@@ -202,7 +227,7 @@ glm_mat3_transpose(mat3 m) {
  */
 CGLM_INLINE
 void
-glm_mat3_mulv(mat3 m, vec3 v, vec3 dest) {
+glm_mat3_mulv(const mat3 m, const vec3 v, vec3 dest) {
   dest[0] = m[0][0] * v[0] + m[1][0] * v[1] + m[2][0] * v[2];
   dest[1] = m[0][1] * v[0] + m[1][1] * v[1] + m[2][1] * v[2];
   dest[2] = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2];
@@ -217,7 +242,7 @@ glm_mat3_mulv(mat3 m, vec3 v, vec3 dest) {
  */
 CGLM_INLINE
 float
-glm_mat3_trace(mat3 m) {
+glm_mat3_trace(const mat3 m) {
   return m[0][0] + m[1][1] + m[2][2];
 }
 
@@ -229,7 +254,7 @@ glm_mat3_trace(mat3 m) {
  */
 CGLM_INLINE
 void
-glm_mat3_quat(mat3 m, versor dest) {
+glm_mat3_quat(const mat3 m, versor dest) {
   float trace, r, rinv;
 
   /* it seems using like m12 instead of m[1][2] causes extra instructions */
@@ -295,7 +320,7 @@ glm_mat3_scale(mat3 m, float s) {
  */
 CGLM_INLINE
 float
-glm_mat3_det(mat3 mat) {
+glm_mat3_det(const mat3 mat) {
   float a = mat[0][0], b = mat[0][1], c = mat[0][2],
         d = mat[1][0], e = mat[1][1], f = mat[1][2],
         g = mat[2][0], h = mat[2][1], i = mat[2][2];
@@ -311,7 +336,7 @@ glm_mat3_det(mat3 mat) {
  */
 CGLM_INLINE
 void
-glm_mat3_inv(mat3 mat, mat3 dest) {
+glm_mat3_inv(const mat3 mat, mat3 dest) {
   float det;
   float a = mat[0][0], b = mat[0][1], c = mat[0][2],
         d = mat[1][0], e = mat[1][1], f = mat[1][2],
@@ -372,4 +397,26 @@ glm_mat3_swap_row(mat3 mat, int row1, int row2) {
   mat[2][row2] = tmp[2];
 }
 
+/*!
+ * @brief helper for  R (row vector) * M (matrix) * C (column vector)
+ *
+ * rmc stands for Row * Matrix * Column
+ *
+ * the result is scalar because R * M = Matrix1x3 (row vector),
+ * then Matrix1x3 * Vec3 (column vector) = Matrix1x1 (Scalar)
+ *
+ * @param[in]  r   row vector or matrix1x3
+ * @param[in]  m   matrix3x3
+ * @param[in]  c   column vector or matrix3x1
+ *
+ * @return scalar value e.g. Matrix1x1
+ */
+CGLM_INLINE
+float
+glm_mat3_rmc(const vec3 r, const mat3 m, const vec3 c) {
+  vec3 tmp;
+  glm_mat3_mulv(m, c, tmp);
+  return glm_vec3_dot(r, tmp);
+}
+
 #endif /* cglm_mat3_h */

include/cglm/mat4.h

@@ -22,6 +22,7 @@
    CGLM_INLINE void  glm_mat4_copy(mat4 mat, mat4 dest);
    CGLM_INLINE void  glm_mat4_identity(mat4 mat);
    CGLM_INLINE void  glm_mat4_identity_array(mat4 * restrict mat, size_t count);
+   CGLM_INLINE void  glm_mat4_zero(mat4 mat);
    CGLM_INLINE void  glm_mat4_pick3(mat4 mat, mat3 dest);
    CGLM_INLINE void  glm_mat4_pick3t(mat4 mat, mat3 dest);
    CGLM_INLINE void  glm_mat4_ins3(mat3 mat, mat4 dest);
@@ -31,6 +32,7 @@
    CGLM_INLINE void  glm_mat4_mulv3(mat4 m, vec3 v, vec3 dest);
    CGLM_INLINE float glm_mat4_trace(mat4 m);
    CGLM_INLINE float glm_mat4_trace3(mat4 m);
+   CGLM_INLINE void  glm_mat4_quat(mat4 m, versor dest) ;
    CGLM_INLINE void  glm_mat4_transpose_to(mat4 m, mat4 dest);
    CGLM_INLINE void  glm_mat4_transpose(mat4 m);
    CGLM_INLINE void  glm_mat4_scale_p(mat4 m, float s);
@@ -40,6 +42,7 @@
    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);
+   CGLM_INLINE float glm_mat4_rmc(vec4 r, mat4 m, vec4 c);
  */
 
 #ifndef cglm_mat_h
@@ -97,8 +100,16 @@
  */
 CGLM_INLINE
 void
-glm_mat4_ucopy(mat4 mat, mat4 dest) {
-  glm__memcpy(float, dest, mat, sizeof(mat4));
+glm_mat4_ucopy(const mat4 mat, mat4 dest) {
+  dest[0][0] = mat[0][0];  dest[1][0] = mat[1][0];
+  dest[0][1] = mat[0][1];  dest[1][1] = mat[1][1];
+  dest[0][2] = mat[0][2];  dest[1][2] = mat[1][2];
+  dest[0][3] = mat[0][3];  dest[1][3] = mat[1][3];
+
+  dest[2][0] = mat[2][0];  dest[3][0] = mat[3][0];
+  dest[2][1] = mat[2][1];  dest[3][1] = mat[3][1];
+  dest[2][2] = mat[2][2];  dest[3][2] = mat[3][2];
+  dest[2][3] = mat[2][3];  dest[3][3] = mat[3][3];
 }
 
 /*!
@@ -109,7 +120,7 @@ glm_mat4_ucopy(mat4 mat, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_mat4_copy(mat4 mat, mat4 dest) {
+glm_mat4_copy(const mat4 mat, mat4 dest) {
 #ifdef __AVX__
   glmm_store256(dest[0], glmm_load256(mat[0]));
   glmm_store256(dest[2], glmm_load256(mat[2]));
@@ -118,6 +129,11 @@ glm_mat4_copy(mat4 mat, mat4 dest) {
   glmm_store(dest[1], glmm_load(mat[1]));
   glmm_store(dest[2], glmm_load(mat[2]));
   glmm_store(dest[3], glmm_load(mat[3]));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest[0], vld1q_f32(mat[0]));
+  vst1q_f32(dest[1], vld1q_f32(mat[1]));
+  vst1q_f32(dest[2], vld1q_f32(mat[2]));
+  vst1q_f32(dest[3], vld1q_f32(mat[3]));
 #else
   glm_mat4_ucopy(mat, dest);
 #endif
@@ -154,7 +170,7 @@ glm_mat4_identity(mat4 mat) {
  */
 CGLM_INLINE
 void
-glm_mat4_identity_array(mat4 * __restrict mat, size_t count) {
+glm_mat4_identity_array(mat4 * const __restrict mat, size_t count) {
   CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
   size_t i;
 
@@ -163,6 +179,18 @@ glm_mat4_identity_array(mat4 * __restrict mat, size_t count) {
   }
 }
 
+/*!
+ * @brief make given matrix zero.
+ *
+ * @param[in, out]  mat  matrix
+ */
+CGLM_INLINE
+void
+glm_mat4_zero(mat4 mat) {
+  CGLM_ALIGN_MAT mat4 t = GLM_MAT4_ZERO_INIT;
+  glm_mat4_copy(t, mat);
+}
+
 /*!
  * @brief copy upper-left of mat4 to mat3
  *
@@ -171,7 +199,7 @@ glm_mat4_identity_array(mat4 * __restrict mat, size_t count) {
  */
 CGLM_INLINE
 void
-glm_mat4_pick3(mat4 mat, mat3 dest) {
+glm_mat4_pick3(const mat4 mat, mat3 dest) {
   dest[0][0] = mat[0][0];
   dest[0][1] = mat[0][1];
   dest[0][2] = mat[0][2];
@@ -195,7 +223,7 @@ glm_mat4_pick3(mat4 mat, mat3 dest) {
  */
 CGLM_INLINE
 void
-glm_mat4_pick3t(mat4 mat, mat3 dest) {
+glm_mat4_pick3t(const mat4 mat, mat3 dest) {
   dest[0][0] = mat[0][0];
   dest[0][1] = mat[1][0];
   dest[0][2] = mat[2][0];
@@ -217,7 +245,7 @@ glm_mat4_pick3t(mat4 mat, mat3 dest) {
  */
 CGLM_INLINE
 void
-glm_mat4_ins3(mat3 mat, mat4 dest) {
+glm_mat4_ins3(const mat3 mat, mat4 dest) {
   dest[0][0] = mat[0][0];
   dest[0][1] = mat[0][1];
   dest[0][2] = mat[0][2];
@@ -247,12 +275,12 @@ glm_mat4_ins3(mat3 mat, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_mat4_mul(mat4 m1, mat4 m2, mat4 dest) {
+glm_mat4_mul(const mat4 m1, const mat4 m2, mat4 dest) {
 #ifdef __AVX__
   glm_mat4_mul_avx(m1, m2, dest);
 #elif defined( __SSE__ ) || defined( __SSE2__ )
   glm_mat4_mul_sse2(m1, m2, dest);
-#elif defined( __ARM_NEON_FP )
+#elif defined(CGLM_NEON_FP)
   glm_mat4_mul_neon(m1, m2, dest);
 #else
   float a00 = m1[0][0], a01 = m1[0][1], a02 = m1[0][2], a03 = m1[0][3],
@@ -305,7 +333,7 @@ glm_mat4_mul(mat4 m1, mat4 m2, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_mat4_mulN(mat4 * __restrict matrices[], uint32_t len, mat4 dest) {
+glm_mat4_mulN(mat4 * const __restrict matrices[], uint32_t len, mat4 dest) {
   uint32_t i;
 
 #ifdef DEBUG
@@ -327,7 +355,7 @@ glm_mat4_mulN(mat4 * __restrict matrices[], uint32_t len, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_mat4_mulv(mat4 m, vec4 v, vec4 dest) {
+glm_mat4_mulv(const mat4 m, const vec4 v, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glm_mat4_mulv_sse2(m, v, dest);
 #else
@@ -349,7 +377,7 @@ glm_mat4_mulv(mat4 m, vec4 v, vec4 dest) {
  */
 CGLM_INLINE
 float
-glm_mat4_trace(mat4 m) {
+glm_mat4_trace(const mat4 m) {
   return m[0][0] + m[1][1] + m[2][2] + m[3][3];
 }
 
@@ -362,7 +390,7 @@ glm_mat4_trace(mat4 m) {
  */
 CGLM_INLINE
 float
-glm_mat4_trace3(mat4 m) {
+glm_mat4_trace3(const mat4 m) {
   return m[0][0] + m[1][1] + m[2][2];
 }
 
@@ -374,7 +402,7 @@ glm_mat4_trace3(mat4 m) {
  */
 CGLM_INLINE
 void
-glm_mat4_quat(mat4 m, versor dest) {
+glm_mat4_quat(const mat4 m, versor dest) {
   float trace, r, rinv;
 
   /* it seems using like m12 instead of m[1][2] causes extra instructions */
@@ -425,7 +453,7 @@ glm_mat4_quat(mat4 m, versor dest) {
  */
 CGLM_INLINE
 void
-glm_mat4_mulv3(mat4 m, vec3 v, float last, vec3 dest) {
+glm_mat4_mulv3(const mat4 m, const vec3 v, float last, vec3 dest) {
   vec4 res;
   glm_vec4(v, last, res);
   glm_mat4_mulv(m, res, res);
@@ -442,7 +470,7 @@ glm_mat4_mulv3(mat4 m, vec3 v, float last, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_mat4_transpose_to(mat4 m, mat4 dest) {
+glm_mat4_transpose_to(const mat4 m, mat4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glm_mat4_transp_sse2(m, dest);
 #else
@@ -469,10 +497,8 @@ glm_mat4_transpose(mat4 m) {
   glm_mat4_transp_sse2(m, m);
 #else
   mat4 d;
-
   glm_mat4_transpose_to(m, d);
-
-  glm__memcpy(float, m, d, sizeof(mat4));
+  glm_mat4_ucopy(d, m);
 #endif
 }
 
@@ -506,6 +532,13 @@ void
 glm_mat4_scale(mat4 m, float s) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glm_mat4_scale_sse2(m, s);
+#elif defined(CGLM_NEON_FP)
+  float32x4_t v0;
+  v0 = vdupq_n_f32(s);
+  vst1q_f32(m[0], vmulq_f32(vld1q_f32(m[0]), v0));
+  vst1q_f32(m[1], vmulq_f32(vld1q_f32(m[1]), v0));
+  vst1q_f32(m[2], vmulq_f32(vld1q_f32(m[2]), v0));
+  vst1q_f32(m[3], vmulq_f32(vld1q_f32(m[3]), v0));
 #else
   glm_mat4_scale_p(m, s);
 #endif
@@ -520,7 +553,7 @@ glm_mat4_scale(mat4 m, float s) {
  */
 CGLM_INLINE
 float
-glm_mat4_det(mat4 mat) {
+glm_mat4_det(const mat4 mat) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   return glm_mat4_det_sse2(mat);
 #else
@@ -553,7 +586,7 @@ glm_mat4_det(mat4 mat) {
  */
 CGLM_INLINE
 void
-glm_mat4_inv(mat4 mat, mat4 dest) {
+glm_mat4_inv(const mat4 mat, mat4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glm_mat4_inv_sse2(mat, dest);
 #else
@@ -614,7 +647,7 @@ glm_mat4_inv(mat4 mat, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_mat4_inv_fast(mat4 mat, mat4 dest) {
+glm_mat4_inv_fast(const mat4 mat, mat4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glm_mat4_inv_fast_sse2(mat, dest);
 #else
@@ -647,7 +680,7 @@ glm_mat4_swap_col(mat4 mat, int col1, int col2) {
  */
 CGLM_INLINE
 void
-glm_mat4_swap_row(mat4 mat, int row1, int row2) {
+glm_mat4_swap_row(mat4 mat, const int row1, const int row2) {
   CGLM_ALIGN(16) vec4 tmp;
   tmp[0] = mat[0][row1];
   tmp[1] = mat[1][row1];
@@ -665,4 +698,26 @@ glm_mat4_swap_row(mat4 mat, int row1, int row2) {
   mat[3][row2] = tmp[3];
 }
 
+/*!
+ * @brief helper for  R (row vector) * M (matrix) * C (column vector)
+ *
+ * rmc stands for Row * Matrix * Column
+ *
+ * the result is scalar because R * M = Matrix1x4 (row vector),
+ * then Matrix1x4 * Vec4 (column vector) = Matrix1x1 (Scalar)
+ *
+ * @param[in]  r   row vector or matrix1x4
+ * @param[in]  m   matrix4x4
+ * @param[in]  c   column vector or matrix4x1
+ *
+ * @return scalar value e.g. B(s)
+ */
+CGLM_INLINE
+float
+glm_mat4_rmc(const vec4 r, const mat4 m, const vec4 c) {
+  vec4 tmp;
+  glm_mat4_mulv(m, c, tmp);
+  return glm_vec4_dot(r, tmp);
+}
+
 #endif /* cglm_mat_h */

include/cglm/project.h

@@ -8,6 +8,7 @@
 #ifndef cglm_project_h
 #define cglm_project_h
 
+#include "common.h"
 #include "vec3.h"
 #include "vec4.h"
 #include "mat4.h"
@@ -40,7 +41,7 @@
  */
 CGLM_INLINE
 void
-glm_unprojecti(vec3 pos, mat4 invMat, vec4 vp, vec3 dest) {
+glm_unprojecti(const vec3 pos, const mat4 invMat, const vec4 vp, vec3 dest) {
   vec4 v;
 
   v[0] = 2.0f * (pos[0] - vp[0]) / vp[2] - 1.0f;
@@ -79,7 +80,7 @@ glm_unprojecti(vec3 pos, mat4 invMat, vec4 vp, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_unproject(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
+glm_unproject(const vec3 pos, const mat4 m, const vec4 vp, vec3 dest) {
   mat4 inv;
   glm_mat4_inv(m, inv);
   glm_unprojecti(pos, inv, vp, dest);
@@ -99,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) {
+glm_project(const vec3 pos, const mat4 m, const vec4 vp, vec3 dest) {
   CGLM_ALIGN(16) vec4 pos4, vone = GLM_VEC4_ONE_INIT;
 
   glm_vec4(pos, 1.0f, pos4);

include/cglm/quat.h

@@ -68,15 +68,15 @@ glm_mat4_identity(mat4 mat);
 
 CGLM_INLINE
 void
-glm_mat4_mulv(mat4 m, vec4 v, vec4 dest);
+glm_mat4_mulv(const mat4 m, const vec4 v, vec4 dest);
 
 CGLM_INLINE
 void
-glm_mul_rot(mat4 m1, mat4 m2, mat4 dest);
+glm_mul_rot(const mat4 m1, const mat4 m2, mat4 dest);
 
 CGLM_INLINE
 void
-glm_translate(mat4 m, vec3 v);
+glm_translate(mat4 m, const vec3 v);
 
 /*
  * IMPORTANT:
@@ -113,7 +113,7 @@ glm_quat_identity(versor q) {
  */
 CGLM_INLINE
 void
-glm_quat_identity_array(versor * __restrict q, size_t count) {
+glm_quat_identity_array(versor * const __restrict q, size_t count) {
   CGLM_ALIGN(16) versor v = GLM_QUAT_IDENTITY_INIT;
   size_t i;
 
@@ -149,7 +149,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) {
+glm_quatv(versor q, float angle, const vec3 axis) {
   CGLM_ALIGN(8) vec3 k;
   float a, c, s;
 
@@ -189,7 +189,7 @@ glm_quat(versor q, float angle, float x, float y, float z) {
  */
 CGLM_INLINE
 void
-glm_quat_copy(versor q, versor dest) {
+glm_quat_copy(const versor q, versor dest) {
   glm_vec4_copy(q, dest);
 }
 
@@ -200,7 +200,7 @@ glm_quat_copy(versor q, versor dest) {
  */
 CGLM_INLINE
 float
-glm_quat_norm(versor q) {
+glm_quat_norm(const versor q) {
   return glm_vec4_norm(q);
 }
 
@@ -212,13 +212,13 @@ glm_quat_norm(versor q) {
  */
 CGLM_INLINE
 void
-glm_quat_normalize_to(versor q, versor dest) {
+glm_quat_normalize_to(const versor q, versor dest) {
 #if defined( __SSE2__ ) || defined( __SSE2__ )
   __m128 xdot, x0;
   float  dot;
 
   x0   = glmm_load(q);
-  xdot = glmm_dot(x0, x0);
+  xdot = glmm_vdot(x0, x0);
   dot  = _mm_cvtss_f32(xdot);
 
   if (dot <= 0.0f) {
@@ -260,7 +260,7 @@ glm_quat_normalize(versor q) {
  */
 CGLM_INLINE
 float
-glm_quat_dot(versor p, versor q) {
+glm_quat_dot(const versor p, const versor q) {
   return glm_vec4_dot(p, q);
 }
 
@@ -272,7 +272,7 @@ glm_quat_dot(versor p, versor q) {
  */
 CGLM_INLINE
 void
-glm_quat_conjugate(versor q, versor dest) {
+glm_quat_conjugate(const versor q, versor dest) {
   glm_vec4_negate_to(q, dest);
   dest[3] = -dest[3];
 }
@@ -285,7 +285,7 @@ glm_quat_conjugate(versor q, versor dest) {
  */
 CGLM_INLINE
 void
-glm_quat_inv(versor q, versor dest) {
+glm_quat_inv(const versor q, versor dest) {
   CGLM_ALIGN(16) versor conj;
   glm_quat_conjugate(q, conj);
   glm_vec4_scale(conj, 1.0f / glm_vec4_norm2(q), dest);
@@ -300,7 +300,7 @@ glm_quat_inv(versor q, versor dest) {
  */
 CGLM_INLINE
 void
-glm_quat_add(versor p, versor q, versor dest) {
+glm_quat_add(const versor p, const versor q, versor dest) {
   glm_vec4_add(p, q, dest);
 }
 
@@ -313,7 +313,7 @@ glm_quat_add(versor p, versor q, versor dest) {
  */
 CGLM_INLINE
 void
-glm_quat_sub(versor p, versor q, versor dest) {
+glm_quat_sub(const versor p, const versor q, versor dest) {
   glm_vec4_sub(p, q, dest);
 }
 
@@ -324,7 +324,7 @@ glm_quat_sub(versor p, versor q, versor dest) {
  */
 CGLM_INLINE
 float
-glm_quat_real(versor q) {
+glm_quat_real(const versor q) {
   return q[3];
 }
 
@@ -336,7 +336,7 @@ glm_quat_real(versor q) {
  */
 CGLM_INLINE
 void
-glm_quat_imag(versor q, vec3 dest) {
+glm_quat_imag(const versor q, vec3 dest) {
   dest[0] = q[0];
   dest[1] = q[1];
   dest[2] = q[2];
@@ -349,7 +349,7 @@ glm_quat_imag(versor q, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_quat_imagn(versor q, vec3 dest) {
+glm_quat_imagn(const versor q, vec3 dest) {
   glm_normalize_to(q, dest);
 }
 
@@ -360,7 +360,7 @@ glm_quat_imagn(versor q, vec3 dest) {
  */
 CGLM_INLINE
 float
-glm_quat_imaglen(versor q) {
+glm_quat_imaglen(const versor q) {
   return glm_vec3_norm(q);
 }
 
@@ -371,7 +371,7 @@ glm_quat_imaglen(versor q) {
  */
 CGLM_INLINE
 float
-glm_quat_angle(versor q) {
+glm_quat_angle(const versor q) {
   /*
    sin(theta / 2) = length(x*x + y*y + z*z)
    cos(theta / 2) = w
@@ -388,7 +388,7 @@ glm_quat_angle(versor q) {
  */
 CGLM_INLINE
 void
-glm_quat_axis(versor q, versor dest) {
+glm_quat_axis(const versor q, versor dest) {
   glm_quat_imagn(q, dest);
 }
 
@@ -406,7 +406,7 @@ glm_quat_axis(versor q, versor dest) {
  */
 CGLM_INLINE
 void
-glm_quat_mul(versor p, versor q, versor dest) {
+glm_quat_mul(const versor p, const versor q, versor dest) {
   /*
     + (a1 b2 + b1 a2 + c1 d2 − d1 c2)i
     + (a1 c2 − b1 d2 + c1 a2 + d1 b2)j
@@ -431,7 +431,7 @@ glm_quat_mul(versor p, versor q, versor dest) {
  */
 CGLM_INLINE
 void
-glm_quat_mat4(versor q, mat4 dest) {
+glm_quat_mat4(const versor q, mat4 dest) {
   float w, x, y, z,
         xx, yy, zz,
         xy, yz, xz,
@@ -478,7 +478,7 @@ glm_quat_mat4(versor q, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_quat_mat4t(versor q, mat4 dest) {
+glm_quat_mat4t(const versor q, mat4 dest) {
   float w, x, y, z,
         xx, yy, zz,
         xy, yz, xz,
@@ -525,7 +525,7 @@ glm_quat_mat4t(versor q, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_quat_mat3(versor q, mat3 dest) {
+glm_quat_mat3(const versor q, mat3 dest) {
   float w, x, y, z,
         xx, yy, zz,
         xy, yz, xz,
@@ -564,7 +564,7 @@ glm_quat_mat3(versor q, mat3 dest) {
  */
 CGLM_INLINE
 void
-glm_quat_mat3t(versor q, mat3 dest) {
+glm_quat_mat3t(const versor q, mat3 dest) {
   float w, x, y, z,
         xx, yy, zz,
         xy, yz, xz,
@@ -606,7 +606,7 @@ glm_quat_mat3t(versor q, mat3 dest) {
  */
 CGLM_INLINE
 void
-glm_quat_lerp(versor from, versor to, float t, versor dest) {
+glm_quat_lerp(const versor from, const versor to, float t, versor dest) {
   glm_vec4_lerp(from, to, t, dest);
 }
 
@@ -621,7 +621,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) {
+glm_quat_slerp(const versor from, const versor to, float t, versor dest) {
   CGLM_ALIGN(16) vec4 q1, q2;
   float cosTheta, sinTheta, angle;
 
@@ -664,7 +664,7 @@ glm_quat_slerp(versor from, versor to, float t, versor dest) {
  */
 CGLM_INLINE
 void
-glm_quat_look(vec3 eye, versor ori, mat4 dest) {
+glm_quat_look(const vec3 eye, const versor ori, mat4 dest) {
   /* orientation */
   glm_quat_mat4t(ori, dest);
 
@@ -683,7 +683,7 @@ glm_quat_look(vec3 eye, versor ori, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest) {
+glm_quat_for(const vec3 dir, const vec3 fwd, const vec3 up, versor dest) {
   CGLM_ALIGN(8) vec3 axis;
   float dot, angle;
 
@@ -717,7 +717,11 @@ 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) {
+glm_quat_forp(const vec3 from,
+              const vec3 to,
+              const vec3 fwd,
+              const vec3 up,
+              versor     dest) {
   CGLM_ALIGN(8) vec3 dir;
   glm_vec3_sub(to, from, dir);
   glm_quat_for(dir, fwd, up, dest);
@@ -732,7 +736,7 @@ 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) {
+glm_quat_rotatev(const versor q, const vec3 v, vec3 dest) {
   CGLM_ALIGN(16) versor p;
   CGLM_ALIGN(8)  vec3   u, v1, v2;
   float s;
@@ -760,7 +764,7 @@ glm_quat_rotatev(versor q, vec3 v, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_quat_rotate(mat4 m, versor q, mat4 dest) {
+glm_quat_rotate(const mat4 m, const versor q, mat4 dest) {
   CGLM_ALIGN_MAT mat4 rot;
   glm_quat_mat4(q, rot);
   glm_mul_rot(m, rot, dest);
@@ -775,7 +779,7 @@ glm_quat_rotate(mat4 m, versor q, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_quat_rotate_at(mat4 m, versor q, vec3 pivot) {
+glm_quat_rotate_at(mat4 m, const versor q, const vec3 pivot) {
   CGLM_ALIGN(8) vec3 pivotInv;
 
   glm_vec3_negate_to(pivot, pivotInv);
@@ -799,7 +803,7 @@ glm_quat_rotate_at(mat4 m, versor q, vec3 pivot) {
  */
 CGLM_INLINE
 void
-glm_quat_rotate_atm(mat4 m, versor q, vec3 pivot) {
+glm_quat_rotate_atm(mat4 m, const versor q, const vec3 pivot) {
   CGLM_ALIGN(8) vec3 pivotInv;
 
   glm_vec3_negate_to(pivot, pivotInv);

include/cglm/simd/arm.h

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglm_simd_arm_h
+#define cglm_simd_arm_h
+#include "intrin.h"
+#ifdef CGLM_SIMD_ARM
+
+#define glmm_load(p)      vld1q_f32(p)
+#define glmm_store(p, a)  vst1q_f32(p, a)
+
+static inline
+float
+glmm_hadd(float32x4_t v) {
+#if defined(__aarch64__)
+  return vaddvq_f32(v);
+#else
+  v = vaddq_f32(v, vrev64q_f32(v));
+  v = vaddq_f32(v, vcombine_f32(vget_high_f32(v), vget_low_f32(v)));
+  return vgetq_lane_f32(v, 0);
+#endif
+}
+
+static inline
+float
+glmm_dot(float32x4_t a, float32x4_t b) {
+  return glmm_hadd(vmulq_f32(a, b));
+}
+
+static inline
+float
+glmm_norm(float32x4_t a) {
+  return sqrtf(glmm_dot(a, a));
+}
+
+#endif
+#endif /* cglm_simd_arm_h */

include/cglm/simd/avx/affine.h

@@ -16,7 +16,7 @@
 
 CGLM_INLINE
 void
-glm_mul_avx(mat4 m1, mat4 m2, mat4 dest) {
+glm_mul_avx(const mat4 m1, const mat4 m2, mat4 dest) {
   /* D = R * L (Column-Major) */
 
   __m256 y0, y1, y2, y3, y4, y5, y6, y7, y8, y9;

include/cglm/simd/avx/mat4.h

@@ -16,7 +16,7 @@
 
 CGLM_INLINE
 void
-glm_mat4_mul_avx(mat4 m1, mat4 m2, mat4 dest) {
+glm_mat4_mul_avx(const mat4 m1, const mat4 m2, mat4 dest) {
   /* D = R * L (Column-Major) */
 
   __m256 y0, y1, y2, y3, y4, y5, y6, y7, y8, y9;

include/cglm/simd/intrin.h

@@ -27,90 +27,64 @@
 #if defined( __SSE__ ) || defined( __SSE2__ )
 #  include <xmmintrin.h>
 #  include <emmintrin.h>
-
-/* OPTIONAL: You may save some instructions but latency (not sure) */
-#ifdef CGLM_USE_INT_DOMAIN
-#  define glmm_shuff1(xmm, z, y, x, w)                                        \
-     _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(xmm),                \
-                                        _MM_SHUFFLE(z, y, x, w)))
-#else
-#  define glmm_shuff1(xmm, z, y, x, w)                                        \
-     _mm_shuffle_ps(xmm, xmm, _MM_SHUFFLE(z, y, x, w))
-#endif
-
-#define glmm_shuff1x(xmm, x) glmm_shuff1(xmm, x, x, x, x)
-#define glmm_shuff2(a, b, z0, y0, x0, w0, z1, y1, x1, w1)                     \
-     glmm_shuff1(_mm_shuffle_ps(a, b, _MM_SHUFFLE(z0, y0, x0, w0)),           \
-                 z1, y1, x1, w1)
-
-static inline
-__m128
-glmm_dot(__m128 a, __m128 b) {
-  __m128 x0;
-  x0 = _mm_mul_ps(a, b);
-  x0 = _mm_add_ps(x0, glmm_shuff1(x0, 1, 0, 3, 2));
-  return _mm_add_ps(x0, glmm_shuff1(x0, 0, 1, 0, 1));
-}
-
-static inline
-__m128
-glmm_norm(__m128 a) {
-  return _mm_sqrt_ps(glmm_dot(a, a));
-}
-
-static inline
-__m128
-glmm_load3(float v[3]) {
-  __m128i xy;
-  __m128  z;
-
-  xy = _mm_loadl_epi64((const __m128i *)v);
-  z  = _mm_load_ss(&v[2]);
-
-  return _mm_movelh_ps(_mm_castsi128_ps(xy), z);
-}
-
-static inline
-void
-glmm_store3(__m128 vx, float v[3]) {
-  _mm_storel_pi((__m64 *)&v[0], vx);
-  _mm_store_ss(&v[2], glmm_shuff1(vx, 2, 2, 2, 2));
-}
-
-#ifdef CGLM_ALL_UNALIGNED
-#  define glmm_load(p)      _mm_loadu_ps(p)
-#  define glmm_store(p, a)  _mm_storeu_ps(p, a)
-#else
-#  define glmm_load(p)      _mm_load_ps(p)
-#  define glmm_store(p, a)  _mm_store_ps(p, a)
-#endif
-
-#endif
-
-/* x86, x64 */
-#if defined( __SSE__ ) || defined( __SSE2__ )
 #  define CGLM_SSE_FP 1
+#  ifndef CGLM_SIMD_x86
+#    define CGLM_SIMD_x86
+#  endif
+#endif
+
+#if defined(__SSE3__)
+#  include <x86intrin.h>
+#  ifndef CGLM_SIMD_x86
+#    define CGLM_SIMD_x86
+#  endif
+#endif
+
+#if defined(__SSE4_1__)
+#  include <smmintrin.h>
+#  ifndef CGLM_SIMD_x86
+#    define CGLM_SIMD_x86
+#  endif
+#endif
+
+#if defined(__SSE4_2__)
+#  include <nmmintrin.h>
+#  ifndef CGLM_SIMD_x86
+#    define CGLM_SIMD_x86
+#  endif
 #endif
 
 #ifdef __AVX__
+#  include <immintrin.h>
 #  define CGLM_AVX_FP 1
-
-#ifdef CGLM_ALL_UNALIGNED
-#  define glmm_load256(p)      _mm256_loadu_ps(p)
-#  define glmm_store256(p, a)  _mm256_storeu_ps(p, a)
-#else
-#  define glmm_load256(p)      _mm256_load_ps(p)
-#  define glmm_store256(p, a)  _mm256_store_ps(p, a)
+#  ifndef CGLM_SIMD_x86
+#    define CGLM_SIMD_x86
 #  endif
-
 #endif
 
 /* ARM Neon */
-#if defined(__ARM_NEON) && defined(__ARM_NEON_FP)
+#if defined(__ARM_NEON)
 #  include <arm_neon.h>
+#  if defined(__ARM_NEON_FP)
 #    define CGLM_NEON_FP 1
-#else
-#  undef  CGLM_NEON_FP
+#    ifndef CGLM_SIMD_ARM
+#      define CGLM_SIMD_ARM
+#    endif
+#  endif
+#endif
+
+#if defined(CGLM_SIMD_x86) || defined(CGLM_NEON_FP)
+#  ifndef CGLM_SIMD
+#    define CGLM_SIMD
+#  endif
+#endif
+
+#if defined(CGLM_SIMD_x86)
+#  include "x86.h"
+#endif
+
+#if defined(CGLM_SIMD_ARM)
+#  include "arm.h"
 #endif
 
 #endif /* cglm_intrin_h */

include/cglm/simd/neon/mat4.h

@@ -14,7 +14,7 @@
 
 CGLM_INLINE
 void
-glm_mat4_mul_neon(mat4 m1, mat4 m2, mat4 dest) {
+glm_mat4_mul_neon(const mat4 m1, const mat4 m2, mat4 dest) {
   /* D = R * L (Column-Major) */
   float32x4_t l0, l1, l2, l3, r, d0, d1, d2, d3;
 

include/cglm/simd/sse2/affine.h

@@ -14,7 +14,7 @@
 
 CGLM_INLINE
 void
-glm_mul_sse2(mat4 m1, mat4 m2, mat4 dest) {
+glm_mul_sse2(const mat4 m1, const mat4 m2, mat4 dest) {
   /* D = R * L (Column-Major) */
   __m128 l0, l1, l2, l3, r;
 
@@ -51,7 +51,7 @@ glm_mul_sse2(mat4 m1, mat4 m2, mat4 dest) {
 
 CGLM_INLINE
 void
-glm_mul_rot_sse2(mat4 m1, mat4 m2, mat4 dest) {
+glm_mul_rot_sse2(const mat4 m1, const mat4 m2, mat4 dest) {
   /* D = R * L (Column-Major) */
   __m128 l0, l1, l2, l3, r;
 

include/cglm/simd/sse2/mat3.h

@@ -14,7 +14,7 @@
 
 CGLM_INLINE
 void
-glm_mat3_mul_sse2(mat3 m1, mat3 m2, mat3 dest) {
+glm_mat3_mul_sse2(const mat3 m1, const mat3 m2, mat3 dest) {
   __m128 l0, l1, l2;
   __m128 r0, r1, r2;
   __m128 x0, x1, x2;

include/cglm/simd/sse2/mat4.h

@@ -28,7 +28,7 @@ glm_mat4_scale_sse2(mat4 m, float s) {
 
 CGLM_INLINE
 void
-glm_mat4_transp_sse2(mat4 m, mat4 dest) {
+glm_mat4_transp_sse2(const mat4 m, mat4 dest) {
   __m128 r0, r1, r2, r3;
 
   r0 = glmm_load(m[0]);
@@ -46,7 +46,7 @@ glm_mat4_transp_sse2(mat4 m, mat4 dest) {
 
 CGLM_INLINE
 void
-glm_mat4_mul_sse2(mat4 m1, mat4 m2, mat4 dest) {
+glm_mat4_mul_sse2(const mat4 m1, const mat4 m2, mat4 dest) {
   /* D = R * L (Column-Major) */
 
   __m128 l0, l1, l2, l3, r;
@@ -85,7 +85,7 @@ glm_mat4_mul_sse2(mat4 m1, mat4 m2, mat4 dest) {
 
 CGLM_INLINE
 void
-glm_mat4_mulv_sse2(mat4 m, vec4 v, vec4 dest) {
+glm_mat4_mulv_sse2(const mat4 m, const vec4 v, vec4 dest) {
   __m128 x0, x1, x2;
 
   x0 = glmm_load(v);
@@ -100,7 +100,7 @@ glm_mat4_mulv_sse2(mat4 m, vec4 v, vec4 dest) {
 
 CGLM_INLINE
 float
-glm_mat4_det_sse2(mat4 mat) {
+glm_mat4_det_sse2(const mat4 mat) {
   __m128 r0, r1, r2, r3, x0, x1, x2;
 
   /* 127 <- 0, [square] det(A) = det(At) */
@@ -155,7 +155,7 @@ glm_mat4_det_sse2(mat4 mat) {
 
 CGLM_INLINE
 void
-glm_mat4_inv_fast_sse2(mat4 mat, mat4 dest) {
+glm_mat4_inv_fast_sse2(const mat4 mat, mat4 dest) {
   __m128 r0, r1, r2, r3,
          v0, v1, v2, v3,
          t0, t1, t2, t3, t4, t5,
@@ -279,7 +279,7 @@ glm_mat4_inv_fast_sse2(mat4 mat, mat4 dest) {
 
 CGLM_INLINE
 void
-glm_mat4_inv_sse2(mat4 mat, mat4 dest) {
+glm_mat4_inv_sse2(const mat4 mat, mat4 dest) {
   __m128 r0, r1, r2, r3,
          v0, v1, v2, v3,
          t0, t1, t2, t3, t4, t5,

include/cglm/simd/sse2/quat.h

@@ -14,7 +14,7 @@
 
 CGLM_INLINE
 void
-glm_quat_mul_sse2(versor p, versor q, versor dest) {
+glm_quat_mul_sse2(const versor p, const versor q, versor dest) {
   /*
    + (a1 b2 + b1 a2 + c1 d2 − d1 c2)i
    + (a1 c2 − b1 d2 + c1 a2 + d1 b2)j

include/cglm/simd/x86.h

@@ -0,0 +1,136 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglm_simd_x86_h
+#define cglm_simd_x86_h
+#include "intrin.h"
+#ifdef CGLM_SIMD_x86
+
+#ifdef CGLM_ALL_UNALIGNED
+#  define glmm_load(p)      _mm_loadu_ps(p)
+#  define glmm_store(p, a)  _mm_storeu_ps(p, a)
+#else
+#  define glmm_load(p)      _mm_load_ps(p)
+#  define glmm_store(p, a)  _mm_store_ps(p, a)
+#endif
+
+#ifdef CGLM_USE_INT_DOMAIN
+#  define glmm_shuff1(xmm, z, y, x, w)                                        \
+     _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(xmm),                \
+                                        _MM_SHUFFLE(z, y, x, w)))
+#else
+#  define glmm_shuff1(xmm, z, y, x, w)                                        \
+       _mm_shuffle_ps(xmm, xmm, _MM_SHUFFLE(z, y, x, w))
+#endif
+
+#define glmm_shuff1x(xmm, x) glmm_shuff1(xmm, x, x, x, x)
+#define glmm_shuff2(a, b, z0, y0, x0, w0, z1, y1, x1, w1)                     \
+     glmm_shuff1(_mm_shuffle_ps(a, b, _MM_SHUFFLE(z0, y0, x0, w0)),           \
+                 z1, y1, x1, w1)
+
+#ifdef __AVX__
+#  ifdef CGLM_ALL_UNALIGNED
+#    define glmm_load256(p)      _mm256_loadu_ps(p)
+#    define glmm_store256(p, a)  _mm256_storeu_ps(p, a)
+#  else
+#    define glmm_load256(p)      _mm256_load_ps(p)
+#    define glmm_store256(p, a)  _mm256_store_ps(p, a)
+#  endif
+#endif
+
+static inline
+__m128
+glmm_vhadds(__m128 v) {
+#if defined(__SSE3__)
+  __m128 shuf, sums;
+  shuf = _mm_movehdup_ps(v);
+  sums = _mm_add_ps(v, shuf);
+  shuf = _mm_movehl_ps(shuf, sums);
+  sums = _mm_add_ss(sums, shuf);
+  return sums;
+#else
+  __m128 shuf, sums;
+  shuf = glmm_shuff1(v, 2, 3, 0, 1);
+  sums = _mm_add_ps(v, shuf);
+  shuf = _mm_movehl_ps(shuf, sums);
+  sums = _mm_add_ss(sums, shuf);
+  return sums;
+#endif
+}
+
+static inline
+float
+glmm_hadd(__m128 v) {
+  return _mm_cvtss_f32(glmm_vhadds(v));
+}
+
+static inline
+__m128
+glmm_vdots(__m128 a, __m128 b) {
+#if (defined(__SSE4_1__) || defined(__SSE4_2__)) && defined(CGLM_SSE4_DOT)
+  return _mm_dp_ps(a, b, 0xFF);
+#elif defined(__SSE3__) && defined(CGLM_SSE3_DOT)
+  __m128 x0, x1;
+  x0 = _mm_mul_ps(a, b);
+  x1 = _mm_hadd_ps(x0, x0);
+  return _mm_hadd_ps(x1, x1);
+#else
+  return glmm_vhadds(_mm_mul_ps(a, b));
+#endif
+}
+
+static inline
+__m128
+glmm_vdot(__m128 a, __m128 b) {
+#if (defined(__SSE4_1__) || defined(__SSE4_2__)) && defined(CGLM_SSE4_DOT)
+  return _mm_dp_ps(a, b, 0xFF);
+#elif defined(__SSE3__) && defined(CGLM_SSE3_DOT)
+  __m128 x0, x1;
+  x0 = _mm_mul_ps(a, b);
+  x1 = _mm_hadd_ps(x0, x0);
+  return _mm_hadd_ps(x1, x1);
+#else
+  __m128 x0;
+  x0 = _mm_mul_ps(a, b);
+  x0 = _mm_add_ps(x0, glmm_shuff1(x0, 1, 0, 3, 2));
+  return _mm_add_ps(x0, glmm_shuff1(x0, 0, 1, 0, 1));
+#endif
+}
+
+static inline
+float
+glmm_dot(const __m128 a, const __m128 b) {
+  return _mm_cvtss_f32(glmm_vdots(a, b));
+}
+
+static inline
+float
+glmm_norm(__m128 a) {
+  return _mm_cvtss_f32(_mm_sqrt_ss(glmm_vhadds(_mm_mul_ps(a, a))));
+}
+
+static inline
+__m128
+glmm_load3(const float v[3]) {
+  __m128i xy;
+  __m128  z;
+
+  xy = _mm_loadl_epi64((const __m128i *)v);
+  z  = _mm_load_ss(&v[2]);
+
+  return _mm_movelh_ps(_mm_castsi128_ps(xy), z);
+}
+
+static inline
+void
+glmm_store3(__m128 vx, float v[3]) {
+  _mm_storel_pi((__m64 *)&v[0], vx);
+  _mm_store_ss(&v[2], glmm_shuff1(vx, 2, 2, 2, 2));
+}
+
+#endif
+#endif /* cglm_simd_x86_h */

include/cglm/sphere.h

@@ -27,7 +27,7 @@
  */
 CGLM_INLINE
 float
-glm_sphere_radii(vec4 s) {
+glm_sphere_radii(const vec4 s) {
   return s[3];
 }
 
@@ -40,7 +40,7 @@ glm_sphere_radii(vec4 s) {
  */
 CGLM_INLINE
 void
-glm_sphere_transform(vec4 s, mat4 m, vec4 dest) {
+glm_sphere_transform(const vec4 s, const mat4 m, vec4 dest) {
   glm_mat4_mulv3(m, s, 1.0f, dest);
   dest[3] = s[3];
 }
@@ -57,7 +57,7 @@ glm_sphere_transform(vec4 s, mat4 m, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_sphere_merge(vec4 s1, vec4 s2, vec4 dest) {
+glm_sphere_merge(const vec4 s1, const vec4 s2, vec4 dest) {
   float dist, radii;
 
   dist  = glm_vec3_distance(s1, s2);
@@ -78,7 +78,7 @@ glm_sphere_merge(vec4 s1, vec4 s2, vec4 dest) {
  */
 CGLM_INLINE
 bool
-glm_sphere_sphere(vec4 s1, vec4 s2) {
+glm_sphere_sphere(const vec4 s1, const vec4 s2) {
   return glm_vec3_distance2(s1, s2) <= glm_pow2(s1[3] + s2[3]);
 }
 
@@ -90,7 +90,7 @@ glm_sphere_sphere(vec4 s1, vec4 s2) {
  */
 CGLM_INLINE
 bool
-glm_sphere_point(vec4 s, vec3 point) {
+glm_sphere_point(const vec4 s, const vec3 point) {
   float rr;
   rr = s[3] * s[3];
   return glm_vec3_distance2(point, s) <= rr;

include/cglm/util.h

@@ -19,7 +19,6 @@
 #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))

include/cglm/vec3-ext.h

@@ -31,9 +31,6 @@
 
 #include "common.h"
 #include "util.h"
-#include <stdbool.h>
-#include <math.h>
-#include <float.h>
 
 /*!
  * @brief fill a vector with specified value
@@ -55,7 +52,7 @@ glm_vec3_broadcast(float val, vec3 d) {
  */
 CGLM_INLINE
 bool
-glm_vec3_eq(vec3 v, float val) {
+glm_vec3_eq(const vec3 v, float val) {
   return v[0] == val && v[0] == v[1] && v[0] == v[2];
 }
 
@@ -67,7 +64,7 @@ glm_vec3_eq(vec3 v, float val) {
  */
 CGLM_INLINE
 bool
-glm_vec3_eq_eps(vec3 v, float val) {
+glm_vec3_eq_eps(const vec3 v, float val) {
   return fabsf(v[0] - val) <= FLT_EPSILON
          && fabsf(v[1] - val) <= FLT_EPSILON
          && fabsf(v[2] - val) <= FLT_EPSILON;
@@ -80,7 +77,7 @@ glm_vec3_eq_eps(vec3 v, float val) {
  */
 CGLM_INLINE
 bool
-glm_vec3_eq_all(vec3 v) {
+glm_vec3_eq_all(const vec3 v) {
   return v[0] == v[1] && v[0] == v[2];
 }
 
@@ -92,7 +89,7 @@ glm_vec3_eq_all(vec3 v) {
  */
 CGLM_INLINE
 bool
-glm_vec3_eqv(vec3 a, vec3 b) {
+glm_vec3_eqv(const vec3 a, const vec3 b) {
   return a[0] == b[0]
          && a[1] == b[1]
          && a[2] == b[2];
@@ -106,7 +103,7 @@ glm_vec3_eqv(vec3 a, vec3 b) {
  */
 CGLM_INLINE
 bool
-glm_vec3_eqv_eps(vec3 a, vec3 b) {
+glm_vec3_eqv_eps(const vec3 a, const vec3 b) {
   return fabsf(a[0] - b[0]) <= FLT_EPSILON
          && fabsf(a[1] - b[1]) <= FLT_EPSILON
          && fabsf(a[2] - b[2]) <= FLT_EPSILON;
@@ -119,7 +116,7 @@ glm_vec3_eqv_eps(vec3 a, vec3 b) {
  */
 CGLM_INLINE
 float
-glm_vec3_max(vec3 v) {
+glm_vec3_max(const vec3 v) {
   float max;
 
   max = v[0];
@@ -138,7 +135,7 @@ glm_vec3_max(vec3 v) {
  */
 CGLM_INLINE
 float
-glm_vec3_min(vec3 v) {
+glm_vec3_min(const vec3 v) {
   float min;
 
   min = v[0];
@@ -158,7 +155,7 @@ glm_vec3_min(vec3 v) {
  */
 CGLM_INLINE
 bool
-glm_vec3_isnan(vec3 v) {
+glm_vec3_isnan(const vec3 v) {
   return isnan(v[0]) || isnan(v[1]) || isnan(v[2]);
 }
 
@@ -170,7 +167,7 @@ glm_vec3_isnan(vec3 v) {
  */
 CGLM_INLINE
 bool
-glm_vec3_isinf(vec3 v) {
+glm_vec3_isinf(const vec3 v) {
   return isinf(v[0]) || isinf(v[1]) || isinf(v[2]);
 }
 
@@ -182,7 +179,7 @@ glm_vec3_isinf(vec3 v) {
  */
 CGLM_INLINE
 bool
-glm_vec3_isvalid(vec3 v) {
+glm_vec3_isvalid(const vec3 v) {
   return !glm_vec3_isnan(v) && !glm_vec3_isinf(v);
 }
 
@@ -195,7 +192,7 @@ glm_vec3_isvalid(vec3 v) {
  */
 CGLM_INLINE
 void
-glm_vec3_sign(vec3 v, vec3 dest) {
+glm_vec3_sign(const vec3 v, vec3 dest) {
   dest[0] = glm_signf(v[0]);
   dest[1] = glm_signf(v[1]);
   dest[2] = glm_signf(v[2]);
@@ -209,7 +206,7 @@ glm_vec3_sign(vec3 v, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_sqrt(vec3 v, vec3 dest) {
+glm_vec3_sqrt(const vec3 v, vec3 dest) {
   dest[0] = sqrtf(v[0]);
   dest[1] = sqrtf(v[1]);
   dest[2] = sqrtf(v[2]);

include/cglm/vec3.h

@@ -111,7 +111,7 @@
  */
 CGLM_INLINE
 void
-glm_vec3(vec4 v4, vec3 dest) {
+glm_vec3(const vec4 v4, vec3 dest) {
   dest[0] = v4[0];
   dest[1] = v4[1];
   dest[2] = v4[2];
@@ -125,7 +125,7 @@ glm_vec3(vec4 v4, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_copy(vec3 a, vec3 dest) {
+glm_vec3_copy(const vec3 a, vec3 dest) {
   dest[0] = a[0];
   dest[1] = a[1];
   dest[2] = a[2];
@@ -163,7 +163,7 @@ glm_vec3_one(vec3 v) {
  */
 CGLM_INLINE
 float
-glm_vec3_dot(vec3 a, vec3 b) {
+glm_vec3_dot(const vec3 a, const vec3 b) {
   return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
 }
 
@@ -180,7 +180,7 @@ glm_vec3_dot(vec3 a, vec3 b) {
  */
 CGLM_INLINE
 float
-glm_vec3_norm2(vec3 v) {
+glm_vec3_norm2(const vec3 v) {
   return glm_vec3_dot(v, v);
 }
 
@@ -193,7 +193,7 @@ glm_vec3_norm2(vec3 v) {
  */
 CGLM_INLINE
 float
-glm_vec3_norm(vec3 v) {
+glm_vec3_norm(const vec3 v) {
   return sqrtf(glm_vec3_norm2(v));
 }
 
@@ -206,7 +206,7 @@ glm_vec3_norm(vec3 v) {
  */
 CGLM_INLINE
 void
-glm_vec3_add(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_add(const vec3 a, const vec3 b, vec3 dest) {
   dest[0] = a[0] + b[0];
   dest[1] = a[1] + b[1];
   dest[2] = a[2] + b[2];
@@ -221,7 +221,7 @@ glm_vec3_add(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_adds(vec3 v, float s, vec3 dest) {
+glm_vec3_adds(const vec3 v, float s, vec3 dest) {
   dest[0] = v[0] + s;
   dest[1] = v[1] + s;
   dest[2] = v[2] + s;
@@ -236,7 +236,7 @@ glm_vec3_adds(vec3 v, float s, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_sub(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_sub(const vec3 a, const vec3 b, vec3 dest) {
   dest[0] = a[0] - b[0];
   dest[1] = a[1] - b[1];
   dest[2] = a[2] - b[2];
@@ -251,7 +251,7 @@ glm_vec3_sub(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_subs(vec3 v, float s, vec3 dest) {
+glm_vec3_subs(const vec3 v, float s, vec3 dest) {
   dest[0] = v[0] - s;
   dest[1] = v[1] - s;
   dest[2] = v[2] - s;
@@ -266,7 +266,7 @@ glm_vec3_subs(vec3 v, float s, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_mul(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_mul(const vec3 a, const vec3 b, vec3 dest) {
   dest[0] = a[0] * b[0];
   dest[1] = a[1] * b[1];
   dest[2] = a[2] * b[2];
@@ -281,7 +281,7 @@ glm_vec3_mul(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_scale(vec3 v, float s, vec3 dest) {
+glm_vec3_scale(const vec3 v, float s, vec3 dest) {
   dest[0] = v[0] * s;
   dest[1] = v[1] * s;
   dest[2] = v[2] * s;
@@ -296,7 +296,7 @@ glm_vec3_scale(vec3 v, float s, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_scale_as(vec3 v, float s, vec3 dest) {
+glm_vec3_scale_as(const vec3 v, float s, vec3 dest) {
   float norm;
   norm = glm_vec3_norm(v);
 
@@ -317,7 +317,7 @@ glm_vec3_scale_as(vec3 v, float s, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_div(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_div(const vec3 a, const vec3 b, vec3 dest) {
   dest[0] = a[0] / b[0];
   dest[1] = a[1] / b[1];
   dest[2] = a[2] / b[2];
@@ -332,7 +332,7 @@ glm_vec3_div(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_divs(vec3 v, float s, vec3 dest) {
+glm_vec3_divs(const vec3 v, float s, vec3 dest) {
   dest[0] = v[0] / s;
   dest[1] = v[1] / s;
   dest[2] = v[2] / s;
@@ -349,7 +349,7 @@ glm_vec3_divs(vec3 v, float s, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_addadd(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_addadd(const vec3 a, const vec3 b, vec3 dest) {
   dest[0] += a[0] + b[0];
   dest[1] += a[1] + b[1];
   dest[2] += a[2] + b[2];
@@ -366,7 +366,7 @@ glm_vec3_addadd(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_subadd(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_subadd(const vec3 a, const vec3 b, vec3 dest) {
   dest[0] += a[0] - b[0];
   dest[1] += a[1] - b[1];
   dest[2] += a[2] - b[2];
@@ -383,7 +383,7 @@ glm_vec3_subadd(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_muladd(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_muladd(const vec3 a, const vec3 b, vec3 dest) {
   dest[0] += a[0] * b[0];
   dest[1] += a[1] * b[1];
   dest[2] += a[2] * b[2];
@@ -400,7 +400,7 @@ glm_vec3_muladd(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_muladds(vec3 a, float s, vec3 dest) {
+glm_vec3_muladds(const vec3 a, float s, vec3 dest) {
   dest[0] += a[0] * s;
   dest[1] += a[1] * s;
   dest[2] += a[2] * s;
@@ -417,7 +417,7 @@ glm_vec3_muladds(vec3 a, float s, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_maxadd(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_maxadd(const vec3 a, const vec3 b, vec3 dest) {
   dest[0] += glm_max(a[0], b[0]);
   dest[1] += glm_max(a[1], b[1]);
   dest[2] += glm_max(a[2], b[2]);
@@ -428,13 +428,13 @@ glm_vec3_maxadd(vec3 a, vec3 b, vec3 dest) {
  *
  * it applies += operator so dest must be initialized
  *
- * @param[in]  a    vector
- * @param[in]  b    scalar
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
  * @param[out] dest dest += min(a, b)
  */
 CGLM_INLINE
 void
-glm_vec3_minadd(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_minadd(const vec3 a, const vec3 b, vec3 dest) {
   dest[0] += glm_min(a[0], b[0]);
   dest[1] += glm_min(a[1], b[1]);
   dest[2] += glm_min(a[2], b[2]);
@@ -448,7 +448,7 @@ glm_vec3_minadd(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_negate_to(vec3 v, vec3 dest) {
+glm_vec3_negate_to(const vec3 v, vec3 dest) {
   dest[0] = -v[0];
   dest[1] = -v[1];
   dest[2] = -v[2];
@@ -493,7 +493,7 @@ glm_vec3_normalize(vec3 v) {
  */
 CGLM_INLINE
 void
-glm_vec3_normalize_to(vec3 v, vec3 dest) {
+glm_vec3_normalize_to(const vec3 v, vec3 dest) {
   float norm;
 
   norm = glm_vec3_norm(v);
@@ -515,7 +515,7 @@ glm_vec3_normalize_to(vec3 v, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_cross(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_cross(const vec3 a, const vec3 b, vec3 dest) {
   /* (u2.v3 - u3.v2, u3.v1 - u1.v3, u1.v2 - u2.v1) */
   dest[0] = a[1] * b[2] - a[2] * b[1];
   dest[1] = a[2] * b[0] - a[0] * b[2];
@@ -531,7 +531,7 @@ glm_vec3_cross(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_crossn(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_crossn(const vec3 a, const vec3 b, vec3 dest) {
   glm_vec3_cross(a, b, dest);
   glm_vec3_normalize(dest);
 }
@@ -546,7 +546,7 @@ glm_vec3_crossn(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 float
-glm_vec3_angle(vec3 a, vec3 b) {
+glm_vec3_angle(const vec3 a, const vec3 b) {
   float norm, dot;
 
   /* maybe compiler generate approximation instruction (rcp) */
@@ -570,7 +570,7 @@ glm_vec3_angle(vec3 a, vec3 b) {
  */
 CGLM_INLINE
 void
-glm_vec3_rotate(vec3 v, float angle, vec3 axis) {
+glm_vec3_rotate(vec3 v, float angle, const vec3 axis) {
   vec3   v1, v2, k;
   float  c, s;
 
@@ -608,7 +608,7 @@ glm_vec3_rotate(vec3 v, float angle, vec3 axis) {
  */
 CGLM_INLINE
 void
-glm_vec3_rotate_m4(mat4 m, vec3 v, vec3 dest) {
+glm_vec3_rotate_m4(const mat4 m, const vec3 v, vec3 dest) {
   vec4 x, y, z, res;
 
   glm_vec4_normalize_to(m[0], x);
@@ -631,7 +631,7 @@ glm_vec3_rotate_m4(mat4 m, vec3 v, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_rotate_m3(mat3 m, vec3 v, vec3 dest) {
+glm_vec3_rotate_m3(const mat3 m, const vec3 v, vec3 dest) {
   vec4 res, x, y, z;
 
   glm_vec4(m[0], 0.0f, x);
@@ -658,7 +658,7 @@ glm_vec3_rotate_m3(mat3 m, vec3 v, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_proj(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_proj(const vec3 a, const vec3 b, vec3 dest) {
   glm_vec3_scale(b,
                  glm_vec3_dot(a, b) / glm_vec3_norm2(b),
                  dest);
@@ -673,7 +673,7 @@ glm_vec3_proj(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_center(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_center(const vec3 a, const vec3 b, vec3 dest) {
   glm_vec3_add(a, b, dest);
   glm_vec3_scale(dest, 0.5f, dest);
 }
@@ -687,7 +687,7 @@ glm_vec3_center(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 float
-glm_vec3_distance2(vec3 a, vec3 b) {
+glm_vec3_distance2(const vec3 a, const vec3 b) {
   return glm_pow2(b[0] - a[0])
        + glm_pow2(b[1] - a[1])
        + glm_pow2(b[2] - a[2]);
@@ -702,7 +702,7 @@ glm_vec3_distance2(vec3 a, vec3 b) {
  */
 CGLM_INLINE
 float
-glm_vec3_distance(vec3 a, vec3 b) {
+glm_vec3_distance(const vec3 a, const vec3 b) {
   return sqrtf(glm_vec3_distance2(a, b));
 }
 
@@ -715,7 +715,7 @@ glm_vec3_distance(vec3 a, vec3 b) {
  */
 CGLM_INLINE
 void
-glm_vec3_maxv(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_maxv(const vec3 a, const vec3 b, vec3 dest) {
   dest[0] = glm_max(a[0], b[0]);
   dest[1] = glm_max(a[1], b[1]);
   dest[2] = glm_max(a[2], b[2]);
@@ -730,7 +730,7 @@ glm_vec3_maxv(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_minv(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_minv(const vec3 a, const vec3 b, vec3 dest) {
   dest[0] = glm_min(a[0], b[0]);
   dest[1] = glm_min(a[1], b[1]);
   dest[2] = glm_min(a[2], b[2]);
@@ -744,7 +744,7 @@ glm_vec3_minv(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_ortho(vec3 v, vec3 dest) {
+glm_vec3_ortho(const vec3 v, vec3 dest) {
   dest[0] = v[1] - v[2];
   dest[1] = v[2] - v[0];
   dest[2] = v[0] - v[1];
@@ -777,7 +777,7 @@ glm_vec3_clamp(vec3 v, float minVal, float maxVal) {
  */
 CGLM_INLINE
 void
-glm_vec3_lerp(vec3 from, vec3 to, float t, vec3 dest) {
+glm_vec3_lerp(const vec3 from, const vec3 to, float t, vec3 dest) {
   vec3 s, v;
 
   /* from + s * (to - from) */
@@ -798,7 +798,7 @@ glm_vec3_lerp(vec3 from, vec3 to, float t, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_cross(vec3 a, vec3 b, vec3 d) {
+glm_cross(const vec3 a, const vec3 b, vec3 d) {
   glm_vec3_cross(a, b, d);
 }
 
@@ -814,7 +814,7 @@ glm_cross(vec3 a, vec3 b, vec3 d) {
  */
 CGLM_INLINE
 float
-glm_dot(vec3 a, vec3 b) {
+glm_dot(const vec3 a, const vec3 b) {
   return glm_vec3_dot(a, b);
 }
 
@@ -841,7 +841,7 @@ glm_normalize(vec3 v) {
  */
 CGLM_INLINE
 void
-glm_normalize_to(vec3 v, vec3 dest) {
+glm_normalize_to(const vec3 v, vec3 dest) {
   glm_vec3_normalize_to(v, dest);
 }
 

include/cglm/vec4-ext.h

@@ -31,9 +31,6 @@
 
 #include "common.h"
 #include "vec3-ext.h"
-#include <stdbool.h>
-#include <math.h>
-#include <float.h>
 
 /*!
  * @brief fill a vector with specified value
@@ -59,7 +56,7 @@ glm_vec4_broadcast(float val, vec4 d) {
  */
 CGLM_INLINE
 bool
-glm_vec4_eq(vec4 v, float val) {
+glm_vec4_eq(const vec4 v, float val) {
   return v[0] == val
          && v[0] == v[1]
          && v[0] == v[2]
@@ -74,7 +71,7 @@ glm_vec4_eq(vec4 v, float val) {
  */
 CGLM_INLINE
 bool
-glm_vec4_eq_eps(vec4 v, float val) {
+glm_vec4_eq_eps(const vec4 v, float val) {
   return fabsf(v[0] - val) <= FLT_EPSILON
          && fabsf(v[1] - val) <= FLT_EPSILON
          && fabsf(v[2] - val) <= FLT_EPSILON
@@ -88,7 +85,7 @@ glm_vec4_eq_eps(vec4 v, float val) {
  */
 CGLM_INLINE
 bool
-glm_vec4_eq_all(vec4 v) {
+glm_vec4_eq_all(const vec4 v) {
   return v[0] == v[1]
          && v[0] == v[2]
          && v[0] == v[3];
@@ -102,7 +99,7 @@ glm_vec4_eq_all(vec4 v) {
  */
 CGLM_INLINE
 bool
-glm_vec4_eqv(vec4 a, vec4 b) {
+glm_vec4_eqv(const vec4 a, const vec4 b) {
   return a[0] == b[0]
          && a[1] == b[1]
          && a[2] == b[2]
@@ -117,7 +114,7 @@ glm_vec4_eqv(vec4 a, vec4 b) {
  */
 CGLM_INLINE
 bool
-glm_vec4_eqv_eps(vec4 a, vec4 b) {
+glm_vec4_eqv_eps(const vec4 a, const vec4 b) {
   return fabsf(a[0] - b[0]) <= FLT_EPSILON
          && fabsf(a[1] - b[1]) <= FLT_EPSILON
          && fabsf(a[2] - b[2]) <= FLT_EPSILON
@@ -131,7 +128,7 @@ glm_vec4_eqv_eps(vec4 a, vec4 b) {
  */
 CGLM_INLINE
 float
-glm_vec4_max(vec4 v) {
+glm_vec4_max(const vec4 v) {
   float max;
 
   max = glm_vec3_max(v);
@@ -148,7 +145,7 @@ glm_vec4_max(vec4 v) {
  */
 CGLM_INLINE
 float
-glm_vec4_min(vec4 v) {
+glm_vec4_min(const vec4 v) {
   float min;
 
   min = glm_vec3_min(v);
@@ -166,7 +163,7 @@ glm_vec4_min(vec4 v) {
  */
 CGLM_INLINE
 bool
-glm_vec4_isnan(vec4 v) {
+glm_vec4_isnan(const vec4 v) {
   return isnan(v[0]) || isnan(v[1]) || isnan(v[2]) || isnan(v[3]);
 }
 
@@ -178,7 +175,7 @@ glm_vec4_isnan(vec4 v) {
  */
 CGLM_INLINE
 bool
-glm_vec4_isinf(vec4 v) {
+glm_vec4_isinf(const vec4 v) {
   return isinf(v[0]) || isinf(v[1]) || isinf(v[2]) || isinf(v[3]);
 }
 
@@ -190,7 +187,7 @@ glm_vec4_isinf(vec4 v) {
  */
 CGLM_INLINE
 bool
-glm_vec4_isvalid(vec4 v) {
+glm_vec4_isvalid(const vec4 v) {
   return !glm_vec4_isnan(v) && !glm_vec4_isinf(v);
 }
 
@@ -203,7 +200,7 @@ glm_vec4_isvalid(vec4 v) {
  */
 CGLM_INLINE
 void
-glm_vec4_sign(vec4 v, vec4 dest) {
+glm_vec4_sign(const vec4 v, vec4 dest) {
 #if defined( __SSE2__ ) || defined( __SSE2__ )
   __m128 x0, x1, x2, x3, x4;
 
@@ -231,7 +228,7 @@ glm_vec4_sign(vec4 v, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_sqrt(vec4 v, vec4 dest) {
+glm_vec4_sqrt(const vec4 v, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_sqrt_ps(glmm_load(v)));
 #else

include/cglm/vec4.h

@@ -90,7 +90,7 @@
  */
 CGLM_INLINE
 void
-glm_vec4(vec3 v3, float last, vec4 dest) {
+glm_vec4(const vec3 v3, float last, vec4 dest) {
   dest[0] = v3[0];
   dest[1] = v3[1];
   dest[2] = v3[2];
@@ -105,7 +105,7 @@ glm_vec4(vec3 v3, float last, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_copy3(vec4 a, vec3 dest) {
+glm_vec4_copy3(const vec4 a, vec3 dest) {
   dest[0] = a[0];
   dest[1] = a[1];
   dest[2] = a[2];
@@ -119,9 +119,11 @@ glm_vec4_copy3(vec4 a, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_copy(vec4 v, vec4 dest) {
+glm_vec4_copy(const vec4 v, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, glmm_load(v));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, vld1q_f32(v));
 #else
   dest[0] = v[0];
   dest[1] = v[1];
@@ -140,7 +142,7 @@ glm_vec4_copy(vec4 v, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_ucopy(vec4 v, vec4 dest) {
+glm_vec4_ucopy(const vec4 v, vec4 dest) {
   dest[0] = v[0];
   dest[1] = v[1];
   dest[2] = v[2];
@@ -157,6 +159,8 @@ void
 glm_vec4_zero(vec4 v) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(v, _mm_setzero_ps());
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(v, vdupq_n_f32(0.0f));
 #else
   v[0] = 0.0f;
   v[1] = 0.0f;
@@ -175,6 +179,8 @@ void
 glm_vec4_one(vec4 v) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(v, _mm_set1_ps(1.0f));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(v, vdupq_n_f32(1.0f));
 #else
   v[0] = 1.0f;
   v[1] = 1.0f;
@@ -193,12 +199,9 @@ glm_vec4_one(vec4 v) {
  */
 CGLM_INLINE
 float
-glm_vec4_dot(vec4 a, vec4 b) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
-  __m128 x0;
-  x0 = _mm_mul_ps(glmm_load(a), glmm_load(b));
-  x0 = _mm_add_ps(x0, glmm_shuff1(x0, 1, 0, 3, 2));
-  return _mm_cvtss_f32(_mm_add_ss(x0, glmm_shuff1(x0, 0, 1, 0, 1)));
+glm_vec4_dot(const vec4 a, const vec4 b) {
+#if defined(CGLM_SIMD)
+  return glmm_dot(glmm_load(a), glmm_load(b));
 #else
   return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
 #endif
@@ -217,16 +220,8 @@ glm_vec4_dot(vec4 a, vec4 b) {
  */
 CGLM_INLINE
 float
-glm_vec4_norm2(vec4 v) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
-  __m128 x0;
-  x0 = glmm_load(v);
-  x0 = _mm_mul_ps(x0, x0);
-  x0 = _mm_add_ps(x0, glmm_shuff1(x0, 1, 0, 3, 2));
-  return _mm_cvtss_f32(_mm_add_ss(x0, glmm_shuff1(x0, 0, 1, 0, 1)));
-#else
-  return v[0] * v[0] + v[1] * v[1] + v[2] * v[2] + v[3] * v[3];
-#endif
+glm_vec4_norm2(const vec4 v) {
+  return glm_vec4_dot(v, v);
 }
 
 /*!
@@ -238,13 +233,11 @@ glm_vec4_norm2(vec4 v) {
  */
 CGLM_INLINE
 float
-glm_vec4_norm(vec4 v) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
-  __m128 x0;
-  x0 = glmm_load(v);
-  return _mm_cvtss_f32(_mm_sqrt_ss(glmm_dot(x0, x0)));
+glm_vec4_norm(const vec4 v) {
+#if defined(CGLM_SIMD)
+  return glmm_norm(glmm_load(v));
 #else
-  return sqrtf(glm_vec4_norm2(v));
+  return sqrtf(glm_vec4_dot(v, v));
 #endif
 }
 
@@ -257,9 +250,11 @@ glm_vec4_norm(vec4 v) {
  */
 CGLM_INLINE
 void
-glm_vec4_add(vec4 a, vec4 b, vec4 dest) {
+glm_vec4_add(const vec4 a, const vec4 b, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_add_ps(glmm_load(a), glmm_load(b)));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, vaddq_f32(vld1q_f32(a), vld1q_f32(b)));
 #else
   dest[0] = a[0] + b[0];
   dest[1] = a[1] + b[1];
@@ -277,9 +272,11 @@ glm_vec4_add(vec4 a, vec4 b, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_adds(vec4 v, float s, vec4 dest) {
+glm_vec4_adds(const vec4 v, float s, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_add_ps(glmm_load(v), _mm_set1_ps(s)));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, vaddq_f32(vld1q_f32(v), vdupq_n_f32(s)));
 #else
   dest[0] = v[0] + s;
   dest[1] = v[1] + s;
@@ -297,9 +294,11 @@ glm_vec4_adds(vec4 v, float s, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_sub(vec4 a, vec4 b, vec4 dest) {
+glm_vec4_sub(const vec4 a, const vec4 b, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_sub_ps(glmm_load(a), glmm_load(b)));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, vsubq_f32(vld1q_f32(a), vld1q_f32(b)));
 #else
   dest[0] = a[0] - b[0];
   dest[1] = a[1] - b[1];
@@ -317,9 +316,11 @@ glm_vec4_sub(vec4 a, vec4 b, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_subs(vec4 v, float s, vec4 dest) {
+glm_vec4_subs(const vec4 v, float s, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_sub_ps(glmm_load(v), _mm_set1_ps(s)));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, vsubq_f32(vld1q_f32(v), vdupq_n_f32(s)));
 #else
   dest[0] = v[0] - s;
   dest[1] = v[1] - s;
@@ -337,9 +338,11 @@ glm_vec4_subs(vec4 v, float s, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_mul(vec4 a, vec4 b, vec4 dest) {
+glm_vec4_mul(const vec4 a, const vec4 b, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_mul_ps(glmm_load(a), glmm_load(b)));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, vmulq_f32(vld1q_f32(a), vld1q_f32(b)));
 #else
   dest[0] = a[0] * b[0];
   dest[1] = a[1] * b[1];
@@ -357,9 +360,11 @@ glm_vec4_mul(vec4 a, vec4 b, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_scale(vec4 v, float s, vec4 dest) {
+glm_vec4_scale(const vec4 v, float s, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_mul_ps(glmm_load(v), _mm_set1_ps(s)));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, vmulq_f32(vld1q_f32(v), vdupq_n_f32(s)));
 #else
   dest[0] = v[0] * s;
   dest[1] = v[1] * s;
@@ -377,7 +382,7 @@ glm_vec4_scale(vec4 v, float s, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_scale_as(vec4 v, float s, vec4 dest) {
+glm_vec4_scale_as(const vec4 v, float s, vec4 dest) {
   float norm;
   norm = glm_vec4_norm(v);
 
@@ -398,7 +403,7 @@ glm_vec4_scale_as(vec4 v, float s, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_div(vec4 a, vec4 b, vec4 dest) {
+glm_vec4_div(const vec4 a, const vec4 b, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_div_ps(glmm_load(a), glmm_load(b)));
 #else
@@ -418,7 +423,7 @@ glm_vec4_div(vec4 a, vec4 b, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_divs(vec4 v, float s, vec4 dest) {
+glm_vec4_divs(const vec4 v, float s, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_div_ps(glmm_load(v), _mm_set1_ps(s)));
 #else
@@ -437,11 +442,15 @@ glm_vec4_divs(vec4 v, float s, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_addadd(vec4 a, vec4 b, vec4 dest) {
+glm_vec4_addadd(const vec4 a, const vec4 b, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_add_ps(glmm_load(dest),
                               _mm_add_ps(glmm_load(a),
                                          glmm_load(b))));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, vaddq_f32(vld1q_f32(dest),
+                            vaddq_f32(vld1q_f32(a),
+                                      vld1q_f32(b))));
 #else
   dest[0] += a[0] + b[0];
   dest[1] += a[1] + b[1];
@@ -461,11 +470,15 @@ glm_vec4_addadd(vec4 a, vec4 b, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_subadd(vec4 a, vec4 b, vec4 dest) {
+glm_vec4_subadd(const vec4 a, const vec4 b, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_add_ps(glmm_load(dest),
                               _mm_sub_ps(glmm_load(a),
                                          glmm_load(b))));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, vaddq_f32(vld1q_f32(dest),
+                            vsubq_f32(vld1q_f32(a),
+                                      vld1q_f32(b))));
 #else
   dest[0] += a[0] - b[0];
   dest[1] += a[1] - b[1];
@@ -485,11 +498,15 @@ glm_vec4_subadd(vec4 a, vec4 b, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_muladd(vec4 a, vec4 b, vec4 dest) {
+glm_vec4_muladd(const vec4 a, const vec4 b, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_add_ps(glmm_load(dest),
                               _mm_mul_ps(glmm_load(a),
                                          glmm_load(b))));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, vaddq_f32(vld1q_f32(dest),
+                            vmulq_f32(vld1q_f32(a),
+                                      vld1q_f32(b))));
 #else
   dest[0] += a[0] * b[0];
   dest[1] += a[1] * b[1];
@@ -509,11 +526,15 @@ glm_vec4_muladd(vec4 a, vec4 b, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_muladds(vec4 a, float s, vec4 dest) {
+glm_vec4_muladds(const vec4 a, float s, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_add_ps(glmm_load(dest),
                               _mm_mul_ps(glmm_load(a),
                                          _mm_set1_ps(s))));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, vaddq_f32(vld1q_f32(dest),
+                            vsubq_f32(vld1q_f32(a),
+                                      vdupq_n_f32(s))));
 #else
   dest[0] += a[0] * s;
   dest[1] += a[1] * s;
@@ -533,11 +554,15 @@ glm_vec4_muladds(vec4 a, float s, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_maxadd(vec4 a, vec4 b, vec4 dest) {
+glm_vec4_maxadd(const vec4 a, const vec4 b, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_add_ps(glmm_load(dest),
                               _mm_max_ps(glmm_load(a),
                                          glmm_load(b))));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, vaddq_f32(vld1q_f32(dest),
+                            vmaxq_f32(vld1q_f32(a),
+                                      vld1q_f32(b))));
 #else
   dest[0] += glm_max(a[0], b[0]);
   dest[1] += glm_max(a[1], b[1]);
@@ -551,17 +576,21 @@ glm_vec4_maxadd(vec4 a, vec4 b, vec4 dest) {
  *
  * it applies += operator so dest must be initialized
  *
- * @param[in]  a    vector
- * @param[in]  b    scalar
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
  * @param[out] dest dest += min(a, b)
  */
 CGLM_INLINE
 void
-glm_vec4_minadd(vec4 a, vec4 b, vec4 dest) {
+glm_vec4_minadd(const vec4 a,const  vec4 b, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_add_ps(glmm_load(dest),
                               _mm_min_ps(glmm_load(a),
                                          glmm_load(b))));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, vaddq_f32(vld1q_f32(dest),
+                            vminq_f32(vld1q_f32(a),
+                                      vld1q_f32(b))));
 #else
   dest[0] += glm_min(a[0], b[0]);
   dest[1] += glm_min(a[1], b[1]);
@@ -578,9 +607,11 @@ glm_vec4_minadd(vec4 a, vec4 b, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_negate_to(vec4 v, vec4 dest) {
+glm_vec4_negate_to(const vec4 v, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_xor_ps(glmm_load(v), _mm_set1_ps(-0.0f)));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, veorq_s32(vld1q_f32(v), vdupq_n_f32(-0.0f)));
 #else
   dest[0] = -v[0];
   dest[1] = -v[1];
@@ -608,13 +639,13 @@ glm_vec4_negate(vec4 v) {
  */
 CGLM_INLINE
 void
-glm_vec4_normalize_to(vec4 v, vec4 dest) {
+glm_vec4_normalize_to(const vec4 v, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   __m128 xdot, x0;
   float  dot;
 
   x0   = glmm_load(v);
-  xdot = glmm_dot(x0, x0);
+  xdot = glmm_vdot(x0, x0);
   dot  = _mm_cvtss_f32(xdot);
 
   if (dot == 0.0f) {
@@ -657,11 +688,17 @@ glm_vec4_normalize(vec4 v) {
  */
 CGLM_INLINE
 float
-glm_vec4_distance(vec4 a, vec4 b) {
+glm_vec4_distance(const vec4 a, const vec4 b) {
+#if defined( __SSE__ ) || defined( __SSE2__ )
+  return glmm_norm(_mm_sub_ps(glmm_load(b), glmm_load(a)));
+#elif defined(CGLM_NEON_FP)
+  return glmm_norm(vsubq_f32(glmm_load(a), glmm_load(b)));
+#else
   return sqrtf(glm_pow2(b[0] - a[0])
              + glm_pow2(b[1] - a[1])
              + glm_pow2(b[2] - a[2])
              + glm_pow2(b[3] - a[3]));
+#endif
 }
 
 /*!
@@ -673,9 +710,11 @@ glm_vec4_distance(vec4 a, vec4 b) {
  */
 CGLM_INLINE
 void
-glm_vec4_maxv(vec4 a, vec4 b, vec4 dest) {
+glm_vec4_maxv(const vec4 a, const vec4 b, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_max_ps(glmm_load(a), glmm_load(b)));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, vmaxq_f32(vld1q_f32(a), vld1q_f32(b)));
 #else
   dest[0] = glm_max(a[0], b[0]);
   dest[1] = glm_max(a[1], b[1]);
@@ -693,9 +732,11 @@ glm_vec4_maxv(vec4 a, vec4 b, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_minv(vec4 a, vec4 b, vec4 dest) {
+glm_vec4_minv(const vec4 a, const vec4 b, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_min_ps(glmm_load(a), glmm_load(b)));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, vminq_f32(vld1q_f32(a), vld1q_f32(b)));
 #else
   dest[0] = glm_min(a[0], b[0]);
   dest[1] = glm_min(a[1], b[1]);
@@ -717,6 +758,9 @@ glm_vec4_clamp(vec4 v, float minVal, float maxVal) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(v, _mm_min_ps(_mm_max_ps(glmm_load(v), _mm_set1_ps(minVal)),
                            _mm_set1_ps(maxVal)));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(v, vminq_f32(vmaxq_f32(vld1q_f32(v), vdupq_n_f32(minVal)),
+                         vdupq_n_f32(maxVal)));
 #else
   v[0] = glm_clamp(v[0], minVal, maxVal);
   v[1] = glm_clamp(v[1], minVal, maxVal);
@@ -737,7 +781,7 @@ glm_vec4_clamp(vec4 v, float minVal, float maxVal) {
  */
 CGLM_INLINE
 void
-glm_vec4_lerp(vec4 from, vec4 to, float t, vec4 dest) {
+glm_vec4_lerp(const vec4 from, const vec4 to, float t, vec4 dest) {
   vec4 s, v;
 
   /* from + s * (to - from) */
@@ -747,4 +791,23 @@ glm_vec4_lerp(vec4 from, vec4 to, float t, vec4 dest) {
   glm_vec4_add(from, v, dest);
 }
 
+/*!
+ * @brief helper to fill vec4 as [S^3, S^2, S, 1]
+ *
+ * @param[in]   s    parameter
+ * @param[out]  dest destination
+ */
+CGLM_INLINE
+void
+glm_vec4_cubic(float s, vec4 dest) {
+  float ss;
+
+  ss = s * s;
+
+  dest[0] = ss * s;
+  dest[1] = ss;
+  dest[2] = s;
+  dest[3] = 1.0f;
+}
+
 #endif /* cglm_vec4_h */

include/cglm/version.h

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

makefile.am

@@ -57,7 +57,9 @@ cglm_HEADERS = include/cglm/version.h \
                include/cglm/color.h \
                include/cglm/project.h \
                include/cglm/sphere.h \
-                  include/cglm/ease.h
+               include/cglm/ease.h \
+               include/cglm/curve.h \
+               include/cglm/bezier.h
 
 cglm_calldir=$(includedir)/cglm/call
 cglm_call_HEADERS = include/cglm/call/mat4.h \
@@ -74,10 +76,14 @@ cglm_call_HEADERS = include/cglm/call/mat4.h \
                     include/cglm/call/box.h \
                     include/cglm/call/project.h \
                     include/cglm/call/sphere.h \
-                    include/cglm/call/ease.h
+                    include/cglm/call/ease.h \
+                    include/cglm/call/curve.h \
+                    include/cglm/call/bezier.h
 
 cglm_simddir=$(includedir)/cglm/simd
-cglm_simd_HEADERS = include/cglm/simd/intrin.h
+cglm_simd_HEADERS = include/cglm/simd/intrin.h \
+                    include/cglm/simd/x86.h \
+                    include/cglm/simd/arm.h
 
 cglm_simd_sse2dir=$(includedir)/cglm/simd/sse2
 cglm_simd_sse2_HEADERS = include/cglm/simd/sse2/affine.h \
@@ -107,7 +113,9 @@ libcglm_la_SOURCES=\
     src/box.c \
     src/project.c \
     src/sphere.c \
-    src/ease.c
+    src/ease.c \
+    src/curve.c \
+    src/bezier.c
 
 test_tests_SOURCES=\
     test/src/test_common.c \
@@ -121,7 +129,8 @@ test_tests_SOURCES=\
     test/src/test_vec4.c \
     test/src/test_vec3.c \
     test/src/test_mat3.c \
-    test/src/test_affine.c
+    test/src/test_affine.c \
+    test/src/test_bezier.c
 
 all-local:
 	sh ./post-build.sh

post-build.sh

@@ -8,12 +8,17 @@
 
 cd $(dirname "$0")
 
-mkdir -p .libs
+mkdir -p "$(pwd)/.libs"
+
+libmocka_folder=$(pwd)/test/lib/cmocka/build/src/
 
 if [ "$(uname)" = "Darwin" ]; then
-  ln -sf $(pwd)/test/lib/cmocka/build/src/libcmocka.0.dylib \
-      .libs/libcmocka.0.dylib;
+  libcmocka=libcmocka.0.dylib
 else
-  ln -sf $(pwd)/test/lib/cmocka/build/src/libcmocka.so.0 \
-      .libs/libcmocka.so.0;
+  libcmocka=libcmocka.so.0
+fi
+
+libcmocka_path="$libmocka_folder$libcmocka"
+if [ -f "$libcmocka_path" ]; then
+  ln -sf "$libcmocka_path" "$(pwd)/.libs/$libcmocka";
 fi

src/affine.c

@@ -10,19 +10,19 @@
 
 CGLM_EXPORT
 void
-glmc_translate_make(mat4 m, vec3 v) {
+glmc_translate_make(mat4 m, const vec3 v) {
   glm_translate_make(m, v);
 }
 
 CGLM_EXPORT
 void
-glmc_translate_to(mat4 m, vec3 v, mat4 dest) {
+glmc_translate_to(const mat4 m, const vec3 v, mat4 dest) {
   glm_translate_to(m, v, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_translate(mat4 m, vec3 v) {
+glmc_translate(mat4 m, const vec3 v) {
   glm_translate(m, v);
 }
 
@@ -46,19 +46,19 @@ glmc_translate_z(mat4 m, float to) {
 
 CGLM_EXPORT
 void
-glmc_scale_make(mat4 m, vec3 v) {
+glmc_scale_make(mat4 m, const vec3 v) {
   glm_scale_make(m, v);
 }
 
 CGLM_EXPORT
 void
-glmc_scale_to(mat4 m, vec3 v, mat4 dest) {
+glmc_scale_to(const mat4 m, const vec3 v, mat4 dest) {
   glm_scale_to(m, v, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_scale(mat4 m, vec3 v) {
+glmc_scale(mat4 m, const vec3 v) {
   glm_scale(m, v);
 }
 
@@ -70,79 +70,79 @@ glmc_scale_uni(mat4 m, float s) {
 
 CGLM_EXPORT
 void
-glmc_rotate_x(mat4 m, float rad, mat4 dest) {
+glmc_rotate_x(const mat4 m, float rad, mat4 dest) {
   glm_rotate_x(m, rad, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_rotate_y(mat4 m, float rad, mat4 dest) {
+glmc_rotate_y(const mat4 m, float rad, mat4 dest) {
   glm_rotate_y(m, rad, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_rotate_z(mat4 m, float rad, mat4 dest) {
+glmc_rotate_z(const mat4 m, float rad, mat4 dest) {
   glm_rotate_z(m, rad, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_rotate_make(mat4 m, float angle, vec3 axis) {
+glmc_rotate_make(mat4 m, float angle, const vec3 axis) {
   glm_rotate_make(m, angle, axis);
 }
 
 CGLM_EXPORT
 void
-glmc_rotate(mat4 m, float angle, vec3 axis) {
+glmc_rotate(mat4 m, float angle, const vec3 axis) {
   glm_rotate(m, angle, axis);
 }
 
 CGLM_EXPORT
 void
-glmc_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis) {
+glmc_rotate_at(mat4 m, const vec3 pivot, float angle, const vec3 axis) {
   glm_rotate_at(m, pivot, angle, axis);
 }
 
 CGLM_EXPORT
 void
-glmc_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis) {
+glmc_rotate_atm(mat4 m, const vec3 pivot, float angle, const vec3 axis) {
   glm_rotate_atm(m, pivot, angle, axis);
 }
 
 CGLM_EXPORT
 void
-glmc_decompose_scalev(mat4 m, vec3 s) {
+glmc_decompose_scalev(const mat4 m, vec3 s) {
   glm_decompose_scalev(m, s);
 }
 
 CGLM_EXPORT
 bool
-glmc_uniscaled(mat4 m) {
+glmc_uniscaled(const mat4 m) {
   return glm_uniscaled(m);
 }
 
 CGLM_EXPORT
 void
-glmc_decompose_rs(mat4 m, mat4 r, vec3 s) {
+glmc_decompose_rs(const mat4 m, mat4 r, vec3 s) {
   glm_decompose_rs(m, r, s);
 }
 
 CGLM_EXPORT
 void
-glmc_decompose(mat4 m, vec4 t, mat4 r, vec3 s) {
+glmc_decompose(const 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) {
+glmc_mul(const mat4 m1, const mat4 m2, mat4 dest) {
   glm_mul(m1, m2, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_mul_rot(mat4 m1, mat4 m2, mat4 dest) {
+glmc_mul_rot(const mat4 m1, const mat4 m2, mat4 dest) {
   glm_mul_rot(m1, m2, dest);
 }
 

src/bezier.c

@@ -0,0 +1,27 @@
+/*
+ * 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_bezier(float s, float p0, float c0, float c1, float p1) {
+  return glm_bezier(s, p0, c0, c1, p1);
+}
+
+CGLM_EXPORT
+float
+glmc_hermite(float s, float p0, float t0, float t1, float p1) {
+  return glm_hermite(s, p0, t0, t1, p1);
+}
+
+CGLM_EXPORT
+float
+glmc_decasteljau(float prm, float p0, float c0, float c1, float p1) {
+  return glm_decasteljau(prm, p0, c0, c1, p1);
+}

src/box.c

@@ -10,34 +10,34 @@
 
 CGLM_EXPORT
 void
-glmc_aabb_transform(vec3 box[2], mat4 m, vec3 dest[2]) {
+glmc_aabb_transform(const vec3 box[2], const mat4 m, vec3 dest[2]) {
   glm_aabb_transform(box, m, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_aabb_merge(vec3 box1[2], vec3 box2[2], vec3 dest[2]) {
+glmc_aabb_merge(const vec3 box1[2], const vec3 box2[2], vec3 dest[2]) {
   glm_aabb_merge(box1, box2, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_aabb_crop(vec3 box[2], vec3 cropBox[2], vec3 dest[2]) {
+glmc_aabb_crop(const vec3 box[2], const vec3 cropBox[2], vec3 dest[2]) {
   glm_aabb_crop(box, cropBox, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_aabb_crop_until(vec3 box[2],
-                     vec3 cropBox[2],
-                     vec3 clampBox[2],
+glmc_aabb_crop_until(const vec3 box[2],
+                     const vec3 cropBox[2],
+                     const vec3 clampBox[2],
                      vec3       dest[2]) {
   glm_aabb_crop_until(box, cropBox, clampBox, dest);
 }
 
 CGLM_EXPORT
 bool
-glmc_aabb_frustum(vec3 box[2], vec4 planes[6]) {
+glmc_aabb_frustum(const vec3 box[2], vec4 planes[6]) {
   return glm_aabb_frustum(box, planes);
 }
 
@@ -49,48 +49,48 @@ glmc_aabb_invalidate(vec3 box[2]) {
 
 CGLM_EXPORT
 bool
-glmc_aabb_isvalid(vec3 box[2]) {
+glmc_aabb_isvalid(const vec3 box[2]) {
   return glm_aabb_isvalid(box);
 }
 
 CGLM_EXPORT
 float
-glmc_aabb_size(vec3 box[2]) {
+glmc_aabb_size(const vec3 box[2]) {
   return glm_aabb_size(box);
 }
 
 CGLM_EXPORT
 float
-glmc_aabb_radius(vec3 box[2]) {
+glmc_aabb_radius(const vec3 box[2]) {
   return glm_aabb_radius(box);
 }
 
 CGLM_EXPORT
 void
-glmc_aabb_center(vec3 box[2], vec3 dest) {
+glmc_aabb_center(const vec3 box[2], vec3 dest) {
   glm_aabb_center(box, dest);
 }
 
 CGLM_EXPORT
 bool
-glmc_aabb_aabb(vec3 box[2], vec3 other[2]) {
+glmc_aabb_aabb(const vec3 box[2], const vec3 other[2]) {
   return glm_aabb_aabb(box, other);
 }
 
 CGLM_EXPORT
 bool
-glmc_aabb_point(vec3 box[2], vec3 point) {
+glmc_aabb_point(const vec3 box[2], const vec3 point) {
   return glm_aabb_point(box, point);
 }
 
 CGLM_EXPORT
 bool
-glmc_aabb_contains(vec3 box[2], vec3 other[2]) {
+glmc_aabb_contains(const vec3 box[2], const vec3 other[2]) {
   return glm_aabb_contains(box, other);
 }
 
 CGLM_EXPORT
 bool
-glmc_aabb_sphere(vec3 box[2], vec4 s) {
+glmc_aabb_sphere(const vec3 box[2], const vec4 s) {
   return glm_aabb_sphere(box, s);
 }

src/cam.c

@@ -46,19 +46,19 @@ glmc_ortho(float left,
 
 CGLM_EXPORT
 void
-glmc_ortho_aabb(vec3 box[2], mat4 dest) {
+glmc_ortho_aabb(const vec3 box[2], mat4 dest) {
   glm_ortho_aabb(box, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_ortho_aabb_p(vec3 box[2], float padding, mat4 dest) {
+glmc_ortho_aabb_p(const 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) {
+glmc_ortho_aabb_pz(const vec3 box[2], float padding, mat4 dest) {
   glm_ortho_aabb_pz(box, padding, dest);
 }
 
@@ -88,6 +88,12 @@ glmc_perspective(float fovy,
                   dest);
 }
 
+CGLM_EXPORT
+void
+glmc_persp_move_far(mat4 proj, float deltaFar) {
+  glm_persp_move_far(proj, deltaFar);
+}
+
 CGLM_EXPORT
 void
 glmc_perspective_default(float aspect, mat4 dest) {
@@ -102,28 +108,28 @@ glmc_perspective_resize(float aspect, mat4 proj) {
 
 CGLM_EXPORT
 void
-glmc_lookat(vec3 eye,
-            vec3 center,
-            vec3 up,
+glmc_lookat(const vec3 eye,
+            const vec3 center,
+            const vec3 up,
             mat4       dest) {
   glm_lookat(eye, center, up, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_look(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
+glmc_look(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest) {
   glm_look(eye, dir, up, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_look_anyup(vec3 eye, vec3 dir, mat4 dest) {
+glmc_look_anyup(const vec3 eye, const vec3 dir, mat4 dest) {
   glm_look_anyup(eye, dir, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_persp_decomp(mat4 proj,
+glmc_persp_decomp(const mat4 proj,
                   float * __restrict nearVal,
                   float * __restrict farVal,
                   float * __restrict top,
@@ -135,13 +141,13 @@ glmc_persp_decomp(mat4 proj,
 
 CGLM_EXPORT
 void
-glmc_persp_decompv(mat4 proj, float dest[6]) {
+glmc_persp_decompv(const mat4 proj, float dest[6]) {
   glm_persp_decompv(proj, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_persp_decomp_x(mat4 proj,
+glmc_persp_decomp_x(const mat4 proj,
                     float * __restrict left,
                     float * __restrict right) {
   glm_persp_decomp_x(proj, left, right);
@@ -149,7 +155,7 @@ glmc_persp_decomp_x(mat4 proj,
 
 CGLM_EXPORT
 void
-glmc_persp_decomp_y(mat4 proj,
+glmc_persp_decomp_y(const mat4 proj,
                     float * __restrict top,
                     float * __restrict bottom) {
   glm_persp_decomp_y(proj, top, bottom);
@@ -157,7 +163,7 @@ glmc_persp_decomp_y(mat4 proj,
 
 CGLM_EXPORT
 void
-glmc_persp_decomp_z(mat4 proj,
+glmc_persp_decomp_z(const mat4 proj,
                     float * __restrict nearVal,
                     float * __restrict farVal) {
   glm_persp_decomp_z(proj, nearVal, farVal);
@@ -165,30 +171,30 @@ glmc_persp_decomp_z(mat4 proj,
 
 CGLM_EXPORT
 void
-glmc_persp_decomp_far(mat4 proj, float * __restrict farVal) {
+glmc_persp_decomp_far(const mat4 proj, float * __restrict farVal) {
   glm_persp_decomp_far(proj, farVal);
 }
 
 CGLM_EXPORT
 void
-glmc_persp_decomp_near(mat4 proj, float * __restrict nearVal) {
+glmc_persp_decomp_near(const mat4 proj, float * __restrict nearVal) {
   glm_persp_decomp_near(proj, nearVal);
 }
 
 CGLM_EXPORT
 float
-glmc_persp_fovy(mat4 proj) {
+glmc_persp_fovy(const mat4 proj) {
   return glm_persp_fovy(proj);
 }
 
 CGLM_EXPORT
 float
-glmc_persp_aspect(mat4 proj) {
+glmc_persp_aspect(const mat4 proj) {
   return glm_persp_aspect(proj);
 }
 
 CGLM_EXPORT
 void
-glmc_persp_sizes(mat4 proj, float fovy, vec4 dest) {
+glmc_persp_sizes(const mat4 proj, float fovy, vec4 dest) {
   glm_persp_sizes(proj, fovy, dest);
 }

src/curve.c

@@ -0,0 +1,15 @@
+/*
+ * 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_smc(float s, const mat4 m, const vec4 c) {
+  return glm_smc(s, m, c);
+}

src/euler.c

@@ -10,54 +10,54 @@
 
 CGLM_EXPORT
 void
-glmc_euler_angles(mat4 m, vec3 dest) {
+glmc_euler_angles(const mat4 m, vec3 dest) {
   glm_euler_angles(m, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_euler(vec3 angles, mat4 dest) {
+glmc_euler(const vec3 angles, mat4 dest) {
   glm_euler(angles, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_euler_xyz(vec3 angles,  mat4 dest) {
+glmc_euler_xyz(const vec3 angles,  mat4 dest) {
   glm_euler_xyz(angles, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_euler_zyx(vec3 angles,  mat4 dest) {
+glmc_euler_zyx(const vec3 angles,  mat4 dest) {
   glm_euler_zyx(angles, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_euler_zxy(vec3 angles, mat4 dest) {
+glmc_euler_zxy(const vec3 angles, mat4 dest) {
   glm_euler_zxy(angles, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_euler_xzy(vec3 angles, mat4 dest) {
+glmc_euler_xzy(const vec3 angles, mat4 dest) {
   glm_euler_xzy(angles, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_euler_yzx(vec3 angles, mat4 dest) {
+glmc_euler_yzx(const vec3 angles, mat4 dest) {
   glm_euler_yzx(angles, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_euler_yxz(vec3 angles, mat4 dest) {
+glmc_euler_yxz(const vec3 angles, mat4 dest) {
   glm_euler_yxz(angles, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_euler_by_order(vec3 angles, glm_euler_sq axis, mat4 dest) {
+glmc_euler_by_order(const vec3 angles, glm_euler_sq axis, mat4 dest) {
   glm_euler_by_order(angles, axis, dest);
 }

src/frustum.c

@@ -10,31 +10,31 @@
 
 CGLM_EXPORT
 void
-glmc_frustum_planes(mat4 m, vec4 dest[6]) {
+glmc_frustum_planes(const mat4 m, vec4 dest[6]) {
   glm_frustum_planes(m, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_frustum_corners(mat4 invMat, vec4 dest[8]) {
+glmc_frustum_corners(const mat4 invMat, vec4 dest[8]) {
   glm_frustum_corners(invMat, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_frustum_center(vec4 corners[8], vec4 dest) {
+glmc_frustum_center(const vec4 corners[8], vec4 dest) {
   glm_frustum_center(corners, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_frustum_box(vec4 corners[8], mat4 m, vec3 box[2]) {
+glmc_frustum_box(const vec4 corners[8], const mat4 m, vec3 box[2]) {
   glm_frustum_box(corners, m, box);
 }
 
 CGLM_EXPORT
 void
-glmc_frustum_corners_at(vec4  corners[8],
+glmc_frustum_corners_at(const vec4 corners[8],
                         float      splitDist,
                         float      farDist,
                         vec4       planeCorners[4]) {

src/io.c

@@ -10,35 +10,35 @@
 
 CGLM_EXPORT
 void
-glmc_mat4_print(mat4   matrix,
-                FILE * __restrict ostream) {
+glmc_mat4_print(const mat4   matrix,
+                FILE * const __restrict ostream) {
   glm_mat4_print(matrix, ostream);
 }
 
 CGLM_EXPORT
 void
-glmc_mat3_print(mat3 matrix,
-                FILE * __restrict ostream) {
+glmc_mat3_print(const mat3 matrix,
+                FILE * const __restrict ostream) {
   glm_mat3_print(matrix, ostream);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_print(vec4 vec,
-                FILE * __restrict ostream) {
+glmc_vec4_print(const vec4 vec,
+                FILE * const __restrict ostream) {
   glm_vec4_print(vec, ostream);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_print(vec3 vec,
-                FILE * __restrict ostream) {
+glmc_vec3_print(const vec3 vec,
+                FILE * const __restrict ostream) {
   glm_vec3_print(vec, ostream);
 }
 
 CGLM_EXPORT
 void
-glmc_versor_print(versor vec,
-                  FILE * __restrict ostream) {
+glmc_versor_print(const versor vec,
+                  FILE * const __restrict ostream) {
   glm_versor_print(vec, ostream);
 }

src/mat3.c

@@ -10,7 +10,7 @@
 
 CGLM_EXPORT
 void
-glmc_mat3_copy(mat3 mat, mat3 dest) {
+glmc_mat3_copy(const mat3 mat, mat3 dest) {
   glm_mat3_copy(mat, dest);
 }
 
@@ -22,19 +22,19 @@ glmc_mat3_identity(mat3 mat) {
 
 CGLM_EXPORT
 void
-glmc_mat3_identity_array(mat3 * __restrict mat, size_t count) {
+glmc_mat3_identity_array(mat3 * const  __restrict mat, size_t count) {
   glm_mat3_identity_array(mat, count);
 }
 
 CGLM_EXPORT
 void
-glmc_mat3_mul(mat3 m1, mat3 m2, mat3 dest) {
+glmc_mat3_mul(const mat3 m1, const mat3 m2, mat3 dest) {
   glm_mat3_mul(m1, m2, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_mat3_transpose_to(mat3 m, mat3 dest) {
+glmc_mat3_transpose_to(const mat3 m, mat3 dest) {
   glm_mat3_transpose_to(m, dest);
 }
 
@@ -46,19 +46,19 @@ glmc_mat3_transpose(mat3 m) {
 
 CGLM_EXPORT
 void
-glmc_mat3_mulv(mat3 m, vec3 v, vec3 dest) {
+glmc_mat3_mulv(const mat3 m, const vec3 v, vec3 dest) {
   glm_mat3_mulv(m, v, dest);
 }
 
 CGLM_EXPORT
 float
-glmc_mat3_trace(mat3 m) {
+glmc_mat3_trace(const mat3 m) {
   return glm_mat3_trace(m);
 }
 
 CGLM_EXPORT
 void
-glmc_mat3_quat(mat3 m, versor dest) {
+glmc_mat3_quat(const mat3 m, versor dest) {
   glm_mat3_quat(m, dest);
 }
 
@@ -70,13 +70,13 @@ glmc_mat3_scale(mat3 m, float s) {
 
 CGLM_EXPORT
 float
-glmc_mat3_det(mat3 mat) {
+glmc_mat3_det(const mat3 mat) {
   return glm_mat3_det(mat);
 }
 
 CGLM_EXPORT
 void
-glmc_mat3_inv(mat3 mat, mat3 dest) {
+glmc_mat3_inv(const mat3 mat, mat3 dest) {
   glm_mat3_inv(mat, dest);
 }
 
@@ -91,3 +91,9 @@ void
 glmc_mat3_swap_row(mat3 mat, int row1, int row2) {
   glm_mat3_swap_row(mat, row1, row2);
 }
+
+CGLM_EXPORT
+float
+glmc_mat3_rmc(const vec3 r, const mat3 m, const vec3 c) {
+  return glm_mat3_rmc(r, m, c);
+}

src/mat4.c

@@ -10,13 +10,13 @@
 
 CGLM_EXPORT
 void
-glmc_mat4_ucopy(mat4 mat, mat4 dest) {
+glmc_mat4_ucopy(const mat4 mat, mat4 dest) {
   glm_mat4_copy(mat, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_mat4_copy(mat4 mat, mat4 dest) {
+glmc_mat4_copy(const mat4 mat, mat4 dest) {
   glm_mat4_copy(mat, dest);
 }
 
@@ -28,73 +28,73 @@ glmc_mat4_identity(mat4 mat) {
 
 CGLM_EXPORT
 void
-glmc_mat4_identity_array(mat4 * __restrict mat, size_t count) {
+glmc_mat4_identity_array(mat4 * const __restrict mat, size_t count) {
   glm_mat4_identity_array(mat, count);
 }
 
 CGLM_EXPORT
 void
-glmc_mat4_pick3(mat4 mat, mat3 dest) {
+glmc_mat4_pick3(const mat4 mat, mat3 dest) {
   glm_mat4_pick3(mat, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_mat4_pick3t(mat4 mat, mat3 dest) {
+glmc_mat4_pick3t(const mat4 mat, mat3 dest) {
   glm_mat4_pick3t(mat, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_mat4_ins3(mat3 mat, mat4 dest) {
+glmc_mat4_ins3(const mat3 mat, mat4 dest) {
   glm_mat4_ins3(mat, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_mat4_mul(mat4 m1, mat4 m2, mat4 dest) {
+glmc_mat4_mul(const mat4 m1, const mat4 m2, mat4 dest) {
   glm_mat4_mul(m1, m2, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_mat4_mulN(mat4 * __restrict matrices[], uint32_t len, mat4 dest) {
+glmc_mat4_mulN(mat4 * const __restrict matrices[], uint32_t len, mat4 dest) {
   glm_mat4_mulN(matrices, len, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_mat4_mulv(mat4 m, vec4 v, vec4 dest) {
+glmc_mat4_mulv(const mat4 m, const vec4 v, vec4 dest) {
   glm_mat4_mulv(m, v, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_mat4_mulv3(mat4 m, vec3 v, float last, vec3 dest) {
+glmc_mat4_mulv3(const mat4 m, const vec3 v, float last, vec3 dest) {
   glm_mat4_mulv3(m, v, last, dest);
 }
 
 CGLM_EXPORT
 float
-glmc_mat4_trace(mat4 m) {
+glmc_mat4_trace(const mat4 m) {
   return glm_mat4_trace(m);
 }
 
 CGLM_EXPORT
 float
-glmc_mat4_trace3(mat4 m) {
+glmc_mat4_trace3(const mat4 m) {
   return glm_mat4_trace3(m);
 }
 
 CGLM_EXPORT
 void
-glmc_mat4_quat(mat4 m, versor dest) {
+glmc_mat4_quat(const mat4 m, versor dest) {
   glm_mat4_quat(m, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_mat4_transpose_to(mat4 m, mat4 dest) {
+glmc_mat4_transpose_to(const mat4 m, mat4 dest) {
   glm_mat4_transpose_to(m, dest);
 }
 
@@ -118,25 +118,25 @@ glmc_mat4_scale(mat4 m, float s) {
 
 CGLM_EXPORT
 float
-glmc_mat4_det(mat4 mat) {
+glmc_mat4_det(const mat4 mat) {
   return glm_mat4_det(mat);
 }
 
 CGLM_EXPORT
 void
-glmc_mat4_inv(mat4 mat, mat4 dest) {
+glmc_mat4_inv(const mat4 mat, mat4 dest) {
   glm_mat4_inv(mat, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_mat4_inv_precise(mat4 mat, mat4 dest) {
+glmc_mat4_inv_precise(const mat4 mat, mat4 dest) {
   glm_mat4_inv_precise(mat, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_mat4_inv_fast(mat4 mat, mat4 dest) {
+glmc_mat4_inv_fast(const mat4 mat, mat4 dest) {
   glm_mat4_inv_fast(mat, dest);
 }
 
@@ -151,3 +151,9 @@ void
 glmc_mat4_swap_row(mat4 mat, int row1, int row2) {
   glm_mat4_swap_row(mat, row1, row2);
 }
+
+CGLM_EXPORT
+float
+glmc_mat4_rmc(const vec4 r, const mat4 m, const vec4 c) {
+  return glm_mat4_rmc(r, m, c);
+}

src/project.c

@@ -10,18 +10,18 @@
 
 CGLM_EXPORT
 void
-glmc_unprojecti(vec3 pos, mat4 invMat, vec4 vp, vec3 dest) {
+glmc_unprojecti(const vec3 pos, const mat4 invMat, const vec4 vp, vec3 dest) {
   glm_unprojecti(pos, invMat, vp, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_unproject(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
+glmc_unproject(const vec3 pos, const mat4 m, const vec4 vp, vec3 dest) {
   glm_unproject(pos, m, vp, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_project(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
+glmc_project(const vec3 pos, const mat4 m, const vec4 vp, vec3 dest) {
   glm_project(pos, m, vp, dest);
 }

src/quat.c

@@ -16,7 +16,7 @@ glmc_quat_identity(versor q) {
 
 CGLM_EXPORT
 void
-glmc_quat_identity_array(versor * __restrict q, size_t count) {
+glmc_quat_identity_array(versor * const __restrict q, size_t count) {
   glm_quat_identity_array(q, count);
 }
 
@@ -34,25 +34,25 @@ glmc_quat(versor q, float angle, float x, float y, float z) {
 
 CGLM_EXPORT
 void
-glmc_quatv(versor q, float angle, vec3 axis) {
+glmc_quatv(versor q, float angle, const vec3 axis) {
   glm_quatv(q, angle, axis);
 }
 
 CGLM_EXPORT
 void
-glmc_quat_copy(versor q, versor dest) {
+glmc_quat_copy(const versor q, versor dest) {
   glm_quat_copy(q, dest);
 }
 
 CGLM_EXPORT
 float
-glmc_quat_norm(versor q) {
+glmc_quat_norm(const versor q) {
   return glm_quat_norm(q);
 }
 
 CGLM_EXPORT
 void
-glmc_quat_normalize_to(versor q, versor dest) {
+glmc_quat_normalize_to(const versor q, versor dest) {
   glm_quat_normalize_to(q, dest);
 }
 
@@ -64,150 +64,154 @@ glmc_quat_normalize(versor q) {
 
 CGLM_EXPORT
 float
-glmc_quat_dot(versor p, versor q) {
+glmc_quat_dot(const versor p, const versor q) {
   return glm_quat_dot(p, q);
 }
 
 CGLM_EXPORT
 void
-glmc_quat_conjugate(versor q, versor dest) {
+glmc_quat_conjugate(const versor q, versor dest) {
   glm_quat_conjugate(q, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_quat_inv(versor q, versor dest) {
+glmc_quat_inv(const versor q, versor dest) {
   glm_quat_inv(q, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_quat_add(versor p, versor q, versor dest) {
+glmc_quat_add(const versor p, const versor q, versor dest) {
   glm_quat_add(p, q, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_quat_sub(versor p, versor q, versor dest) {
+glmc_quat_sub(const versor p, const versor q, versor dest) {
   glm_quat_sub(p, q, dest);
 }
 
 CGLM_EXPORT
 float
-glmc_quat_real(versor q) {
+glmc_quat_real(const versor q) {
   return glm_quat_real(q);
 }
 
 CGLM_EXPORT
 void
-glmc_quat_imag(versor q, vec3 dest) {
+glmc_quat_imag(const versor q, vec3 dest) {
   glm_quat_imag(q, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_quat_imagn(versor q, vec3 dest) {
+glmc_quat_imagn(const versor q, vec3 dest) {
   glm_quat_imagn(q, dest);
 }
 
 CGLM_EXPORT
 float
-glmc_quat_imaglen(versor q) {
+glmc_quat_imaglen(const versor q) {
   return glm_quat_imaglen(q);
 }
 
 CGLM_EXPORT
 float
-glmc_quat_angle(versor q) {
+glmc_quat_angle(const versor q) {
   return glm_quat_angle(q);
 }
 
 CGLM_EXPORT
 void
-glmc_quat_axis(versor q, versor dest) {
+glmc_quat_axis(const versor q, versor dest) {
   glm_quat_axis(q, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_quat_mul(versor p, versor q, versor dest) {
+glmc_quat_mul(const versor p, const versor q, versor dest) {
   glm_quat_mul(p, q, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_quat_mat4(versor q, mat4 dest) {
+glmc_quat_mat4(const versor q, mat4 dest) {
   glm_quat_mat4(q, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_quat_mat4t(versor q, mat4 dest) {
+glmc_quat_mat4t(const versor q, mat4 dest) {
   glm_quat_mat4t(q, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_quat_mat3(versor q, mat3 dest) {
+glmc_quat_mat3(const versor q, mat3 dest) {
   glm_quat_mat3(q, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_quat_mat3t(versor q, mat3 dest) {
+glmc_quat_mat3t(const versor q, mat3 dest) {
   glm_quat_mat3t(q, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_quat_lerp(versor from, versor to, float t, versor dest) {
+glmc_quat_lerp(const versor from, const versor to, float t, versor dest) {
   glm_quat_lerp(from, to, t, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_quat_slerp(versor from, versor to, float t, versor dest) {
+glmc_quat_slerp(const versor from, const versor to, float t, versor dest) {
   glm_quat_slerp(from, to, t, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_quat_look(vec3 eye, versor ori, mat4 dest) {
+glmc_quat_look(const vec3 eye, const versor ori, mat4 dest) {
   glm_quat_look(eye, ori, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest) {
+glmc_quat_for(const vec3 dir, const vec3 fwd, const vec3 up, versor dest) {
   glm_quat_for(dir, fwd, up, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_quat_forp(vec3 from, vec3 to, vec3 fwd, vec3 up, versor dest) {
+glmc_quat_forp(const vec3 from,
+               const vec3 to,
+               const vec3 fwd,
+               const vec3 up,
+               versor     dest) {
   glm_quat_forp(from, to, fwd, up, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_quat_rotatev(versor q, vec3 v, vec3 dest) {
+glmc_quat_rotatev(const versor q, const vec3 v, vec3 dest) {
   glm_quat_rotatev(q, v, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_quat_rotate(mat4 m, versor q, mat4 dest) {
+glmc_quat_rotate(const mat4 m, const versor q, mat4 dest) {
   glm_quat_rotate(m, q, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_quat_rotate_at(mat4 model, versor q, vec3 pivot) {
+glmc_quat_rotate_at(mat4 model, const versor q, const vec3 pivot) {
   glm_quat_rotate_at(model, q, pivot);
 }
 
 CGLM_EXPORT
 void
-glmc_quat_rotate_atm(mat4 m, versor q, vec3 pivot) {
+glmc_quat_rotate_atm(mat4 m, const versor q, const vec3 pivot) {
   glm_quat_rotate_atm(m, q, pivot);
 }

src/sphere.c

@@ -10,30 +10,30 @@
 
 CGLM_EXPORT
 float
-glmc_sphere_radii(vec4 s) {
+glmc_sphere_radii(const vec4 s) {
   return glm_sphere_radii(s);
 }
 
 CGLM_EXPORT
 void
-glmc_sphere_transform(vec4 s, mat4 m, vec4 dest) {
+glmc_sphere_transform(const vec4 s, const mat4 m, vec4 dest) {
   glm_sphere_transform(s, m, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_sphere_merge(vec4 s1, vec4 s2, vec4 dest) {
+glmc_sphere_merge(const vec4 s1, const vec4 s2, vec4 dest) {
   glm_sphere_merge(s1, s2, dest);
 }
 
 CGLM_EXPORT
 bool
-glmc_sphere_sphere(vec4 s1, vec4 s2) {
+glmc_sphere_sphere(const vec4 s1, const vec4 s2) {
   return glm_sphere_sphere(s1, s2);
 }
 
 CGLM_EXPORT
 bool
-glmc_sphere_point(vec4 s, vec3 point) {
+glmc_sphere_point(const vec4 s, const vec3 point) {
   return glm_sphere_point(s, point);
 }

src/vec3.c

@@ -10,13 +10,13 @@
 
 CGLM_EXPORT
 void
-glmc_vec3(vec4 v4, vec3 dest) {
+glmc_vec3(const vec4 v4, vec3 dest) {
   glm_vec3(v4, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_copy(vec3 a, vec3 dest) {
+glmc_vec3_copy(const vec3 a, vec3 dest) {
   glm_vec3_copy(a, dest);
 }
 
@@ -34,31 +34,31 @@ glmc_vec3_one(vec3 v) {
 
 CGLM_EXPORT
 float
-glmc_vec3_dot(vec3 a, vec3 b) {
+glmc_vec3_dot(const vec3 a, const vec3 b) {
   return glm_vec3_dot(a, b);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_cross(vec3 a, vec3 b, vec3 dest) {
+glmc_vec3_cross(const vec3 a, const vec3 b, vec3 dest) {
   glm_vec3_cross(a, b, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_crossn(vec3 a, vec3 b, vec3 dest) {
+glmc_vec3_crossn(const vec3 a, const vec3 b, vec3 dest) {
   glm_vec3_crossn(a, b, dest);
 }
 
 CGLM_EXPORT
 float
-glmc_vec3_norm(vec3 v) {
+glmc_vec3_norm(const vec3 v) {
   return glm_vec3_norm(v);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_normalize_to(vec3 v, vec3 dest) {
+glmc_vec3_normalize_to(const vec3 v, vec3 dest) {
   glm_vec3_normalize_to(v, dest);
 }
 
@@ -70,97 +70,97 @@ glmc_vec3_normalize(vec3 v) {
 
 CGLM_EXPORT
 float
-glmc_vec3_norm2(vec3 v) {
+glmc_vec3_norm2(const vec3 v) {
   return glm_vec3_norm2(v);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_add(vec3 a, vec3 b, vec3 dest) {
+glmc_vec3_add(const vec3 a, const vec3 b, vec3 dest) {
   glm_vec3_add(a, b, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_adds(vec3 v, float s, vec3 dest) {
+glmc_vec3_adds(const vec3 v, float s, vec3 dest) {
   glm_vec3_adds(v, s, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_sub(vec3 a, vec3 b, vec3 dest) {
+glmc_vec3_sub(const vec3 a, const vec3 b, vec3 dest) {
   glm_vec3_sub(a, b, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_subs(vec3 v, float s, vec3 dest) {
+glmc_vec3_subs(const vec3 v, float s, vec3 dest) {
   glm_vec3_subs(v, s, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_mul(vec3 a, vec3 b, vec3 d) {
+glmc_vec3_mul(const vec3 a, const vec3 b, vec3 d) {
   glm_vec3_mul(a, b, d);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_scale(vec3 v, float s, vec3 dest) {
+glmc_vec3_scale(const vec3 v, float s, vec3 dest) {
   glm_vec3_scale(v, s, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_scale_as(vec3 v, float s, vec3 dest) {
+glmc_vec3_scale_as(const vec3 v, float s, vec3 dest) {
   glm_vec3_scale_as(v, s, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_div(vec3 a, vec3 b, vec3 dest) {
+glmc_vec3_div(const vec3 a, const vec3 b, vec3 dest) {
   glm_vec3_div(a, b, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_divs(vec3 a, float s, vec3 dest) {
+glmc_vec3_divs(const vec3 a, float s, vec3 dest) {
   glm_vec3_divs(a, s, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_addadd(vec3 a, vec3 b, vec3 dest) {
+glmc_vec3_addadd(const vec3 a, const vec3 b, vec3 dest) {
   glm_vec3_addadd(a, b, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_subadd(vec3 a, vec3 b, vec3 dest) {
+glmc_vec3_subadd(const vec3 a, const vec3 b, vec3 dest) {
   glm_vec3_subadd(a, b, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_muladd(vec3 a, vec3 b, vec3 dest) {
+glmc_vec3_muladd(const vec3 a, const vec3 b, vec3 dest) {
   glm_vec3_muladd(a, b, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_muladds(vec3 a, float s, vec3 dest) {
+glmc_vec3_muladds(const vec3 a, float s, vec3 dest) {
   glm_vec3_muladds(a, s, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_maxadd(vec3 a, vec3 b, vec3 dest) {
+glmc_vec3_maxadd(const vec3 a, const vec3 b, vec3 dest) {
   glm_vec3_maxadd(a, b, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_minadd(vec3 a, vec3 b, vec3 dest) {
+glmc_vec3_minadd(const vec3 a, const vec3 b, vec3 dest) {
   glm_vec3_minadd(a, b, dest);
 }
 
@@ -172,67 +172,67 @@ glmc_vec3_negate(vec3 v) {
 
 CGLM_EXPORT
 void
-glmc_vec3_negate_to(vec3 v, vec3 dest) {
+glmc_vec3_negate_to(const vec3 v, vec3 dest) {
   glm_vec3_negate_to(v, dest);
 }
 
 CGLM_EXPORT
 float
-glmc_vec3_angle(vec3 a, vec3 b) {
+glmc_vec3_angle(const vec3 a, const vec3 b) {
   return glm_vec3_angle(a, b);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_rotate(vec3 v, float angle, vec3 axis) {
+glmc_vec3_rotate(vec3 v, float angle, const vec3 axis) {
   glm_vec3_rotate(v, angle, axis);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_rotate_m4(mat4 m, vec3 v, vec3 dest) {
+glmc_vec3_rotate_m4(const mat4 m, const vec3 v, vec3 dest) {
   glm_vec3_rotate_m4(m, v, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_rotate_m3(mat3 m, vec3 v, vec3 dest) {
+glmc_vec3_rotate_m3(const mat3 m, const vec3 v, vec3 dest) {
   glm_vec3_rotate_m3(m, v, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_proj(vec3 a, vec3 b, vec3 dest) {
+glmc_vec3_proj(const vec3 a, const vec3 b, vec3 dest) {
   glm_vec3_proj(a, b, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_center(vec3 a, vec3 b, vec3 dest) {
+glmc_vec3_center(const vec3 a, const vec3 b, vec3 dest) {
   glm_vec3_center(a, b, dest);
 }
 
 CGLM_EXPORT
 float
-glmc_vec3_distance2(vec3 a, vec3 b) {
+glmc_vec3_distance2(const vec3 a, const vec3 b) {
   return glm_vec3_distance2(a, b);
 }
 
 CGLM_EXPORT
 float
-glmc_vec3_distance(vec3 a, vec3 b) {
+glmc_vec3_distance(const vec3 a, const vec3 b) {
   return glm_vec3_distance(a, b);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_maxv(vec3 a, vec3 b, vec3 dest) {
+glmc_vec3_maxv(const vec3 a, const vec3 b, vec3 dest) {
   glm_vec3_minv(a, b, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_minv(vec3 a, vec3 b, vec3 dest) {
+glmc_vec3_minv(const vec3 a, const vec3 b, vec3 dest) {
   glm_vec3_maxv(a, b, dest);
 }
 
@@ -244,13 +244,13 @@ glmc_vec3_clamp(vec3 v, float minVal, float maxVal) {
 
 CGLM_EXPORT
 void
-glmc_vec3_ortho(vec3 v, vec3 dest) {
+glmc_vec3_ortho(const vec3 v, vec3 dest) {
   glm_vec3_ortho(v, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_lerp(vec3 from, vec3 to, float t, vec3 dest) {
+glmc_vec3_lerp(const vec3 from, const vec3 to, float t, vec3 dest) {
   glm_vec3_lerp(from, to, t, dest);
 }
 
@@ -258,7 +258,7 @@ glmc_vec3_lerp(vec3 from, vec3 to, float t, vec3 dest) {
 
 CGLM_EXPORT
 void
-glmc_vec3_mulv(vec3 a, vec3 b, vec3 d) {
+glmc_vec3_mulv(const vec3 a, const vec3 b, vec3 d) {
   glm_vec3_mulv(a, b, d);
 }
 
@@ -270,72 +270,72 @@ glmc_vec3_broadcast(float val, vec3 d) {
 
 CGLM_EXPORT
 bool
-glmc_vec3_eq(vec3 v, float val) {
+glmc_vec3_eq(const vec3 v, float val) {
   return glm_vec3_eq(v, val);
 }
 
 CGLM_EXPORT
 bool
-glmc_vec3_eq_eps(vec3 v, float val) {
+glmc_vec3_eq_eps(const vec3 v, float val) {
   return glm_vec3_eq_eps(v, val);
 }
 
 CGLM_EXPORT
 bool
-glmc_vec3_eq_all(vec3 v) {
+glmc_vec3_eq_all(const vec3 v) {
   return glm_vec3_eq_all(v);
 }
 
 CGLM_EXPORT
 bool
-glmc_vec3_eqv(vec3 a, vec3 b) {
+glmc_vec3_eqv(const vec3 a, const vec3 b) {
   return glm_vec3_eqv(a, b);
 }
 
 CGLM_EXPORT
 bool
-glmc_vec3_eqv_eps(vec3 a, vec3 b) {
+glmc_vec3_eqv_eps(const vec3 a, const vec3 b) {
   return glm_vec3_eqv_eps(a, b);
 }
 
 CGLM_EXPORT
 float
-glmc_vec3_max(vec3 v) {
+glmc_vec3_max(const vec3 v) {
   return glm_vec3_max(v);
 }
 
 CGLM_EXPORT
 float
-glmc_vec3_min(vec3 v) {
+glmc_vec3_min(const vec3 v) {
   return glm_vec3_min(v);
 }
 
 CGLM_EXPORT
 bool
-glmc_vec3_isnan(vec3 v) {
+glmc_vec3_isnan(const vec3 v) {
   return glm_vec3_isnan(v);
 }
 
 CGLM_EXPORT
 bool
-glmc_vec3_isinf(vec3 v) {
+glmc_vec3_isinf(const vec3 v) {
   return glm_vec3_isinf(v);
 }
 
 CGLM_EXPORT
 bool
-glmc_vec3_isvalid(vec3 v) {
+glmc_vec3_isvalid(const vec3 v) {
   return glm_vec3_isvalid(v);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_sign(vec3 v, vec3 dest) {
+glmc_vec3_sign(const vec3 v, vec3 dest) {
   glm_vec3_sign(v, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_sqrt(vec3 v, vec3 dest) {
+glmc_vec3_sqrt(const vec3 v, vec3 dest) {
   glm_vec3_sqrt(v, dest);
 }

src/vec4.c

@@ -10,7 +10,7 @@
 
 CGLM_EXPORT
 void
-glmc_vec4(vec3 v3, float last, vec4 dest) {
+glmc_vec4(const vec3 v3, float last, vec4 dest) {
   glm_vec4(v3, last, dest);
 }
 
@@ -28,37 +28,37 @@ glmc_vec4_one(vec4 v) {
 
 CGLM_EXPORT
 void
-glmc_vec4_copy3(vec4 v, vec3 dest) {
+glmc_vec4_copy3(const vec4 v, vec3 dest) {
   glm_vec4_copy3(v, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_copy(vec4 v, vec4 dest) {
+glmc_vec4_copy(const vec4 v, vec4 dest) {
   glm_vec4_copy(v, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_ucopy(vec4 v, vec4 dest) {
+glmc_vec4_ucopy(const vec4 v, vec4 dest) {
   glm_vec4_ucopy(v, dest);
 }
 
 CGLM_EXPORT
 float
-glmc_vec4_dot(vec4 a, vec4 b) {
+glmc_vec4_dot(const vec4 a, const vec4 b) {
   return glm_vec4_dot(a, b);
 }
 
 CGLM_EXPORT
 float
-glmc_vec4_norm(vec4 v) {
+glmc_vec4_norm(const vec4 v) {
   return glm_vec4_norm(v);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_normalize_to(vec4 v, vec4 dest) {
+glmc_vec4_normalize_to(const vec4 v, vec4 dest) {
   glm_vec4_normalize_to(v, dest);
 }
 
@@ -70,97 +70,97 @@ glmc_vec4_normalize(vec4 v) {
 
 CGLM_EXPORT
 float
-glmc_vec4_norm2(vec4 v) {
+glmc_vec4_norm2(const vec4 v) {
   return glm_vec4_norm2(v);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_add(vec4 a, vec4 b, vec4 dest) {
+glmc_vec4_add(const vec4 a, const vec4 b, vec4 dest) {
   glm_vec4_add(a, b, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_adds(vec4 v, float s, vec4 dest) {
+glmc_vec4_adds(const vec4 v, float s, vec4 dest) {
   glm_vec4_adds(v, s, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_sub(vec4 a, vec4 b, vec4 dest) {
+glmc_vec4_sub(const vec4 a, const vec4 b, vec4 dest) {
   glm_vec4_sub(a, b, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_subs(vec4 v, float s, vec4 dest) {
+glmc_vec4_subs(const vec4 v, float s, vec4 dest) {
   glm_vec4_subs(v, s, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_mul(vec4 a, vec4 b, vec4 d) {
+glmc_vec4_mul(const vec4 a, const vec4 b, vec4 d) {
   glm_vec4_mul(a, b, d);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_scale(vec4 v, float s, vec4 dest) {
+glmc_vec4_scale(const vec4 v, float s, vec4 dest) {
   glm_vec4_scale(v, s, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_scale_as(vec4 v, float s, vec4 dest) {
+glmc_vec4_scale_as(const vec4 v, float s, vec4 dest) {
   glm_vec4_scale_as(v, s, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_div(vec4 a, vec4 b, vec4 dest) {
+glmc_vec4_div(const vec4 a, const vec4 b, vec4 dest) {
   glm_vec4_div(a, b, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_divs(vec4 v, float s, vec4 dest) {
+glmc_vec4_divs(const vec4 v, float s, vec4 dest) {
   glm_vec4_divs(v, s, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_addadd(vec4 a, vec4 b, vec4 dest) {
+glmc_vec4_addadd(const vec4 a, const vec4 b, vec4 dest) {
   glm_vec4_addadd(a, b, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_subadd(vec4 a, vec4 b, vec4 dest) {
+glmc_vec4_subadd(const vec4 a, const vec4 b, vec4 dest) {
   glm_vec4_subadd(a, b, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_muladd(vec4 a, vec4 b, vec4 dest) {
+glmc_vec4_muladd(const vec4 a, const vec4 b, vec4 dest) {
   glm_vec4_muladd(a, b, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_muladds(vec4 a, float s, vec4 dest) {
+glmc_vec4_muladds(const vec4 a, float s, vec4 dest) {
   glm_vec4_muladds(a, s, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_maxadd(vec4 a, vec4 b, vec4 dest) {
+glmc_vec4_maxadd(const vec4 a, const vec4 b, vec4 dest) {
   glm_vec4_maxadd(a, b, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_minadd(vec4 a, vec4 b, vec4 dest) {
+glmc_vec4_minadd(const vec4 a, const vec4 b, vec4 dest) {
   glm_vec4_minadd(a, b, dest);
 }
 
@@ -172,25 +172,25 @@ glmc_vec4_negate(vec4 v) {
 
 CGLM_EXPORT
 void
-glmc_vec4_negate_to(vec4 v, vec4 dest) {
+glmc_vec4_negate_to(const vec4 v, vec4 dest) {
   glm_vec4_negate_to(v, dest);
 }
 
 CGLM_EXPORT
 float
-glmc_vec4_distance(vec4 a, vec4 b) {
+glmc_vec4_distance(const vec4 a, const vec4 b) {
   return glm_vec4_distance(a, b);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_maxv(vec4 a, vec4 b, vec4 dest) {
+glmc_vec4_maxv(const vec4 a, const vec4 b, vec4 dest) {
   glm_vec4_minv(a, b, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_minv(vec4 a, vec4 b, vec4 dest) {
+glmc_vec4_minv(const vec4 a, const vec4 b, vec4 dest) {
   glm_vec4_maxv(a, b, dest);
 }
 
@@ -202,15 +202,21 @@ glmc_vec4_clamp(vec4 v, float minVal, float maxVal) {
 
 CGLM_EXPORT
 void
-glmc_vec4_lerp(vec4 from, vec4 to, float t, vec4 dest) {
+glmc_vec4_lerp(const vec4 from, const vec4 to, float t, vec4 dest) {
   glm_vec4_lerp(from, to, t, dest);
 }
 
+CGLM_EXPORT
+void
+glmc_vec4_cubic(float s, vec4 dest) {
+  glm_vec4_cubic(s, dest);
+}
+
 /* ext */
 
 CGLM_EXPORT
 void
-glmc_vec4_mulv(vec4 a, vec4 b, vec4 d) {
+glmc_vec4_mulv(const vec4 a, const vec4 b, vec4 d) {
   glm_vec4_mulv(a, b, d);
 }
 
@@ -222,72 +228,72 @@ glmc_vec4_broadcast(float val, vec4 d) {
 
 CGLM_EXPORT
 bool
-glmc_vec4_eq(vec4 v, float val) {
+glmc_vec4_eq(const vec4 v, float val) {
   return glm_vec4_eq(v, val);
 }
 
 CGLM_EXPORT
 bool
-glmc_vec4_eq_eps(vec4 v, float val) {
+glmc_vec4_eq_eps(const vec4 v, float val) {
   return glm_vec4_eq_eps(v, val);
 }
 
 CGLM_EXPORT
 bool
-glmc_vec4_eq_all(vec4 v) {
+glmc_vec4_eq_all(const vec4 v) {
   return glm_vec4_eq_all(v);
 }
 
 CGLM_EXPORT
 bool
-glmc_vec4_eqv(vec4 a, vec4 b) {
+glmc_vec4_eqv(const vec4 a, const vec4 b) {
   return glm_vec4_eqv(a, b);
 }
 
 CGLM_EXPORT
 bool
-glmc_vec4_eqv_eps(vec4 a, vec4 b) {
+glmc_vec4_eqv_eps(const vec4 a, const vec4 b) {
   return glm_vec4_eqv_eps(a, b);
 }
 
 CGLM_EXPORT
 float
-glmc_vec4_max(vec4 v) {
+glmc_vec4_max(const vec4 v) {
   return glm_vec4_max(v);
 }
 
 CGLM_EXPORT
 float
-glmc_vec4_min(vec4 v) {
+glmc_vec4_min(const vec4 v) {
   return glm_vec4_min(v);
 }
 
 CGLM_EXPORT
 bool
-glmc_vec4_isnan(vec4 v) {
+glmc_vec4_isnan(const vec4 v) {
   return glm_vec4_isnan(v);
 }
 
 CGLM_EXPORT
 bool
-glmc_vec4_isinf(vec4 v) {
+glmc_vec4_isinf(const vec4 v) {
   return glm_vec4_isinf(v);
 }
 
 CGLM_EXPORT
 bool
-glmc_vec4_isvalid(vec4 v) {
+glmc_vec4_isvalid(const vec4 v) {
   return glm_vec4_isvalid(v);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_sign(vec4 v, vec4 dest) {
+glmc_vec4_sign(const vec4 v, vec4 dest) {
   glm_vec4_sign(v, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_sqrt(vec4 v, vec4 dest) {
+glmc_vec4_sqrt(const vec4 v, vec4 dest) {
   glm_vec4_sqrt(v, dest);
 }

test/src/test_bezier.c

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "test_common.h"
+
+CGLM_INLINE
+float
+test_bezier_plain(float s, float p0, float c0, float c1, float p1) {
+  float x, xx, xxx, ss, sss;
+
+  x   = 1.0f - s;
+  xx  = x * x;
+  xxx = xx * x;
+  ss  = s * s;
+  sss = ss * s;
+
+  return p0 * xxx + 3.0f * (c0 * s * xx + c1 * ss * x) + p1 * sss;
+}
+
+CGLM_INLINE
+float
+test_hermite_plain(float s, float p0, float t0, float t1, float p1) {
+  float ss, sss;
+
+  ss  = s  * s;
+  sss = ss * s;
+
+  return p0 * (2.0f * sss - 3.0f * ss + 1.0f)
+       + t0 * (sss - 2.0f * ss + s)
+       + p1 * (-2.0f * sss + 3.0f * ss)
+       + t1 * (sss - ss);
+}
+
+void
+test_bezier(void **state) {
+  float s, p0, p1, c0, c1, smc, Bs, Bs_plain;
+
+  s        = test_rand();
+  p0       = test_rand();
+  p1       = test_rand();
+  c0       = test_rand();
+  c1       = test_rand();
+
+  /* test cubic bezier */
+  smc      = glm_smc(s, GLM_BEZIER_MAT, (vec4){p0, c0, c1, p1});
+  Bs       = glm_bezier(s, p0, c0, c1, p1);
+  Bs_plain = test_bezier_plain(s, p0, c0, c1, p1);
+
+  assert_true(glm_eq(Bs,  Bs_plain));
+  test_assert_eqf(smc, Bs_plain);
+  test_assert_eqf(Bs,  smc);
+
+  /* test cubic hermite */
+  smc      = glm_smc(s, GLM_HERMITE_MAT, (vec4){p0, p1, c0, c1});
+  Bs       = glm_hermite(s, p0, c0, c1, p1);
+  Bs_plain = test_hermite_plain(s, p0, c0, c1, p1);
+
+  assert_true(glm_eq(Bs,  Bs_plain));
+  assert_true(glm_eq(smc, Bs_plain));
+  assert_true(glm_eq(Bs,  smc));
+}

test/src/test_common.c

@@ -5,6 +5,7 @@
 
 #include "test_common.h"
 #include <stdlib.h>
+#include <math.h>
 
 #define m 4
 #define n 4
@@ -58,7 +59,7 @@ test_rand_vec4(vec4 dest) {
 }
 
 float
-test_rand_angle(void) {
+test_rand(void) {
   srand((unsigned int)time(NULL));
   return drand48();
 }

test/src/test_common.h

@@ -59,7 +59,7 @@ void
 test_rand_vec4(vec4 dest) ;
 
 float
-test_rand_angle(void);
+test_rand(void);
 
 void
 test_rand_quat(versor q);

test/src/test_main.c

@@ -38,7 +38,10 @@ main(int argc, const char * argv[]) {
     cmocka_unit_test(test_vec3),
 
     /* affine */
-    cmocka_unit_test(test_affine)
+    cmocka_unit_test(test_affine),
+
+    /* bezier */
+    cmocka_unit_test(test_bezier)
   };
 
   return cmocka_run_group_tests(tests, NULL, NULL);

test/src/test_tests.h

@@ -40,4 +40,7 @@ test_vec3(void **state);
 void
 test_affine(void **state);
 
+void
+test_bezier(void **state);
+
 #endif /* test_tests_h */

test/src/test_vec4.c

@@ -93,6 +93,13 @@ test_vec4(void **state) {
     /* 3. test SIMD norm2 */
     test_rand_vec4(v);
     test_assert_eqf(test_vec4_norm2(v), glm_vec4_norm2(v));
+
+    /* 4. test SSE/SIMD distance */
+    test_rand_vec4(v1);
+    test_rand_vec4(v2);
+    d1 = glm_vec4_distance(v1, v2);
+    d2 = sqrtf(powf(v1[0]-v2[0], 2.0f) + pow(v1[1]-v2[1], 2.0f) + pow(v1[2]-v2[2], 2.0f) + pow(v1[3]-v2[3], 2.0f));
+    assert_true(fabsf(d1 - d2) <= 0.000009);
   }
 
   /* test zero */

win/cglm.vcxproj

@@ -20,8 +20,10 @@
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="..\src\affine.c" />
+    <ClCompile Include="..\src\bezier.c" />
     <ClCompile Include="..\src\box.c" />
     <ClCompile Include="..\src\cam.c" />
+    <ClCompile Include="..\src\curve.c" />
     <ClCompile Include="..\src\dllmain.c" />
     <ClCompile Include="..\src\ease.c" />
     <ClCompile Include="..\src\euler.c" />
@@ -39,11 +41,14 @@
   <ItemGroup>
     <ClInclude Include="..\include\cglm\affine-mat.h" />
     <ClInclude Include="..\include\cglm\affine.h" />
+    <ClInclude Include="..\include\cglm\bezier.h" />
     <ClInclude Include="..\include\cglm\box.h" />
     <ClInclude Include="..\include\cglm\call.h" />
     <ClInclude Include="..\include\cglm\call\affine.h" />
+    <ClInclude Include="..\include\cglm\call\bezier.h" />
     <ClInclude Include="..\include\cglm\call\box.h" />
     <ClInclude Include="..\include\cglm\call\cam.h" />
+    <ClInclude Include="..\include\cglm\call\curve.h" />
     <ClInclude Include="..\include\cglm\call\ease.h" />
     <ClInclude Include="..\include\cglm\call\euler.h" />
     <ClInclude Include="..\include\cglm\call\frustum.h" />
@@ -60,6 +65,7 @@
     <ClInclude Include="..\include\cglm\cglm.h" />
     <ClInclude Include="..\include\cglm\color.h" />
     <ClInclude Include="..\include\cglm\common.h" />
+    <ClInclude Include="..\include\cglm\curve.h" />
     <ClInclude Include="..\include\cglm\ease.h" />
     <ClInclude Include="..\include\cglm\euler.h" />
     <ClInclude Include="..\include\cglm\frustum.h" />
@@ -69,6 +75,7 @@
     <ClInclude Include="..\include\cglm\plane.h" />
     <ClInclude Include="..\include\cglm\project.h" />
     <ClInclude Include="..\include\cglm\quat.h" />
+    <ClInclude Include="..\include\cglm\simd\arm.h" />
     <ClInclude Include="..\include\cglm\simd\avx\affine.h" />
     <ClInclude Include="..\include\cglm\simd\avx\mat4.h" />
     <ClInclude Include="..\include\cglm\simd\intrin.h" />
@@ -77,6 +84,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\simd\x86.h" />
     <ClInclude Include="..\include\cglm\sphere.h" />
     <ClInclude Include="..\include\cglm\types.h" />
     <ClInclude Include="..\include\cglm\util.h" />

win/cglm.vcxproj.filters

@@ -84,6 +84,12 @@
     <ClCompile Include="..\src\ease.c">
       <Filter>src</Filter>
     </ClCompile>
+    <ClCompile Include="..\src\curve.c">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\bezier.c">
+      <Filter>src</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\src\config.h">
@@ -233,5 +239,23 @@
     <ClInclude Include="..\include\cglm\ease.h">
       <Filter>include\cglm</Filter>
     </ClInclude>
+    <ClInclude Include="..\include\cglm\simd\arm.h">
+      <Filter>include\cglm\simd</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\simd\x86.h">
+      <Filter>include\cglm\simd</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\call\curve.h">
+      <Filter>include\cglm\call</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\curve.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\bezier.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\call\bezier.h">
+      <Filter>include\cglm\call</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>