re-organise files, remove cglm prefix from file to make them more clean

glm_vec_scale multiplies vector (all items) by a scalar
result = vector * factor, new scale = old scale * factor

now it is possible to scale a vector as specified factor
result = unit(vector) * factor, new scale = factor

.gitignore

@@ -51,4 +51,9 @@ cscope.*
 test/*.trs
 test/test_*
 *.log
-test-*
+test-*
+test/.libs/*
+test/tests
+cglm_arm/*
+cglm_test_ios/*
+cglm_test_iosTests/*

CONTRIBUTING.md

@@ -0,0 +1,53 @@
+# CONTRIBUTING
+
+Any contributions (code, documentation, ...) are welcome. This project uses [cmocka](http://cmocka.org) for testing, you may need to check their documentation 
+
+# New Features
+- This library may not accept all new features, it is better to create an issue and get approval before coding
+- You must add test for every new feature
+- The feature must be compiled in both UNIX/POSIX systems (e.g. macos, linux...) and Windows
+
+# Code Style
+This library is written with C99, don't try to add C++ files (yes it can compiled into lib),
+if you have enough reason to add C++ files than create an issue and get approval before coding,
+
+- All functions must have `glm` prefix
+- Lines should be wrapped at 80 characters.
+- Don't invent new style for existing ones
+- Use C89 style comments (`/* comments */`) not C++ style comments (`// comments`)
+- Don't use TABs instead use 2 spaces for TABs
+- All indents must be 2 spaces, not 1 nor 4 space
+- All functions in `include` folder must be exported by `CGLM_EXPORT` and wrapped by `extern "C" {` for C++
+- Crate new line for return type, attribs:
+
+```C
+CGLM_INLINE
+void
+glm_mul(mat4 m1, mat4 m2, mat4 dest)
+```
+
+not acceptable:
+
+```C
+CGLM_INLINE void glm_mul(mat4 m1, mat4 m2, mat4 dest)
+```
+- Variables must be declared at the top of a scope before usage:
+```C
+int x;
+int y;
+
+x = y = 0;
+```
+
+not acceptable:
+
+```C
+int x;
+
+x = 0;
+int y = 0;
+```
+
+- All files must retain same LICENSE statement
+- Code with warnings will not be accepted, please suppress them (not by disabling them)
+- Run code anaylysis before submitting pull requests, if you use Xcode you can enable Sanitizer in scheme, you can use valgrind in linux

README.md

@@ -6,6 +6,11 @@
 
 The original glm library is for C++ only (templates, namespaces, classes...), this library targeted to C99 but currently you can use it for C89 safely by language extensions e.g `__register`
 
+#### Documentation
+
+Almost all functions (inline versions) and parameters are documented inside related headers. <br />
+Complete documentation is in progress: http://cglm.readthedocs.io
+
 #### Note for previous versions:
 
 - _dup (duplicate) is changed to _copy. For instance `glm_vec_dup -> glm_vec_copy`

docs/make.bat

@@ -0,0 +1,36 @@
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=python -msphinx
+)
+set SOURCEDIR=source
+set BUILDDIR=build
+set SPHINXPROJ=cglm
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The Sphinx module was not found. Make sure you have Sphinx installed,
+	echo.then set the SPHINXBUILD environment variable to point to the full
+	echo.path of the 'sphinx-build' executable. Alternatively you may add the
+	echo.Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.http://sphinx-doc.org/
+	exit /b 1
+)
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
+
+:end
+popd

docs/source/build.rst

@@ -0,0 +1,52 @@
+Building 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.
+
+External dependencies:
+  * cmocka - for unit testing
+
+**NOTE:**
+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):**
+
+.. code-block:: bash
+  :linenos:
+
+  $ sh ./build-deps.sh    # run this only once (dependencies)
+
+  $ sh autogen.sh
+  $ ./configure
+  $ make
+  $ make check            # run tests (optional)
+  $ [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.
+
+**Build dependencies (windows):**
+
+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.
+
+.. code-block:: bash
+  :linenos:
+
+  $ cd win
+  $ .\build.bat
+
+if *msbuild* is not worked (because of multi versions of Visual Studio)
+then try to build with *devenv*:
+
+.. code-block:: bash
+  :linenos:
+
+  $ devenv cglm.sln /Build Release
+
+Currently tests are not available on Windows.

docs/source/conf.py

@@ -0,0 +1,163 @@
+# -*- coding: utf-8 -*-
+#
+# cglm documentation build configuration file, created by
+# sphinx-quickstart on Tue Jun  6 20:31:05 2017.
+#
+# This file is execfile()d with the current directory set to its
+# containing dir.
+#
+# Note that not all possible configuration values are present in this
+# autogenerated file.
+#
+# All configuration values have a default; values that are commented out
+# serve to show the default.
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+# import os
+# import sys
+# sys.path.insert(0, os.path.abspath('.'))
+
+
+# -- General configuration ------------------------------------------------
+
+# If your documentation needs a minimal Sphinx version, state it here.
+#
+# needs_sphinx = '1.0'
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = []
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# The suffix(es) of source filenames.
+# You can specify multiple suffix as a list of string:
+#
+# source_suffix = ['.rst', '.md']
+source_suffix = '.rst'
+
+# The master toctree document.
+master_doc = 'index'
+
+# General information about the project.
+project = u'cglm'
+copyright = u'2017, Recep Aslantas'
+author = u'Recep Aslantas'
+
+# The version info for the project you're documenting, acts as replacement for
+# |version| and |release|, also used in various other places throughout the
+# built documents.
+#
+# The short X.Y version.
+version = u'0.2.1'
+# The full version, including alpha/beta/rc tags.
+release = u'0.2.1'
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#
+# This is also used if you do content translation via gettext catalogs.
+# Usually you set "language" from the command line for these cases.
+language = None
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This patterns also effect to html_static_path and html_extra_path
+exclude_patterns = []
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = 'sphinx'
+
+# If true, `todo` and `todoList` produce output, else they produce nothing.
+todo_include_todos = False
+
+
+# -- Options for HTML output ----------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+html_theme = 'alabaster'
+
+# 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
+# documentation.
+#
+# 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'
+}
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']
+
+
+# -- Options for HTMLHelp output ------------------------------------------
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = 'cglmdoc'
+
+
+# -- Options for LaTeX output ---------------------------------------------
+
+latex_elements = {
+    # The paper size ('letterpaper' or 'a4paper').
+    #
+    # 'papersize': 'letterpaper',
+
+    # The font size ('10pt', '11pt' or '12pt').
+    #
+    # 'pointsize': '10pt',
+
+    # Additional stuff for the LaTeX preamble.
+    #
+    # 'preamble': '',
+
+    # Latex figure (float) alignment
+    #
+    # 'figure_align': 'htbp',
+}
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title,
+#  author, documentclass [howto, manual, or own class]).
+latex_documents = [
+    (master_doc, 'cglm.tex', u'cglm Documentation',
+     u'Recep Aslantas', 'manual'),
+]
+
+
+# -- Options for manual page output ---------------------------------------
+
+# One entry per manual page. List of tuples
+# (source start file, name, description, authors, manual section).
+man_pages = [
+    (master_doc, 'cglm', u'cglm Documentation',
+     [author], 1)
+]
+
+
+# -- Options for Texinfo output -------------------------------------------
+
+# Grouping the document tree into Texinfo files. List of tuples
+# (source start file, target name, title, author,
+#  dir menu entry, description, category)
+texinfo_documents = [
+    (master_doc, 'cglm', u'cglm Documentation',
+     author, 'cglm', 'One line description of project.',
+     'Miscellaneous'),
+]

docs/source/getting_started.rst

@@ -0,0 +1,66 @@
+Getting Started
+================================
+
+**cglm** uses **glm** prefix for all functions e.g. glm_lookat. You can see supported types in common header file:
+
+.. code-block:: c
+  :linenos:
+
+   typedef float vec3[3];
+   typedef int  ivec3[3];
+   typedef CGLM_ALIGN(16) float vec4[4];
+
+   typedef vec3 mat3[3];
+   typedef vec4 mat4[4];
+
+   typedef vec4 versor;
+
+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*
+
+*vec4* and *mat4* requires 16 byte aligment because vec4 and mat4 operations are
+vectorized by SIMD instructions (SSE/AVX).
+
+**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**
+
+cglm provides a few way to call a function to do same operation.
+
+* Inline - *glm_, glm_u*
+   * aligned
+   * unaligned (todo)
+* Pre-compiled - *glmc_, glmc_u*
+   * aligned
+   * unaligned (todo)
+
+For instance **glm_mat4_mul** is inline (all *glm_* functions are inline), to make it non-inline (pre-compiled)
+call it as **glmc_mat4_mul** from library, to use unaligned version use **glm_umat4_mul** (todo).
+
+Most functions have **dest** parameter for output. For instance mat4_mul func looks like this:
+
+.. code-block:: c
+
+   CGLM_INLINE
+   void
+   glm_mat4_mul(mat4 m1, mat4 m2, mat4 dest)
+
+The dest parameter is out parameter. Result will be stored in **dest**.
+Also in this case matrix multiplication order is dest = m1 * m2.
+
+* Changing parameter order will change the multiplication order.
+* You can pass all parameter same (this is similar to m1 `*=` m1), you can pass **dest** as m1 or m2 (this is similar to m1 `*=` m2)
+
+**v** postfix in function names
+-------------------------------
+
+You may see **v** postfix in some function names, v stands for vector.
+For instance consider a function that accepts three parameters x, y, z.
+This function may be overloaded by **v** postfix to accept vector (vec3) instead of separate parameters.
+In some places the v means that it will be apply to a vector.
+
+**_to** postfix in function names
+---------------------------------
+
+*_to* version of function will store the result in specified parameter instead of in-out parameter.
+Some functions don't have _to prefix but they still behave like this e.g. glm_mat4_mul.

docs/source/index.rst

@@ -0,0 +1,45 @@
+.. cglm documentation master file, created by
+   sphinx-quickstart on Tue Jun  6 20:31:05 2017.
+   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** is optimized 3D math library written in C99 (compatible with C89).
+It is similar to original **glm** library except this is mainly for **C**
+
+This library stores matrices as row-major order but in the future column-major
+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
+* more features (todo)
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Table Of Contents:
+
+   build
+   getting_started
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`modindex`
+* :ref:`search`

include/arch/simd/cglm-intrin.h

@@ -1,36 +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_intrin_h
-#define cglm_intrin_h
-
-#if defined( _WIN32 )
-#  if (defined(_M_AMD64) || defined(_M_X64)) || _M_IX86_FP == 2
-#    define __SSE2__
-#  elif _M_IX86_FP == 1
-#    define __SSE__
-#  endif
-#endif
-
-#if defined( __SSE__ ) || defined( __SSE2__ )
-
-#include <xmmintrin.h>
-#include <emmintrin.h>
-
-/* float */
-#define _mm_shuffle1_ps(a, z, y, x, w)                                        \
-  _mm_shuffle_ps(a, a, _MM_SHUFFLE(z, y, x, w))
-
-#define _mm_shuffle1_ps1(a, x)                                                \
-  _mm_shuffle_ps(a, a, _MM_SHUFFLE(x, x, x, x))
-
-#define _mm_shuffle2_ps(a, b, z0, y0, x0, w0, z1, y1, x1, w1)                 \
-  _mm_shuffle1_ps(_mm_shuffle_ps(a, b, _MM_SHUFFLE(z0, y0, x0, w0)),          \
-                  z1, y1, x1, w1)
-
-#endif
-#endif /* cglm_intrin_h */

include/cglm-vec-ext.h

@@ -1,158 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-/*!
- * @brief SIMD like functions
- */
-
-#ifndef cglm_vec_ext_h
-#define cglm_vec_ext_h
-
-#include "cglm-common.h"
-#include "arch/simd/cglm-intrin.h"
-#include <stdbool.h>
-
-/*!
- * @brief multiplies individual items, just for convenient like SIMD
- *
- * @param a vec1
- * @param b vec2
- * @param d vec3 = (v1[0] * v2[0],  v1[1] * v2[1], v1[2] * v2[2])
- */
-CGLM_INLINE
-void
-glm_vec_mulv(vec3 a, vec3 b, vec3 d) {
-  d[0] = a[0] * b[0];
-  d[1] = a[1] * b[1];
-  d[2] = a[2] * b[2];
-}
-
-/*!
- * @brief multiplies individual items, just for convenient like SIMD
- *
- * @param a v1
- * @param b v2
- * @param d v3 = (v1[0] * v2[0],  v1[1] * v2[1], v1[2] * v2[2], v1[3] * v2[3])
- */
-CGLM_INLINE
-void
-glm_vec4_mulv(vec4 a, vec4 b, vec4 d) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
-  _mm_store_ps(d, _mm_mul_ps(_mm_load_ps(a), _mm_load_ps(b)));
-#else
-  d[0] = a[0] * b[0];
-  d[1] = a[1] * b[1];
-  d[2] = a[2] * b[2];
-  d[3] = a[3] * b[3];
-#endif
-}
-
-CGLM_INLINE
-void
-glm_vec_broadcast(float val, vec3 d) {
-  d[0] = d[1] = d[2] = val;
-}
-
-CGLM_INLINE
-void
-glm_vec4_broadcast(float val, vec4 d) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
-  _mm_store_ps(d, _mm_set1_ps(val));
-#else
-  d[0] = d[1] = d[2] = d[3] = val;
-#endif
-}
-
-CGLM_INLINE
-bool
-glm_vec_eq(vec3 v, float val) {
-  return v[0] == val && v[0] == v[1] && v[0] == v[2];
-}
-
-CGLM_INLINE
-bool
-glm_vec_eq_all(vec3 v) {
-  return v[0] == v[1] && v[0] == v[2];
-}
-
-CGLM_INLINE
-bool
-glm_vec_eqv(vec3 v1, vec3 v2) {
-  return v1[0] == v2[0] && v1[1] == v2[1] && v1[2] == v2[2];
-}
-
-CGLM_INLINE
-bool
-glm_vec4_eq(vec4 v, float val) {
-  return v[0] == val && v[0] == v[1] && v[0] == v[2] && v[0] == v[3];
-}
-
-CGLM_INLINE
-bool
-glm_vec4_eq_all(vec4 v) {
-  return v[0] == v[1] && v[0] == v[2] && v[0] == v[3];
-}
-
-CGLM_INLINE
-bool
-glm_vec4_eqv(vec4 v1, vec4 v2) {
-  return v1[0] == v2[0] && v1[1] == v2[1] && v1[2] == v2[2] && v1[3] == v2[3];
-}
-
-CGLM_INLINE
-float
-glm_vec_max(vec3 v) {
-  float max;
-
-  max = v[0];
-  if (v[1] > max)
-    max = v[1];
-  if (v[2] > max)
-    max = v[2];
-
-  return max;
-}
-
-CGLM_INLINE
-float
-glm_vec_min(vec3 v) {
-  float min;
-
-  min = v[0];
-  if (v[1] < min)
-    min = v[1];
-  if (v[2] < min)
-    min = v[2];
-
-  return min;
-}
-
-CGLM_INLINE
-float
-glm_vec4_max(vec4 v) {
-  float max;
-
-  max = glm_vec_max(v);
-  if (v[3] > max)
-    max = v[3];
-
-  return max;
-}
-
-CGLM_INLINE
-float
-glm_vec4_min(vec4 v) {
-  float min;
-
-  min = glm_vec_min(v);
-  if (v[3] < min)
-    min = v[3];
-
-  return min;
-}
-
-#endif /* cglm_vec_ext_h */

include/cglm.h

@@ -1,22 +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_h
-#define cglm_h
-
-#include "cglm-common.h"
-#include "cglm-vec.h"
-#include "cglm-mat.h"
-#include "cglm-mat3.h"
-#include "cglm-affine.h"
-#include "cglm-cam.h"
-#include "cglm-quat.h"
-#include "cglm-euler.h"
-#include "cglm-util.h"
-#include "cglm-io.h"
-
-#endif /* cglm_h */

include/cglm/affine-mat.h

@@ -5,14 +5,25 @@
  * Full license can be found in the LICENSE file
  */
 
+/*
+ Functions:
+   CGLM_INLINE void glm_mul(mat4 m1, mat4 m2, mat4 dest);
+   CGLM_INLINE void glm_inv_tr(mat4 mat);
+ */
+
 #ifndef cglm_affine_mat_h
 #define cglm_affine_mat_h
 
-#include "cglm-common.h"
-#include "cglm-mat.h"
-#include "cglm-mat3.h"
-#include "arch/simd/cglm-affine-mat-sse2.h"
-#include "arch/simd/cglm-affine-mat-avx.h"
+#include "common.h"
+#include "mat4.h"
+
+#ifdef CGLM_SSE_FP
+#  include "simd/sse2/affine.h"
+#endif
+
+#ifdef CGLM_AVX_FP
+#  include "simd/avx/affine.h"
+#endif
 
 #include <assert.h>
 
@@ -24,20 +35,15 @@ glm_mul(mat4 m1, mat4 m2, mat4 dest) {
 #elif defined( __SSE__ ) || defined( __SSE2__ )
   glm_mul_sse2(m1, m2, dest);
 #else
-  float a00, a01, a02, a03,    b00, b01, b02,
-        a10, a11, a12, a13,    b10, b11, b12,
-        a20, a21, a22, a23,    b20, b21, b22,
-        a30, a31, a32, a33,    b30, b31, b32, b33;
+  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],
+        a20 = m1[2][0], a21 = m1[2][1], a22 = m1[2][2], a23 = m1[2][3],
+        a30 = m1[3][0], a31 = m1[3][1], a32 = m1[3][2], a33 = m1[3][3],
 
-  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],
-  a20 = m1[2][0], a21 = m1[2][1], a22 = m1[2][2], a23 = m1[2][3],
-  a30 = m1[3][0], a31 = m1[3][1], a32 = m1[3][2], a33 = m1[3][3];
-
-  b00 = m2[0][0], b01 = m2[0][1], b02 = m2[0][2],
-  b10 = m2[1][0], b11 = m2[1][1], b12 = m2[1][2],
-  b20 = m2[2][0], b21 = m2[2][1], b22 = m2[2][2],
-  b30 = m2[3][0], b31 = m2[3][1], b32 = m2[3][2], b33 = m2[3][3];
+        b00 = m2[0][0], b01 = m2[0][1], b02 = m2[0][2],
+        b10 = m2[1][0], b11 = m2[1][1], b12 = m2[1][2],
+        b20 = m2[2][0], b21 = m2[2][1], b22 = m2[2][2],
+        b30 = m2[3][0], b31 = m2[3][1], b32 = m2[3][2], b33 = m2[3][3];
 
   dest[0][0] = a00 * b00 + a10 * b01 + a20 * b02;
   dest[0][1] = a01 * b00 + a11 * b01 + a21 * b02;

include/cglm/affine.h

@@ -5,13 +5,38 @@
  * Full license can be found in the LICENSE file
  */
 
+/*
+ Functions:
+   CGLM_INLINE void glm_translate_to(mat4 m, vec3 v, mat4 dest);
+   CGLM_INLINE void glm_translate(mat4 m, vec3 v);
+   CGLM_INLINE void glm_translate_x(mat4 m, float to);
+   CGLM_INLINE void glm_translate_y(mat4 m, float to);
+   CGLM_INLINE void glm_translate_z(mat4 m, float to);
+   CGLM_INLINE void glm_translate_make(mat4 m, vec3 v);
+   CGLM_INLINE void glm_scale_to(mat4 m, vec3 v, mat4 dest);
+   CGLM_INLINE void glm_scale_make(mat4 m, vec3 v);
+   CGLM_INLINE void glm_scale(mat4 m, vec3 v);
+   CGLM_INLINE void glm_scale1(mat4 m, float s);
+   CGLM_INLINE void glm_rotate_x(mat4 m, float rad, mat4 dest);
+   CGLM_INLINE void glm_rotate_y(mat4 m, float rad, mat4 dest);
+   CGLM_INLINE void glm_rotate_z(mat4 m, float rad, mat4 dest);
+   CGLM_INLINE void glm_rotate_ndc_make(mat4 m, float angle, vec3 axis_ndc);
+   CGLM_INLINE void glm_rotate_make(mat4 m, float angle, vec3 axis);
+   CGLM_INLINE void glm_rotate_ndc(mat4 m, float angle, vec3 axis_ndc);
+   CGLM_INLINE void glm_rotate(mat4 m, float angle, vec3 axis);
+   CGLM_INLINE void glm_decompose_scalev(mat4 m, vec3 s);
+   CGLM_INLINE bool glm_uniscaled(mat4 m);
+   CGLM_INLINE void glm_decompose_rs(mat4 m, mat4 r, vec3 s);
+   CGLM_INLINE void glm_decompose(mat4 m, vec4 t, mat4 r, vec3 s);
+ */
+
 #ifndef cglm_affine_h
 #define cglm_affine_h
 
-#include "cglm-common.h"
-#include "cglm-vec.h"
-#include "cglm-affine-mat.h"
-#include "cglm-util.h"
+#include "common.h"
+#include "vec4.h"
+#include "affine-mat.h"
+#include "util.h"
 
 CGLM_INLINE
 void
@@ -313,7 +338,7 @@ glm_decompose_scalev(mat4 m, vec3 s) {
  * @brief returns true if matrix is uniform scaled. This is helpful for 
  *        creating normal matrix.
  *
- * @param m[in] m
+ * @param[in] m m
  *
  * @return boolean
  */
@@ -328,10 +353,11 @@ glm_uniscaled(mat4 m) {
 
 /*!
  * @brief decompose rotation matrix (mat4) and scale vector [Sx, Sy, Sz]
+ *        DON'T pass projected matrix here
  *
  * @param[in]  m affine transform
  * @param[out] r rotation matrix
- * @param[out] r scale matrix
+ * @param[out] s scale matrix
  */
 CGLM_INLINE
 void
@@ -352,18 +378,21 @@ 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 (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_vec_cross(m[0], m[1], v);
   if (glm_vec_dot(v, m[2]) < 0.0f) {
-    glm_vec4_scale(r[0], -1.0f, r[0]);
-    glm_vec4_scale(r[1], -1.0f, r[1]);
-    glm_vec4_scale(r[2], -1.0f, r[2]);
-
-    glm_vec_scale(s, -1.0f, s);
+    glm_vec4_flipsign(r[0]);
+    glm_vec4_flipsign(r[1]);
+    glm_vec4_flipsign(r[2]);
+    glm_vec_flipsign(s);
   }
 }
 
 /*!
- * @brief decompose affine transform
+ * @brief decompose affine transform, TODO: extract shear factors.
+ *        DON'T pass projected matrix here
  *
  * @param[in]  m affine transfrom
  * @param[out] t translation vector

include/cglm/call.h

@@ -12,14 +12,15 @@ extern "C" {
 #endif
 
 #include "cglm.h"
-#include "call/cglmc-vec.h"
-#include "call/cglmc-mat.h"
-#include "call/cglmc-mat3.h"
-#include "call/cglmc-affine.h"
-#include "call/cglmc-cam.h"
-#include "call/cglmc-quat.h"
-#include "call/cglmc-euler.h"
-#include "call/cglmc-io.h"
+#include "call/vec3.h"
+#include "call/vec4.h"
+#include "call/mat4.h"
+#include "call/mat3.h"
+#include "call/affine.h"
+#include "call/cam.h"
+#include "call/quat.h"
+#include "call/euler.h"
+#include "call/io.h"
 
 #ifdef __cplusplus
 }

include/cglm/call/euler.h

@@ -5,8 +5,8 @@
  * Full license can be found in the LICENSE file
  */
 
-#ifndef glmc_euler_h
-#define glmc_euler_h
+#ifndef cglmc_euler_h
+#define cglmc_euler_h
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -48,4 +48,4 @@ glmc_euler_by_order(vec3 angles, glm_euler_sq axis, mat4 dest);
 #ifdef __cplusplus
 }
 #endif
-#endif /* glmc_euler_h */
+#endif /* cglmc_euler_h */

include/cglm/call/mat3.h

@@ -20,6 +20,10 @@ CGLM_EXPORT
 void
 glmc_mat3_copy(mat3 mat, mat3 dest);
 
+CGLM_EXPORT
+void
+glmc_mat3_identity(mat3 mat);
+
 CGLM_EXPORT
 void
 glmc_mat3_mul(mat3 m1, mat3 m2, mat3 dest);

include/cglm/call/mat4.h

@@ -25,6 +25,10 @@ CGLM_EXPORT
 void
 glmc_mat4_copy(mat4 mat, mat4 dest);
 
+CGLM_EXPORT
+void
+glmc_mat4_identity(mat4 mat);
+
 CGLM_EXPORT
 void
 glmc_mat4_pick3(mat4 mat, mat3 dest);

include/cglm/call/vec3.h

@@ -5,8 +5,8 @@
  * Full license can be found in the LICENSE file
  */
 
-#ifndef cglm_vec_h
-#define cglm_vec_h
+#ifndef cglmc_vec3_h
+#define cglmc_vec3_h
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -14,30 +14,16 @@ extern "C" {
 #include "../cglm.h"
 
 /* DEPRECATED! use _copy, _ucopy versions */
-#define glmc_vec_dup(v, dest)   glmc_vec_copy(v, dest)
-#define glmc_vec4_dup3(v, dest) glmc_vec4_copy3(v, dest)
-#define glmc_vec4_dup(v, dest)  glmc_vec4_copy(v, dest)
+#define glmc_vec_dup(v, dest) glmc_vec_copy(v, dest)
 
 CGLM_EXPORT
 void
 glmc_vec_copy(vec3 a, vec3 dest);
 
-CGLM_EXPORT
-void
-glmc_vec4_copy3(vec4 a, vec3 dest);
-
-CGLM_EXPORT
-void
-glmc_vec4_copy(vec4 v, vec4 dest);
-
 CGLM_EXPORT
 float
 glmc_vec_dot(vec3 a, vec3 b);
 
-CGLM_EXPORT
-float
-glmc_vec4_dot(vec4 a, vec4 b);
-
 CGLM_EXPORT
 void
 glmc_vec_cross(vec3 a, vec3 b, vec3 d);
@@ -46,69 +32,41 @@ CGLM_EXPORT
 float
 glmc_vec_norm(vec3 vec);
 
-CGLM_EXPORT
-float
-glmc_vec4_norm(vec4 vec);
-
 CGLM_EXPORT
 float
 glmc_vec_norm2(vec3 vec);
 
-CGLM_EXPORT
-float
-glmc_vec4_norm2(vec4 vec);
-
 CGLM_EXPORT
 void
 glmc_vec_normalize_to(vec3 vec, vec3 dest);
 
-CGLM_EXPORT
-void
-glmc_vec4_normalize_to(vec4 vec, vec4 dest);
-
 CGLM_EXPORT
 void
 glmc_vec_normalize(vec3 v);
 
-CGLM_EXPORT
-void
-glmc_vec4_normalize(vec4 v);
-
 CGLM_EXPORT
 void
 glmc_vec_add(vec3 v1, vec3 v2, vec3 dest);
 
-CGLM_EXPORT
-void
-glmc_vec4_add(vec4 v1, vec4 v2, vec4 dest);
-
 CGLM_EXPORT
 void
 glmc_vec_sub(vec3 v1, vec3 v2, vec3 dest);
 
-CGLM_EXPORT
-void
-glmc_vec4_sub(vec4 v1, vec4 v2, vec4 dest);
-
 CGLM_EXPORT
 void
 glmc_vec_scale(vec3 v, float s, vec3 dest);
 
+CGLM_EXPORT
+void
+glmc_vec_scale_as(vec3 v, float s, vec3 dest);
+
 CGLM_EXPORT
 void
 glmc_vec_flipsign(vec3 v);
 
-CGLM_EXPORT
-void
-glmc_vec4_flipsign(vec4 v);
-
-CGLM_EXPORT
-void
-glmc_vec4_scale(vec4 v, float s, vec4 dest);
-
 CGLM_EXPORT
 float
-glmc_vec_angle(vec3 v1, vec3 v2)
+glmc_vec_angle(vec3 v1, vec3 v2);
 
 CGLM_EXPORT
 void
@@ -122,7 +80,7 @@ CGLM_EXPORT
 void
 glmc_vec_proj(vec3 a, vec3 b, vec3 dest);
 
-CGLM_INLINE
+CGLM_EXPORT
 void
 glmc_vec_center(vec3 v1, vec3 v2, vec3 dest);
 
@@ -130,11 +88,7 @@ CGLM_EXPORT
 float
 glmc_vec_distance(vec3 v1, vec3 v2);
 
-CGLM_EXPORT
-float
-glmc_vec4_distance(vec4 v1, vec4 v2);
-
 #ifdef __cplusplus
 }
 #endif
-#endif /* cglm_vec_h */
+#endif /* cglmc_vec3_h */

include/cglm/call/vec4.h

@@ -0,0 +1,76 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_vec4_h
+#define cglmc_vec4_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+/* DEPRECATED! use _copy, _ucopy versions */
+#define glmc_vec4_dup3(v, dest) glmc_vec4_copy3(v, dest)
+#define glmc_vec4_dup(v, dest)  glmc_vec4_copy(v, dest)
+
+CGLM_EXPORT
+void
+glmc_vec4_copy3(vec4 a, vec3 dest);
+
+CGLM_EXPORT
+void
+glmc_vec4_copy(vec4 v, vec4 dest);
+
+CGLM_EXPORT
+float
+glmc_vec4_dot(vec4 a, vec4 b);
+
+CGLM_EXPORT
+float
+glmc_vec4_norm(vec4 vec);
+
+CGLM_EXPORT
+float
+glmc_vec4_norm2(vec4 vec);
+
+CGLM_EXPORT
+void
+glmc_vec4_normalize_to(vec4 vec, vec4 dest);
+
+CGLM_EXPORT
+void
+glmc_vec4_normalize(vec4 v);
+
+CGLM_EXPORT
+void
+glmc_vec4_add(vec4 v1, vec4 v2, vec4 dest);
+
+CGLM_EXPORT
+void
+glmc_vec4_sub(vec4 v1, vec4 v2, vec4 dest);
+
+CGLM_EXPORT
+void
+glmc_vec4_scale(vec4 v, float s, vec4 dest);
+
+CGLM_EXPORT
+void
+glmc_vec4_scale_as(vec3 v, float s, vec3 dest);
+
+CGLM_EXPORT
+void
+glmc_vec4_flipsign(vec4 v);
+
+CGLM_EXPORT
+float
+glmc_vec4_distance(vec4 v1, vec4 v2);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_vec4_h */
+

include/cglm/cam.h

@@ -5,10 +5,38 @@
  * Full license can be found in the LICENSE file
  */
 
+/*
+ Functions:
+   CGLM_INLINE void glm_frustum(float left,
+                                float right,
+                                float bottom,
+                                float top,
+                                float near,
+                                float far,
+                                mat4  dest);
+   CGLM_INLINE void glm_ortho(float left,
+                              float right,
+                              float bottom,
+                              float top,
+                              float near,
+                              float far,
+                              mat4  dest);
+   CGLM_INLINE void glm_ortho_default(float aspect, mat4  dest);
+   CGLM_INLINE void glm_ortho_default_s(float aspect, float size, mat4  dest);
+   CGLM_INLINE void glm_perspective(float fovy,
+                                    float aspect,
+                                    float near,
+                                    float far,
+                                    mat4  dest);
+   CGLM_INLINE void glm_perspective_default(float aspect, mat4  dest);
+   CGLM_INLINE void glm_perspective_resize(float aspect, mat4  proj);
+   CGLM_INLINE void glm_lookat(vec3 eye, vec3 center, vec3 up, mat4 dest);
+ */
+
 #ifndef cglm_vcam_h
 #define cglm_vcam_h
 
-#include "cglm-common.h"
+#include "common.h"
 
 /*!
  * @brief set up perspective peprojection matrix
@@ -30,21 +58,22 @@ glm_frustum(float left,
             float nearVal,
             float farVal,
             mat4  dest) {
-  float rl, tb, fn;
+  float rl, tb, fn, nv;
 
   glm__memzero(float, dest, sizeof(mat4));
 
-  rl = 1.0f / (right - left);
-  tb = 1.0f / (top - bottom);
-  fn = 1.0f / (farVal - nearVal);
+  rl = 1.0f / (right  - left);
+  tb = 1.0f / (top    - bottom);
+  fn =-1.0f / (farVal - nearVal);
+  nv = 2.0f * nearVal;
 
-  dest[0][0] = 2.0f * nearVal * rl;
-  dest[1][1] = 2.0f * nearVal * tb;
-  dest[2][0] = (right + left) * rl;
-  dest[2][1] = (top + bottom) * tb;
-  dest[2][2] = -(farVal + nearVal) * fn;
-  dest[2][3] = -1.0f;
-  dest[3][2] = -2.0f * farVal * nearVal * fn;
+  dest[0][0] = nv * rl;
+  dest[1][1] = nv * tb;
+  dest[2][0] = (right  + left)    * rl;
+  dest[2][1] = (top    + bottom)  * tb;
+  dest[2][2] = (farVal + nearVal) * fn;
+  dest[2][3] =-1.0f;
+  dest[3][2] = farVal * nv * fn;
 }
 
 /*!
@@ -71,16 +100,16 @@ glm_ortho(float left,
 
   glm__memzero(float, dest, sizeof(mat4));
 
-  rl = 1.0f / (right - left);
-  tb = 1.0f / (top - bottom);
-  fn = 1.0f / (farVal - nearVal);
+  rl = 1.0f / (right  - left);
+  tb = 1.0f / (top    - bottom);
+  fn =-1.0f / (farVal - nearVal);
 
   dest[0][0] = 2.0f * rl;
   dest[1][1] = 2.0f * tb;
-  dest[2][2] =-2.0f * fn;
-  dest[3][0] =-(right + left) * rl;
-  dest[3][1] =-(top + bottom) * tb;
-  dest[3][2] =-(farVal + nearVal) * fn;
+  dest[2][2] = 2.0f * fn;
+  dest[3][0] =-(right  + left)    * rl;
+  dest[3][1] =-(top    + bottom)  * tb;
+  dest[3][2] = (farVal + nearVal) * fn;
   dest[3][3] = 1.0f;
 }
 
@@ -102,7 +131,7 @@ glm_ortho_default(float aspect,
               -100.0f,
                100.0f,
                dest);
-	return;
+	  return;
   }
 
   glm_ortho(-1.0f,
@@ -134,7 +163,7 @@ glm_ortho_default_s(float aspect,
               -size - 100.0f,
                size + 100.0f,
                dest);
-	return;
+	  return;
   }
 
   glm_ortho(-size,
@@ -166,14 +195,14 @@ glm_perspective(float fovy,
 
   glm__memzero(float, dest, sizeof(mat4));
 
-  f  = cosf(fovy * 0.5f) / sinf(fovy * 0.5f);
+  f  = 1.0f / tanf(fovy * 0.5f);
   fn = 1.0f / (nearVal - farVal);
 
   dest[0][0] = f / aspect;
   dest[1][1] = f;
   dest[2][2] = (nearVal + farVal) * fn;
   dest[2][3] =-1.0f;
-  dest[3][2] = 2 * nearVal * farVal * fn;
+  dest[3][2] = 2.0f * nearVal * farVal * fn;
 }
 
 /*!
@@ -206,7 +235,7 @@ CGLM_INLINE
 void
 glm_perspective_resize(float aspect,
                        mat4  proj) {
-  if (proj[0][0] == 0)
+  if (proj[0][0] == 0.0f)
     return;
 
   proj[0][0] = proj[1][1] / aspect;

include/cglm/cglm.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 cglm_h
+#define cglm_h
+
+#include "common.h"
+#include "vec3.h"
+#include "vec4.h"
+#include "mat4.h"
+#include "mat3.h"
+#include "affine.h"
+#include "cam.h"
+#include "quat.h"
+#include "euler.h"
+#include "util.h"
+#include "io.h"
+
+#endif /* cglm_h */

include/cglm/common.h

@@ -53,6 +53,7 @@
 
 #define glm__memzero(type, dest, size) glm__memset(type, dest, size, 0)
 
-#include "cglm-types.h"
+#include "types.h"
+#include "simd/intrin.h"
 
 #endif /* cglm_common_h */

include/cglm/euler.h

@@ -5,10 +5,28 @@
  * Full license can be found in the LICENSE file
  */
 
+/*
+ Types:
+   enum glm_euler_sq
+ 
+ Functions:
+   CGLM_INLINE glm_euler_sq glm_euler_order(int newOrder[3]);
+   CGLM_INLINE void glm_euler_angles(mat4 m, vec3 dest);
+   CGLM_INLINE void glm_euler(vec3 angles, mat4 dest);
+   CGLM_INLINE void glm_euler_zyx(vec3 angles, mat4 dest);
+   CGLM_INLINE void glm_euler_zxy(vec3 angles, mat4 dest);
+   CGLM_INLINE void glm_euler_xzy(vec3 angles, mat4 dest);
+   CGLM_INLINE void glm_euler_yzx(vec3 angles, mat4 dest);
+   CGLM_INLINE void glm_euler_yxz(vec3 angles, mat4 dest);
+   CGLM_INLINE void glm_euler_by_order(vec3         angles,
+                                       glm_euler_sq axis,
+                                       mat4         dest);
+ */
+
 #ifndef cglm_euler_h
 #define cglm_euler_h
 
-#include "cglm-common.h"
+#include "common.h"
 
 /*!
  * if you have axis order like vec3 orderVec = [0, 1, 2] or [0, 2, 1]...
@@ -37,8 +55,8 @@ glm_euler_order(int newOrder[3]) {
 /*!
  * @brief euler angles (in radian) using xyz sequence
  *
- * @param[in]  m affine transform
- * @param[out] v angles vector [x, y, z]
+ * @param[in]  m    affine transform
+ * @param[out] dest angles vector [x, y, z]
  */
 CGLM_INLINE
 void

include/cglm/io.h

@@ -5,10 +5,20 @@
  * Full license can be found in the LICENSE file
  */
 
+/*
+ Functions:
+   CGLM_INLINE void glm_mat4_print(mat4 matrix, FILE *ostream);
+   CGLM_INLINE void glm_mat3_print(mat3 matrix, FILE *ostream);
+   CGLM_INLINE void glm_vec4_print(vec4 vec, FILE *ostream);
+   CGLM_INLINE void glm_vec3_print(vec3 vec, FILE *ostream);
+   CGLM_INLINE void glm_ivec3_print(ivec3 vec, FILE *ostream);
+   CGLM_INLINE void glm_versor_print(versor vec, FILE *ostream);
+ */
+
 #ifndef cglm_io_h
 #define cglm_io_h
 
-#include "cglm-common.h"
+#include "common.h"
 
 #include <stdio.h>
 #include <stdlib.h>

include/cglm/mat3.h

@@ -5,11 +5,36 @@
  * Full license can be found in the LICENSE file
  */
 
+/*
+ Macros:
+   GLM_MAT3_IDENTITY_INIT
+   GLM_MAT3_ZERO_INIT
+   GLM_MAT3_IDENTITY
+   GLM_MAT3_ZERO
+   glm_mat3_dup(mat, dest)
+
+ Functions:
+   CGLM_INLINE void  glm_mat3_copy(mat3 mat, mat3 dest);
+   CGLM_INLINE void  glm_mat3_identity(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 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);
+ */
+
 #ifndef cglm_mat3_h
 #define cglm_mat3_h
 
-#include "cglm-common.h"
-#include "arch/simd/cglm-mat3-simd-sse2.h"
+#include "common.h"
+
+#ifdef CGLM_SSE_FP
+#  include "simd/sse2/mat3.h"
+#endif
 
 #define GLM_MAT3_IDENTITY_INIT  {{1.0f, 0.0f, 0.0f},                          \
                                  {0.0f, 1.0f, 0.0f},                          \
@@ -38,6 +63,27 @@ glm_mat3_copy(mat3 mat, mat3 dest) {
   glm__memcpy(float, dest, mat, sizeof(mat3));
 }
 
+/*!
+ * @brief make given matrix identity. It is identical with below,
+ *        but it is more easy to do that with this func especially for members
+ *        e.g. glm_mat3_identity(aStruct->aMatrix);
+ *
+ * @code
+ * glm_mat3_copy(GLM_MAT3_IDENTITY, mat); // C only
+ *
+ * // or
+ * mat3 mat = GLM_MAT3_IDENTITY_INIT;
+ * @endcode
+ *
+ * @param[in, out]  mat  destination
+ */
+CGLM_INLINE
+void
+glm_mat3_identity(mat3 mat) {
+  mat3 t = GLM_MAT3_IDENTITY_INIT;
+  glm_mat3_copy(t, mat);
+}
+
 /*!
  * @brief multiply m1 and m2 to dest
  *
@@ -58,17 +104,13 @@ glm_mat3_mul(mat3 m1, mat3 m2, mat3 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glm_mat3_mul_sse2(m1, m2, dest);
 #else
-  float a00, a01, a02,    b00, b01, b02,
-        a10, a11, a12,    b10, b11, b12,
-        a20, a21, a22,    b20, b21, b22;
+  float a00 = m1[0][0], a01 = m1[0][1], a02 = m1[0][2],
+        a10 = m1[1][0], a11 = m1[1][1], a12 = m1[1][2],
+        a20 = m1[2][0], a21 = m1[2][1], a22 = m1[2][2],
 
-  a00 = m1[0][0], a01 = m1[0][1], a02 = m1[0][2],
-  a10 = m1[1][0], a11 = m1[1][1], a12 = m1[1][2],
-  a20 = m1[2][0], a21 = m1[2][1], a22 = m1[2][2],
-
-  b00 = m2[0][0], b01 = m2[0][1], b02 = m2[0][2],
-  b10 = m2[1][0], b11 = m2[1][1], b12 = m2[1][2],
-  b20 = m2[2][0], b21 = m2[2][1], b22 = m2[2][2],
+        b00 = m2[0][0], b01 = m2[0][1], b02 = m2[0][2],
+        b10 = m2[1][0], b11 = m2[1][1], b12 = m2[1][2],
+        b20 = m2[2][0], b21 = m2[2][1], b22 = m2[2][2];
 
   dest[0][0] = a00 * b00 + a10 * b01 + a20 * b02;
   dest[0][1] = a01 * b00 + a11 * b01 + a21 * b02;
@@ -87,8 +129,8 @@ glm_mat3_mul(mat3 m1, mat3 m2, mat3 dest) {
  *
  * source matrix will not be transposed unless dest is m
  *
- * @param m[in]     matrix
- * @param dest[out] result
+ * @param[in]  m     matrix
+ * @param[out] dest  result
  */
 CGLM_INLINE
 void
@@ -170,13 +212,9 @@ glm_mat3_scale(mat3 m, float s) {
 CGLM_INLINE
 float
 glm_mat3_det(mat3 mat) {
-  float a, b, c,
-        d, e, f,
-        g, h, i;
-
-  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];
+  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];
 
   return a * (e * i - h * f) - d * (b * i - c * h) + g * (b * f - c * e);
 }
@@ -191,13 +229,9 @@ CGLM_INLINE
 void
 glm_mat3_inv(mat3 mat, mat3 dest) {
   float det;
-  float a, b, c,
-        d, e, f,
-        g, h, i;
-
-  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];
+  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];
 
   dest[0][0] =   e * i - f * h;
   dest[0][1] = -(b * i - h * c);
@@ -234,8 +268,8 @@ glm_mat3_swap_col(mat3 mat, int col1, int col2) {
  * @brief swap two matrix rows
  *
  * @param[in,out] mat  matrix
- * @param[in]     col1 col1
- * @param[in]     col2 col2
+ * @param[in]     row1 row1
+ * @param[in]     row2 row2
  */
 CGLM_INLINE
 void

include/cglm/mat4.h

@@ -10,12 +10,53 @@
  * if available. You dont need to call/incude SIMD headers manually
  */
 
+/*
+ Macros:
+   GLM_MAT4_IDENTITY_INIT
+   GLM_MAT4_ZERO_INIT
+   GLM_MAT4_IDENTITY
+   GLM_MAT4_ZERO
+   glm_mat4_udup(mat, dest)
+   glm_mat4_dup(mat, dest)
+
+ Functions:
+   CGLM_INLINE void  glm_mat4_ucopy(mat4 mat, mat4 dest);
+   CGLM_INLINE void  glm_mat4_copy(mat4 mat, mat4 dest);
+   CGLM_INLINE void  glm_mat4_identity(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);
+   CGLM_INLINE void  glm_mat4_mul(mat4 m1, mat4 m2, mat4 dest);
+   CGLM_INLINE void  glm_mat4_mulN(mat4 *matrices[], int len, mat4 dest);
+   CGLM_INLINE void  glm_mat4_mulv(mat4 m, vec4 v, vec4 dest);
+   CGLM_INLINE void  glm_mat4_mulv3(mat4 m, vec3 v, vec3 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);
+   CGLM_INLINE void  glm_mat4_scale(mat4 m, float s);
+   CGLM_INLINE float glm_mat4_det(mat4 mat);
+   CGLM_INLINE void  glm_mat4_inv(mat4 mat, mat4 dest);
+   CGLM_INLINE void  glm_mat4_inv_precise(mat4 mat, mat4 dest);
+   CGLM_INLINE void  glm_mat4_swap_col(mat4 mat, int col1, int col2);
+   CGLM_INLINE void  glm_mat4_swap_row(mat4 mat, int row1, int row2);
+ */
+
 #ifndef cglm_mat_h
 #define cglm_mat_h
 
-#include "cglm-common.h"
-#include "arch/simd/cglm-mat-simd-sse2.h"
-#include "arch/simd/cglm-mat-simd-avx.h"
+#include "common.h"
+
+#ifdef CGLM_SSE_FP
+#  include "simd/sse2/mat4.h"
+#endif
+
+#ifdef CGLM_AVX_FP
+#  include "simd/avx/mat4.h"
+#endif
+
+#ifdef CGLM_NEON_FP
+#  include "simd/neon/mat4.h"
+#endif
 
 #include <assert.h>
 
@@ -74,6 +115,27 @@ glm_mat4_copy(mat4 mat, mat4 dest) {
 #endif
 }
 
+/*!
+ * @brief make given matrix identity. It is identical with below, 
+ *        but it is more easy to do that with this func especially for members
+ *        e.g. glm_mat4_identity(aStruct->aMatrix);
+ *
+ * @code
+ * glm_mat4_copy(GLM_MAT4_IDENTITY, mat); // C only
+ *
+ * // or
+ * mat4 mat = GLM_MAT4_IDENTITY_INIT;
+ * @endcode
+ *
+ * @param[in, out]  mat  destination
+ */
+CGLM_INLINE
+void
+glm_mat4_identity(mat4 mat) {
+  mat4 t = GLM_MAT4_IDENTITY_INIT;
+  glm_mat4_copy(t, mat);
+}
+
 /*!
  * @brief copy upper-left of mat4 to mat3
  *
@@ -163,21 +225,18 @@ glm_mat4_mul(mat4 m1, mat4 m2, mat4 dest) {
   glm_mat4_mul_avx(m1, m2, dest);
 #elif defined( __SSE__ ) || defined( __SSE2__ )
   glm_mat4_mul_sse2(m1, m2, dest);
+#elif defined( __ARM_NEON_FP )
+  glm_mat4_mul_neon(m1, m2, dest);
 #else
-  float a00, a01, a02, a03,    b00, b01, b02, b03,
-        a10, a11, a12, a13,    b10, b11, b12, b13,
-        a20, a21, a22, a23,    b20, b21, b22, b23,
-        a30, a31, a32, a33,    b30, b31, b32, b33;
+  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],
+        a20 = m1[2][0], a21 = m1[2][1], a22 = m1[2][2], a23 = m1[2][3],
+        a30 = m1[3][0], a31 = m1[3][1], a32 = m1[3][2], a33 = m1[3][3],
 
-  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],
-  a20 = m1[2][0], a21 = m1[2][1], a22 = m1[2][2], a23 = m1[2][3],
-  a30 = m1[3][0], a31 = m1[3][1], a32 = m1[3][2], a33 = m1[3][3];
-
-  b00 = m2[0][0], b01 = m2[0][1], b02 = m2[0][2], b03 = m2[0][3],
-  b10 = m2[1][0], b11 = m2[1][1], b12 = m2[1][2], b13 = m2[1][3],
-  b20 = m2[2][0], b21 = m2[2][1], b22 = m2[2][2], b23 = m2[2][3],
-  b30 = m2[3][0], b31 = m2[3][1], b32 = m2[3][2], b33 = m2[3][3];
+        b00 = m2[0][0], b01 = m2[0][1], b02 = m2[0][2], b03 = m2[0][3],
+        b10 = m2[1][0], b11 = m2[1][1], b12 = m2[1][2], b13 = m2[1][3],
+        b20 = m2[2][0], b21 = m2[2][1], b22 = m2[2][2], b23 = m2[2][3],
+        b30 = m2[3][0], b31 = m2[3][1], b32 = m2[3][2], b33 = m2[3][3];
 
   dest[0][0] = a00 * b00 + a10 * b01 + a20 * b02 + a30 * b03;
   dest[0][1] = a01 * b00 + a11 * b01 + a21 * b02 + a31 * b03;
@@ -278,8 +337,8 @@ glm_mat4_mulv3(mat4 m, vec3 v, vec3 dest) {
  *
  * source matrix will not be transposed unless dest is m
  *
- * @param m[in]     matrix
- * @param dest[out] result
+ * @param[in]  m    matrix
+ * @param[out] dest result
  */
 CGLM_INLINE
 void
@@ -367,15 +426,10 @@ glm_mat4_det(mat4 mat) {
 #else
   /* [square] det(A) = det(At) */
   float t[6];
-  float a, b, c, d,
-        e, f, g, h,
-        i, j, k, l,
-        m, n, o, p;
-
-  a = mat[0][0], b = mat[0][1], c = mat[0][2], d = mat[0][3],
-  e = mat[1][0], f = mat[1][1], g = mat[1][2], h = mat[1][3],
-  i = mat[2][0], j = mat[2][1], k = mat[2][2], l = mat[2][3],
-  m = mat[3][0], n = mat[3][1], o = mat[3][2], p = mat[3][3];
+  float a = mat[0][0], b = mat[0][1], c = mat[0][2], d = mat[0][3],
+        e = mat[1][0], f = mat[1][1], g = mat[1][2], h = mat[1][3],
+        i = mat[2][0], j = mat[2][1], k = mat[2][2], l = mat[2][3],
+        m = mat[3][0], n = mat[3][1], o = mat[3][2], p = mat[3][3];
 
   t[0] = k * p - o * l;
   t[1] = j * p - n * l;
@@ -409,15 +463,10 @@ glm_mat4_inv(mat4 mat, mat4 dest) {
 #else
   float t[6];
   float det;
-  float a, b, c, d,
-        e, f, g, h,
-        i, j, k, l,
-        m, n, o, p;
-
-  a = mat[0][0], b = mat[0][1], c = mat[0][2], d = mat[0][3],
-  e = mat[1][0], f = mat[1][1], g = mat[1][2], h = mat[1][3],
-  i = mat[2][0], j = mat[2][1], k = mat[2][2], l = mat[2][3],
-  m = mat[3][0], n = mat[3][1], o = mat[3][2], p = mat[3][3];
+  float a = mat[0][0], b = mat[0][1], c = mat[0][2], d = mat[0][3],
+        e = mat[1][0], f = mat[1][1], g = mat[1][2], h = mat[1][3],
+        i = mat[2][0], j = mat[2][1], k = mat[2][2], l = mat[2][3],
+        m = mat[3][0], n = mat[3][1], o = mat[3][2], p = mat[3][3];
 
   t[0] = k * p - o * l; t[1] = j * p - n * l; t[2] = j * o - n * k;
   t[3] = i * p - m * l; t[4] = i * o - m * k; t[5] = i * n - m * j;
@@ -472,7 +521,7 @@ glm_mat4_inv_precise(mat4 mat, mat4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glm_mat4_inv_precise_sse2(mat, dest);
 #else
-  glm_mat4_inv_precise(mat, dest);
+  glm_mat4_inv(mat, dest);
 #endif
 }
 
@@ -496,8 +545,8 @@ glm_mat4_swap_col(mat4 mat, int col1, int col2) {
  * @brief swap two matrix rows
  *
  * @param[in,out] mat  matrix
- * @param[in]     col1 col1
- * @param[in]     col2 col2
+ * @param[in]     row1 row1
+ * @param[in]     row2 row2
  */
 CGLM_INLINE
 void

include/cglm/quat.h

@@ -5,13 +5,32 @@
  * Full license can be found in the LICENSE file
  */
 
+/*
+ Macros:
+   GLM_QUAT_IDENTITY_INIT
+   GLM_QUAT_IDENTITY
+
+ Functions:
+   CGLM_INLINE void  glm_quat_identity(versor q);
+   CGLM_INLINE void  glm_quat(versor q, float angle, float x, float y, float z);
+   CGLM_INLINE void  glm_quatv(versor q, float angle, vec3 v);
+   CGLM_INLINE float glm_quat_norm(versor q);
+   CGLM_INLINE void  glm_quat_normalize(versor q);
+   CGLM_INLINE float glm_quat_dot(versor q, versor r);
+   CGLM_INLINE void  glm_quat_mulv(versor q1, versor q2, versor dest);
+   CGLM_INLINE void  glm_quat_mat4(versor q, mat4 dest);
+   CGLM_INLINE void  glm_quat_slerp(versor q, versor r, float t, versor dest);
+ */
+
 #ifndef cglm_quat_h
 #define cglm_quat_h
 
-#include "cglm-common.h"
-#include "cglm-vec.h"
-#include "arch/simd/cglm-intrin.h"
-#include "arch/simd/cglm-quat-simd.h"
+#include "common.h"
+#include "vec4.h"
+
+#ifdef CGLM_SSE_FP
+#  include "simd/sse2/quat.h"
+#endif
 
 #define GLM_QUAT_IDENTITY_INIT  {0.0f, 0.0f, 0.0f, 1.0f}
 #define GLM_QUAT_IDENTITY       (versor){0.0f, 0.0f, 0.0f, 1.0f}

include/cglm/simd/avx/affine.h

@@ -9,8 +9,8 @@
 #define cglm_affine_mat_avx_h
 #ifdef __AVX__
 
-#include "../../cglm-common.h"
-#include "cglm-intrin.h"
+#include "../../common.h"
+#include "../intrin.h"
 
 #include <immintrin.h>
 

include/cglm/simd/avx/mat4.h

@@ -9,8 +9,8 @@
 #define cglm_mat_simd_avx_h
 #ifdef __AVX__
 
-#include "../../cglm-common.h"
-#include "cglm-intrin.h"
+#include "../../common.h"
+#include "../intrin.h"
 
 #include <immintrin.h>
 

include/cglm/simd/intrin.h

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglm_intrin_h
+#define cglm_intrin_h
+
+#if defined( _WIN32 )
+#  if (defined(_M_AMD64) || defined(_M_X64)) || _M_IX86_FP == 2
+#    define __SSE2__
+#  elif _M_IX86_FP == 1
+#    define __SSE__
+#  endif
+#endif
+
+#if defined( __SSE__ ) || defined( __SSE2__ )
+#  include <xmmintrin.h>
+#  include <emmintrin.h>
+
+/* float */
+#  define _mm_shuffle1_ps(a, z, y, x, w)                                       \
+     _mm_shuffle_ps(a, a, _MM_SHUFFLE(z, y, x, w))
+
+#  define _mm_shuffle1_ps1(a, x)                                               \
+     _mm_shuffle_ps(a, a, _MM_SHUFFLE(x, x, x, x))
+
+#  define _mm_shuffle2_ps(a, b, z0, y0, x0, w0, z1, y1, x1, w1)                \
+     _mm_shuffle1_ps(_mm_shuffle_ps(a, b, _MM_SHUFFLE(z0, y0, x0, w0)),        \
+                                    z1, y1, x1, w1)
+#endif
+
+/* x86, x64 */
+#if defined( __SSE__ ) || defined( __SSE2__ )
+#  define CGLM_SSE_FP 1
+#endif
+
+#ifdef __AVX__
+#  define CGLM_AVX_FP 1
+#endif
+
+/* ARM Neon */
+#if defined(__ARM_NEON) && defined(__ARM_NEON_FP)
+#  include <arm_neon.h>
+#  define CGLM_NEON_FP 1
+#else
+#  undef  CGLM_NEON_FP
+#endif
+
+#endif /* cglm_intrin_h */

include/cglm/simd/neon/mat4.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglm_mat4_neon_h
+#define cglm_mat4_neon_h
+#if defined(__ARM_NEON_FP)
+
+#include "../../common.h"
+#include "../intrin.h"
+
+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;
+
+  l0 = vld1q_f32(m2[0]);
+  l1 = vld1q_f32(m2[1]);
+  l2 = vld1q_f32(m2[2]);
+  l3 = vld1q_f32(m2[3]);
+
+  r  = vld1q_f32(m1[0]);
+  d0 = vmulq_lane_f32(r, vget_low_f32(l0), 0);
+  d1 = vmulq_lane_f32(r, vget_low_f32(l1), 0);
+  d2 = vmulq_lane_f32(r, vget_low_f32(l2), 0);
+  d3 = vmulq_lane_f32(r, vget_low_f32(l3), 0);
+
+  r  = vld1q_f32(m1[1]);
+  d0 = vmlaq_lane_f32(d0, r, vget_low_f32(l0), 1);
+  d1 = vmlaq_lane_f32(d1, r, vget_low_f32(l1), 1);
+  d2 = vmlaq_lane_f32(d2, r, vget_low_f32(l2), 1);
+  d3 = vmlaq_lane_f32(d3, r, vget_low_f32(l3), 1);
+
+  r  = vld1q_f32(m1[2]);
+  d0 = vmlaq_lane_f32(d0, r, vget_high_f32(l0), 0);
+  d1 = vmlaq_lane_f32(d1, r, vget_high_f32(l1), 0);
+  d2 = vmlaq_lane_f32(d2, r, vget_high_f32(l2), 0);
+  d3 = vmlaq_lane_f32(d3, r, vget_high_f32(l3), 0);
+
+  r  = vld1q_f32(m1[3]);
+  d0 = vmlaq_lane_f32(d0, r, vget_high_f32(l0), 1);
+  d1 = vmlaq_lane_f32(d1, r, vget_high_f32(l1), 1);
+  d2 = vmlaq_lane_f32(d2, r, vget_high_f32(l2), 1);
+  d3 = vmlaq_lane_f32(d3, r, vget_high_f32(l3), 1);
+
+  vst1q_f32(dest[0], d0);
+  vst1q_f32(dest[1], d1);
+  vst1q_f32(dest[2], d2);
+  vst1q_f32(dest[3], d3);
+}
+
+#endif
+#endif /* cglm_mat4_neon_h */

include/cglm/simd/sse2/affine.h

@@ -9,8 +9,8 @@
 #define cglm_affine_mat_sse2_h
 #if defined( __SSE__ ) || defined( __SSE2__ )
 
-#include "../../cglm-common.h"
-#include "cglm-intrin.h"
+#include "../../common.h"
+#include "../intrin.h"
 
 CGLM_INLINE
 void

include/cglm/simd/sse2/mat3.h

@@ -9,8 +9,8 @@
 #define cglm_mat3_sse_h
 #if defined( __SSE__ ) || defined( __SSE2__ )
 
-#include "../../cglm-common.h"
-#include "cglm-intrin.h"
+#include "../../common.h"
+#include "../intrin.h"
 
 CGLM_INLINE
 void

include/cglm/simd/sse2/mat4.h

@@ -9,8 +9,8 @@
 #define cglm_mat_sse_h
 #if defined( __SSE__ ) || defined( __SSE2__ )
 
-#include "../../cglm-common.h"
-#include "cglm-intrin.h"
+#include "../../common.h"
+#include "../intrin.h"
 
 CGLM_INLINE
 void

include/cglm/simd/sse2/quat.h

@@ -7,9 +7,10 @@
 
 #ifndef cglm_quat_simd_h
 #define cglm_quat_simd_h
+#if defined( __SSE__ ) || defined( __SSE2__ )
 
-#include "../../cglm-common.h"
-#include "cglm-intrin.h"
+#include "../../common.h"
+#include "../intrin.h"
 
 CGLM_INLINE
 void
@@ -64,4 +65,5 @@ glm_quat_slerp_sse2(versor q,
                           _mm_set1_ps(sinTheta)));
 }
 
+#endif
 #endif /* cglm_quat_simd_h */

include/cglm/util.h

@@ -5,15 +5,25 @@
  * Full license can be found in the LICENSE file
  */
 
+/*
+ Functions:
+   CGLM_INLINE int   glm_sign(int val);
+   CGLM_INLINE float glm_rad(float deg);
+   CGLM_INLINE float glm_deg(float rad);
+   CGLM_INLINE void  glm_make_rad(float *deg);
+   CGLM_INLINE void  glm_make_deg(float *rad);
+   CGLM_INLINE float glm_pow2(float x);
+ */
+
 #ifndef cglm_util_h
 #define cglm_util_h
 
-#include "cglm-common.h"
+#include "common.h"
 
 /*!
  * @brief get sign of 32 bit integer as +1 or -1
  *
- * @param X integer value
+ * @param val integer value
  */
 CGLM_INLINE
 int

include/cglm/vec3-ext.h

@@ -0,0 +1,163 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*!
+ * @brief SIMD like functions
+ */
+
+/*
+ Functions:
+   CGLM_INLINE void  glm_vec_mulv(vec3 a, vec3 b, vec3 d);
+   CGLM_INLINE void  glm_vec_broadcast(float val, vec3 d);
+   CGLM_INLINE bool  glm_vec_eq(vec3 v, float val);
+   CGLM_INLINE bool  glm_vec_eq_eps(vec4 v, float val);
+   CGLM_INLINE bool  glm_vec_eq_all(vec3 v);
+   CGLM_INLINE bool  glm_vec_eqv(vec3 v1, vec3 v2);
+   CGLM_INLINE bool  glm_vec_eqv_eps(vec3 v1, vec3 v2);
+   CGLM_INLINE float glm_vec_max(vec3 v);
+   CGLM_INLINE float glm_vec_min(vec3 v);
+ */
+
+#ifndef cglm_vec3_ext_h
+#define cglm_vec3_ext_h
+
+#include "common.h"
+#include <stdbool.h>
+#include <math.h>
+#include <float.h>
+
+/*!
+ * @brief multiplies individual items, just for convenient like SIMD
+ *
+ * @param a vec1
+ * @param b vec2
+ * @param d vec3 = (v1[0] * v2[0],  v1[1] * v2[1], v1[2] * v2[2])
+ */
+CGLM_INLINE
+void
+glm_vec_mulv(vec3 a, vec3 b, vec3 d) {
+  d[0] = a[0] * b[0];
+  d[1] = a[1] * b[1];
+  d[2] = a[2] * b[2];
+}
+
+/*!
+ * @brief fill a vector with specified value
+ *
+ * @param val value
+ * @param d   dest
+ */
+CGLM_INLINE
+void
+glm_vec_broadcast(float val, vec3 d) {
+  d[0] = d[1] = d[2] = val;
+}
+
+/*!
+ * @brief check if vector is equal to value (without epsilon)
+ *
+ * @param v   vector
+ * @param val value
+ */
+CGLM_INLINE
+bool
+glm_vec_eq(vec3 v, float val) {
+  return v[0] == val && v[0] == v[1] && v[0] == v[2];
+}
+
+/*!
+ * @brief check if vector is equal to value (with epsilon)
+ *
+ * @param v   vector
+ * @param val value
+ */
+CGLM_INLINE
+bool
+glm_vec_eq_eps(vec4 v, float val) {
+  return fabsf(v[0] - val) <= FLT_EPSILON
+         && fabsf(v[1] - val) <= FLT_EPSILON
+         && fabsf(v[2] - val) <= FLT_EPSILON;
+}
+
+/*!
+ * @brief check if vectors members are equal (without epsilon)
+ *
+ * @param v   vector
+ */
+CGLM_INLINE
+bool
+glm_vec_eq_all(vec3 v) {
+  return v[0] == v[1] && v[0] == v[2];
+}
+
+/*!
+ * @brief check if vector is equal to another (without epsilon)
+ *
+ * @param v1 vector
+ * @param v2 vector
+ */
+CGLM_INLINE
+bool
+glm_vec_eqv(vec3 v1, vec3 v2) {
+  return v1[0] == v2[0]
+        && v1[1] == v2[1]
+        && v1[2] == v2[2];
+}
+
+/*!
+ * @brief check if vector is equal to another (with epsilon)
+ *
+ * @param v1 vector
+ * @param v2 vector
+ */
+CGLM_INLINE
+bool
+glm_vec_eqv_eps(vec3 v1, vec3 v2) {
+  return fabsf(v1[0] - v2[0]) <= FLT_EPSILON
+         && fabsf(v1[1] - v2[1]) <= FLT_EPSILON
+         && fabsf(v1[2] - v2[2]) <= FLT_EPSILON;
+}
+
+/*!
+ * @brief max value of vector
+ *
+ * @param v vector
+ */
+CGLM_INLINE
+float
+glm_vec_max(vec3 v) {
+  float max;
+
+  max = v[0];
+  if (v[1] > max)
+    max = v[1];
+  if (v[2] > max)
+    max = v[2];
+
+  return max;
+}
+
+/*!
+ * @brief min value of vector
+ *
+ * @param v vector
+ */
+CGLM_INLINE
+float
+glm_vec_min(vec3 v) {
+  float min;
+
+  min = v[0];
+  if (v[1] < min)
+    min = v[1];
+  if (v[2] < min)
+    min = v[2];
+
+  return min;
+}
+
+#endif /* cglm_vec3_ext_h */

include/cglm/vec3.h

@@ -10,18 +10,40 @@
  * all functions without suffix are vec3 functions
  */
 
-#ifndef cglm_vec_h
-#define cglm_vec_h
+/*
+ Macros:
+   glm_vec_dup(v, dest)
 
-#include "cglm-common.h"
-#include "cglm-vec-ext.h"
-#include "arch/simd/cglm-intrin.h"
-#include "cglm-util.h"
+ Functions:
+   CGLM_INLINE void  glm_vec_copy(vec3 a, vec3 dest);
+   CGLM_INLINE float glm_vec_dot(vec3 a, vec3 b);
+   CGLM_INLINE void  glm_vec_cross(vec3 a, vec3 b, vec3 d);
+   CGLM_INLINE float glm_vec_norm2(vec3 v);
+   CGLM_INLINE float glm_vec_norm(vec3 vec);
+   CGLM_INLINE void  glm_vec_add(vec3 v1, vec3 v2, vec3 dest);
+   CGLM_INLINE void  glm_vec_sub(vec3 v1, vec3 v2, vec3 dest);
+   CGLM_INLINE void  glm_vec_scale(vec3 v, float s, vec3 dest);
+   CGLM_INLINE void  glm_vec_scale_as(vec3 v, float s, vec3 dest);
+   CGLM_INLINE void  glm_vec_flipsign(vec3 v);
+   CGLM_INLINE void  glm_vec_normalize(vec3 v);
+   CGLM_INLINE void  glm_vec_normalize_to(vec3 vec, vec3 dest);
+   CGLM_INLINE float glm_vec_distance(vec3 v1, vec3 v2);
+   CGLM_INLINE float glm_vec_angle(vec3 v1, vec3 v2);
+   CGLM_INLINE void  glm_vec_rotate(vec3 v, float angle, vec3 axis);
+   CGLM_INLINE void  glm_vec_rotate_m4(mat4 m, vec3 v, vec3 dest);
+   CGLM_INLINE void  glm_vec_proj(vec3 a, vec3 b, vec3 dest);
+   CGLM_INLINE void  glm_vec_center(vec3 v1, vec3 v2, vec3 dest);
+ */
+
+#ifndef cglm_vec3_h
+#define cglm_vec3_h
+
+#include "common.h"
+#include "vec3-ext.h"
+#include "util.h"
 
 /* DEPRECATED! use _copy, _ucopy versions */
-#define glm_vec_dup(v, dest)   glm_vec_copy(v, dest)
-#define glm_vec4_dup3(v, dest) glm_vec4_copy3(v, dest)
-#define glm_vec4_dup(v, dest)  glm_vec4_copy(v, dest)
+#define glm_vec_dup(v, dest) glm_vec_copy(v, dest)
 
 /*!
  * @brief copy all members of [a] to [dest]
@@ -37,44 +59,11 @@ glm_vec_copy(vec3 a, vec3 dest) {
   dest[2] = a[2];
 }
 
-/*!
- * @brief copy first 3 members of [a] to [dest]
- *
- * @param[in]  a    source
- * @param[out] dest destination
- */
-CGLM_INLINE
-void
-glm_vec4_copy3(vec4 a, vec3 dest) {
-  dest[0] = a[0];
-  dest[1] = a[1];
-  dest[2] = a[2];
-}
-
-/*!
- * @brief copy all members of [a] to [dest]
- *
- * @param[in]  a    source
- * @param[out] dest destination
- */
-CGLM_INLINE
-void
-glm_vec4_copy(vec4 v, vec4 dest) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
-  _mm_store_ps(dest, _mm_load_ps(v));
-#else
-  dest[0] = v[0];
-  dest[1] = v[1];
-  dest[2] = v[2];
-  dest[3] = v[3];
-#endif
-}
-
 /*!
  * @brief vec3 dot product
  *
- * @param[in] a
- * @param[in] b
+ * @param[in] a vector1
+ * @param[in] b vector2
  *
  * @return dot product
  */
@@ -84,20 +73,6 @@ glm_vec_dot(vec3 a, vec3 b) {
   return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
 }
 
-/*!
- * @brief vec4 dot product
- *
- * @param[in] a
- * @param[in] b
- *
- * @return dot product
- */
-CGLM_INLINE
-float
-glm_vec4_dot(vec4 a, vec4 b) {
-  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
-}
-
 /*!
  * @brief vec3 cross product
  *
@@ -121,7 +96,7 @@ glm_vec_cross(vec3 a, vec3 b, vec3 d) {
  * sqrtf fuction twice but with this func we can avoid func call, maybe this is 
  * not good name for this func
  *
- * @param[in] vec vec
+ * @param[in] v vector
  *
  * @return norm * norm
  */
@@ -134,7 +109,7 @@ glm_vec_norm2(vec3 v) {
 /*!
  * @brief norm (magnitude) of vec3
  *
- * @param[in] vec
+ * @param[in] vec vector
  *
  * @return norm
  */
@@ -144,41 +119,11 @@ glm_vec_norm(vec3 vec) {
   return sqrtf(glm_vec_norm2(vec));
 }
 
-/*!
- * @brief norm * norm (magnitude) of vec
- *
- * we can use this func instead of calling norm * norm, because it would call
- * sqrtf fuction twice but with this func we can avoid func call, maybe this is
- * not good name for this func
- *
- * @param[in] vec vec4
- *
- * @return norm * norm
- */
-CGLM_INLINE
-float
-glm_vec4_norm2(vec4 v) {
-  return v[0] * v[0] + v[1] * v[1] + v[2] * v[2] + v[3] * v[3];
-}
-
-/*!
- * @brief norm (magnitude) of vec4
- *
- * @param[in] vec
- *
- * @return norm
- */
-CGLM_INLINE
-float
-glm_vec4_norm(vec4 vec) {
-  return sqrtf(glm_vec4_norm2(vec));
-}
-
 /*!
  * @brief add v2 vector to v1 vector store result in dest
  *
- * @param[in]  v1
- * @param[in]  v2
+ * @param[in]  v1 vector1
+ * @param[in]  v2 vector2
  * @param[out] dest destination vector
  */
 CGLM_INLINE
@@ -189,33 +134,11 @@ glm_vec_add(vec3 v1, vec3 v2, vec3 dest) {
   dest[2] = v1[2] + v2[2];
 }
 
-/*!
- * @brief add v2 vector to v1 vector store result in dest
- *
- * @param[in]  v1
- * @param[in]  v2
- * @param[out] dest destination vector
- */
-CGLM_INLINE
-void
-glm_vec4_add(vec4 v1, vec4 v2, vec4 dest) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
-  _mm_store_ps(dest,
-               _mm_add_ps(_mm_load_ps(v1),
-                          _mm_load_ps(v2)));
-#else
-  dest[0] = v1[0] + v2[0];
-  dest[1] = v1[1] + v2[1];
-  dest[2] = v1[2] + v2[2];
-  dest[3] = v1[3] + v2[3];
-#endif
-}
-
 /*!
  * @brief subtract v2 vector from v1 vector store result in dest
  *
- * @param[in]  v1
- * @param[in]  v2
+ * @param[in]  v1 vector1
+ * @param[in]  v2 vector2
  * @param[out] dest destination vector
  */
 CGLM_INLINE
@@ -227,29 +150,7 @@ glm_vec_sub(vec3 v1, vec3 v2, vec3 dest) {
 }
 
 /*!
- * @brief subtract v2 vector from v1 vector store result in dest
- *
- * @param[in]  v1
- * @param[in]  v2
- * @param[out] dest destination vector
- */
-CGLM_INLINE
-void
-glm_vec4_sub(vec4 v1, vec4 v2, vec4 dest) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
-  _mm_store_ps(dest,
-               _mm_sub_ps(_mm_load_ps(v1),
-                          _mm_load_ps(v2)));
-#else
-  dest[0] = v1[0] - v2[0];
-  dest[1] = v1[1] - v2[1];
-  dest[2] = v1[2] - v2[2];
-  dest[3] = v1[3] - v2[3];
-#endif
-}
-
-/*!
- * @brief multiply vec3 vector with scalar
+ * @brief multiply/scale vec3 vector with scalar: result = v * s
  *
  * @param[in]  v    vector
  * @param[in]  s    scalar
@@ -264,7 +165,7 @@ glm_vec_scale(vec3 v, float s, vec3 dest) {
 }
 
 /*!
- * @brief flip sign of all vec3 members
+ * @brief make vec3 vector scale as specified: result = unit(v) * s
  *
  * @param[in]  v    vector
  * @param[in]  s    scalar
@@ -272,55 +173,31 @@ glm_vec_scale(vec3 v, float s, vec3 dest) {
  */
 CGLM_INLINE
 void
+glm_vec_scale_as(vec3 v, float s, vec3 dest) {
+  float norm;
+  norm = glm_vec_norm(v);
+
+  if (norm == 0) {
+    glm_vec_copy(v, dest);
+    return;
+  }
+
+  glm_vec_scale(v, s / norm, dest);
+}
+
+/*!
+ * @brief flip sign of all vec3 members
+ *
+ * @param[in, out]  v  vector
+ */
+CGLM_INLINE
+void
 glm_vec_flipsign(vec3 v) {
   v[0] = -v[0];
   v[1] = -v[1];
   v[2] = -v[2];
 }
 
-/*!
- * @brief flip sign of all vec4 members
- *
- * @param[in]  v    vector
- * @param[in]  s    scalar
- * @param[out] dest destination vector
- */
-CGLM_INLINE
-void
-glm_vec4_flipsign(vec4 v) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
-  _mm_store_ps(v, _mm_xor_ps(_mm_load_ps(v),
-                             _mm_set1_ps(-0.0f)));
-#else
-  v[0] = -v[0];
-  v[1] = -v[1];
-  v[2] = -v[2];
-  v[3] = -v[3];
-#endif
-}
-
-/*!
- * @brief multiply vec4 vector with scalar
- *
- * @param[in]  v    vector
- * @param[in]  s    scalar
- * @param[out] dest destination vector
- */
-CGLM_INLINE
-void
-glm_vec4_scale(vec4 v, float s, vec4 dest) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
-  _mm_store_ps(dest,
-               _mm_mul_ps(_mm_load_ps(v),
-                          _mm_set1_ps(s)));
-#else
-  dest[0] = v[0] * s;
-  dest[1] = v[1] * s;
-  dest[2] = v[2] * s;
-  dest[3] = v[3] * s;
-#endif
-}
-
 /*!
  * @brief normalize vec3 and store result in same vec
  *
@@ -341,26 +218,6 @@ glm_vec_normalize(vec3 v) {
   glm_vec_scale(v, 1.0f / norm, v);
 }
 
-/*!
- * @brief normalize vec4 and store result in same vec
- *
- * @param[in, out] v vector
- */
-CGLM_INLINE
-void
-glm_vec4_normalize(vec4 v) {
-  float norm;
-
-  norm = glm_vec4_norm(v);
-
-  if (norm == 0.0f) {
-    v[0] = v[1] = v[2] = v[3] = 0.0f;
-    return;
-  }
-
-  glm_vec4_scale(v, 1.0f / norm, v);
-}
-
 /*!
  * @brief normalize vec3 to dest
  *
@@ -382,27 +239,6 @@ glm_vec_normalize_to(vec3 vec, vec3 dest) {
   glm_vec_scale(vec, 1.0f / norm, dest);
 }
 
-/*!
- * @brief normalize vec4 to dest
- *
- * @param[in]  vec  source
- * @param[out] dest destination
- */
-CGLM_INLINE
-void
-glm_vec4_normalize_to(vec4 vec, vec4 dest) {
-  float norm;
-
-  norm = glm_vec4_norm(vec);
-
-  if (norm == 0.0f) {
-    dest[0] = dest[1] = dest[2] = dest[3] = 0.0f;
-    return;
-  }
-
-  glm_vec4_scale(vec, 1.0f / norm, dest);
-}
-
 /*!
  * @brief angle betwen two vector
  *
@@ -487,8 +323,8 @@ glm_vec_rotate_m4(mat4 m, vec3 v, vec3 dest) {
 /*!
  * @brief project a vector onto b vector
  *
- * @param[in]  a
- * @param[in]  b
+ * @param[in]  a vector1
+ * @param[in]  b vector2
  * @param[out] dest projected vector
  */
 CGLM_INLINE
@@ -502,8 +338,8 @@ glm_vec_proj(vec3 a, vec3 b, vec3 dest) {
 /**
  * @brief find center point of two vector
  *
- * @param[in]  v1
- * @param[in]  v2
+ * @param[in]  v1 vector1
+ * @param[in]  v2 vector2
  * @param[out] dest center point
  */
 CGLM_INLINE
@@ -516,8 +352,8 @@ glm_vec_center(vec3 v1, vec3 v2, vec3 dest) {
 /**
  * @brief distance between two vectors
  *
- * @param[in] v1
- * @param[in] v2
+ * @param[in] v1 vector1
+ * @param[in] v2 vector2
  * @return returns distance
  */
 CGLM_INLINE
@@ -528,20 +364,4 @@ glm_vec_distance(vec3 v1, vec3 v2) {
                + glm_pow2(v2[2] - v1[2]));
 }
 
-/**
- * @brief distance between two vectors
- *
- * @param[in] v1
- * @param[in] v2
- * @return returns distance
- */
-CGLM_INLINE
-float
-glm_vec4_distance(vec4 v1, vec4 v2) {
-  return sqrtf(glm_pow2(v2[0] - v1[0])
-               + glm_pow2(v2[1] - v1[1])
-               + glm_pow2(v2[2] - v1[2])
-               + glm_pow2(v2[3] - v1[3]));
-}
-
-#endif /* cglm_vec_h */
+#endif /* cglm_vec3_h */

include/cglm/vec4-ext.h

@@ -0,0 +1,177 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*!
+ * @brief SIMD like functions
+ */
+
+/*
+ Functions:
+   CGLM_INLINE void  glm_vec4_mulv(vec4 a, vec4 b, vec4 d);
+   CGLM_INLINE void  glm_vec4_broadcast(float val, vec4 d);
+   CGLM_INLINE bool  glm_vec4_eq(vec4 v, float val);
+   CGLM_INLINE bool  glm_vec4_eq_eps(vec4 v, float val);
+   CGLM_INLINE bool  glm_vec4_eq_all(vec4 v);
+   CGLM_INLINE bool  glm_vec4_eqv(vec4 v1, vec4 v2);
+   CGLM_INLINE bool  glm_vec4_eqv_eps(vec3 v1, vec3 v2);
+   CGLM_INLINE float glm_vec4_max(vec4 v);
+   CGLM_INLINE float glm_vec4_min(vec4 v);
+ */
+
+#ifndef cglm_vec4_ext_h
+#define cglm_vec4_ext_h
+
+#include "common.h"
+#include <stdbool.h>
+#include <math.h>
+#include <float.h>
+
+/*!
+ * @brief multiplies individual items, just for convenient like SIMD
+ *
+ * @param a v1
+ * @param b v2
+ * @param d v3 = (v1[0] * v2[0],  v1[1] * v2[1], v1[2] * v2[2], v1[3] * v2[3])
+ */
+CGLM_INLINE
+void
+glm_vec4_mulv(vec4 a, vec4 b, vec4 d) {
+#if defined( __SSE__ ) || defined( __SSE2__ )
+  _mm_store_ps(d, _mm_mul_ps(_mm_load_ps(a), _mm_load_ps(b)));
+#else
+  d[0] = a[0] * b[0];
+  d[1] = a[1] * b[1];
+  d[2] = a[2] * b[2];
+  d[3] = a[3] * b[3];
+#endif
+}
+
+/*!
+ * @brief fill a vector with specified value
+ *
+ * @param val value
+ * @param d   dest
+ */
+CGLM_INLINE
+void
+glm_vec4_broadcast(float val, vec4 d) {
+#if defined( __SSE__ ) || defined( __SSE2__ )
+  _mm_store_ps(d, _mm_set1_ps(val));
+#else
+  d[0] = d[1] = d[2] = d[3] = val;
+#endif
+}
+
+/*!
+ * @brief check if vector is equal to value (without epsilon)
+ *
+ * @param v   vector
+ * @param val value
+ */
+CGLM_INLINE
+bool
+glm_vec4_eq(vec4 v, float val) {
+  return v[0] == val
+         && v[0] == v[1]
+         && v[0] == v[2]
+         && v[0] == v[3];
+}
+
+/*!
+ * @brief check if vector is equal to value (with epsilon)
+ *
+ * @param v   vector
+ * @param val value
+ */
+CGLM_INLINE
+bool
+glm_vec4_eq_eps(vec4 v, float val) {
+  return fabsf(v[0] - val) <= FLT_EPSILON
+         && fabsf(v[1] - val) <= FLT_EPSILON
+         && fabsf(v[2] - val) <= FLT_EPSILON
+         && fabsf(v[3] - val) <= FLT_EPSILON;
+}
+
+/*!
+ * @brief check if vectors members are equal (without epsilon)
+ *
+ * @param v   vector
+ */
+CGLM_INLINE
+bool
+glm_vec4_eq_all(vec4 v) {
+  return v[0] == v[1]
+         && v[0] == v[2]
+         && v[0] == v[3];
+}
+
+/*!
+ * @brief check if vector is equal to another (without epsilon)
+ *
+ * @param v1 vector
+ * @param v2 vector
+ */
+CGLM_INLINE
+bool
+glm_vec4_eqv(vec4 v1, vec4 v2) {
+  return v1[0] == v2[0]
+         && v1[1] == v2[1]
+         && v1[2] == v2[2]
+         && v1[3] == v2[3];
+}
+
+/*!
+ * @brief check if vector is equal to another (with epsilon)
+ *
+ * @param v1 vector
+ * @param v2 vector
+ */
+CGLM_INLINE
+bool
+glm_vec4_eqv_eps(vec3 v1, vec3 v2) {
+  return fabsf(v1[0] - v2[0]) <= FLT_EPSILON
+         && fabsf(v1[1] - v2[1]) <= FLT_EPSILON
+         && fabsf(v1[2] - v2[2]) <= FLT_EPSILON
+         && fabsf(v1[3] - v2[3]) <= FLT_EPSILON;
+}
+
+/*!
+ * @brief max value of vector
+ *
+ * @param v vector
+ */
+CGLM_INLINE
+float
+glm_vec4_max(vec4 v) {
+  float max;
+
+  max = glm_vec_max(v);
+  if (v[3] > max)
+    max = v[3];
+
+  return max;
+}
+
+/*!
+ * @brief min value of vector
+ *
+ * @param v vector
+ */
+CGLM_INLINE
+float
+glm_vec4_min(vec4 v) {
+  float min;
+
+  min = glm_vec_min(v);
+  if (v[3] < min)
+    min = v[3];
+
+  return min;
+}
+
+#endif /* cglm_vec4_ext_h */
+

include/cglm/vec4.h

@@ -0,0 +1,285 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*!
+ * vec3 functions dont have suffix e.g glm_vec_dot (not glm_vec3_dot)
+ * all functions without suffix are vec3 functions
+ */
+
+/*
+ Macros:
+   glm_vec4_dup3(v, dest)
+   glm_vec4_dup(v, dest)
+
+ Functions:
+   CGLM_INLINE void  glm_vec4_copy3(vec4 a, vec3 dest);
+   CGLM_INLINE void  glm_vec4_copy(vec4 v, vec4 dest);
+   CGLM_INLINE float glm_vec4_dot(vec4 a, vec4 b);
+   CGLM_INLINE float glm_vec4_norm2(vec4 v);
+   CGLM_INLINE float glm_vec4_norm(vec4 vec);
+   CGLM_INLINE void  glm_vec4_add(vec4 v1, vec4 v2, vec4 dest);
+   CGLM_INLINE void  glm_vec4_sub(vec4 v1, vec4 v2, vec4 dest);
+   CGLM_INLINE void  glm_vec4_scale(vec4 v, float s, vec4 dest);
+   CGLM_INLINE void  glm_vec4_scale_as(vec4 v, float s, vec4 dest);
+   CGLM_INLINE void  glm_vec4_flipsign(vec4 v);
+   CGLM_INLINE void  glm_vec4_normalize(vec4 v);
+   CGLM_INLINE void  glm_vec4_normalize_to(vec4 vec, vec4 dest);
+   CGLM_INLINE float glm_vec4_distance(vec4 v1, vec4 v2);
+ */
+
+#ifndef cglm_vec4_h
+#define cglm_vec4_h
+
+#include "common.h"
+#include "vec4-ext.h"
+#include "util.h"
+
+/* DEPRECATED! use _copy, _ucopy versions */
+#define glm_vec4_dup3(v, dest) glm_vec4_copy3(v, dest)
+#define glm_vec4_dup(v, dest)  glm_vec4_copy(v, dest)
+
+/*!
+ * @brief copy first 3 members of [a] to [dest]
+ *
+ * @param[in]  a    source
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_vec4_copy3(vec4 a, vec3 dest) {
+  dest[0] = a[0];
+  dest[1] = a[1];
+  dest[2] = a[2];
+}
+
+/*!
+ * @brief copy all members of [a] to [dest]
+ *
+ * @param[in]  v    source
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_vec4_copy(vec4 v, vec4 dest) {
+#if defined( __SSE__ ) || defined( __SSE2__ )
+  _mm_store_ps(dest, _mm_load_ps(v));
+#else
+  dest[0] = v[0];
+  dest[1] = v[1];
+  dest[2] = v[2];
+  dest[3] = v[3];
+#endif
+}
+
+/*!
+ * @brief vec4 dot product
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ *
+ * @return dot product
+ */
+CGLM_INLINE
+float
+glm_vec4_dot(vec4 a, vec4 b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
+}
+
+/*!
+ * @brief norm * norm (magnitude) of vec
+ *
+ * we can use this func instead of calling norm * norm, because it would call
+ * sqrtf fuction twice but with this func we can avoid func call, maybe this is
+ * not good name for this func
+ *
+ * @param[in] v vec4
+ *
+ * @return norm * norm
+ */
+CGLM_INLINE
+float
+glm_vec4_norm2(vec4 v) {
+  return v[0] * v[0] + v[1] * v[1] + v[2] * v[2] + v[3] * v[3];
+}
+
+/*!
+ * @brief norm (magnitude) of vec4
+ *
+ * @param[in] vec vector
+ *
+ * @return norm
+ */
+CGLM_INLINE
+float
+glm_vec4_norm(vec4 vec) {
+  return sqrtf(glm_vec4_norm2(vec));
+}
+
+/*!
+ * @brief add v2 vector to v1 vector store result in dest
+ *
+ * @param[in]  v1 vector1
+ * @param[in]  v2 vector2
+ * @param[out] dest destination vector
+ */
+CGLM_INLINE
+void
+glm_vec4_add(vec4 v1, vec4 v2, vec4 dest) {
+#if defined( __SSE__ ) || defined( __SSE2__ )
+  _mm_store_ps(dest,
+               _mm_add_ps(_mm_load_ps(v1),
+                          _mm_load_ps(v2)));
+#else
+  dest[0] = v1[0] + v2[0];
+  dest[1] = v1[1] + v2[1];
+  dest[2] = v1[2] + v2[2];
+  dest[3] = v1[3] + v2[3];
+#endif
+}
+
+/*!
+ * @brief subtract v2 vector from v1 vector store result in dest
+ *
+ * @param[in]  v1 vector1
+ * @param[in]  v2 vector2
+ * @param[out] dest destination vector
+ */
+CGLM_INLINE
+void
+glm_vec4_sub(vec4 v1, vec4 v2, vec4 dest) {
+#if defined( __SSE__ ) || defined( __SSE2__ )
+  _mm_store_ps(dest,
+               _mm_sub_ps(_mm_load_ps(v1),
+                          _mm_load_ps(v2)));
+#else
+  dest[0] = v1[0] - v2[0];
+  dest[1] = v1[1] - v2[1];
+  dest[2] = v1[2] - v2[2];
+  dest[3] = v1[3] - v2[3];
+#endif
+}
+
+/*!
+ * @brief multiply/scale vec4 vector with scalar: result = v * s
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @param[out] dest destination vector
+ */
+CGLM_INLINE
+void
+glm_vec4_scale(vec4 v, float s, vec4 dest) {
+#if defined( __SSE__ ) || defined( __SSE2__ )
+  _mm_store_ps(dest,
+               _mm_mul_ps(_mm_load_ps(v),
+                          _mm_set1_ps(s)));
+#else
+  dest[0] = v[0] * s;
+  dest[1] = v[1] * s;
+  dest[2] = v[2] * s;
+  dest[3] = v[3] * s;
+#endif
+}
+
+/*!
+ * @brief make vec4 vector scale as specified: result = unit(v) * s
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @param[out] dest destination vector
+ */
+CGLM_INLINE
+void
+glm_vec4_scale_as(vec4 v, float s, vec4 dest) {
+  float norm;
+  norm = glm_vec4_norm(v);
+
+  if (norm == 0) {
+    glm_vec4_copy(v, dest);
+    return;
+  }
+
+  glm_vec4_scale(v, s / norm, dest);
+}
+
+/*!
+ * @brief flip sign of all vec4 members
+ *
+ * @param[in, out]  v  vector
+ */
+CGLM_INLINE
+void
+glm_vec4_flipsign(vec4 v) {
+#if defined( __SSE__ ) || defined( __SSE2__ )
+  _mm_store_ps(v, _mm_xor_ps(_mm_load_ps(v),
+                             _mm_set1_ps(-0.0f)));
+#else
+  v[0] = -v[0];
+  v[1] = -v[1];
+  v[2] = -v[2];
+  v[3] = -v[3];
+#endif
+}
+
+/*!
+ * @brief normalize vec4 and store result in same vec
+ *
+ * @param[in, out] v vector
+ */
+CGLM_INLINE
+void
+glm_vec4_normalize(vec4 v) {
+  float norm;
+
+  norm = glm_vec4_norm(v);
+
+  if (norm == 0.0f) {
+    v[0] = v[1] = v[2] = v[3] = 0.0f;
+    return;
+  }
+
+  glm_vec4_scale(v, 1.0f / norm, v);
+}
+
+/*!
+ * @brief normalize vec4 to dest
+ *
+ * @param[in]  vec  source
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_vec4_normalize_to(vec4 vec, vec4 dest) {
+  float norm;
+
+  norm = glm_vec4_norm(vec);
+
+  if (norm == 0.0f) {
+    dest[0] = dest[1] = dest[2] = dest[3] = 0.0f;
+    return;
+  }
+
+  glm_vec4_scale(vec, 1.0f / norm, dest);
+}
+
+/**
+ * @brief distance between two vectors
+ *
+ * @param[in] v1 vector1
+ * @param[in] v2 vector2
+ * @return returns distance
+ */
+CGLM_INLINE
+float
+glm_vec4_distance(vec4 v1, vec4 v2) {
+  return sqrtf(glm_pow2(v2[0] - v1[0])
+               + glm_pow2(v2[1] - v1[1])
+               + glm_pow2(v2[2] - v1[2])
+               + glm_pow2(v2[3] - v1[3]));
+}
+
+#endif /* cglm_vec4_h */

makefile.am

@@ -26,59 +26,74 @@ checkLDFLAGS = -L./.libs \
 checkCFLAGS = -I./test/lib/cmocka/include \
               -I./include
 
-check_PROGRAMS = test/test_mat4
+check_PROGRAMS = test/tests
 TESTS = $(check_PROGRAMS)
 
-test_test_mat4_LDFLAGS = $(checkLDFLAGS)
-test_test_mat4_CFLAGS  = $(checkCFLAGS)
+test_tests_LDFLAGS = $(checkLDFLAGS)
+test_tests_CFLAGS  = $(checkCFLAGS)
 
 cglmdir=$(includedir)/cglm
-cglm_HEADERS = include/cglm-version.h \
-               include/cglm.h \
-               include/cglm-call.h \
-               include/cglm-cam.h \
-               include/cglm-io.h \
-               include/cglm-mat3.h \
-               include/cglm-types.h \
-               include/cglm-common.h \
-               include/cglm-affine.h \
-               include/cglm-vec.h \
-               include/cglm-euler.h \
-               include/cglm-util.h \
-               include/cglm-quat.h \
-               include/cglm-mat.h \
-               include/cglm-affine-mat.h
-
-cglm_arch_simddir=$(includedir)/cglm/arch/simd/
-cglm_arch_simd_HEADERS = include/arch/simd/cglm-mat-simd-avx.h \
-                         include/arch/simd/cglm-affine-mat-avx.h \
-                         include/arch/simd/cglm-quat-simd.h \
-                         include/arch/simd/cglm-affine-mat-sse2.h \
-                         include/arch/simd/cglm-mat3-simd-sse2.h \
-                         include/arch/simd/cglm-mat-simd-sse2.h \
-                         include/arch/simd/cglm-intrin.h
+cglm_HEADERS = include/cglm/version.h \
+                  include/cglm/cglm.h \
+                  include/cglm/call.h \
+                  include/cglm/cam.h \
+                  include/cglm/io.h \
+                  include/cglm/mat4.h \
+                  include/cglm/mat3.h \
+                  include/cglm/types.h \
+                  include/cglm/common.h \
+                  include/cglm/affine.h \
+                  include/cglm/vec3.h \
+                  include/cglm/vec3-ext.h \
+                  include/cglm/vec4.h \
+                  include/cglm/vec4-ext.h \
+                  include/cglm/euler.h \
+                  include/cglm/util.h \
+                  include/cglm/quat.h \
+                  include/cglm/affine-mat.h
 
 cglm_calldir=$(includedir)/cglm/call
-cglm_call_HEADERS = include/call/cglmc-euler.h \
-                    include/call/cglmc-quat.h \
-                    include/call/cglmc-cam.h \
-                    include/call/cglmc-io.h \
-                    include/call/cglmc-affine.h \
-                    include/call/cglmc-vec.h \
-                    include/call/cglmc-mat3.h \
-                    include/call/cglmc-mat.h
+cglm_call_HEADERS = include/cglm/call/mat4.h \
+                    include/cglm/call/mat3.h \
+                    include/cglm/call/vec3.h \
+                    include/cglm/call/vec4.h \
+                    include/cglm/call/affine.h \
+                    include/cglm/call/io.h \
+                    include/cglm/call/cam.h \
+                    include/cglm/call/quat.h \
+                    include/cglm/call/euler.h
+
+cglm_simddir=$(includedir)/cglm/simd
+cglm_simd_HEADERS = include/cglm/simd/intrin.h
+
+cglm_simd_sse2dir=$(includedir)/cglm/simd/sse2
+cglm_simd_sse2_HEADERS = include/cglm/simd/sse2/affine.h \
+                         include/cglm/simd/sse2/mat4.h \
+                         include/cglm/simd/sse2/mat3.h \
+                         include/cglm/simd/sse2/quat.h
+
+cglm_simd_avxdir=$(includedir)/cglm/simd/avx
+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
 
 libcglm_la_SOURCES=\
-    src/cglm-euler.c \
-    src/clgm-affine.c \
-    src/cglm-io.c \
-    src/cglm-quat.c \
-    src/cglm-cam.c \
-    src/cglm-vec.c \
-    src/cglm-mat3.c \
-    src/cglm-mat.c
+    src/euler.c \
+    src/affine.c \
+    src/io.c \
+    src/quat.c \
+    src/cam.c \
+    src/vec3.c \
+    src/vec4.c \
+    src/mat3.c \
+    src/mat4.c
 
-test_test_mat4_SOURCES=test/src/test_mat4.c
+test_tests_SOURCES=\
+    test/src/test_common.c \
+    test/src/test_main.c \
+    test/src/test_mat4.c
 
 all-local:
 	sh ./post-build.sh

src/affine.c

@@ -5,7 +5,8 @@
  * Full license can be found in the LICENSE file
  */
 
-#include "../include/cglm.h"
+#include "../include/cglm/cglm.h"
+#include "../include/cglm/call.h"
 
 CGLM_EXPORT
 void

src/cam.c

@@ -5,7 +5,8 @@
  * Full license can be found in the LICENSE file
  */
 
-#include "../include/cglm.h"
+#include "../include/cglm/cglm.h"
+#include "../include/cglm/call.h"
 
 CGLM_EXPORT
 void

src/euler.c

@@ -5,7 +5,8 @@
  * Full license can be found in the LICENSE file
  */
 
-#include "../include/cglm.h"
+#include "../include/cglm/cglm.h"
+#include "../include/cglm/call.h"
 
 CGLM_EXPORT
 void

src/io.c

@@ -5,7 +5,8 @@
  * Full license can be found in the LICENSE file
  */
 
-#include "../include/cglm.h"
+#include "../include/cglm/cglm.h"
+#include "../include/cglm/call.h"
 
 CGLM_EXPORT
 void

src/mat3.c

@@ -5,7 +5,8 @@
  * Full license can be found in the LICENSE file
  */
 
-#include "../include/cglm.h"
+#include "../include/cglm/cglm.h"
+#include "../include/cglm/call.h"
 
 CGLM_EXPORT
 void
@@ -13,6 +14,12 @@ glmc_mat3_copy(mat3 mat, mat3 dest) {
   glm_mat3_copy(mat, dest);
 }
 
+CGLM_EXPORT
+void
+glmc_mat3_identity(mat3 mat) {
+  glm_mat3_identity(mat);
+}
+
 CGLM_EXPORT
 void
 glmc_mat3_mul(mat3 m1, mat3 m2, mat3 dest) {

src/mat4.c

@@ -5,7 +5,8 @@
  * Full license can be found in the LICENSE file
  */
 
-#include "../include/cglm.h"
+#include "../include/cglm/cglm.h"
+#include "../include/cglm/call.h"
 
 CGLM_EXPORT
 void
@@ -19,6 +20,12 @@ glmc_mat4_copy(mat4 mat, mat4 dest) {
   glm_mat4_copy(mat, dest);
 }
 
+CGLM_EXPORT
+void
+glmc_mat4_identity(mat4 mat) {
+  glm_mat4_identity(mat);
+}
+
 CGLM_EXPORT
 void
 glmc_mat4_pick3(mat4 mat, mat3 dest) {

src/quat.c

@@ -5,7 +5,8 @@
  * Full license can be found in the LICENSE file
  */
 
-#include "../include/cglm.h"
+#include "../include/cglm/cglm.h"
+#include "../include/cglm/call.h"
 
 CGLM_EXPORT
 void

src/vec3.c

@@ -5,7 +5,8 @@
  * Full license can be found in the LICENSE file
  */
 
-#include "../include/cglm.h"
+#include "../include/cglm/cglm.h"
+#include "../include/cglm/call.h"
 
 CGLM_EXPORT
 void
@@ -13,30 +14,12 @@ glmc_vec_copy(vec3 a, vec3 dest) {
   glm_vec_copy(a, dest);
 }
 
-CGLM_EXPORT
-void
-glmc_vec4_copy3(vec4 a, vec3 dest) {
-  glm_vec4_copy3(a, dest);
-}
-
-CGLM_EXPORT
-void
-glmc_vec4_copy(vec4 v, vec4 dest) {
-  glm_vec4_copy(v, dest);
-}
-
 CGLM_EXPORT
 float
 glmc_vec_dot(vec3 a, vec3 b) {
   return glm_vec_dot(a, b);
 }
 
-CGLM_EXPORT
-float
-glmc_vec4_dot(vec4 a, vec4 b) {
-  return glm_vec4_dot(a, b);
-}
-
 CGLM_EXPORT
 void
 glmc_vec_cross(vec3 a, vec3 b, vec3 d) {
@@ -49,96 +32,54 @@ glmc_vec_norm(vec3 vec) {
   return glm_vec_norm(vec);
 }
 
-CGLM_EXPORT
-float
-glmc_vec4_norm(vec4 vec) {
-  return glm_vec4_norm(vec);
-}
-
 CGLM_EXPORT
 void
 glmc_vec_normalize_to(vec3 vec, vec3 dest) {
   glm_vec_normalize_to(vec, dest);
 }
 
-CGLM_EXPORT
-void
-glmc_vec4_normalize_to(vec4 vec, vec4 dest) {
-  glm_vec4_normalize_to(vec, dest);
-}
-
 CGLM_EXPORT
 void
 glmc_vec_normalize(vec3 v) {
   glm_vec_normalize(v);
 }
 
-CGLM_EXPORT
-void
-glmc_vec4_normalize(vec4 v) {
-  glm_vec4_normalize(v);
-}
-
 CGLM_EXPORT
 float
 glmc_vec_norm2(vec3 vec) {
   return glm_vec_norm2(vec);
 }
 
-CGLM_EXPORT
-float
-glmc_vec4_norm2(vec4 vec) {
-  return glm_vec4_norm2(vec);
-}
-
 CGLM_EXPORT
 void
 glmc_vec_add(vec3 v1, vec3 v2, vec3 dest) {
   glm_vec_add(v1, v2, dest);
 }
 
-CGLM_EXPORT
-void
-glmc_vec4_add(vec4 v1, vec4 v2, vec4 dest) {
-  glm_vec4_add(v1, v2, dest);
-}
-
 CGLM_EXPORT
 void
 glmc_vec_sub(vec3 v1, vec3 v2, vec3 dest) {
   glm_vec_sub(v1, v2, dest);
 }
 
-CGLM_EXPORT
-void
-glmc_vec4_sub(vec4 v1, vec4 v2, vec4 dest) {
-  glm_vec4_sub(v1, v2, dest);
-}
-
 CGLM_EXPORT
 void
 glmc_vec_scale(vec3 v, float s, vec3 dest) {
   glm_vec_scale(v, s, dest);
 }
 
+CGLM_EXPORT
+void
+glmc_vec_scale_as(vec3 v, float s, vec3 dest) {
+  glm_vec_scale_as(v, s, dest);
+}
+
 CGLM_EXPORT
 void
 glmc_vec_flipsign(vec3 v) {
   glm_vec_flipsign(v);
 }
 
-CGLM_EXPORT
-void
-glmc_vec4_flipsign(vec4 v) {
-  glm_vec4_flipsign(v);
-}
-
-CGLM_EXPORT
-void
-glmc_vec4_scale(vec4 v, float s, vec4 dest) {
-  glm_vec4_scale(v, s, dest);
-}
-
 CGLM_EXPORT
 float
 glmc_vec_angle(vec3 v1, vec3 v2) {
@@ -174,9 +115,3 @@ float
 glmc_vec_distance(vec3 v1, vec3 v2) {
   return glm_vec_distance(v1, v2);
 }
-
-CGLM_EXPORT
-float
-glmc_vec4_distance(vec4 v1, vec4 v2) {
-  return glm_vec4_distance(v1, v2);
-}

src/vec4.c

@@ -0,0 +1,87 @@
+/*
+ * 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
+void
+glmc_vec4_copy3(vec4 a, vec3 dest) {
+  glm_vec4_copy3(a, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec4_copy(vec4 v, vec4 dest) {
+  glm_vec4_copy(v, dest);
+}
+
+CGLM_EXPORT
+float
+glmc_vec4_dot(vec4 a, vec4 b) {
+  return glm_vec4_dot(a, b);
+}
+
+CGLM_EXPORT
+float
+glmc_vec4_norm(vec4 vec) {
+  return glm_vec4_norm(vec);
+}
+
+CGLM_EXPORT
+void
+glmc_vec4_normalize_to(vec4 vec, vec4 dest) {
+  glm_vec4_normalize_to(vec, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec4_normalize(vec4 v) {
+  glm_vec4_normalize(v);
+}
+
+CGLM_EXPORT
+float
+glmc_vec4_norm2(vec4 vec) {
+  return glm_vec4_norm2(vec);
+}
+
+CGLM_EXPORT
+void
+glmc_vec4_add(vec4 v1, vec4 v2, vec4 dest) {
+  glm_vec4_add(v1, v2, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec4_sub(vec4 v1, vec4 v2, vec4 dest) {
+  glm_vec4_sub(v1, v2, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec4_scale(vec4 v, float s, vec4 dest) {
+  glm_vec4_scale(v, s, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec4_scale_as(vec3 v, float s, vec3 dest) {
+  glm_vec4_scale_as(v, s, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec4_flipsign(vec4 v) {
+  glm_vec4_flipsign(v);
+}
+
+CGLM_EXPORT
+float
+glmc_vec4_distance(vec4 v1, vec4 v2) {
+  return glm_vec4_distance(v1, v2);
+}

test/src/test_common.c

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ */
+
+#include "test_common.h"
+#include <stdlib.h>
+
+void
+test_rand_mat4(mat4 dest) {
+  int i, j;
+
+  srand((unsigned int)time(NULL));
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 4; j++) {
+      dest[i][j] = drand48();
+    }
+  }
+}
+
+void
+test_assert_mat4_eq(mat4 m1, mat4 m2) {
+  int i, j, k;
+
+#define m 4
+#define n 4
+  for (i = 0; i < m; i++) {
+    for (j = 0; j < n; j++) {
+      for (k = 0; k < m; k++)
+        assert_true(fabsf(m1[i][j] - m2[i][j]) <= FLT_EPSILON);
+    }
+  }
+#undef m
+#undef n
+}
+

test/src/test_common.h

@@ -14,27 +14,18 @@
 #include <setjmp.h>
 #include <cmocka.h>
 #include <time.h>
+#include <stdlib.h>
+#include <math.h>
+#include <float.h>
+#include <stdbool.h>
 
-#include <cglm.h>
-#include <cglm-call.h>
+#include <cglm/cglm.h>
+#include <cglm/call.h>
 
-#define precision 0.00001f
-
-static
 void
 test_rand_mat4(mat4 dest);
 
-static
 void
-test_rand_mat4(mat4 dest) {
-  int i, j;
-
-  srand((unsigned int)time(NULL));
-  for (i = 0; i < 4; i++) {
-    for (j = 0; j < 4; j++) {
-      dest[i][j] = drand48();
-    }
-  }
-}
+test_assert_mat4_eq(mat4 m1, mat4 m2);
 
 #endif /* test_common_h */

test/src/test_main.c

@@ -0,0 +1,19 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ */
+
+#include "test_common.h"
+#include "test_tests.h"
+
+int
+main(int argc, const char * argv[]) {
+  const struct CMUnitTest tests[] = {
+    /* mat4 */
+    cmocka_unit_test(test_mat4),
+  };
+
+  return cmocka_run_group_tests(tests,
+                                NULL,
+                                NULL);
+}

test/src/test_mat4.c

@@ -5,18 +5,13 @@
  * Full license can be found in the LICENSE file
  */
 
-#include <time.h>
-#include <stdlib.h>
-#include <math.h>
-#include <float.h>
-
 #include "test_common.h"
 
 #define m 4
 #define n 4
 
 void
-test_mat4_mul(void **state) {
+test_mat4(void **state) {
   mat4  m1 = GLM_MAT4_IDENTITY_INIT;
   mat4  m2 = GLM_MAT4_IDENTITY_INIT;
   mat4  m3;
@@ -48,30 +43,9 @@ test_mat4_mul(void **state) {
     }
   }
 
-  for (i = 0; i < m; i++) {
-    for (j = 0; j < n; j++) {
-      for (k = 0; k < m; k++)
-        assert_true(fabsf(m3[i][j] - m4[i][j]) <= FLT_EPSILON);
-    }
-  }
+  test_assert_mat4_eq(m3, m4);
 
   /* test pre compiled */
   glmc_mat4_mul(m1, m2, m3);
-  for (i = 0; i < m; i++) {
-    for (j = 0; j < n; j++) {
-      for (k = 0; k < m; k++)
-        assert_true(fabsf(m3[i][j] - m4[i][j]) <= FLT_EPSILON);
-    }
-  }
-}
-
-int
-main(int argc, const char * argv[]) {
-  const struct CMUnitTest tests[] = {
-    cmocka_unit_test(test_mat4_mul)
-  };
-
-  return cmocka_run_group_tests(tests,
-                                NULL,
-                                NULL);
+  test_assert_mat4_eq(m3, m4);
 }

test/src/test_tests.h

@@ -0,0 +1,12 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ */
+
+#ifndef test_tests_h
+#define test_tests_h
+
+/* mat4 */
+void test_mat4(void **state);
+
+#endif /* test_tests_h */

win/cglm.vcxproj

@@ -18,6 +18,56 @@
       <Platform>x64</Platform>
     </ProjectConfiguration>
   </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\src\affine.c" />
+    <ClCompile Include="..\src\cam.c" />
+    <ClCompile Include="..\src\dllmain.c" />
+    <ClCompile Include="..\src\euler.c" />
+    <ClCompile Include="..\src\io.c" />
+    <ClCompile Include="..\src\mat3.c" />
+    <ClCompile Include="..\src\mat4.c" />
+    <ClCompile Include="..\src\quat.c" />
+    <ClCompile Include="..\src\vec3.c" />
+    <ClCompile Include="..\src\vec4.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\include\cglm\affine-mat.h" />
+    <ClInclude Include="..\include\cglm\affine.h" />
+    <ClInclude Include="..\include\cglm\call.h" />
+    <ClInclude Include="..\include\cglm\call\affine.h" />
+    <ClInclude Include="..\include\cglm\call\cam.h" />
+    <ClInclude Include="..\include\cglm\call\euler.h" />
+    <ClInclude Include="..\include\cglm\call\io.h" />
+    <ClInclude Include="..\include\cglm\call\mat3.h" />
+    <ClInclude Include="..\include\cglm\call\mat4.h" />
+    <ClInclude Include="..\include\cglm\call\quat.h" />
+    <ClInclude Include="..\include\cglm\call\vec3.h" />
+    <ClInclude Include="..\include\cglm\call\vec4.h" />
+    <ClInclude Include="..\include\cglm\cam.h" />
+    <ClInclude Include="..\include\cglm\cglm.h" />
+    <ClInclude Include="..\include\cglm\common.h" />
+    <ClInclude Include="..\include\cglm\euler.h" />
+    <ClInclude Include="..\include\cglm\io.h" />
+    <ClInclude Include="..\include\cglm\mat3.h" />
+    <ClInclude Include="..\include\cglm\mat4.h" />
+    <ClInclude Include="..\include\cglm\quat.h" />
+    <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\mat4.h" />
+    <ClInclude Include="..\include\cglm\simd\sse2\affine.h" />
+    <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\types.h" />
+    <ClInclude Include="..\include\cglm\util.h" />
+    <ClInclude Include="..\include\cglm\vec3-ext.h" />
+    <ClInclude Include="..\include\cglm\vec3.h" />
+    <ClInclude Include="..\include\cglm\vec4-ext.h" />
+    <ClInclude Include="..\include\cglm\vec4.h" />
+    <ClInclude Include="..\include\cglm\version.h" />
+    <ClInclude Include="..\src\config.h" />
+  </ItemGroup>
   <PropertyGroup Label="Globals">
     <VCProjectVersion>15.0</VCProjectVersion>
     <ProjectGuid>{CA8BCAF9-CD25-4133-8F62-3D1449B5D2FC}</ProjectGuid>
@@ -162,51 +212,6 @@
       <OptimizeReferences>true</OptimizeReferences>
     </Link>
   </ItemDefinitionGroup>
-  <ItemGroup>
-    <ClInclude Include="..\include\arch\simd\cglm-affine-mat-avx.h" />
-    <ClInclude Include="..\include\arch\simd\cglm-affine-mat-sse2.h" />
-    <ClInclude Include="..\include\arch\simd\cglm-intrin.h" />
-    <ClInclude Include="..\include\arch\simd\cglm-mat-simd-avx.h" />
-    <ClInclude Include="..\include\arch\simd\cglm-mat-simd-sse2.h" />
-    <ClInclude Include="..\include\arch\simd\cglm-mat3-simd-sse2.h" />
-    <ClInclude Include="..\include\arch\simd\cglm-quat-simd.h" />
-    <ClInclude Include="..\include\call\cglmc-affine.h" />
-    <ClInclude Include="..\include\call\cglmc-cam.h" />
-    <ClInclude Include="..\include\call\cglmc-euler.h" />
-    <ClInclude Include="..\include\call\cglmc-io.h" />
-    <ClInclude Include="..\include\call\cglmc-mat.h" />
-    <ClInclude Include="..\include\call\cglmc-mat3.h" />
-    <ClInclude Include="..\include\call\cglmc-quat.h" />
-    <ClInclude Include="..\include\call\cglmc-vec.h" />
-    <ClInclude Include="..\include\cglm-affine-mat.h" />
-    <ClInclude Include="..\include\cglm-affine.h" />
-    <ClInclude Include="..\include\cglm-call.h" />
-    <ClInclude Include="..\include\cglm-cam.h" />
-    <ClInclude Include="..\include\cglm-common.h" />
-    <ClInclude Include="..\include\cglm-euler.h" />
-    <ClInclude Include="..\include\cglm-io.h" />
-    <ClInclude Include="..\include\cglm-mat.h" />
-    <ClInclude Include="..\include\cglm-mat3.h" />
-    <ClInclude Include="..\include\cglm-quat.h" />
-    <ClInclude Include="..\include\cglm-types.h" />
-    <ClInclude Include="..\include\cglm-util.h" />
-    <ClInclude Include="..\include\cglm-vec-ext.h" />
-    <ClInclude Include="..\include\cglm-vec.h" />
-    <ClInclude Include="..\include\cglm-version.h" />
-    <ClInclude Include="..\include\cglm.h" />
-    <ClInclude Include="..\src\config.h" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="..\src\cglm-cam.c" />
-    <ClCompile Include="..\src\cglm-euler.c" />
-    <ClCompile Include="..\src\cglm-io.c" />
-    <ClCompile Include="..\src\cglm-mat.c" />
-    <ClCompile Include="..\src\cglm-mat3.c" />
-    <ClCompile Include="..\src\cglm-quat.c" />
-    <ClCompile Include="..\src\cglm-vec.c" />
-    <ClCompile Include="..\src\clgm-affine.c" />
-    <ClCompile Include="..\src\dllmain.c" />
-  </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>

win/cglm.vcxproj.filters

@@ -16,141 +16,165 @@
     <Filter Include="include">
       <UniqueIdentifier>{f46634e5-c098-41a0-afb3-45afb6a53593}</UniqueIdentifier>
     </Filter>
-    <Filter Include="include\call">
-      <UniqueIdentifier>{496b3b53-1258-4efa-87b2-4280ea82f87e}</UniqueIdentifier>
+    <Filter Include="include\cglm">
+      <UniqueIdentifier>{b982cbd3-03d9-4557-bed8-8224e4d95945}</UniqueIdentifier>
     </Filter>
-    <Filter Include="include\arch">
-      <UniqueIdentifier>{28919415-29bd-4edd-8ab1-1ec9a16e46f0}</UniqueIdentifier>
+    <Filter Include="include\cglm\call">
+      <UniqueIdentifier>{6a2a4ebb-ac68-4ed6-a4a1-f6d2243814e9}</UniqueIdentifier>
     </Filter>
-    <Filter Include="include\arch\simd">
-      <UniqueIdentifier>{792cb1a9-bdc8-4f00-bfde-067750b0ab41}</UniqueIdentifier>
+    <Filter Include="include\cglm\simd">
+      <UniqueIdentifier>{4bcb64d3-e522-48f7-85ef-3ddfacf50874}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="include\cglm\simd\sse2">
+      <UniqueIdentifier>{ccf6244c-614c-4016-a5d9-8a78ffc7765a}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="include\cglm\simd\avx">
+      <UniqueIdentifier>{8607b04c-6eb6-49af-8ac2-e534ba78bf76}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="include\cglm\simd\neon">
+      <UniqueIdentifier>{fb97f276-fe14-47ba-8a9f-01032f065a19}</UniqueIdentifier>
     </Filter>
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="..\include\cglm.h">
-      <Filter>include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\cglm-affine.h">
-      <Filter>include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\cglm-affine-mat.h">
-      <Filter>include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\cglm-call.h">
-      <Filter>include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\cglm-cam.h">
-      <Filter>include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\cglm-common.h">
-      <Filter>include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\cglm-euler.h">
-      <Filter>include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\cglm-io.h">
-      <Filter>include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\cglm-mat.h">
-      <Filter>include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\cglm-mat3.h">
-      <Filter>include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\cglm-quat.h">
-      <Filter>include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\cglm-types.h">
-      <Filter>include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\cglm-util.h">
-      <Filter>include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\cglm-vec.h">
-      <Filter>include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\cglm-vec-ext.h">
-      <Filter>include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\call\cglmc-affine.h">
-      <Filter>include\call</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\call\cglmc-cam.h">
-      <Filter>include\call</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\call\cglmc-euler.h">
-      <Filter>include\call</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\call\cglmc-io.h">
-      <Filter>include\call</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\call\cglmc-mat.h">
-      <Filter>include\call</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\call\cglmc-mat3.h">
-      <Filter>include\call</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\call\cglmc-quat.h">
-      <Filter>include\call</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\call\cglmc-vec.h">
-      <Filter>include\call</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\arch\simd\cglm-affine-mat-avx.h">
-      <Filter>include\arch\simd</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\arch\simd\cglm-affine-mat-sse2.h">
-      <Filter>include\arch\simd</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\arch\simd\cglm-intrin.h">
-      <Filter>include\arch\simd</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\arch\simd\cglm-mat3-simd-sse2.h">
-      <Filter>include\arch\simd</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\arch\simd\cglm-mat-simd-avx.h">
-      <Filter>include\arch\simd</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\arch\simd\cglm-mat-simd-sse2.h">
-      <Filter>include\arch\simd</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\arch\simd\cglm-quat-simd.h">
-      <Filter>include\arch\simd</Filter>
-    </ClInclude>
-    <ClInclude Include="..\src\config.h">
-      <Filter>src</Filter>
-    </ClInclude>
-    <ClInclude Include="..\include\cglm-version.h">
-      <Filter>include</Filter>
-    </ClInclude>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="..\src\cglm-cam.c">
+    <ClCompile Include="..\src\affine.c">
       <Filter>src</Filter>
     </ClCompile>
-    <ClCompile Include="..\src\cglm-euler.c">
-      <Filter>src</Filter>
-    </ClCompile>
-    <ClCompile Include="..\src\cglm-io.c">
-      <Filter>src</Filter>
-    </ClCompile>
-    <ClCompile Include="..\src\cglm-mat.c">
-      <Filter>src</Filter>
-    </ClCompile>
-    <ClCompile Include="..\src\cglm-mat3.c">
-      <Filter>src</Filter>
-    </ClCompile>
-    <ClCompile Include="..\src\cglm-quat.c">
-      <Filter>src</Filter>
-    </ClCompile>
-    <ClCompile Include="..\src\cglm-vec.c">
-      <Filter>src</Filter>
-    </ClCompile>
-    <ClCompile Include="..\src\clgm-affine.c">
+    <ClCompile Include="..\src\cam.c">
       <Filter>src</Filter>
     </ClCompile>
     <ClCompile Include="..\src\dllmain.c">
       <Filter>src</Filter>
     </ClCompile>
+    <ClCompile Include="..\src\euler.c">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\io.c">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\mat3.c">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\mat4.c">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\quat.c">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\vec3.c">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\vec4.c">
+      <Filter>src</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\src\config.h">
+      <Filter>src</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\call\affine.h">
+      <Filter>include\cglm\call</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\call\cam.h">
+      <Filter>include\cglm\call</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\call\euler.h">
+      <Filter>include\cglm\call</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\call\io.h">
+      <Filter>include\cglm\call</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\call\mat3.h">
+      <Filter>include\cglm\call</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\call\mat4.h">
+      <Filter>include\cglm\call</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\call\quat.h">
+      <Filter>include\cglm\call</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\call\vec3.h">
+      <Filter>include\cglm\call</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\call\vec4.h">
+      <Filter>include\cglm\call</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\simd\avx\affine.h">
+      <Filter>include\cglm\simd\avx</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\simd\avx\mat4.h">
+      <Filter>include\cglm\simd\avx</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\simd\neon\mat4.h">
+      <Filter>include\cglm\simd\neon</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\simd\sse2\affine.h">
+      <Filter>include\cglm\simd\sse2</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\simd\sse2\mat3.h">
+      <Filter>include\cglm\simd\sse2</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\simd\sse2\mat4.h">
+      <Filter>include\cglm\simd\sse2</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\simd\sse2\quat.h">
+      <Filter>include\cglm\simd\sse2</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\simd\intrin.h">
+      <Filter>include\cglm\simd</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\affine.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\affine-mat.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\call.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\cam.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\cglm.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\common.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\euler.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\io.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\mat3.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\mat4.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\quat.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\types.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\util.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\vec3.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\vec3-ext.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\vec4.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\vec4-ext.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\version.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>