Update affine.h

* to override float epsilon we just need to define GLM_FLT_EPSILON
* CGLM_USE_DEFAULT_EPSILON was redundant, also it forces to override system default epsilon which may not be good idea, because not all systems may support smaller epsilon values

CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.8.2)
-project(cglm VERSION 0.8.3 LANGUAGES C)
+project(cglm VERSION 0.8.0 LANGUAGES C)
 
 set(CMAKE_C_STANDARD 11)
 set(CMAKE_C_STANDARD_REQUIRED YES)
@@ -18,7 +18,7 @@ else(CGLM_STATIC)
 endif()
 
 if(CGLM_USE_C99)
-  set(CMAKE_C_STANDARD 99)
+  set(C_STANDARD 99)
 endif()
 
 if(MSVC)
@@ -93,11 +93,6 @@ target_include_directories(${PROJECT_NAME}
         ${CMAKE_CURRENT_SOURCE_DIR}/src
 )
 
-# Target for header-only usage
-add_library(${PROJECT_NAME}_headers INTERFACE)
-target_include_directories(${PROJECT_NAME}_headers INTERFACE
-  ${CMAKE_CURRENT_SOURCE_DIR}/include)
-
 # Test Configuration
 if(CGLM_USE_TEST)
   include(CTest)
@@ -122,16 +117,6 @@ export(TARGETS ${PROJECT_NAME}
 )
 
 install(EXPORT      ${PROJECT_NAME}
-        FILE        "${PROJECT_NAME}Config.cmake"
         NAMESPACE   ${PROJECT_NAME}::
-        DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME})
+        DESTINATION ${CMAKE_INSTALL_LIBDIR}/${PROJECT_NAME}/cmake)
 
-set(PACKAGE_NAME ${PROJECT_NAME})
-set(prefix ${CMAKE_INSTALL_PREFIX})
-set(exec_prefix ${CMAKE_INSTALL_PREFIX})
-set(includedir "\${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")
-set(libdir "\${prefix}/${CMAKE_INSTALL_LIBDIR}")
-configure_file(${CMAKE_CURRENT_LIST_DIR}/cglm.pc.in ${CMAKE_BINARY_DIR}/cglm.pc @ONLY)
-
-install(FILES ${CMAKE_BINARY_DIR}/cglm.pc
-  DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)

CREDITS

@@ -74,7 +74,3 @@ Link to paper: http://webserver2.tecgraf.puc-rio.br/~mgattass/cg/trbRR/Fast%20Mi
 
 14. ARM NEON: Matrix Vector Multiplication
 https://stackoverflow.com/a/57793352/2676533
-
-16. ARM NEON Div
-
-http://github.com/microsoft/DirectXMath

Makefile.am

@@ -109,10 +109,7 @@ cglm_simd_avx_HEADERS = include/cglm/simd/avx/mat4.h \
                         include/cglm/simd/avx/affine.h
 
 cglm_simd_neondir=$(includedir)/cglm/simd/neon
-cglm_simd_neon_HEADERS = include/cglm/simd/neon/mat4.h \
+cglm_simd_neon_HEADERS = include/cglm/simd/neon/mat4.h
-                         include/cglm/simd/neon/mat2.h \
-                         include/cglm/simd/neon/affine.h \
-                         include/cglm/simd/neon/quat.h
 
 cglm_structdir=$(includedir)/cglm/struct
 cglm_struct_HEADERS = include/cglm/struct/mat4.h \

README.md

@@ -95,9 +95,9 @@ Currently *cglm* uses default clip space configuration (-1, 1) for camera functi
 
 <hr />
 
-You have two options to call a function/operation: inline or library call (link)
+You have two option to call a function/operation: inline or library call (link)
 Almost all functions are marked inline (always_inline) so compiler will probably inline.
-To call pre-compiled versions, just use `glmc_` (c stands for 'call') instead of `glm_`.
+To call pre-compiled version, just use `glmc_` (c stands for 'call') instead of `glm_`.
 
 ```C
   #include <cglm/cglm.h>   /* for inline */
@@ -168,24 +168,6 @@ option(CGLM_USE_C99 "" OFF) # C11
 option(CGLM_USE_TEST "Enable Tests" OFF) # for make check - make test
 ```
 
-#### Use as header-only library with your CMake project
-
-This requires no building or installation of cglm.
-
-* Example:
-
-``` cmake
-cmake_minimum_required(VERSION 3.8.2)
-
-project(<Your Project Name>)
-
-add_executable(${PROJECT_NAME} src/main.c)
-target_link_libraries(${LIBRARY_NAME} PRIVATE
-  cglm_headers)
-
-add_subdirectory(external/cglm/ EXCLUDE_FROM_ALL)
-```
-
 #### Use with your CMake project
 * Example:
 ```cmake

cglm.podspec

@@ -2,7 +2,7 @@ Pod::Spec.new do |s|
 
   # Description
   s.name         = "cglm"
-  s.version      = "0.8.2"
+  s.version      = "0.7.9"
   s.summary      = "📽 Highly Optimized Graphics Math (glm) for C"
   s.description  = <<-DESC
 cglm is math library for graphics programming for C. See the documentation or README for all features.

configure.ac

@@ -7,7 +7,7 @@
 #*****************************************************************************
 
 AC_PREREQ([2.69])
-AC_INIT([cglm], [0.8.3], [info@recp.me])
+AC_INIT([cglm], [0.8.0], [info@recp.me])
 AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects serial-tests])
 
 # Don't use the default cflags (-O2 -g), we set ours manually in Makefile.am.

docs/source/build.rst

@@ -32,22 +32,6 @@ If you don't want to install **cglm** to your system's folder you can get static
   option(CGLM_USE_C99 "" OFF) # C11 
   option(CGLM_USE_TEST "Enable Tests" OFF) # for make check - make test
 
-**Use as header-only library with your CMake project example**
-This requires no building or installation of cglm.
-
-.. code-block:: CMake
-  :linenos:
-
-  cmake_minimum_required(VERSION 3.8.2)
-  
-  project(<Your Project Name>)
-  
-  add_executable(${PROJECT_NAME} src/main.c)
-  target_link_libraries(${LIBRARY_NAME} PRIVATE
-    cglm_headers)
-  
-  add_subdirectory(external/cglm/ EXCLUDE_FROM_ALL)
-
 **Use with your CMake project example**
 
 .. code-block:: CMake

docs/source/conf.py

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

docs/source/opengl.rst

@@ -2,7 +2,7 @@ How to send vector or matrix to OpenGL like API
 ==================================================
 
 *cglm*'s vector and matrix types are arrays. So you can send them directly to a
-function which accepts pointer. But you may got warnings for matrix because it is
+function which accecpts pointer. But you may got warnings for matrix because it is
 two dimensional array.
 
 Passing / Uniforming Matrix to OpenGL:

docs/source/quat.rst

@@ -52,7 +52,6 @@ Functions:
 #. :c:func:`glm_quat_mat3`
 #. :c:func:`glm_quat_mat3t`
 #. :c:func:`glm_quat_lerp`
-#. :c:func:`glm_quat_nlerp`
 #. :c:func:`glm_quat_slerp`
 #. :c:func:`glm_quat_look`
 #. :c:func:`glm_quat_for`
@@ -305,25 +304,6 @@ Functions documentation
       | *[in]*  **t**     interpolant (amount) clamped between 0 and 1
       | *[out]* **dest**  result quaternion
 
-.. c:function:: void glm_quat_nlerp(versor q, versor r, float  t, versor dest)
-
-    | interpolates between two quaternions
-    | taking the shortest rotation path using
-    | normalized linear interpolation (NLERP)
-
-    | This is a cheaper alternative to slerp; most games use nlerp
-    | for animations as it visually makes little difference.
-
-    References:
-      * `Understanding Slerp, Then Not Using it <http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It>`_
-      * `Lerp, Slerp and Nlerp <https://keithmaggio.wordpress.com/2011/02/15/math-magician-lerp-slerp-and-nlerp/>`_
-
-    Parameters:
-      | *[in]*  **from**  from
-      | *[in]*  **to**    to
-      | *[in]*  **t**     interpolant (amount) clamped between 0 and 1
-      | *[out]* **dest**  result quaternion
-
 .. c:function:: void glm_quat_slerp(versor q, versor r, float  t, versor dest)
 
     | interpolates between two quaternions

include/cglm/affine-mat.h

@@ -26,10 +26,6 @@
 #  include "simd/avx/affine.h"
 #endif
 
-#ifdef CGLM_NEON_FP
-#  include "simd/neon/affine.h"
-#endif
-
 /*!
  * @brief this is similar to glm_mat4_mul but specialized to affine transform
  *
@@ -53,8 +49,6 @@ glm_mul(mat4 m1, mat4 m2, mat4 dest) {
   glm_mul_avx(m1, m2, dest);
 #elif defined( __SSE__ ) || defined( __SSE2__ )
   glm_mul_sse2(m1, m2, dest);
-#elif defined(CGLM_NEON_FP)
-  glm_mul_neon(m1, m2, dest);
 #else
   float a00 = m1[0][0], a01 = m1[0][1], a02 = m1[0][2], a03 = m1[0][3],
         a10 = m1[1][0], a11 = m1[1][1], a12 = m1[1][2], a13 = m1[1][3],
@@ -109,8 +103,6 @@ void
 glm_mul_rot(mat4 m1, mat4 m2, mat4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glm_mul_rot_sse2(m1, m2, dest);
-#elif defined(CGLM_NEON_FP)
-  glm_mul_rot_neon(m1, m2, dest);
 #else
   float a00 = m1[0][0], a01 = m1[0][1], a02 = m1[0][2], a03 = m1[0][3],
         a10 = m1[1][0], a11 = m1[1][1], a12 = m1[1][2], a13 = m1[1][3],
@@ -158,8 +150,6 @@ void
 glm_inv_tr(mat4 mat) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glm_inv_tr_sse2(mat);
-#elif defined(CGLM_NEON_FP)
-  glm_inv_tr_neon(mat);
 #else
   CGLM_ALIGN_MAT mat3 r;
   CGLM_ALIGN(8)  vec3 t;

include/cglm/affine.h

@@ -50,22 +50,26 @@
 CGLM_INLINE
 void
 glm_translate(mat4 m, vec3 v) {
-#if defined(CGLM_SIMD)
+#if defined( __SSE__ ) || defined( __SSE2__ )
-  glmm_128 m0, m1, m2, m3;
-
-  m0 = glmm_load(m[0]);
-  m1 = glmm_load(m[1]);
-  m2 = glmm_load(m[2]);
-  m3 = glmm_load(m[3]);
-
   glmm_store(m[3],
-             glmm_fmadd(m0, glmm_set1(v[0]),
+             _mm_add_ps(_mm_add_ps(_mm_mul_ps(glmm_load(m[0]),
-                        glmm_fmadd(m1, glmm_set1(v[1]),
+                                              _mm_set1_ps(v[0])),
-                                   glmm_fmadd(m2, glmm_set1(v[2]), m3))));
+                                   _mm_mul_ps(glmm_load(m[1]),
+                                              _mm_set1_ps(v[1]))),
+                        _mm_add_ps(_mm_mul_ps(glmm_load(m[2]),
+                                              _mm_set1_ps(v[2])),
+                                   glmm_load(m[3]))))
+  ;
 #else
-  glm_vec4_muladds(m[0], v[0], m[3]);
+  vec4 v1, v2, v3;
-  glm_vec4_muladds(m[1], v[1], m[3]);
+
-  glm_vec4_muladds(m[2], v[2], m[3]);
+  glm_vec4_scale(m[0], v[0], v1);
+  glm_vec4_scale(m[1], v[1], v2);
+  glm_vec4_scale(m[2], v[2], v3);
+
+  glm_vec4_add(v1, m[3], m[3]);
+  glm_vec4_add(v2, m[3], m[3]);
+  glm_vec4_add(v3, m[3], m[3]);
 #endif
 }
 
@@ -95,8 +99,12 @@ glm_translate_to(mat4 m, vec3 v, mat4 dest) {
 CGLM_INLINE
 void
 glm_translate_x(mat4 m, float x) {
-#if defined(CGLM_SIMD)
+#if defined( __SSE__ ) || defined( __SSE2__ )
-  glmm_store(m[3], glmm_fmadd(glmm_load(m[0]), glmm_set1(x), glmm_load(m[3])));
+  glmm_store(m[3],
+             _mm_add_ps(_mm_mul_ps(glmm_load(m[0]),
+                                   _mm_set1_ps(x)),
+                        glmm_load(m[3])))
+  ;
 #else
   vec4 v1;
   glm_vec4_scale(m[0], x, v1);
@@ -113,8 +121,12 @@ glm_translate_x(mat4 m, float x) {
 CGLM_INLINE
 void
 glm_translate_y(mat4 m, float y) {
-#if defined(CGLM_SIMD)
+#if defined( __SSE__ ) || defined( __SSE2__ )
-  glmm_store(m[3], glmm_fmadd(glmm_load(m[1]), glmm_set1(y), glmm_load(m[3])));
+  glmm_store(m[3],
+             _mm_add_ps(_mm_mul_ps(glmm_load(m[1]),
+                                   _mm_set1_ps(y)),
+                        glmm_load(m[3])))
+  ;
 #else
   vec4 v1;
   glm_vec4_scale(m[1], y, v1);
@@ -131,8 +143,12 @@ glm_translate_y(mat4 m, float y) {
 CGLM_INLINE
 void
 glm_translate_z(mat4 m, float z) {
-#if defined(CGLM_SIMD)
+#if defined( __SSE__ ) || defined( __SSE2__ )
-  glmm_store(m[3], glmm_fmadd(glmm_load(m[2]), glmm_set1(z), glmm_load(m[3])));
+  glmm_store(m[3],
+             _mm_add_ps(_mm_mul_ps(glmm_load(m[2]),
+                                   _mm_set1_ps(z)),
+                        glmm_load(m[3])))
+  ;
 #else
   vec4 v1;
   glm_vec4_scale(m[2], z, v1);
@@ -409,7 +425,7 @@ bool
 glm_uniscaled(mat4 m) {
   CGLM_ALIGN(8) vec3 s;
   glm_decompose_scalev(m, s);
-  return glm_vec3_eq_all(s);
+  return glm_vec3_eq_eps(s, s[0]);
 }
 
 /*!
@@ -439,7 +455,7 @@ glm_decompose_rs(mat4 m, mat4 r, vec3 s) {
   glm_vec4_scale(r[1], 1.0f/s[1], r[1]);
   glm_vec4_scale(r[2], 1.0f/s[2], r[2]);
 
-  /* Note from Apple Open Source (assume that the matrix is orthonormal):
+  /* Note from Apple Open Source (asume that the matrix is orthonormal):
      check for a coordinate system flip.  If the determinant
      is -1, then negate the matrix and the scaling factors. */
   glm_vec3_cross(m[0], m[1], v);

include/cglm/box.h

@@ -228,8 +228,6 @@ glm_aabb_aabb(vec3 box[2], vec3 other[2]) {
  * https://github.com/erich666/GraphicsGems/blob/master/gems/BoxSphere.c
  * Solid Box - Solid Sphere test.
  *
- * Sphere Representation in cglm: [center.x, center.y, center.z, radii]
- *
  * @param[in]   box    solid bounding box
  * @param[in]   s      solid sphere
  */
@@ -239,13 +237,13 @@ glm_aabb_sphere(vec3 box[2], vec4 s) {
   float dmin;
   int   a, b, c;
 
-  a = (s[0] < box[0][0]) + (s[0] > box[1][0]);
+  a = s[0] >= box[0][0];
-  b = (s[1] < box[0][1]) + (s[1] > box[1][1]);
+  b = s[1] >= box[0][1];
-  c = (s[2] < box[0][2]) + (s[2] > box[1][2]);
+  c = s[2] >= box[0][2];
 
-  dmin  = glm_pow2((s[0] - box[!(a - 1)][0]) * (a != 0))
+  dmin  = glm_pow2(s[0] - box[a][0])
-        + glm_pow2((s[1] - box[!(b - 1)][1]) * (b != 0))
+        + glm_pow2(s[1] - box[b][1])
-        + glm_pow2((s[2] - box[!(c - 1)][2]) * (c != 0));
+        + glm_pow2(s[2] - box[c][2]);
 
   return dmin <= glm_pow2(s[3]);
 }

include/cglm/call/quat.h

@@ -121,10 +121,6 @@ CGLM_EXPORT
 void
 glmc_quat_lerpc(versor from, versor to, float t, versor dest);
 
-CGLM_EXPORT
-void
-glmc_quat_nlerp(versor q, versor r, float t, versor dest);
-
 CGLM_EXPORT
 void
 glmc_quat_slerp(versor q, versor r, float t, versor dest);

include/cglm/call/vec4.h

@@ -99,7 +99,7 @@ glmc_vec4_scale(vec4 v, float s, vec4 dest);
 
 CGLM_EXPORT
 void
-glmc_vec4_scale_as(vec4 v, float s, vec4 dest);
+glmc_vec4_scale_as(vec3 v, float s, vec3 dest);
 
 CGLM_EXPORT
 void

include/cglm/common.h

@@ -42,12 +42,18 @@
 #include "types.h"
 #include "simd/intrin.h"
 
-#ifndef CGLM_USE_DEFAULT_EPSILON
+/** CGLM_USE_DEFAULT_EPSILON is removed, to override float epsilon,
-#  ifndef GLM_FLT_EPSILON
+ *  just define GLM_FLT_EPSILON with epsilon value like below
-#    define GLM_FLT_EPSILON 1e-6
+ *
-#  endif
+ *  #define GLM_FLT_EPSILON 1e-6f
-#else
+ */
+
+#ifndef GLM_FLT_EPSILON
+#  ifndef FLT_EPSILON
+#    define GLM_FLT_EPSILON 1e-6f
+#  else
 #    define GLM_FLT_EPSILON FLT_EPSILON
+#  endif
 #endif
 
 #endif /* cglm_common_h */

include/cglm/mat2.h

@@ -40,10 +40,6 @@
 #  include "simd/sse2/mat2.h"
 #endif
 
-#ifdef CGLM_NEON_FP
-#  include "simd/neon/mat2.h"
-#endif
-
 #define GLM_MAT2_IDENTITY_INIT  {{1.0f, 0.0f}, {0.0f, 1.0f}}
 #define GLM_MAT2_ZERO_INIT      {{0.0f, 0.0f}, {0.0f, 0.0f}}
 
@@ -134,8 +130,6 @@ void
 glm_mat2_mul(mat2 m1, mat2 m2, mat2 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glm_mat2_mul_sse2(m1, m2, dest);
-#elif defined(CGLM_NEON_FP)
-  glm_mat2_mul_neon(m1, m2, dest);
 #else
   float a00 = m1[0][0], a01 = m1[0][1],
         a10 = m1[1][0], a11 = m1[1][1],

include/cglm/mat4.h

@@ -187,29 +187,8 @@ glm_mat4_identity_array(mat4 * __restrict mat, size_t count) {
 CGLM_INLINE
 void
 glm_mat4_zero(mat4 mat) {
-#ifdef __AVX__
-  __m256 y0;
-  y0 = _mm256_setzero_ps();
-  glmm_store256(mat[0], y0);
-  glmm_store256(mat[2], y0);
-#elif defined( __SSE__ ) || defined( __SSE2__ )
-  glmm_128 x0;
-  x0 = _mm_setzero_ps();
-  glmm_store(mat[0], x0);
-  glmm_store(mat[1], x0);
-  glmm_store(mat[2], x0);
-  glmm_store(mat[3], x0);
-#elif defined(CGLM_NEON_FP)
-  glmm_128 x0;
-  x0 = vdupq_n_f32(0.0f);
-  vst1q_f32(mat[0], x0);
-  vst1q_f32(mat[1], x0);
-  vst1q_f32(mat[2], x0);
-  vst1q_f32(mat[3], x0);
-#else
   CGLM_ALIGN_MAT mat4 t = GLM_MAT4_ZERO_INIT;
   glm_mat4_copy(t, mat);
-#endif
 }
 
 /*!
@@ -560,9 +539,7 @@ glm_mat4_scale_p(mat4 m, float s) {
 CGLM_INLINE
 void
 glm_mat4_scale(mat4 m, float s) {
-#ifdef __AVX__
+#if defined( __SSE__ ) || defined( __SSE2__ )
-  glm_mat4_scale_avx(m, s);
-#elif defined( __SSE__ ) || defined( __SSE2__ )
   glm_mat4_scale_sse2(m, s);
 #elif defined(CGLM_NEON_FP)
   glm_mat4_scale_neon(m, s);
@@ -583,8 +560,6 @@ float
 glm_mat4_det(mat4 mat) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   return glm_mat4_det_sse2(mat);
-#elif defined(CGLM_NEON_FP)
-  return glm_mat4_det_neon(mat);
 #else
   /* [square] det(A) = det(At) */
   float t[6];
@@ -618,8 +593,6 @@ void
 glm_mat4_inv(mat4 mat, mat4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glm_mat4_inv_sse2(mat, dest);
-#elif defined(CGLM_NEON_FP)
-  glm_mat4_inv_neon(mat, dest);
 #else
   float t[6];
   float det;

include/cglm/quat.h

@@ -38,7 +38,6 @@
    CGLM_INLINE void glm_quat_lerp(versor from, versor to, float t, versor dest);
    CGLM_INLINE void glm_quat_lerpc(versor from, versor to, float t, versor dest);
    CGLM_INLINE void glm_quat_slerp(versor q, versor r, float t, versor dest);
-   CGLM_INLINE void glm_quat_nlerp(versor q, versor r, float t, versor dest);
    CGLM_INLINE void glm_quat_look(vec3 eye, versor ori, mat4 dest);
    CGLM_INLINE void glm_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest);
    CGLM_INLINE void glm_quat_forp(vec3 from,
@@ -64,10 +63,6 @@
 #  include "simd/sse2/quat.h"
 #endif
 
-#ifdef CGLM_NEON_FP
-#  include "simd/neon/quat.h"
-#endif
-
 CGLM_INLINE
 void
 glm_mat4_mulv(mat4 m, vec4 v, vec4 dest);
@@ -417,8 +412,6 @@ glm_quat_mul(versor p, versor q, versor dest) {
    */
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glm_quat_mul_sse2(p, q, dest);
-#elif defined(CGLM_NEON_FP)
-  glm_quat_mul_neon(p, q, dest);
 #else
   dest[0] = p[3] * q[0] + p[0] * q[3] + p[1] * q[2] - p[2] * q[1];
   dest[1] = p[3] * q[1] - p[0] * q[2] + p[1] * q[3] + p[2] * q[0];
@@ -629,26 +622,6 @@ glm_quat_lerpc(versor from, versor to, float t, versor dest) {
   glm_vec4_lerpc(from, to, t, dest);
 }
 
-/*!
- * @brief interpolates between two quaternions
- *        taking the shortest rotation path using
- *        normalized linear interpolation (NLERP)
- *
- * @param[in]   from  from
- * @param[in]   to    to
- * @param[in]   t     interpolant (amount)
- * @param[out]  dest  result quaternion
- */
-CGLM_INLINE
-void
-glm_quat_nlerp(versor from, versor to, float t, versor dest) {
-  float dot = glm_vec4_dot(from, to);
-  versor target;
-  glm_vec4_scale(to, (dot >= 0) ? 1 : -1, target);
-  glm_quat_lerp(from, target, t, dest);
-  glm_quat_normalize(dest);
-}
-
 /*!
  * @brief interpolates between two quaternions
  *        using spherical linear interpolation (SLERP)

include/cglm/simd/arm.h

@@ -10,56 +10,19 @@
 #include "intrin.h"
 #ifdef CGLM_SIMD_ARM
 
-#if defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || defined(__aarch64__)
-# define CGLM_ARM64 1
-#endif
-
 #define glmm_load(p)      vld1q_f32(p)
 #define glmm_store(p, a)  vst1q_f32(p, a)
 
-#define glmm_set1(x) vdupq_n_f32(x)
-#define glmm_128     float32x4_t
-
-#define glmm_splat_x(x) vdupq_lane_f32(vget_low_f32(x),  0)
-#define glmm_splat_y(x) vdupq_lane_f32(vget_low_f32(x),  1)
-#define glmm_splat_z(x) vdupq_lane_f32(vget_high_f32(x), 0)
-#define glmm_splat_w(x) vdupq_lane_f32(vget_high_f32(x), 1)
-
-#define glmm_xor(a, b)                                                        \
-  vreinterpretq_f32_s32(veorq_s32(vreinterpretq_s32_f32(a),                   \
-                                  vreinterpretq_s32_f32(b)))
-
-#define glmm_swplane(v) vextq_f32(v, v, 2)
-#define glmm_low(x)     vget_low_f32(x)
-#define glmm_high(x)    vget_high_f32(x)
-
-#define glmm_combine_ll(x, y) vcombine_f32(vget_low_f32(x),  vget_low_f32(y))
-#define glmm_combine_hl(x, y) vcombine_f32(vget_high_f32(x), vget_low_f32(y))
-#define glmm_combine_lh(x, y) vcombine_f32(vget_low_f32(x),  vget_high_f32(y))
-#define glmm_combine_hh(x, y) vcombine_f32(vget_high_f32(x), vget_high_f32(y))
-
 static inline
 float32x4_t
 glmm_abs(float32x4_t v) {
   return vabsq_f32(v);
 }
 
-static inline
-float32x4_t
-glmm_vhadd(float32x4_t v) {
-  return vaddq_f32(vaddq_f32(glmm_splat_x(v), glmm_splat_y(v)),
-                   vaddq_f32(glmm_splat_z(v), glmm_splat_w(v)));
-  /*
-   this seems slower:
-   v = vaddq_f32(v, vrev64q_f32(v));
-   return vaddq_f32(v, vcombine_f32(vget_high_f32(v), vget_low_f32(v)));
-   */
-}
-
 static inline
 float
 glmm_hadd(float32x4_t v) {
-#if CGLM_ARM64
+#if defined(__aarch64__)
   return vaddvq_f32(v);
 #else
   v = vaddq_f32(v, vrev64q_f32(v));
@@ -116,58 +79,5 @@ glmm_norm_inf(float32x4_t a) {
   return glmm_hmax(glmm_abs(a));
 }
 
-static inline
-float32x4_t
-glmm_div(float32x4_t a, float32x4_t b) {
-#if CGLM_ARM64
-  return vdivq_f32(a, b);
-#else
-  /* 2 iterations of Newton-Raphson refinement of reciprocal */
-  float32x4_t r0, r1;
-  r0 = vrecpeq_f32(b);
-  r1 = vrecpsq_f32(r0, b);
-  r0 = vmulq_f32(r1, r0);
-  r1 = vrecpsq_f32(r0, b);
-  r0 = vmulq_f32(r1, r0);
-  return vmulq_f32(a, r0);
-#endif
-}
-
-static inline
-float32x4_t
-glmm_fmadd(float32x4_t a, float32x4_t b, float32x4_t c) {
-#if CGLM_ARM64
-  return vfmaq_f32(c, a, b); /* why vfmaq_f32 is slower than vmlaq_f32 ??? */
-#else
-  return vmlaq_f32(c, a, b);
-#endif
-}
-
-static inline
-float32x4_t
-glmm_fnmadd(float32x4_t a, float32x4_t b, float32x4_t c) {
-#if CGLM_ARM64
-  return vfmsq_f32(c, a, b);
-#else
-  return vmlsq_f32(c, a, b);
-#endif
-}
-
-static inline
-float32x4_t
-glmm_fmsub(float32x4_t a, float32x4_t b, float32x4_t c) {
-#if CGLM_ARM64
-  return vfmsq_f32(c, a, b);
-#else
-  return vmlsq_f32(c, a, b);
-#endif
-}
-
-static inline
-float32x4_t
-glmm_fnmsub(float32x4_t a, float32x4_t b, float32x4_t c) {
-  return vsubq_f32(vdupq_n_f32(0.0f), glmm_fmadd(a, b, c));
-}
-
 #endif
 #endif /* cglm_simd_arm_h */

include/cglm/simd/avx/mat4.h

@@ -14,16 +14,6 @@
 
 #include <immintrin.h>
 
-CGLM_INLINE
-void
-glm_mat4_scale_avx(mat4 m, float s) {
-  __m256 y0;
-  y0 = _mm256_set1_ps(s);
-  
-  glmm_store256(m[0], _mm256_mul_ps(y0, glmm_load256(m[0])));
-  glmm_store256(m[2], _mm256_mul_ps(y0, glmm_load256(m[2])));
-}
-
 CGLM_INLINE
 void
 glm_mat4_mul_avx(mat4 m1, mat4 m2, mat4 dest) {

include/cglm/simd/neon/affine.h

@@ -1,122 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglm_affine_neon_h
-#define cglm_affine_neon_h
-#if defined(__ARM_NEON_FP)
-
-#include "../../common.h"
-#include "../intrin.h"
-
-CGLM_INLINE
-void
-glm_mul_neon(mat4 m1, mat4 m2, mat4 dest) {
-  /* D = R * L (Column-Major) */
-
-  glmm_128 l, r0, r1, r2, r3, v0, v1, v2, v3;
-
-  l  = glmm_load(m1[0]);
-  r0 = glmm_load(m2[0]);
-  r1 = glmm_load(m2[1]);
-  r2 = glmm_load(m2[2]);
-  r3 = glmm_load(m2[3]);
-
-  v0 = vmulq_f32(glmm_splat_x(r0), l);
-  v1 = vmulq_f32(glmm_splat_x(r1), l);
-  v2 = vmulq_f32(glmm_splat_x(r2), l);
-  v3 = vmulq_f32(glmm_splat_x(r3), l);
-
-  l  = glmm_load(m1[1]);
-  v0 = glmm_fmadd(glmm_splat_y(r0), l, v0);
-  v1 = glmm_fmadd(glmm_splat_y(r1), l, v1);
-  v2 = glmm_fmadd(glmm_splat_y(r2), l, v2);
-  v3 = glmm_fmadd(glmm_splat_y(r3), l, v3);
-
-  l  = glmm_load(m1[2]);
-  v0 = glmm_fmadd(glmm_splat_z(r0), l, v0);
-  v1 = glmm_fmadd(glmm_splat_z(r1), l, v1);
-  v2 = glmm_fmadd(glmm_splat_z(r2), l, v2);
-  v3 = glmm_fmadd(glmm_splat_z(r3), l, v3);
-
-  v3 = glmm_fmadd(glmm_splat_w(r3), glmm_load(m1[3]), v3);
-
-  glmm_store(dest[0], v0);
-  glmm_store(dest[1], v1);
-  glmm_store(dest[2], v2);
-  glmm_store(dest[3], v3);
-}
-
-CGLM_INLINE
-void
-glm_mul_rot_neon(mat4 m1, mat4 m2, mat4 dest) {
-  /* D = R * L (Column-Major) */
-
-  glmm_128 l, r0, r1, r2, v0, v1, v2;
-
-  l  = glmm_load(m1[0]);
-  r0 = glmm_load(m2[0]);
-  r1 = glmm_load(m2[1]);
-  r2 = glmm_load(m2[2]);
-
-  v0 = vmulq_f32(glmm_splat_x(r0), l);
-  v1 = vmulq_f32(glmm_splat_x(r1), l);
-  v2 = vmulq_f32(glmm_splat_x(r2), l);
-
-  l  = glmm_load(m1[1]);
-  v0 = glmm_fmadd(glmm_splat_y(r0), l, v0);
-  v1 = glmm_fmadd(glmm_splat_y(r1), l, v1);
-  v2 = glmm_fmadd(glmm_splat_y(r2), l, v2);
-  
-  l  = glmm_load(m1[2]);
-  v0 = glmm_fmadd(glmm_splat_z(r0), l, v0);
-  v1 = glmm_fmadd(glmm_splat_z(r1), l, v1);
-  v2 = glmm_fmadd(glmm_splat_z(r2), l, v2);
-
-  glmm_store(dest[0], v0);
-  glmm_store(dest[1], v1);
-  glmm_store(dest[2], v2);
-  glmm_store(dest[3], glmm_load(m1[3]));
-}
-
-CGLM_INLINE
-void
-glm_inv_tr_neon(mat4 mat) {
-  float32x4x4_t vmat;
-  glmm_128      r0, r1, r2, r3, x0;
-
-  vmat = vld4q_f32(mat[0]);
-  r0   = vmat.val[0];
-  r1   = vmat.val[1];
-  r2   = vmat.val[2];
-  r3   = vmat.val[3];
-
-  x0 = glmm_fmadd(r0, glmm_splat_w(r0),
-                  glmm_fmadd(r1, glmm_splat_w(r1),
-                             vmulq_f32(r2, glmm_splat_w(r2))));
-  x0 = vnegq_f32(x0);
-
-  glmm_store(mat[0], r0);
-  glmm_store(mat[1], r1);
-  glmm_store(mat[2], r2);
-  glmm_store(mat[3], x0);
-  
-  mat[0][3] = 0.0f;
-  mat[1][3] = 0.0f;
-  mat[2][3] = 0.0f;
-  mat[3][3] = 1.0f;
-
-  /* TODO: ?
-  zo   = vget_high_f32(r3);
-  vst1_lane_f32(&mat[0][3], zo, 0);
-  vst1_lane_f32(&mat[1][3], zo, 0);
-  vst1_lane_f32(&mat[2][3], zo, 0);
-  vst1_lane_f32(&mat[3][3], zo, 1);
-  */
-}
-
-#endif
-#endif /* cglm_affine_neon_h */

include/cglm/simd/neon/mat2.h

@@ -1,44 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglm_mat2_neon_h
-#define cglm_mat2_neon_h
-#if defined(__ARM_NEON_FP)
-
-#include "../../common.h"
-#include "../intrin.h"
-
-CGLM_INLINE
-void
-glm_mat2_mul_neon(mat2 m1, mat2 m2, mat2 dest) {
-  float32x4x2_t a1;
-  glmm_128 x0,  x1, x2;
-  float32x2_t   dc, ba;
-
-  x1 = glmm_load(m1[0]); /* d c b a */
-  x2 = glmm_load(m2[0]); /* h g f e */
-  
-  dc = vget_high_f32(x1);
-  ba = vget_low_f32(x1);
-
-  /* g g e e, h h f f */
-  a1 = vtrnq_f32(x2, x2);
-  
-  /*
-   dest[0][0] = a * e + c * f;
-   dest[0][1] = b * e + d * f;
-   dest[1][0] = a * g + c * h;
-   dest[1][1] = b * g + d * h;
-   */
-  x0 = glmm_fmadd(vcombine_f32(ba, ba), a1.val[0],
-                  vmulq_f32(vcombine_f32(dc, dc), a1.val[1]));
-
-  glmm_store(dest[0], x0);
-}
-
-#endif
-#endif /* cglm_mat2_neon_h */

include/cglm/simd/neon/mat4.h

@@ -42,42 +42,41 @@ CGLM_INLINE
 void
 glm_mat4_mul_neon(mat4 m1, mat4 m2, mat4 dest) {
   /* D = R * L (Column-Major) */
+  float32x4_t l0, l1, l2, l3, r, d0, d1, d2, d3;
 
-  glmm_128 l, r0, r1, r2, r3, v0, v1, v2, v3;
+  l0 = vld1q_f32(m2[0]);
+  l1 = vld1q_f32(m2[1]);
+  l2 = vld1q_f32(m2[2]);
+  l3 = vld1q_f32(m2[3]);
 
-  l  = glmm_load(m1[0]);
+  r  = vld1q_f32(m1[0]);
-  r0 = glmm_load(m2[0]);
+  d0 = vmulq_lane_f32(r, vget_low_f32(l0), 0);
-  r1 = glmm_load(m2[1]);
+  d1 = vmulq_lane_f32(r, vget_low_f32(l1), 0);
-  r2 = glmm_load(m2[2]);
+  d2 = vmulq_lane_f32(r, vget_low_f32(l2), 0);
-  r3 = glmm_load(m2[3]);
+  d3 = vmulq_lane_f32(r, vget_low_f32(l3), 0);
 
-  v0 = vmulq_f32(glmm_splat_x(r0), l);
+  r  = vld1q_f32(m1[1]);
-  v1 = vmulq_f32(glmm_splat_x(r1), l);
+  d0 = vmlaq_lane_f32(d0, r, vget_low_f32(l0), 1);
-  v2 = vmulq_f32(glmm_splat_x(r2), l);
+  d1 = vmlaq_lane_f32(d1, r, vget_low_f32(l1), 1);
-  v3 = vmulq_f32(glmm_splat_x(r3), l);
+  d2 = vmlaq_lane_f32(d2, r, vget_low_f32(l2), 1);
+  d3 = vmlaq_lane_f32(d3, r, vget_low_f32(l3), 1);
 
-  l  = glmm_load(m1[1]);
+  r  = vld1q_f32(m1[2]);
-  v0 = glmm_fmadd(glmm_splat_y(r0), l, v0);
+  d0 = vmlaq_lane_f32(d0, r, vget_high_f32(l0), 0);
-  v1 = glmm_fmadd(glmm_splat_y(r1), l, v1);
+  d1 = vmlaq_lane_f32(d1, r, vget_high_f32(l1), 0);
-  v2 = glmm_fmadd(glmm_splat_y(r2), l, v2);
+  d2 = vmlaq_lane_f32(d2, r, vget_high_f32(l2), 0);
-  v3 = glmm_fmadd(glmm_splat_y(r3), l, v3);
+  d3 = vmlaq_lane_f32(d3, r, vget_high_f32(l3), 0);
 
-  l  = glmm_load(m1[2]);
+  r  = vld1q_f32(m1[3]);
-  v0 = glmm_fmadd(glmm_splat_z(r0), l, v0);
+  d0 = vmlaq_lane_f32(d0, r, vget_high_f32(l0), 1);
-  v1 = glmm_fmadd(glmm_splat_z(r1), l, v1);
+  d1 = vmlaq_lane_f32(d1, r, vget_high_f32(l1), 1);
-  v2 = glmm_fmadd(glmm_splat_z(r2), l, v2);
+  d2 = vmlaq_lane_f32(d2, r, vget_high_f32(l2), 1);
-  v3 = glmm_fmadd(glmm_splat_z(r3), l, v3);
+  d3 = vmlaq_lane_f32(d3, r, vget_high_f32(l3), 1);
 
-  l  = glmm_load(m1[3]);
+  vst1q_f32(dest[0], d0);
-  v0 = glmm_fmadd(glmm_splat_w(r0), l, v0);
+  vst1q_f32(dest[1], d1);
-  v1 = glmm_fmadd(glmm_splat_w(r1), l, v1);
+  vst1q_f32(dest[2], d2);
-  v2 = glmm_fmadd(glmm_splat_w(r2), l, v2);
+  vst1q_f32(dest[3], d3);
-  v3 = glmm_fmadd(glmm_splat_w(r3), l, v3);
-
-  glmm_store(dest[0], v0);
-  glmm_store(dest[1], v1);
-  glmm_store(dest[2], v2);
-  glmm_store(dest[3], v3);
 }
 
 CGLM_INLINE
@@ -102,216 +101,5 @@ glm_mat4_mulv_neon(mat4 m, vec4 v, vec4 dest) {
   vst1q_f32(dest, l0);
 }
 
-CGLM_INLINE
-float
-glm_mat4_det_neon(mat4 mat) {
-  float32x4_t   r0, r1, r2, r3, x0, x1, x2;
-  float32x2_t   ij, op, mn, kl, nn, mm, jj, ii, gh, ef, t12, t34;
-  float32x4x2_t a1;
-  float32x4_t   x3 = { 0.f, -0.f, 0.f, -0.f };
-
-  /* 127 <- 0, [square] det(A) = det(At) */
-  r0 = glmm_load(mat[0]);              /* d c b a */
-  r1 = vrev64q_f32(glmm_load(mat[1])); /* g h e f */
-  r2 = vrev64q_f32(glmm_load(mat[2])); /* l k i j */
-  r3 = vrev64q_f32(glmm_load(mat[3])); /* o p m n */
-
-  gh = vget_high_f32(r1);
-  ef = vget_low_f32(r1);
-  kl = vget_high_f32(r2);
-  ij = vget_low_f32(r2);
-  op = vget_high_f32(r3);
-  mn = vget_low_f32(r3);
-  mm = vdup_lane_f32(mn, 1);
-  nn = vdup_lane_f32(mn, 0);
-  ii = vdup_lane_f32(ij, 1);
-  jj = vdup_lane_f32(ij, 0);
-  
-  /*
-   t[1] = j * p - n * l;
-   t[2] = j * o - n * k;
-   t[3] = i * p - m * l;
-   t[4] = i * o - m * k;
-   */
-  x0 = glmm_fnmadd(vcombine_f32(kl, kl), vcombine_f32(nn, mm),
-                   vmulq_f32(vcombine_f32(op, op), vcombine_f32(jj, ii)));
-
-  t12 = vget_low_f32(x0);
-  t34 = vget_high_f32(x0);
-  
-  /* 1 3 1 3 2 4 2 4 */
-  a1 = vuzpq_f32(x0, x0);
-  
-  /*
-   t[0] = k * p - o * l;
-   t[0] = k * p - o * l;
-   t[5] = i * n - m * j;
-   t[5] = i * n - m * j;
-   */
-  x1 = glmm_fnmadd(vcombine_f32(vdup_lane_f32(kl, 0), jj),
-                   vcombine_f32(vdup_lane_f32(op, 1), mm),
-                   vmulq_f32(vcombine_f32(vdup_lane_f32(op, 0), nn),
-                             vcombine_f32(vdup_lane_f32(kl, 1), ii)));
-
-  /*
-     a * (f * t[0] - g * t[1] + h * t[2])
-   - b * (e * t[0] - g * t[3] + h * t[4])
-   + c * (e * t[1] - f * t[3] + h * t[5])
-   - d * (e * t[2] - f * t[4] + g * t[5])
-   */
-  x2 = glmm_fnmadd(vcombine_f32(vdup_lane_f32(gh, 1), vdup_lane_f32(ef, 0)),
-                   vcombine_f32(vget_low_f32(a1.val[0]), t34),
-                   vmulq_f32(vcombine_f32(ef, vdup_lane_f32(ef, 1)),
-                             vcombine_f32(vget_low_f32(x1), t12)));
-
-  x2 = glmm_fmadd(vcombine_f32(vdup_lane_f32(gh, 0), gh),
-                  vcombine_f32(vget_low_f32(a1.val[1]), vget_high_f32(x1)), x2);
-
-  x2 = glmm_xor(x2, x3);
-
-  return glmm_hadd(vmulq_f32(x2, r0));
-}
-
-CGLM_INLINE
-void
-glm_mat4_inv_neon(mat4 mat, mat4 dest) {
-  float32x4_t   r0, r1, r2, r3,
-                v0, v1, v2, v3,
-                t0, t1, t2, t3, t4, t5,
-                x0, x1, x2, x3, x4, x5, x6, x7, x8;
-  float32x4x2_t a1;
-  float32x2_t   lp, ko, hg, jn, im, fe, ae, bf, cg, dh;
-  float32x4_t   x9 = { -0.f, 0.f, -0.f, 0.f };
-
-  x8 = vrev64q_f32(x9);
-
-  /* 127 <- 0 */
-  r0 = glmm_load(mat[0]); /* d c b a */
-  r1 = glmm_load(mat[1]); /* h g f e */
-  r2 = glmm_load(mat[2]); /* l k j i */
-  r3 = glmm_load(mat[3]); /* p o n m */
-  
-  /* l p k o, j n i m */
-  a1  = vzipq_f32(r3, r2);
-  
-  jn  = vget_high_f32(a1.val[0]);
-  im  = vget_low_f32(a1.val[0]);
-  lp  = vget_high_f32(a1.val[1]);
-  ko  = vget_low_f32(a1.val[1]);
-  hg  = vget_high_f32(r1);
-
-  x1  = vcombine_f32(vdup_lane_f32(lp, 0), lp);                   /* l p p p */
-  x2  = vcombine_f32(vdup_lane_f32(ko, 0), ko);                   /* k o o o */
-  x0  = vcombine_f32(vdup_lane_f32(lp, 1), vdup_lane_f32(hg, 1)); /* h h l l */
-  x3  = vcombine_f32(vdup_lane_f32(ko, 1), vdup_lane_f32(hg, 0)); /* g g k k */
-  
-  /* t1[0] = k * p - o * l;
-     t1[0] = k * p - o * l;
-     t2[0] = g * p - o * h;
-     t3[0] = g * l - k * h; */
-  t0 = glmm_fnmadd(x2, x0, vmulq_f32(x3, x1));
-
-  fe = vget_low_f32(r1);
-  x4 = vcombine_f32(vdup_lane_f32(jn, 0), jn);                   /* j n n n */
-  x5 = vcombine_f32(vdup_lane_f32(jn, 1), vdup_lane_f32(fe, 1)); /* f f j j */
-  
-  /* t1[1] = j * p - n * l;
-     t1[1] = j * p - n * l;
-     t2[1] = f * p - n * h;
-     t3[1] = f * l - j * h; */
-   t1 = glmm_fnmadd(x4, x0, vmulq_f32(x5, x1));
-  
-  /* t1[2] = j * o - n * k
-     t1[2] = j * o - n * k;
-     t2[2] = f * o - n * g;
-     t3[2] = f * k - j * g; */
-  t2 = glmm_fnmadd(x4, x3, vmulq_f32(x5, x2));
-  
-  x6 = vcombine_f32(vdup_lane_f32(im, 1), vdup_lane_f32(fe, 0)); /* e e i i */
-  x7 = vcombine_f32(vdup_lane_f32(im, 0), im);                   /* i m m m */
-  
-  /* t1[3] = i * p - m * l;
-     t1[3] = i * p - m * l;
-     t2[3] = e * p - m * h;
-     t3[3] = e * l - i * h; */
-  t3 = glmm_fnmadd(x7, x0, vmulq_f32(x6, x1));
-  
-  /* t1[4] = i * o - m * k;
-     t1[4] = i * o - m * k;
-     t2[4] = e * o - m * g;
-     t3[4] = e * k - i * g; */
-  t4 = glmm_fnmadd(x7, x3, vmulq_f32(x6, x2));
-  
-  /* t1[5] = i * n - m * j;
-     t1[5] = i * n - m * j;
-     t2[5] = e * n - m * f;
-     t3[5] = e * j - i * f; */
-  t5 = glmm_fnmadd(x7, x5, vmulq_f32(x6, x4));
-  
-  /* h d f b, g c e a */
-  a1 = vtrnq_f32(r0, r1);
-  
-  x4 = vrev64q_f32(a1.val[0]); /* c g a e */
-  x5 = vrev64q_f32(a1.val[1]); /* d h b f */
-
-  ae = vget_low_f32(x4);
-  cg = vget_high_f32(x4);
-  bf = vget_low_f32(x5);
-  dh = vget_high_f32(x5);
-  
-  x0 = vcombine_f32(ae, vdup_lane_f32(ae, 1)); /* a a a e */
-  x1 = vcombine_f32(bf, vdup_lane_f32(bf, 1)); /* b b b f */
-  x2 = vcombine_f32(cg, vdup_lane_f32(cg, 1)); /* c c c g */
-  x3 = vcombine_f32(dh, vdup_lane_f32(dh, 1)); /* d d d h */
-  
-  /*
-   dest[0][0] =  f * t1[0] - g * t1[1] + h * t1[2];
-   dest[0][1] =-(b * t1[0] - c * t1[1] + d * t1[2]);
-   dest[0][2] =  b * t2[0] - c * t2[1] + d * t2[2];
-   dest[0][3] =-(b * t3[0] - c * t3[1] + d * t3[2]); */
-  v0 = glmm_xor(glmm_fmadd(x3, t2, glmm_fnmadd(x2, t1, vmulq_f32(x1, t0))), x8);
-  
-  /*
-   dest[2][0] =  e * t1[1] - f * t1[3] + h * t1[5];
-   dest[2][1] =-(a * t1[1] - b * t1[3] + d * t1[5]);
-   dest[2][2] =  a * t2[1] - b * t2[3] + d * t2[5];
-   dest[2][3] =-(a * t3[1] - b * t3[3] + d * t3[5]);*/
-  v2 = glmm_xor(glmm_fmadd(x3, t5, glmm_fnmadd(x1, t3, vmulq_f32(x0, t1))), x8);
-
-  /*
-   dest[1][0] =-(e * t1[0] - g * t1[3] + h * t1[4]);
-   dest[1][1] =  a * t1[0] - c * t1[3] + d * t1[4];
-   dest[1][2] =-(a * t2[0] - c * t2[3] + d * t2[4]);
-   dest[1][3] =  a * t3[0] - c * t3[3] + d * t3[4]; */
-  v1 = glmm_xor(glmm_fmadd(x3, t4, glmm_fnmadd(x2, t3, vmulq_f32(x0, t0))), x9);
-  
-  /*
-   dest[3][0] =-(e * t1[2] - f * t1[4] + g * t1[5]);
-   dest[3][1] =  a * t1[2] - b * t1[4] + c * t1[5];
-   dest[3][2] =-(a * t2[2] - b * t2[4] + c * t2[5]);
-   dest[3][3] =  a * t3[2] - b * t3[4] + c * t3[5]; */
-  v3 = glmm_xor(glmm_fmadd(x2, t5, glmm_fnmadd(x1, t4, vmulq_f32(x0, t2))), x9);
-
-  /* determinant */
-  x0 = vcombine_f32(vget_low_f32(vzipq_f32(v0, v1).val[0]),
-                    vget_low_f32(vzipq_f32(v2, v3).val[0]));
-
-  /*
-  x0 = glmm_div(glmm_set1(1.0f), glmm_vhadd(vmulq_f32(x0, r0)));
-
-  glmm_store(dest[0], vmulq_f32(v0, x0));
-  glmm_store(dest[1], vmulq_f32(v1, x0));
-  glmm_store(dest[2], vmulq_f32(v2, x0));
-  glmm_store(dest[3], vmulq_f32(v3, x0));
-  */
-
-  x0 = glmm_vhadd(vmulq_f32(x0, r0));
-
-  glmm_store(dest[0], glmm_div(v0, x0));
-  glmm_store(dest[1], glmm_div(v1, x0));
-  glmm_store(dest[2], glmm_div(v2, x0));
-  glmm_store(dest[3], glmm_div(v3, x0));
-}
-
 #endif
 #endif /* cglm_mat4_neon_h */

include/cglm/simd/neon/quat.h

@@ -1,56 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#ifndef cglm_quat_neon_h
-#define cglm_quat_neon_h
-#if defined(__ARM_NEON_FP)
-
-#include "../../common.h"
-#include "../intrin.h"
-
-CGLM_INLINE
-void
-glm_quat_mul_neon(versor p, versor q, versor dest) {
-  /*
-   + (a1 b2 + b1 a2 + c1 d2 − d1 c2)i
-   + (a1 c2 − b1 d2 + c1 a2 + d1 b2)j
-   + (a1 d2 + b1 c2 − c1 b2 + d1 a2)k
-     a1 a2 − b1 b2 − c1 c2 − d1 d2
-   */
-
-  glmm_128 xp, xq, xqr, r, x, y, z, s2, s3;
-  glmm_128 s1 = {-0.f, 0.f, 0.f, -0.f};
-  float32x2_t   qh, ql;
-  
-  xp  = glmm_load(p); /* 3 2 1 0 */
-  xq  = glmm_load(q);
-
-  r   = vmulq_f32(glmm_splat_w(xp), xq);
-  x   = glmm_splat_x(xp);
-  y   = glmm_splat_y(xp);
-  z   = glmm_splat_z(xp);
-
-  ql  = vget_high_f32(s1);
-  s3  = vcombine_f32(ql, ql);
-  s2  = vzipq_f32(s3, s3).val[0];
-
-  xqr = vrev64q_f32(xq);
-  qh  = vget_high_f32(xqr);
-  ql  = vget_low_f32(xqr);
-
-  r = glmm_fmadd(glmm_xor(x, s3), vcombine_f32(qh, ql), r);
-  
-  r = glmm_fmadd(glmm_xor(y, s2), vcombine_f32(vget_high_f32(xq),
-                                               vget_low_f32(xq)), r);
-  
-  r = glmm_fmadd(glmm_xor(z, s1), vcombine_f32(ql, qh), r);
-
-  glmm_store(dest, r);
-}
-
-#endif
-#endif /* cglm_quat_neon_h */

include/cglm/simd/sse2/affine.h

@@ -16,76 +16,75 @@ CGLM_INLINE
 void
 glm_mul_sse2(mat4 m1, mat4 m2, mat4 dest) {
   /* D = R * L (Column-Major) */
-  glmm_128 l, r0, r1, r2, r3, v0, v1, v2, v3;
+  __m128 l0, l1, l2, l3, r;
 
-  l  = glmm_load(m1[0]);
+  l0 = glmm_load(m1[0]);
-  r0 = glmm_load(m2[0]);
+  l1 = glmm_load(m1[1]);
-  r1 = glmm_load(m2[1]);
+  l2 = glmm_load(m1[2]);
-  r2 = glmm_load(m2[2]);
+  l3 = glmm_load(m1[3]);
-  r3 = glmm_load(m2[3]);
 
-  v0 = _mm_mul_ps(glmm_splat_x(r0), l);
+  r = glmm_load(m2[0]);
-  v1 = _mm_mul_ps(glmm_splat_x(r1), l);
+  glmm_store(dest[0],
-  v2 = _mm_mul_ps(glmm_splat_x(r2), l);
+             _mm_add_ps(_mm_add_ps(_mm_mul_ps(glmm_shuff1x(r, 0), l0),
-  v3 = _mm_mul_ps(glmm_splat_x(r3), l);
+                                   _mm_mul_ps(glmm_shuff1x(r, 1), l1)),
+                        _mm_mul_ps(glmm_shuff1x(r, 2), l2)));
 
-  l  = glmm_load(m1[1]);
+  r = glmm_load(m2[1]);
-  v0 = glmm_fmadd(glmm_splat_y(r0), l, v0);
+  glmm_store(dest[1],
-  v1 = glmm_fmadd(glmm_splat_y(r1), l, v1);
+             _mm_add_ps(_mm_add_ps(_mm_mul_ps(glmm_shuff1x(r, 0), l0),
-  v2 = glmm_fmadd(glmm_splat_y(r2), l, v2);
+                                   _mm_mul_ps(glmm_shuff1x(r, 1), l1)),
-  v3 = glmm_fmadd(glmm_splat_y(r3), l, v3);
+                        _mm_mul_ps(glmm_shuff1x(r, 2), l2)));
 
-  l  = glmm_load(m1[2]);
+  r = glmm_load(m2[2]);
-  v0 = glmm_fmadd(glmm_splat_z(r0), l, v0);
+  glmm_store(dest[2],
-  v1 = glmm_fmadd(glmm_splat_z(r1), l, v1);
+             _mm_add_ps(_mm_add_ps(_mm_mul_ps(glmm_shuff1x(r, 0), l0),
-  v2 = glmm_fmadd(glmm_splat_z(r2), l, v2);
+                                   _mm_mul_ps(glmm_shuff1x(r, 1), l1)),
-  v3 = glmm_fmadd(glmm_splat_z(r3), l, v3);
+                        _mm_mul_ps(glmm_shuff1x(r, 2), l2)));
 
-  l  = glmm_load(m1[3]);
+  r = glmm_load(m2[3]);
-  v3 = glmm_fmadd(glmm_splat_w(r3), l, v3);
+  glmm_store(dest[3],
-
+             _mm_add_ps(_mm_add_ps(_mm_mul_ps(glmm_shuff1x(r, 0), l0),
-  glmm_store(dest[0], v0);
+                                   _mm_mul_ps(glmm_shuff1x(r, 1), l1)),
-  glmm_store(dest[1], v1);
+                        _mm_add_ps(_mm_mul_ps(glmm_shuff1x(r, 2), l2),
-  glmm_store(dest[2], v2);
+                                   _mm_mul_ps(glmm_shuff1x(r, 3), l3))));
-  glmm_store(dest[3], v3);
 }
 
 CGLM_INLINE
 void
 glm_mul_rot_sse2(mat4 m1, mat4 m2, mat4 dest) {
   /* D = R * L (Column-Major) */
+  __m128 l0, l1, l2, l3, r;
 
-  glmm_128 l, r0, r1, r2, v0, v1, v2;
+  l0 = glmm_load(m1[0]);
+  l1 = glmm_load(m1[1]);
+  l2 = glmm_load(m1[2]);
+  l3 = glmm_load(m1[3]);
 
-  l  = glmm_load(m1[0]);
+  r = glmm_load(m2[0]);
-  r0 = glmm_load(m2[0]);
+  glmm_store(dest[0],
-  r1 = glmm_load(m2[1]);
+             _mm_add_ps(_mm_add_ps(_mm_mul_ps(glmm_shuff1x(r, 0), l0),
-  r2 = glmm_load(m2[2]);
+                                   _mm_mul_ps(glmm_shuff1x(r, 1), l1)),
+                        _mm_mul_ps(glmm_shuff1x(r, 2), l2)));
 
-  v0 = _mm_mul_ps(glmm_splat_x(r0), l);
+  r = glmm_load(m2[1]);
-  v1 = _mm_mul_ps(glmm_splat_x(r1), l);
+  glmm_store(dest[1],
-  v2 = _mm_mul_ps(glmm_splat_x(r2), l);
+             _mm_add_ps(_mm_add_ps(_mm_mul_ps(glmm_shuff1x(r, 0), l0),
+                                   _mm_mul_ps(glmm_shuff1x(r, 1), l1)),
+                        _mm_mul_ps(glmm_shuff1x(r, 2), l2)));
 
-  l  = glmm_load(m1[1]);
+  r = glmm_load(m2[2]);
-  v0 = glmm_fmadd(glmm_splat_y(r0), l, v0);
+  glmm_store(dest[2],
-  v1 = glmm_fmadd(glmm_splat_y(r1), l, v1);
+             _mm_add_ps(_mm_add_ps(_mm_mul_ps(glmm_shuff1x(r, 0), l0),
-  v2 = glmm_fmadd(glmm_splat_y(r2), l, v2);
+                                   _mm_mul_ps(glmm_shuff1x(r, 1), l1)),
+                        _mm_mul_ps(glmm_shuff1x(r, 2), l2)));
 
-  l  = glmm_load(m1[2]);
+  glmm_store(dest[3], l3);
-  v0 = glmm_fmadd(glmm_splat_z(r0), l, v0);
-  v1 = glmm_fmadd(glmm_splat_z(r1), l, v1);
-  v2 = glmm_fmadd(glmm_splat_z(r2), l, v2);
-
-  glmm_store(dest[0], v0);
-  glmm_store(dest[1], v1);
-  glmm_store(dest[2], v2);
-  glmm_store(dest[3], glmm_load(m1[3]));
 }
 
 CGLM_INLINE
 void
 glm_inv_tr_sse2(mat4 mat) {
-  __m128 r0, r1, r2, r3, x0, x1, x2, x3, x4, x5;
+  __m128 r0, r1, r2, r3, x0, x1;
 
   r0 = glmm_load(mat[0]);
   r1 = glmm_load(mat[1]);
@@ -95,13 +94,10 @@ glm_inv_tr_sse2(mat4 mat) {
 
   _MM_TRANSPOSE4_PS(r0, r1, r2, x1);
 
-  x2 = glmm_shuff1(r3, 0, 0, 0, 0);
+  x0 = _mm_add_ps(_mm_mul_ps(r0, glmm_shuff1(r3, 0, 0, 0, 0)),
-  x3 = glmm_shuff1(r3, 1, 1, 1, 1);
+                  _mm_mul_ps(r1, glmm_shuff1(r3, 1, 1, 1, 1)));
-  x4 = glmm_shuff1(r3, 2, 2, 2, 2);
+  x0 = _mm_add_ps(x0, _mm_mul_ps(r2, glmm_shuff1(r3, 2, 2, 2, 2)));
-  x5 = _mm_set1_ps(-0.f);
+  x0 = _mm_xor_ps(x0, _mm_set1_ps(-0.f));
-
-  x0 = glmm_fmadd(r0, x2, glmm_fmadd(r1, x3, _mm_mul_ps(r2, x4)));
-  x0 = _mm_xor_ps(x0, x5);
 
   x0 = _mm_add_ps(x0, x1);
 

include/cglm/simd/sse2/mat2.h

@@ -15,25 +15,22 @@
 CGLM_INLINE
 void
 glm_mat2_mul_sse2(mat2 m1, mat2 m2, mat2 dest) {
-  __m128 x0, x1, x2, x3, x4;
+  __m128 x0, x1, x2;
 
   x1 = glmm_load(m1[0]); /* d c b a */
   x2 = glmm_load(m2[0]); /* h g f e */
 
-  x3 = glmm_shuff1(x2, 2, 2, 0, 0);
-  x4 = glmm_shuff1(x2, 3, 3, 1, 1);
-  x0 = _mm_movelh_ps(x1, x1);
-  x2 = _mm_movehl_ps(x1, x1);
-
   /*
    dest[0][0] = a * e + c * f;
    dest[0][1] = b * e + d * f;
    dest[1][0] = a * g + c * h;
    dest[1][1] = b * g + d * h;
    */
-  x0 = glmm_fmadd(x0, x3, _mm_mul_ps(x2, x4));
+  x0 = _mm_mul_ps(_mm_movelh_ps(x1, x1), glmm_shuff1(x2, 2, 2, 0, 0));
+  x1 = _mm_mul_ps(_mm_movehl_ps(x1, x1), glmm_shuff1(x2, 3, 3, 1, 1));
+  x1 = _mm_add_ps(x0, x1);
 
-  glmm_store(dest[0], x0);
+  glmm_store(dest[0], x1);
 }
 
 CGLM_INLINE

include/cglm/simd/sse2/mat3.h

@@ -15,61 +15,44 @@
 CGLM_INLINE
 void
 glm_mat3_mul_sse2(mat3 m1, mat3 m2, mat3 dest) {
-  __m128 l0, l1, l2, r0, r1, r2, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9;
+  __m128 l0, l1, l2;
+  __m128 r0, r1, r2;
+  __m128 x0, x1, x2;
 
   l0 = _mm_loadu_ps(m1[0]);
   l1 = _mm_loadu_ps(&m1[1][1]);
+  l2 = _mm_set1_ps(m1[2][2]);
 
   r0 = _mm_loadu_ps(m2[0]);
   r1 = _mm_loadu_ps(&m2[1][1]);
+  r2 = _mm_set1_ps(m2[2][2]);
 
-  x8 = glmm_shuff1(l0, 0, 2, 1, 0);                     /* a00 a02 a01 a00 */
+  x1 = glmm_shuff2(l0, l1, 1, 0, 3, 3, 0, 3, 2, 0);
-  x1 = glmm_shuff1(r0, 3, 0, 0, 0);                     /* b10 b00 b00 b00 */
+  x2 = glmm_shuff2(l1, l2, 0, 0, 3, 2, 0, 2, 1, 0);
-  x2 = _mm_shuffle_ps(l0, l1, _MM_SHUFFLE(1, 0, 3, 3)); /* a12 a11 a10 a10 */
-  x3 = _mm_shuffle_ps(r0, r1, _MM_SHUFFLE(2, 0, 3, 1)); /* b20 b11 b10 b01 */
-  x0 = _mm_mul_ps(x8, x1);
 
-  x6 = glmm_shuff1(l0, 1, 0, 2, 1);                     /* a01 a00 a02 a01 */
+  x0 = _mm_add_ps(_mm_mul_ps(glmm_shuff1(l0, 0, 2, 1, 0),
-  x7 = glmm_shuff1(x3, 3, 3, 1, 1);                     /* b20 b20 b10 b10 */
+                             glmm_shuff1(r0, 3, 0, 0, 0)),
-  l2 = _mm_load_ss(&m1[2][2]);
+                  _mm_mul_ps(x1, glmm_shuff2(r0, r1, 0, 0, 1, 1, 2, 0, 0, 0)));
-  r2 = _mm_load_ss(&m2[2][2]);
-  x1 = _mm_mul_ps(x6, x7);
-  l2 = glmm_shuff1(l2, 0, 0, 1, 0);                     /* a22 a22 0.f a22 */
-  r2 = glmm_shuff1(r2, 0, 0, 1, 0);                     /* b22 b22 0.f b22 */
 
-  x4 = glmm_shuff1(x2, 0, 3, 2, 0);                     /* a10 a12 a11 a10 */
+  x0 = _mm_add_ps(x0,
-  x5 = glmm_shuff1(x2, 2, 0, 3, 2);                     /* a11 a10 a12 a11 */
+                  _mm_mul_ps(x2, glmm_shuff2(r0, r1, 1, 1, 2, 2, 2, 0, 0, 0)));
-  x6 = glmm_shuff1(x3, 2, 0, 0, 0);                     /* b11 b01 b01 b01 */
-  x2 = glmm_shuff1(r1, 3, 3, 0, 0);                     /* b21 b21 b11 b11 */
 
-  x8 = _mm_unpackhi_ps(x8, x4);                         /* a10 a00 a12 a02 */
+  _mm_storeu_ps(dest[0], x0);
-  x9 = _mm_unpackhi_ps(x7, x2);                         /* b21 b20 b21 b20 */
 
-  x0 = glmm_fmadd(x4, x6, x0);
+  x0 = _mm_add_ps(_mm_mul_ps(glmm_shuff1(l0, 1, 0, 2, 1),
-  x1 = glmm_fmadd(x5, x2, x1);
+                             _mm_shuffle_ps(r0, r1, _MM_SHUFFLE(2, 2, 3, 3))),
+                  _mm_mul_ps(glmm_shuff1(x1, 1, 0, 2, 1),
+                             glmm_shuff1(r1, 3, 3, 0, 0)));
 
-  x2 = _mm_movehl_ps(l2, l1);                           /* a22 a22 a21 a20 */
+  x0 = _mm_add_ps(x0,
-  x3 = glmm_shuff1(x2, 0, 2, 1, 0);                     /* a20 a22 a21 a20 */
+                  _mm_mul_ps(glmm_shuff1(x2, 1, 0, 2, 1),
-  x2 = glmm_shuff1(x2, 1, 0, 2, 1);                     /* a21 a20 a22 a21 */
+                             _mm_shuffle_ps(r1, r2, _MM_SHUFFLE(0, 0, 1, 1))));
-  x4 = _mm_shuffle_ps(r0, r1, _MM_SHUFFLE(1, 1, 2, 2)); /* b12 b12 b02 b02 */
 
-  x5 = glmm_shuff1(x4, 3, 0, 0, 0);                     /* b12 b02 b02 b02 */
+  _mm_storeu_ps(&dest[1][1], x0);
-  x4 = _mm_movehl_ps(r2, x4);                           /* b22 b22 b12 b12 */
-  x0 = glmm_fmadd(x3, x5, x0);
-  x1 = glmm_fmadd(x2, x4, x1);
 
-  /*
+  dest[2][2] = m1[0][2] * m2[2][0]
-   Dot Product : dest[2][2] =  a02 * b20 +
+             + m1[1][2] * m2[2][1]
-                               a12 * b21 +
+             + m1[2][2] * m2[2][2];
-                               a22 * b22 +
-                               0   * 00                                    */
-  x2 = _mm_movelh_ps(x8, l2);                           /* 0.f a22 a12 a02 */
-  x3 = _mm_movelh_ps(x9, r2);                           /* 0.f b22 b21 b20 */
-  x2 = glmm_vdots(x2, x3);
-
-  _mm_storeu_ps(&dest[0][0], x0);
-  _mm_storeu_ps(&dest[1][1], x1);
-  _mm_store_ss (&dest[2][2], x2);
 }
 
 #endif

include/cglm/simd/sse2/mat4.h

@@ -49,65 +49,53 @@ void
 glm_mat4_mul_sse2(mat4 m1, mat4 m2, mat4 dest) {
   /* D = R * L (Column-Major) */
 
-  glmm_128 l, r0, r1, r2, r3, v0, v1, v2, v3;
+  __m128 l0, l1, l2, l3, r;
 
-  l  = glmm_load(m1[0]);
+  l0 = glmm_load(m1[0]);
-  r0 = glmm_load(m2[0]);
+  l1 = glmm_load(m1[1]);
-  r1 = glmm_load(m2[1]);
+  l2 = glmm_load(m1[2]);
-  r2 = glmm_load(m2[2]);
+  l3 = glmm_load(m1[3]);
-  r3 = glmm_load(m2[3]);
 
-  v0 = _mm_mul_ps(glmm_splat_x(r0), l);
+  r = glmm_load(m2[0]);
-  v1 = _mm_mul_ps(glmm_splat_x(r1), l);
+  glmm_store(dest[0],
-  v2 = _mm_mul_ps(glmm_splat_x(r2), l);
+             _mm_add_ps(_mm_add_ps(_mm_mul_ps(glmm_shuff1x(r, 0), l0),
-  v3 = _mm_mul_ps(glmm_splat_x(r3), l);
+                                   _mm_mul_ps(glmm_shuff1x(r, 1), l1)),
+                        _mm_add_ps(_mm_mul_ps(glmm_shuff1x(r, 2), l2),
+                                   _mm_mul_ps(glmm_shuff1x(r, 3), l3))));
+  r = glmm_load(m2[1]);
+  glmm_store(dest[1],
+             _mm_add_ps(_mm_add_ps(_mm_mul_ps(glmm_shuff1x(r, 0), l0),
+                                   _mm_mul_ps(glmm_shuff1x(r, 1), l1)),
+                        _mm_add_ps(_mm_mul_ps(glmm_shuff1x(r, 2), l2),
+                                   _mm_mul_ps(glmm_shuff1x(r, 3), l3))));
+  r = glmm_load(m2[2]);
+  glmm_store(dest[2],
+             _mm_add_ps(_mm_add_ps(_mm_mul_ps(glmm_shuff1x(r, 0), l0),
+                                   _mm_mul_ps(glmm_shuff1x(r, 1), l1)),
+                        _mm_add_ps(_mm_mul_ps(glmm_shuff1x(r, 2), l2),
+                                   _mm_mul_ps(glmm_shuff1x(r, 3), l3))));
 
-  l  = glmm_load(m1[1]);
+  r = glmm_load(m2[3]);
-  v0 = glmm_fmadd(glmm_splat_y(r0), l, v0);
+  glmm_store(dest[3],
-  v1 = glmm_fmadd(glmm_splat_y(r1), l, v1);
+             _mm_add_ps(_mm_add_ps(_mm_mul_ps(glmm_shuff1x(r, 0), l0),
-  v2 = glmm_fmadd(glmm_splat_y(r2), l, v2);
+                                   _mm_mul_ps(glmm_shuff1x(r, 1), l1)),
-  v3 = glmm_fmadd(glmm_splat_y(r3), l, v3);
+                        _mm_add_ps(_mm_mul_ps(glmm_shuff1x(r, 2), l2),
-
+                                   _mm_mul_ps(glmm_shuff1x(r, 3), l3))));
-  l  = glmm_load(m1[2]);
-  v0 = glmm_fmadd(glmm_splat_z(r0), l, v0);
-  v1 = glmm_fmadd(glmm_splat_z(r1), l, v1);
-  v2 = glmm_fmadd(glmm_splat_z(r2), l, v2);
-  v3 = glmm_fmadd(glmm_splat_z(r3), l, v3);
-
-  l  = glmm_load(m1[3]);
-  v0 = glmm_fmadd(glmm_splat_w(r0), l, v0);
-  v1 = glmm_fmadd(glmm_splat_w(r1), l, v1);
-  v2 = glmm_fmadd(glmm_splat_w(r2), l, v2);
-  v3 = glmm_fmadd(glmm_splat_w(r3), l, v3);
-
-  glmm_store(dest[0], v0);
-  glmm_store(dest[1], v1);
-  glmm_store(dest[2], v2);
-  glmm_store(dest[3], v3);
 }
 
 CGLM_INLINE
 void
 glm_mat4_mulv_sse2(mat4 m, vec4 v, vec4 dest) {
-  __m128 x0, x1, m0, m1, m2, m3, v0, v1, v2, v3;
+  __m128 x0, x1, x2;
-
-  m0 = glmm_load(m[0]);
-  m1 = glmm_load(m[1]);
-  m2 = glmm_load(m[2]);
-  m3 = glmm_load(m[3]);
 
   x0 = glmm_load(v);
-  v0 = glmm_splat_x(x0);
+  x1 = _mm_add_ps(_mm_mul_ps(glmm_load(m[0]), glmm_shuff1x(x0, 0)),
-  v1 = glmm_splat_y(x0);
+                  _mm_mul_ps(glmm_load(m[1]), glmm_shuff1x(x0, 1)));
-  v2 = glmm_splat_z(x0);
-  v3 = glmm_splat_w(x0);
 
-  x1 = _mm_mul_ps(m3, v3);
+  x2 = _mm_add_ps(_mm_mul_ps(glmm_load(m[2]), glmm_shuff1x(x0, 2)),
-  x1 = glmm_fmadd(m2, v2, x1);
+                  _mm_mul_ps(glmm_load(m[3]), glmm_shuff1x(x0, 3)));
-  x1 = glmm_fmadd(m1, v1, x1);
-  x1 = glmm_fmadd(m0, v0, x1);
 
-  glmm_store(dest, x1);
+  glmm_store(dest, _mm_add_ps(x1, x2));
 }
 
 CGLM_INLINE
@@ -127,18 +115,20 @@ glm_mat4_det_sse2(mat4 mat) {
    t[3] = i * p - m * l;
    t[4] = i * o - m * k;
    */
-  x0 = glmm_fnmadd(glmm_shuff1(r3, 0, 0, 1, 1), glmm_shuff1(r2, 2, 3, 2, 3),
+  x0 = _mm_sub_ps(_mm_mul_ps(glmm_shuff1(r2, 0, 0, 1, 1),
-                   _mm_mul_ps(glmm_shuff1(r2, 0, 0, 1, 1),
+                             glmm_shuff1(r3, 2, 3, 2, 3)),
-                              glmm_shuff1(r3, 2, 3, 2, 3)));
+                  _mm_mul_ps(glmm_shuff1(r3, 0, 0, 1, 1),
+                             glmm_shuff1(r2, 2, 3, 2, 3)));
   /*
    t[0] = k * p - o * l;
    t[0] = k * p - o * l;
    t[5] = i * n - m * j;
    t[5] = i * n - m * j;
    */
-  x1 = glmm_fnmadd(glmm_shuff1(r3, 0, 0, 2, 2), glmm_shuff1(r2, 1, 1, 3, 3),
+  x1 = _mm_sub_ps(_mm_mul_ps(glmm_shuff1(r2, 0, 0, 2, 2),
-                   _mm_mul_ps(glmm_shuff1(r2, 0, 0, 2, 2),
+                             glmm_shuff1(r3, 1, 1, 3, 3)),
-                              glmm_shuff1(r3, 1, 1, 3, 3)));
+                  _mm_mul_ps(glmm_shuff1(r3, 0, 0, 2, 2),
+                             glmm_shuff1(r2, 1, 1, 3, 3)));
 
   /*
      a * (f * t[0] - g * t[1] + h * t[2])
@@ -146,16 +136,21 @@ glm_mat4_det_sse2(mat4 mat) {
    + c * (e * t[1] - f * t[3] + h * t[5])
    - d * (e * t[2] - f * t[4] + g * t[5])
    */
-  x2 = glmm_fnmadd(glmm_shuff1(r1, 1, 1, 2, 2), glmm_shuff1(x0, 3, 2, 2, 0),
+  x2 = _mm_sub_ps(_mm_mul_ps(glmm_shuff1(r1, 0, 0, 0, 1),
-                   _mm_mul_ps(glmm_shuff1(r1, 0, 0, 0, 1),
+                             _mm_shuffle_ps(x1, x0, _MM_SHUFFLE(1, 0, 0, 0))),
-                              _mm_shuffle_ps(x1, x0, _MM_SHUFFLE(1, 0, 0, 0))));
+                  _mm_mul_ps(glmm_shuff1(r1, 1, 1, 2, 2),
-  x2 = glmm_fmadd(glmm_shuff1(r1, 2, 3, 3, 3),
+                             glmm_shuff1(x0, 3, 2, 2, 0)));
-                  _mm_shuffle_ps(x0, x1, _MM_SHUFFLE(2, 2, 3, 1)),
-                  x2);
 
+  x2 = _mm_add_ps(x2,
+                  _mm_mul_ps(glmm_shuff1(r1, 2, 3, 3, 3),
+                             _mm_shuffle_ps(x0, x1, _MM_SHUFFLE(2, 2, 3, 1))));
   x2 = _mm_xor_ps(x2, _mm_set_ps(-0.f, 0.f, -0.f, 0.f));
 
-  return glmm_hadd(_mm_mul_ps(x2, r0));
+  x0 = _mm_mul_ps(r0, x2);
+  x0 = _mm_add_ps(x0, glmm_shuff1(x0, 0, 1, 2, 3));
+  x0 = _mm_add_ps(x0, glmm_shuff1(x0, 1, 3, 3, 1));
+
+  return _mm_cvtss_f32(x0);
 }
 
 CGLM_INLINE
@@ -164,10 +159,7 @@ glm_mat4_inv_fast_sse2(mat4 mat, mat4 dest) {
   __m128 r0, r1, r2, r3,
          v0, v1, v2, v3,
          t0, t1, t2, t3, t4, t5,
-         x0, x1, x2, x3, x4, x5, x6, x7, x8, x9;
+         x0, x1, x2, x3, x4, x5, x6, x7;
-
-  x8 = _mm_set_ps(-0.f, 0.f, -0.f, 0.f);
-  x9 = glmm_shuff1(x8, 2, 1, 2, 1);
 
   /* 127 <- 0 */
   r0 = glmm_load(mat[0]); /* d c b a */
@@ -175,118 +167,109 @@ glm_mat4_inv_fast_sse2(mat4 mat, mat4 dest) {
   r2 = glmm_load(mat[2]); /* l k j i */
   r3 = glmm_load(mat[3]); /* p o n m */
 
-  x0 = _mm_movehl_ps(r3, r2);                            /* p o l k */
+  x0 = _mm_shuffle_ps(r2, r3, _MM_SHUFFLE(3, 2, 3, 2));  /* p o l k */
-  x3 = _mm_movelh_ps(r2, r3);                            /* n m j i */
+  x1 = glmm_shuff1(x0, 1, 3, 3, 3);                      /* l p p p */
-  x1 = glmm_shuff1(x0, 1, 3, 3 ,3);                      /* l p p p */
   x2 = glmm_shuff1(x0, 0, 2, 2, 2);                      /* k o o o */
-  x4 = glmm_shuff1(x3, 1, 3, 3, 3);                      /* j n n n */
-  x7 = glmm_shuff1(x3, 0, 2, 2, 2);                      /* i m m m */
-
-  x6 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(0, 0, 0, 0));  /* e e i i */
-  x5 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(1, 1, 1, 1));  /* f f j j */
-  x3 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(2, 2, 2, 2));  /* g g k k */
   x0 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(3, 3, 3, 3));  /* h h l l */
-  
+  x3 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(2, 2, 2, 2));  /* g g k k */
-  t0 = _mm_mul_ps(x3, x1);
-  t1 = _mm_mul_ps(x5, x1);
-  t2 = _mm_mul_ps(x5, x2);
-  t3 = _mm_mul_ps(x6, x1);
-  t4 = _mm_mul_ps(x6, x2);
-  t5 = _mm_mul_ps(x6, x4);
 
   /* t1[0] = k * p - o * l;
      t1[0] = k * p - o * l;
      t2[0] = g * p - o * h;
      t3[0] = g * l - k * h; */
-  t0 = glmm_fnmadd(x2, x0, t0);
+  t0 = _mm_sub_ps(_mm_mul_ps(x3, x1), _mm_mul_ps(x2, x0));
+
+  x4 = _mm_shuffle_ps(r2, r3, _MM_SHUFFLE(2, 1, 2, 1)); /* o n k j */
+  x4 = glmm_shuff1(x4, 0, 2, 2, 2);                     /* j n n n */
+  x5 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(1, 1, 1, 1)); /* f f j j */
 
   /* t1[1] = j * p - n * l;
      t1[1] = j * p - n * l;
      t2[1] = f * p - n * h;
      t3[1] = f * l - j * h; */
-   t1 = glmm_fnmadd(x4, x0, t1);
+  t1 = _mm_sub_ps(_mm_mul_ps(x5, x1), _mm_mul_ps(x4, x0));
 
   /* t1[2] = j * o - n * k
      t1[2] = j * o - n * k;
      t2[2] = f * o - n * g;
      t3[2] = f * k - j * g; */
-  t2 = glmm_fnmadd(x4, x3, t2);
+  t2 = _mm_sub_ps(_mm_mul_ps(x5, x2), _mm_mul_ps(x4, x3));
+
+  x6 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(0, 0, 0, 0)); /* e e i i */
+  x7 = glmm_shuff2(r3, r2, 0, 0, 0, 0, 2, 0, 0, 0);     /* i m m m */
 
   /* t1[3] = i * p - m * l;
      t1[3] = i * p - m * l;
      t2[3] = e * p - m * h;
      t3[3] = e * l - i * h; */
-  t3 = glmm_fnmadd(x7, x0, t3);
+  t3 = _mm_sub_ps(_mm_mul_ps(x6, x1), _mm_mul_ps(x7, x0));
 
   /* t1[4] = i * o - m * k;
      t1[4] = i * o - m * k;
      t2[4] = e * o - m * g;
      t3[4] = e * k - i * g; */
-  t4 = glmm_fnmadd(x7, x3, t4);
+  t4 = _mm_sub_ps(_mm_mul_ps(x6, x2), _mm_mul_ps(x7, x3));
 
   /* t1[5] = i * n - m * j;
      t1[5] = i * n - m * j;
      t2[5] = e * n - m * f;
      t3[5] = e * j - i * f; */
-  t5 = glmm_fnmadd(x7, x5, t5);
+  t5 = _mm_sub_ps(_mm_mul_ps(x6, x4), _mm_mul_ps(x7, x5));
 
-  x4 = _mm_movelh_ps(r0, r1);        /* f e b a */
+  x0 = glmm_shuff2(r1, r0, 0, 0, 0, 0, 2, 2, 2, 0); /* a a a e */
-  x5 = _mm_movehl_ps(r1, r0);        /* h g d c */
+  x1 = glmm_shuff2(r1, r0, 1, 1, 1, 1, 2, 2, 2, 0); /* b b b f */
-  
+  x2 = glmm_shuff2(r1, r0, 2, 2, 2, 2, 2, 2, 2, 0); /* c c c g */
-  x0 = glmm_shuff1(x4, 0, 0, 0, 2);  /* a a a e */
+  x3 = glmm_shuff2(r1, r0, 3, 3, 3, 3, 2, 2, 2, 0); /* d d d h */
-  x1 = glmm_shuff1(x4, 1, 1, 1, 3);  /* b b b f */
-  x2 = glmm_shuff1(x5, 0, 0, 0, 2);  /* c c c g */
-  x3 = glmm_shuff1(x5, 1, 1, 1, 3);  /* d d d h */
-  
-  v2 = _mm_mul_ps(x0, t1);
-  v1 = _mm_mul_ps(x0, t0);
-  v3 = _mm_mul_ps(x0, t2);
-  v0 = _mm_mul_ps(x1, t0);
-  
-  v2 = glmm_fnmadd(x1, t3, v2);
-  v3 = glmm_fnmadd(x1, t4, v3);
-  v0 = glmm_fnmadd(x2, t1, v0);
-  v1 = glmm_fnmadd(x2, t3, v1);
-  
-  v3 = glmm_fmadd(x2, t5, v3);
-  v0 = glmm_fmadd(x3, t2, v0);
-  v2 = glmm_fmadd(x3, t5, v2);
-  v1 = glmm_fmadd(x3, t4, v1);
 
   /*
    dest[0][0] =  f * t1[0] - g * t1[1] + h * t1[2];
    dest[0][1] =-(b * t1[0] - c * t1[1] + d * t1[2]);
    dest[0][2] =  b * t2[0] - c * t2[1] + d * t2[2];
    dest[0][3] =-(b * t3[0] - c * t3[1] + d * t3[2]); */
-  v0 = _mm_xor_ps(v0, x8);
+  v0 = _mm_add_ps(_mm_mul_ps(x3, t2),
-  
+                  _mm_sub_ps(_mm_mul_ps(x1, t0),
-  /*
+                             _mm_mul_ps(x2, t1)));
-   dest[2][0] =  e * t1[1] - f * t1[3] + h * t1[5];
+  v0 = _mm_xor_ps(v0, _mm_set_ps(-0.f, 0.f, -0.f, 0.f));
-   dest[2][1] =-(a * t1[1] - b * t1[3] + d * t1[5]);
-   dest[2][2] =  a * t2[1] - b * t2[3] + d * t2[5];
-   dest[2][3] =-(a * t3[1] - b * t3[3] + d * t3[5]);*/
-  v2 = _mm_xor_ps(v2, x8);
 
   /*
    dest[1][0] =-(e * t1[0] - g * t1[3] + h * t1[4]);
    dest[1][1] =  a * t1[0] - c * t1[3] + d * t1[4];
    dest[1][2] =-(a * t2[0] - c * t2[3] + d * t2[4]);
    dest[1][3] =  a * t3[0] - c * t3[3] + d * t3[4]; */
-  v1 = _mm_xor_ps(v1, x9);
+  v1 = _mm_add_ps(_mm_mul_ps(x3, t4),
+                  _mm_sub_ps(_mm_mul_ps(x0, t0),
+                             _mm_mul_ps(x2, t3)));
+  v1 = _mm_xor_ps(v1, _mm_set_ps(0.f, -0.f, 0.f, -0.f));
+
+  /*
+   dest[2][0] =  e * t1[1] - f * t1[3] + h * t1[5];
+   dest[2][1] =-(a * t1[1] - b * t1[3] + d * t1[5]);
+   dest[2][2] =  a * t2[1] - b * t2[3] + d * t2[5];
+   dest[2][3] =-(a * t3[1] - b * t3[3] + d * t3[5]);*/
+  v2 = _mm_add_ps(_mm_mul_ps(x3, t5),
+                  _mm_sub_ps(_mm_mul_ps(x0, t1),
+                             _mm_mul_ps(x1, t3)));
+  v2 = _mm_xor_ps(v2, _mm_set_ps(-0.f, 0.f, -0.f, 0.f));
 
   /*
    dest[3][0] =-(e * t1[2] - f * t1[4] + g * t1[5]);
    dest[3][1] =  a * t1[2] - b * t1[4] + c * t1[5];
    dest[3][2] =-(a * t2[2] - b * t2[4] + c * t2[5]);
    dest[3][3] =  a * t3[2] - b * t3[4] + c * t3[5]; */
-  v3 = _mm_xor_ps(v3, x9);
+  v3 = _mm_add_ps(_mm_mul_ps(x2, t5),
+                  _mm_sub_ps(_mm_mul_ps(x0, t2),
+                             _mm_mul_ps(x1, t4)));
+  v3 = _mm_xor_ps(v3, _mm_set_ps(0.f, -0.f, 0.f, -0.f));
 
   /* determinant */
   x0 = _mm_shuffle_ps(v0, v1, _MM_SHUFFLE(0, 0, 0, 0));
   x1 = _mm_shuffle_ps(v2, v3, _MM_SHUFFLE(0, 0, 0, 0));
   x0 = _mm_shuffle_ps(x0, x1, _MM_SHUFFLE(2, 0, 2, 0));
 
-  x0 = _mm_rcp_ps(glmm_vhadd(_mm_mul_ps(x0, r0)));
+  x0 = _mm_mul_ps(x0, r0);
+  x0 = _mm_add_ps(x0, glmm_shuff1(x0, 0, 1, 2, 3));
+  x0 = _mm_add_ps(x0, glmm_shuff1(x0, 1, 0, 0, 1));
+  x0 = _mm_rcp_ps(x0);
 
   glmm_store(dest[0], _mm_mul_ps(v0, x0));
   glmm_store(dest[1], _mm_mul_ps(v1, x0));
@@ -300,10 +283,7 @@ glm_mat4_inv_sse2(mat4 mat, mat4 dest) {
   __m128 r0, r1, r2, r3,
          v0, v1, v2, v3,
          t0, t1, t2, t3, t4, t5,
-         x0, x1, x2, x3, x4, x5, x6, x7, x8, x9;
+         x0, x1, x2, x3, x4, x5, x6, x7;
-
-  x8 = _mm_set_ps(-0.f, 0.f, -0.f, 0.f);
-  x9 = glmm_shuff1(x8, 2, 1, 2, 1);
 
   /* 127 <- 0 */
   r0 = glmm_load(mat[0]); /* d c b a */
@@ -311,118 +291,109 @@ glm_mat4_inv_sse2(mat4 mat, mat4 dest) {
   r2 = glmm_load(mat[2]); /* l k j i */
   r3 = glmm_load(mat[3]); /* p o n m */
 
-  x0 = _mm_movehl_ps(r3, r2);                            /* p o l k */
+  x0 = _mm_shuffle_ps(r2, r3, _MM_SHUFFLE(3, 2, 3, 2));  /* p o l k */
-  x3 = _mm_movelh_ps(r2, r3);                            /* n m j i */
+  x1 = glmm_shuff1(x0, 1, 3, 3, 3);                      /* l p p p */
-  x1 = glmm_shuff1(x0, 1, 3, 3 ,3);                      /* l p p p */
   x2 = glmm_shuff1(x0, 0, 2, 2, 2);                      /* k o o o */
-  x4 = glmm_shuff1(x3, 1, 3, 3, 3);                      /* j n n n */
-  x7 = glmm_shuff1(x3, 0, 2, 2, 2);                      /* i m m m */
-
-  x6 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(0, 0, 0, 0));  /* e e i i */
-  x5 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(1, 1, 1, 1));  /* f f j j */
-  x3 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(2, 2, 2, 2));  /* g g k k */
   x0 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(3, 3, 3, 3));  /* h h l l */
-  
+  x3 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(2, 2, 2, 2));  /* g g k k */
-  t0 = _mm_mul_ps(x3, x1);
-  t1 = _mm_mul_ps(x5, x1);
-  t2 = _mm_mul_ps(x5, x2);
-  t3 = _mm_mul_ps(x6, x1);
-  t4 = _mm_mul_ps(x6, x2);
-  t5 = _mm_mul_ps(x6, x4);
 
   /* t1[0] = k * p - o * l;
      t1[0] = k * p - o * l;
      t2[0] = g * p - o * h;
      t3[0] = g * l - k * h; */
-  t0 = glmm_fnmadd(x2, x0, t0);
+  t0 = _mm_sub_ps(_mm_mul_ps(x3, x1), _mm_mul_ps(x2, x0));
+
+  x4 = _mm_shuffle_ps(r2, r3, _MM_SHUFFLE(2, 1, 2, 1)); /* o n k j */
+  x4 = glmm_shuff1(x4, 0, 2, 2, 2);                     /* j n n n */
+  x5 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(1, 1, 1, 1)); /* f f j j */
 
   /* t1[1] = j * p - n * l;
      t1[1] = j * p - n * l;
      t2[1] = f * p - n * h;
      t3[1] = f * l - j * h; */
-   t1 = glmm_fnmadd(x4, x0, t1);
+  t1 = _mm_sub_ps(_mm_mul_ps(x5, x1), _mm_mul_ps(x4, x0));
 
   /* t1[2] = j * o - n * k
      t1[2] = j * o - n * k;
      t2[2] = f * o - n * g;
      t3[2] = f * k - j * g; */
-  t2 = glmm_fnmadd(x4, x3, t2);
+  t2 = _mm_sub_ps(_mm_mul_ps(x5, x2), _mm_mul_ps(x4, x3));
+
+  x6 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(0, 0, 0, 0)); /* e e i i */
+  x7 = glmm_shuff2(r3, r2, 0, 0, 0, 0, 2, 0, 0, 0);     /* i m m m */
 
   /* t1[3] = i * p - m * l;
      t1[3] = i * p - m * l;
      t2[3] = e * p - m * h;
      t3[3] = e * l - i * h; */
-  t3 = glmm_fnmadd(x7, x0, t3);
+  t3 = _mm_sub_ps(_mm_mul_ps(x6, x1), _mm_mul_ps(x7, x0));
 
   /* t1[4] = i * o - m * k;
      t1[4] = i * o - m * k;
      t2[4] = e * o - m * g;
      t3[4] = e * k - i * g; */
-  t4 = glmm_fnmadd(x7, x3, t4);
+  t4 = _mm_sub_ps(_mm_mul_ps(x6, x2), _mm_mul_ps(x7, x3));
 
   /* t1[5] = i * n - m * j;
      t1[5] = i * n - m * j;
      t2[5] = e * n - m * f;
      t3[5] = e * j - i * f; */
-  t5 = glmm_fnmadd(x7, x5, t5);
+  t5 = _mm_sub_ps(_mm_mul_ps(x6, x4), _mm_mul_ps(x7, x5));
 
-  x4 = _mm_movelh_ps(r0, r1);        /* f e b a */
+  x0 = glmm_shuff2(r1, r0, 0, 0, 0, 0, 2, 2, 2, 0); /* a a a e */
-  x5 = _mm_movehl_ps(r1, r0);        /* h g d c */
+  x1 = glmm_shuff2(r1, r0, 1, 1, 1, 1, 2, 2, 2, 0); /* b b b f */
-  
+  x2 = glmm_shuff2(r1, r0, 2, 2, 2, 2, 2, 2, 2, 0); /* c c c g */
-  x0 = glmm_shuff1(x4, 0, 0, 0, 2);  /* a a a e */
+  x3 = glmm_shuff2(r1, r0, 3, 3, 3, 3, 2, 2, 2, 0); /* d d d h */
-  x1 = glmm_shuff1(x4, 1, 1, 1, 3);  /* b b b f */
-  x2 = glmm_shuff1(x5, 0, 0, 0, 2);  /* c c c g */
-  x3 = glmm_shuff1(x5, 1, 1, 1, 3);  /* d d d h */
-  
-  v2 = _mm_mul_ps(x0, t1);
-  v1 = _mm_mul_ps(x0, t0);
-  v3 = _mm_mul_ps(x0, t2);
-  v0 = _mm_mul_ps(x1, t0);
-  
-  v2 = glmm_fnmadd(x1, t3, v2);
-  v3 = glmm_fnmadd(x1, t4, v3);
-  v0 = glmm_fnmadd(x2, t1, v0);
-  v1 = glmm_fnmadd(x2, t3, v1);
-  
-  v3 = glmm_fmadd(x2, t5, v3);
-  v0 = glmm_fmadd(x3, t2, v0);
-  v2 = glmm_fmadd(x3, t5, v2);
-  v1 = glmm_fmadd(x3, t4, v1);
 
   /*
    dest[0][0] =  f * t1[0] - g * t1[1] + h * t1[2];
    dest[0][1] =-(b * t1[0] - c * t1[1] + d * t1[2]);
    dest[0][2] =  b * t2[0] - c * t2[1] + d * t2[2];
    dest[0][3] =-(b * t3[0] - c * t3[1] + d * t3[2]); */
-  v0 = _mm_xor_ps(v0, x8);
+  v0 = _mm_add_ps(_mm_mul_ps(x3, t2),
-  
+                  _mm_sub_ps(_mm_mul_ps(x1, t0),
-  /*
+                             _mm_mul_ps(x2, t1)));
-   dest[2][0] =  e * t1[1] - f * t1[3] + h * t1[5];
+  v0 = _mm_xor_ps(v0, _mm_set_ps(-0.f, 0.f, -0.f, 0.f));
-   dest[2][1] =-(a * t1[1] - b * t1[3] + d * t1[5]);
-   dest[2][2] =  a * t2[1] - b * t2[3] + d * t2[5];
-   dest[2][3] =-(a * t3[1] - b * t3[3] + d * t3[5]);*/
-  v2 = _mm_xor_ps(v2, x8);
 
   /*
    dest[1][0] =-(e * t1[0] - g * t1[3] + h * t1[4]);
    dest[1][1] =  a * t1[0] - c * t1[3] + d * t1[4];
    dest[1][2] =-(a * t2[0] - c * t2[3] + d * t2[4]);
    dest[1][3] =  a * t3[0] - c * t3[3] + d * t3[4]; */
-  v1 = _mm_xor_ps(v1, x9);
+  v1 = _mm_add_ps(_mm_mul_ps(x3, t4),
+                  _mm_sub_ps(_mm_mul_ps(x0, t0),
+                             _mm_mul_ps(x2, t3)));
+  v1 = _mm_xor_ps(v1, _mm_set_ps(0.f, -0.f, 0.f, -0.f));
+
+  /*
+   dest[2][0] =  e * t1[1] - f * t1[3] + h * t1[5];
+   dest[2][1] =-(a * t1[1] - b * t1[3] + d * t1[5]);
+   dest[2][2] =  a * t2[1] - b * t2[3] + d * t2[5];
+   dest[2][3] =-(a * t3[1] - b * t3[3] + d * t3[5]);*/
+  v2 = _mm_add_ps(_mm_mul_ps(x3, t5),
+                  _mm_sub_ps(_mm_mul_ps(x0, t1),
+                             _mm_mul_ps(x1, t3)));
+  v2 = _mm_xor_ps(v2, _mm_set_ps(-0.f, 0.f, -0.f, 0.f));
 
   /*
    dest[3][0] =-(e * t1[2] - f * t1[4] + g * t1[5]);
    dest[3][1] =  a * t1[2] - b * t1[4] + c * t1[5];
    dest[3][2] =-(a * t2[2] - b * t2[4] + c * t2[5]);
    dest[3][3] =  a * t3[2] - b * t3[4] + c * t3[5]; */
-  v3 = _mm_xor_ps(v3, x9);
+  v3 = _mm_add_ps(_mm_mul_ps(x2, t5),
+                  _mm_sub_ps(_mm_mul_ps(x0, t2),
+                             _mm_mul_ps(x1, t4)));
+  v3 = _mm_xor_ps(v3, _mm_set_ps(0.f, -0.f, 0.f, -0.f));
 
   /* determinant */
   x0 = _mm_shuffle_ps(v0, v1, _MM_SHUFFLE(0, 0, 0, 0));
   x1 = _mm_shuffle_ps(v2, v3, _MM_SHUFFLE(0, 0, 0, 0));
   x0 = _mm_shuffle_ps(x0, x1, _MM_SHUFFLE(2, 0, 2, 0));
 
-  x0 = _mm_div_ps(_mm_set1_ps(1.0f), glmm_vhadd(_mm_mul_ps(x0, r0)));
+  x0 = _mm_mul_ps(x0, r0);
+  x0 = _mm_add_ps(x0, glmm_shuff1(x0, 0, 1, 2, 3));
+  x0 = _mm_add_ps(x0, glmm_shuff1(x0, 1, 0, 0, 1));
+  x0 = _mm_div_ps(_mm_set1_ps(1.0f), x0);
 
   glmm_store(dest[0], _mm_mul_ps(v0, x0));
   glmm_store(dest[1], _mm_mul_ps(v1, x0));

include/cglm/simd/sse2/quat.h

@@ -22,33 +22,25 @@ glm_quat_mul_sse2(versor p, versor q, versor dest) {
      a1 a2 − b1 b2 − c1 c2 − d1 d2
    */
 
-  __m128 xp, xq, x1, x2, x3, r, x, y, z;
+  __m128 xp, xq, x0, r;
 
   xp = glmm_load(p); /* 3 2 1 0 */
   xq = glmm_load(q);
-  x1 = _mm_set_ps(-0.f, 0.f, -0.f, 0.f); /* TODO: _mm_set1_ss() + shuff ? */
-  r  = _mm_mul_ps(glmm_splat_w(xp), xq);
 
-  x2 = _mm_unpackhi_ps(x1, x1);
+  r  = _mm_mul_ps(glmm_shuff1x(xp, 3), xq);
-  x3 = glmm_shuff1(x1, 3, 2, 0, 1);
-  x  = glmm_splat_x(xp);
-  y  = glmm_splat_y(xp);
-  z  = glmm_splat_z(xp);
 
-  x  = _mm_xor_ps(x, x1);
+  x0 = _mm_xor_ps(glmm_shuff1x(xp, 0), _mm_set_ps(-0.f, 0.f, -0.f, 0.f));
-  y  = _mm_xor_ps(y, x2);
+  r  = _mm_add_ps(r, _mm_mul_ps(x0, glmm_shuff1(xq, 0, 1, 2, 3)));
-  z  = _mm_xor_ps(z, x3);
 
-  x1 = glmm_shuff1(xq, 0, 1, 2, 3);
+  x0 = _mm_xor_ps(glmm_shuff1x(xp, 1), _mm_set_ps(-0.f, -0.f, 0.f, 0.f));
-  x2 = glmm_shuff1(xq, 1, 0, 3, 2);
+  r  = _mm_add_ps(r, _mm_mul_ps(x0, glmm_shuff1(xq, 1, 0, 3, 2)));
-  x3 = glmm_shuff1(xq, 2, 3, 0, 1);
 
-  r  = glmm_fmadd(x, x1, r);
+  x0 = _mm_xor_ps(glmm_shuff1x(xp, 2), _mm_set_ps(-0.f, 0.f, 0.f, -0.f));
-  r  = glmm_fmadd(y, x2, r);
+  r  = _mm_add_ps(r, _mm_mul_ps(x0, glmm_shuff1(xq, 2, 3, 0, 1)));
-  r  = glmm_fmadd(z, x3, r);
 
   glmm_store(dest, r);
 }
 
+
 #endif
 #endif /* cglm_quat_simd_h */

include/cglm/simd/x86.h

@@ -18,9 +18,6 @@
 #  define glmm_store(p, a)  _mm_store_ps(p, a)
 #endif
 
-#define glmm_set1(x) _mm_set1_ps(x)
-#define glmm_128     __m128
-
 #ifdef CGLM_USE_INT_DOMAIN
 #  define glmm_shuff1(xmm, z, y, x, w)                                        \
      _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(xmm),                \
@@ -30,16 +27,7 @@
        _mm_shuffle_ps(xmm, xmm, _MM_SHUFFLE(z, y, x, w))
 #endif
 
-#define glmm_splat(x, lane) glmm_shuff1(x, lane, lane, lane, lane)
-
-#define glmm_splat_x(x) glmm_splat(x, 0)
-#define glmm_splat_y(x) glmm_splat(x, 1)
-#define glmm_splat_z(x) glmm_splat(x, 2)
-#define glmm_splat_w(x) glmm_splat(x, 3)
-
-/* glmm_shuff1x() is DEPRECATED!, use glmm_splat() */
 #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)
@@ -60,15 +48,6 @@ glmm_abs(__m128 x) {
   return _mm_andnot_ps(_mm_set1_ps(-0.0f), x);
 }
 
-static inline
-__m128
-glmm_vhadd(__m128 v) {
-  __m128 x0;
-  x0 = _mm_add_ps(v,  glmm_shuff1(v, 0, 1, 2, 3));
-  x0 = _mm_add_ps(x0, glmm_shuff1(x0, 1, 0, 0, 1));
-  return x0;
-}
-
 static inline
 __m128
 glmm_vhadds(__m128 v) {
@@ -101,7 +80,7 @@ glmm_vhmin(__m128 v) {
   __m128 x0, x1, x2;
   x0 = _mm_movehl_ps(v, v);     /* [2, 3, 2, 3] */
   x1 = _mm_min_ps(x0, v);       /* [0|2, 1|3, 2|2, 3|3] */
-  x2 = glmm_splat(x1, 1);       /* [1|3, 1|3, 1|3, 1|3] */
+  x2 = glmm_shuff1x(x1, 1);     /* [1|3, 1|3, 1|3, 1|3] */
   return _mm_min_ss(x1, x2);
 }
 
@@ -117,7 +96,7 @@ glmm_vhmax(__m128 v) {
   __m128 x0, x1, x2;
   x0 = _mm_movehl_ps(v, v);     /* [2, 3, 2, 3] */
   x1 = _mm_max_ps(x0, v);       /* [0|2, 1|3, 2|2, 3|3] */
-  x2 = glmm_splat(x1, 1);       /* [1|3, 1|3, 1|3, 1|3] */
+  x2 = glmm_shuff1x(x1, 1);     /* [1|3, 1|3, 1|3, 1|3] */
   return _mm_max_ss(x1, x2);
 }
 
@@ -209,99 +188,5 @@ glmm_store3(float v[3], __m128 vx) {
   _mm_store_ss(&v[2], glmm_shuff1(vx, 2, 2, 2, 2));
 }
 
-static inline
-__m128
-glmm_div(__m128 a, __m128 b) {
-  return _mm_div_ps(a, b);
-}
-
-/* enable FMA macro for MSVC? */
-#if defined(_MSC_VER) && !defined(__FMA__) && defined(__AVX2__)
-#  define __FMA__ 1
-#endif
-
-static inline
-__m128
-glmm_fmadd(__m128 a, __m128 b, __m128 c) {
-#ifdef __FMA__
-  return _mm_fmadd_ps(a, b, c);
-#else
-  return _mm_add_ps(c, _mm_mul_ps(a, b));
-#endif
-}
-
-static inline
-__m128
-glmm_fnmadd(__m128 a, __m128 b, __m128 c) {
-#ifdef __FMA__
-  return _mm_fnmadd_ps(a, b, c);
-#else
-  return _mm_sub_ps(c, _mm_mul_ps(a, b));
-#endif
-}
-
-static inline
-__m128
-glmm_fmsub(__m128 a, __m128 b, __m128 c) {
-#ifdef __FMA__
-  return _mm_fmsub_ps(a, b, c);
-#else
-  return _mm_sub_ps(_mm_mul_ps(a, b), c);
-#endif
-}
-
-static inline
-__m128
-glmm_fnmsub(__m128 a, __m128 b, __m128 c) {
-#ifdef __FMA__
-  return _mm_fnmsub_ps(a, b, c);
-#else
-  return _mm_xor_ps(_mm_add_ps(_mm_mul_ps(a, b), c), _mm_set1_ps(-0.0f));
-#endif
-}
-
-#if defined(__AVX__)
-static inline
-__m256
-glmm256_fmadd(__m256 a, __m256 b, __m256 c) {
-#ifdef __FMA__
-  return _mm256_fmadd_ps(a, b, c);
-#else
-  return _mm256_add_ps(c, _mm256_mul_ps(a, b));
-#endif
-}
-
-static inline
-__m256
-glmm256_fnmadd(__m256 a, __m256 b, __m256 c) {
-#ifdef __FMA__
-  return _mm256_fnmadd_ps(a, b, c);
-#else
-  return _mm256_sub_ps(c, _mm256_mul_ps(a, b));
-#endif
-}
-
-static inline
-__m256
-glmm256_fmsub(__m256 a, __m256 b, __m256 c) {
-#ifdef __FMA__
-  return _mm256_fmsub_ps(a, b, c);
-#else
-  return _mm256_sub_ps(_mm256_mul_ps(a, b), c);
-#endif
-}
-
-static inline
-__m256
-glmm256_fnmsub(__m256 a, __m256 b, __m256 c) {
-#ifdef __FMA__
-  return _mm256_fmsub_ps(a, b, c);
-#else
-  return _mm256_xor_ps(_mm256_sub_ps(_mm256_mul_ps(a, b), c),
-                       _mm256_set1_ps(-0.0f));
-#endif
-}
-#endif
-
 #endif
 #endif /* cglm_simd_x86_h */

include/cglm/struct/quat.h

@@ -34,7 +34,6 @@
    CGLM_INLINE mat3s   glms_quat_mat3t(versors q)
    CGLM_INLINE versors glms_quat_lerp(versors from, versors to, float t)
    CGLM_INLINE versors glms_quat_lerpc(versors from, versors to, float t)
-   CGLM_INLINE versors glms_quat_nlerp(versors from, versors to, float t)
    CGLM_INLINE versors glms_quat_slerp(versors from, versors to, float t)
    CGLM_INLINE mat4s.  glms_quat_look(vec3s eye, versors ori)
    CGLM_INLINE versors glms_quat_for(vec3s dir, vec3s fwd, vec3s up)
@@ -402,24 +401,6 @@ glms_quat_lerpc(versors from, versors to, float t) {
   return dest;
 }
 
-/*!
- * @brief interpolates between two quaternions
- *        taking the shortest rotation path using
- *        normalized linear interpolation (NLERP)
- *
- * @param[in]   from  from
- * @param[in]   to    to
- * @param[in]   t     interpolant (amount)
- * @param[out]  dest  result quaternion
- */
-CGLM_INLINE
-versors
-glms_quat_nlerp(versors from, versors to, float t) {
-  versors dest;
-  glm_quat_nlerp(from.raw, to.raw, t, dest.raw);
-  return dest;
-}
-
 /*!
  * @brief interpolates between two quaternions
  *        using spherical linear interpolation (SLERP)

include/cglm/vec3-ext.h

@@ -237,9 +237,9 @@ glm_vec3_abs(vec3 v, vec3 dest) {
 CGLM_INLINE
 void
 glm_vec3_fract(vec3 v, vec3 dest) {
-  dest[0] = fminf(v[0] - floorf(v[0]), 0.999999940395355224609375f);
+  dest[0] = fminf(v[0] - floorf(v[0]), 0x1.fffffep-1f);
-  dest[1] = fminf(v[1] - floorf(v[1]), 0.999999940395355224609375f);
+  dest[1] = fminf(v[1] - floorf(v[1]), 0x1.fffffep-1f);
-  dest[2] = fminf(v[2] - floorf(v[2]), 0.999999940395355224609375f);
+  dest[2] = fminf(v[2] - floorf(v[2]), 0x1.fffffep-1f);
 }
 
 /*!

include/cglm/vec4-ext.h

@@ -224,10 +224,10 @@ glm_vec4_sign(vec4 v, vec4 dest) {
 
   x0 = glmm_load(v);
   x1 = _mm_set_ps(0.0f, 0.0f, 1.0f, -1.0f);
-  x2 = glmm_splat(x1, 2);
+  x2 = glmm_shuff1x(x1, 2);
 
-  x3 = _mm_and_ps(_mm_cmpgt_ps(x0, x2), glmm_splat(x1, 1));
+  x3 = _mm_and_ps(_mm_cmpgt_ps(x0, x2), glmm_shuff1x(x1, 1));
-  x4 = _mm_and_ps(_mm_cmplt_ps(x0, x2), glmm_splat(x1, 0));
+  x4 = _mm_and_ps(_mm_cmplt_ps(x0, x2), glmm_shuff1x(x1, 0));
 
   glmm_store(dest, _mm_or_ps(x3, x4));
 #else
@@ -268,10 +268,10 @@ glm_vec4_abs(vec4 v, vec4 dest) {
 CGLM_INLINE
 void
 glm_vec4_fract(vec4 v, vec4 dest) {
-  dest[0] = fminf(v[0] - floorf(v[0]), 0.999999940395355224609375f);
+  dest[0] = fminf(v[0] - floorf(v[0]), 0x1.fffffep-1f);
-  dest[1] = fminf(v[1] - floorf(v[1]), 0.999999940395355224609375f);
+  dest[1] = fminf(v[1] - floorf(v[1]), 0x1.fffffep-1f);
-  dest[2] = fminf(v[2] - floorf(v[2]), 0.999999940395355224609375f);
+  dest[2] = fminf(v[2] - floorf(v[2]), 0x1.fffffep-1f);
-  dest[3] = fminf(v[3] - floorf(v[3]), 0.999999940395355224609375f);
+  dest[3] = fminf(v[3] - floorf(v[3]), 0x1.fffffep-1f);
 }
 
 /*!

include/cglm/vec4.h

@@ -473,8 +473,8 @@ glm_vec4_scale_as(vec4 v, float s, vec4 dest) {
 CGLM_INLINE
 void
 glm_vec4_div(vec4 a, vec4 b, vec4 dest) {
-#if defined(CGLM_SIMD)
+#if defined( __SSE__ ) || defined( __SSE2__ )
-  glmm_store(dest, glmm_div(glmm_load(a), glmm_load(b)));
+  glmm_store(dest, _mm_div_ps(glmm_load(a), glmm_load(b)));
 #else
   dest[0] = a[0] / b[0];
   dest[1] = a[1] / b[1];
@@ -568,8 +568,14 @@ glm_vec4_subadd(vec4 a, vec4 b, vec4 dest) {
 CGLM_INLINE
 void
 glm_vec4_muladd(vec4 a, vec4 b, vec4 dest) {
-#if defined(CGLM_SIMD)
+#if defined( __SSE__ ) || defined( __SSE2__ )
-  glmm_store(dest, glmm_fmadd(glmm_load(a), glmm_load(b), glmm_load(dest)));
+  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];
@@ -590,8 +596,14 @@ glm_vec4_muladd(vec4 a, vec4 b, vec4 dest) {
 CGLM_INLINE
 void
 glm_vec4_muladds(vec4 a, float s, vec4 dest) {
-#if defined(CGLM_SIMD)
+#if defined( __SSE__ ) || defined( __SSE2__ )
-  glmm_store(dest, glmm_fmadd(glmm_load(a), glmm_set1(s), glmm_load(dest)));
+  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),
+                            vmulq_f32(vld1q_f32(a),
+                                      vdupq_n_f32(s))));
 #else
   dest[0] += a[0] * s;
   dest[1] += a[1] * s;

include/cglm/version.h

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

meson.build

@@ -1,5 +1,5 @@
 project('cglm', 'c',
-    version : '0.8.3', 
+    version : '0.8.0', 
     license : 'mit',
     default_options : [
         'c_std=c11',

src/quat.c

@@ -170,12 +170,6 @@ glmc_quat_lerpc(versor from, versor to, float t, versor dest) {
   glm_quat_lerpc(from, to, t, dest);
 }
 
-CGLM_EXPORT
-void
-glmc_quat_nlerp(versor from, versor to, float t, versor dest) {
-  glm_quat_nlerp(from, to, t, dest);
-}
-
 CGLM_EXPORT
 void
 glmc_quat_slerp(versor from, versor to, float t, versor dest) {

test/src/test_affine_mat.h

@@ -7,25 +7,6 @@
 
 #include "test_common.h"
 
-#ifndef glm_affine_mat_test_guard
-#define glm_affine_mat_test_guard
-CGLM_INLINE
-void
-glm_inv_tr_raw(mat4 mat) {
-  CGLM_ALIGN_MAT mat3 r;
-  CGLM_ALIGN(8)  vec3 t;
-
-  /* rotate */
-  glm_mat4_pick3t(mat, r);
-  glm_mat4_ins3(r, mat);
-
-  /* translate */
-  glm_mat3_mulv(r, mat[3], t);
-  glm_vec3_negate(t);
-  glm_vec3_copy(t, mat[3]);
-}
-#endif
-
 TEST_IMPL(GLM_PREFIX, mul) {
   mat4 m1 = GLM_MAT4_IDENTITY_INIT;
   mat4 m2 = GLM_MAT4_IDENTITY_INIT;
@@ -100,12 +81,6 @@ TEST_IMPL(GLM_PREFIX, inv_tr) {
     GLM(mat4_inv)(m1, m2);
     GLM(inv_tr)(m2);
     ASSERTIFY(test_assert_mat4_eq(m1, m2))
-    
-    /* test with raw */
-    glm_mat4_copy(m1, m2);
-    glm_inv_tr_raw(m2);
-    GLM(inv_tr)(m1);
-    ASSERTIFY(test_assert_mat4_eq(m1, m2))
   }
 
   TEST_SUCCESS

test/src/test_cam.c

@@ -35,9 +35,9 @@ TEST_IMPL(camera_decomp) {
   farVal  = 100.0f;
 
   glm_perspective(fovy, aspect, nearVal, farVal, proj);
-  ASSERT(fabsf(aspect  - glm_persp_aspect(proj)) < GLM_FLT_EPSILON)
+  ASSERT(fabsf(aspect  - glm_persp_aspect(proj)) < 1e-5f)
-  ASSERT(fabsf(fovy    - glm_persp_fovy(proj))   < GLM_FLT_EPSILON)
+  ASSERT(fabsf(fovy    - glm_persp_fovy(proj))   < 1e-5f)
-  ASSERT(fabsf(49.984f - glm_deg(glm_persp_fovy(proj))) < GLM_FLT_EPSILON)
+  ASSERT(fabsf(49.984f - glm_deg(glm_persp_fovy(proj))) < 1e-5f)
 
   glm_persp_sizes(proj, fovy, sizes);
 

test/src/test_common.h

@@ -106,7 +106,7 @@ test_rand_quat(versor q);
 CGLM_INLINE
 bool
 test_eq(float a, float b) {
-  return fabsf(a - b) <= GLM_FLT_EPSILON * 10;
+  return fabsf(a - b) <= 1e-5f;
 }
 
 CGLM_INLINE

test/src/test_quat.h

@@ -708,38 +708,6 @@ TEST_IMPL(GLM_PREFIX, quat_lerpc) {
   TEST_SUCCESS
 }
 
-TEST_IMPL(GLM_PREFIX, quat_nlerp) {
-  versor q1, q2, q3, q4;
-  vec3 v1 = {10.0f, 0.0f, 0.0f}, v2;
-
-  glm_quatv(q1, glm_rad(30.0f), v1);
-  glm_quatv(q2, glm_rad(90.0f), v1);
-
-  GLM(quat_nlerp)(q1, q2, 1.0f, q3);
-  glm_quat_normalize(q2);
-  ASSERTIFY(test_assert_quat_eq(q2, q3));
-
-  glm_quatv(q1, glm_rad(30.001f), v1);
-  glm_quatv(q2, glm_rad(30.002f), v1);
-  GLM(quat_nlerp)(q1, q2, 0.7f, q3);
-  glm_quat_lerp(q1, q2, 0.7f, q4);
-  ASSERTIFY(test_assert_quat_eq(q3, q4));
-
-  glm_quatv(q1, glm_rad(30.0f), v1);
-  glm_quatv(q2, glm_rad(90.0f), v1);
-  GLM(quat_nlerp)(q1, q2, 0.5f, q3);
-
-  glm_quat_axis(q3, v2);
-  glm_vec3_normalize(v1);
-  glm_vec3_normalize(v2);
-
-  ASSERT(glm_quat_angle(q3) > glm_rad(30.0f));
-  ASSERT(glm_quat_angle(q3) < glm_rad(90.0f));
-  ASSERTIFY(test_assert_vec3_eq(v1, v2))
-
-  TEST_SUCCESS
-}
-
 TEST_IMPL(GLM_PREFIX, quat_slerp) {
   versor q1, q2, q3, q4;
   vec3 v1 = {10.0f, 0.0f, 0.0f}, v2;

test/tests.h

@@ -284,7 +284,6 @@ TEST_DECLARE(glm_quat_mat3)
 TEST_DECLARE(glm_quat_mat3t)
 TEST_DECLARE(glm_quat_lerp)
 TEST_DECLARE(glm_quat_lerpc)
-TEST_DECLARE(glm_quat_nlerp)
 TEST_DECLARE(glm_quat_slerp)
 TEST_DECLARE(glm_quat_look)
 TEST_DECLARE(glm_quat_for)
@@ -321,7 +320,6 @@ TEST_DECLARE(glmc_quat_mat3)
 TEST_DECLARE(glmc_quat_mat3t)
 TEST_DECLARE(glmc_quat_lerp)
 TEST_DECLARE(glmc_quat_lerpc)
-TEST_DECLARE(glmc_quat_nlerp)
 TEST_DECLARE(glmc_quat_slerp)
 TEST_DECLARE(glmc_quat_look)
 TEST_DECLARE(glmc_quat_for)
@@ -1008,7 +1006,6 @@ TEST_LIST {
   TEST_ENTRY(glm_quat_mat3t)
   TEST_ENTRY(glm_quat_lerp)
   TEST_ENTRY(glm_quat_lerpc)
-  TEST_ENTRY(glm_quat_nlerp)
   TEST_ENTRY(glm_quat_slerp)
   TEST_ENTRY(glm_quat_look)
   TEST_ENTRY(glm_quat_for)
@@ -1045,7 +1042,6 @@ TEST_LIST {
   TEST_ENTRY(glmc_quat_mat3t)
   TEST_ENTRY(glmc_quat_lerp)
   TEST_ENTRY(glmc_quat_lerpc)
-  TEST_ENTRY(glmc_quat_nlerp)
   TEST_ENTRY(glmc_quat_slerp)
   TEST_ENTRY(glmc_quat_look)
   TEST_ENTRY(glmc_quat_for)

win/cglm.vcxproj

@@ -90,10 +90,7 @@
     <ClInclude Include="..\include\cglm\simd\avx\affine.h" />
     <ClInclude Include="..\include\cglm\simd\avx\mat4.h" />
     <ClInclude Include="..\include\cglm\simd\intrin.h" />
-    <ClInclude Include="..\include\cglm\simd\neon\affine.h" />
-    <ClInclude Include="..\include\cglm\simd\neon\mat2.h" />
     <ClInclude Include="..\include\cglm\simd\neon\mat4.h" />
-    <ClInclude Include="..\include\cglm\simd\neon\quat.h" />
     <ClInclude Include="..\include\cglm\simd\sse2\affine.h" />
     <ClInclude Include="..\include\cglm\simd\sse2\mat2.h" />
     <ClInclude Include="..\include\cglm\simd\sse2\mat3.h" />

win/cglm.vcxproj.filters

@@ -370,14 +370,5 @@
     <ClInclude Include="..\include\cglm\struct\affine2d.h">
       <Filter>include\cglm\struct</Filter>
     </ClInclude>
-    <ClInclude Include="..\include\cglm\simd\neon\affine.h">
-      <Filter>include\cglm\simd\neon</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\cglm\simd\neon\mat2.h">
-      <Filter>include\cglm\simd\neon</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\cglm\simd\neon\quat.h">
-      <Filter>include\cglm\simd\neon</Filter>
-    </ClInclude>
   </ItemGroup>
 </Project>