update version

* now the glm_mat4_inv_precise is deault, because I don't think all people are aware of this func
* the old behavior (fast) replaced with new func: glm_mat4_inv_fast

if fast version is desired then glm_mat4_inv_fast must be used.

.gitignore

@@ -51,4 +51,12 @@ cscope.*
 test/*.trs
 test/test_*
 *.log
-test-*
+test-*
+test/.libs/*
+test/tests
+cglm_arm/*
+cglm_test_ios/*
+cglm_test_iosTests/*
+docs/build/*
+win/cglm_test_*
+* copy.*

.travis.yml

@@ -36,9 +36,6 @@ branches:
   only:
     - master
 
-before_install:
-  - pip install --user cpp-coveralls
-
 script:
   - sh ./build-deps.sh
   - sh ./autogen.sh
@@ -52,6 +49,7 @@ script:
 
 after_success:
   - if [[ "$CC" == "gcc" && "$CODE_COVERAGE" == "ON" ]]; then
+      pip install --user cpp-coveralls
       coveralls
         --build-root .
         --exclude lib

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`
@@ -53,8 +58,8 @@ Almost all functions are marked inline (always_inline) so compiler probably will
 To call pre-compiled version, just use `glmc_` (c stands for 'call') instead of `glm_`.
 
 ```C
-  #include <cglm.h>        /* for inline */
+  #include <cglm/cglm.h>   /* for inline */
-  #include <cglm-call.h>   /* for library call (this also includes cglm.h) */
+  #include <cglm/call.h>   /* for library call (this also includes cglm.h) */
 
   mat4 rot, trans, rt;
   /* ... */
@@ -120,7 +125,7 @@ $ devenv cglm.sln /Build Release
 ## How to use
 If you want to use inline versions of funcstions then; include main header
 ```C
-#include <cglm.h>
+#include <cglm/cglm.h>
 ```
 the haeder will include all headers. Then call func you want e.g. rotate vector by axis:
 ```C
@@ -139,7 +144,7 @@ like this function you may see `_to` postfix, this functions store results to an
 
 to call pre-compiled versions include header with `c` postfix, c means call. Pre-compiled versions are just wrappers.
 ```C
-#include <cglm-call.h>
+#include <cglm/call.h>
 ```
 this header will include all heaers with c postfix. You need to call functions with c posfix:
 ```C
@@ -153,9 +158,9 @@ Function usage and parameters are documented inside related headers.
 - If headers are not working properly with your compiler, IDE please open an issue, because I'm using GCC and clang to test it maybe sometimes MSVC
 
 **TODO:**
-- [ ] Unit tests
+- [ ] Unit tests (In Progress)
 - [ ] Unit tests for comparing cglm with glm results
 - [x] Add version info
 - [ ] Unaligned operations (e.g. `glm_umat4_mul`)
 - [ ] Extra documentation
-- [ ] ARM Neon Arch
+- [ ] ARM Neon Arch (In Progress)

autogen.sh

@@ -6,12 +6,15 @@
 # Full license can be found in the LICENSE file
 #
 
-cd `dirname "$0"`
+cd $(dirname "$0")
 
-if [ "`uname`" = "Darwin" ]; then
+if [ "$(uname)" = "Darwin" ]; then
-  libtoolBin=$(which glibtoolize)
+libtoolBin=$(which glibtoolize)
-  libtoolBinDir=$(dirname "${libtoolBin}")
+libtoolBinDir=$(dirname "${libtoolBin}")
-  ln -s $libtoolBin "${libtoolBinDir}/libtoolize"
+
+if [ ! -f "${libtoolBinDir}/libtoolize" ]; then
+ln -s $libtoolBin "${libtoolBinDir}/libtoolize"
+fi
 fi
 
 autoheader

configure.ac

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

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-cam.h

@@ -1,255 +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_vcam_h
-#define cglm_vcam_h
-
-#include "cglm-common.h"
-
-/*!
- * @brief set up perspective peprojection matrix
- *
- * @param[in]  left    viewport.left
- * @param[in]  right   viewport.right
- * @param[in]  bottom  viewport.bottom
- * @param[in]  top     viewport.top
- * @param[in]  nearVal near clipping plane
- * @param[in]  farVal  far clipping plane
- * @param[out] dest    result matrix
- */
-CGLM_INLINE
-void
-glm_frustum(float left,
-            float right,
-            float bottom,
-            float top,
-            float nearVal,
-            float farVal,
-            mat4  dest) {
-  float rl, tb, fn;
-
-  glm__memzero(float, dest, sizeof(mat4));
-
-  rl = 1.0f / (right - left);
-  tb = 1.0f / (top - bottom);
-  fn = 1.0f / (farVal - 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;
-}
-
-/*!
- * @brief set up orthographic projection matrix
- *
- * @param[in]  left    viewport.left
- * @param[in]  right   viewport.right
- * @param[in]  bottom  viewport.bottom
- * @param[in]  top     viewport.top
- * @param[in]  nearVal near clipping plane
- * @param[in]  farVal  far clipping plane
- * @param[out] dest    result matrix
- */
-CGLM_INLINE
-void
-glm_ortho(float left,
-          float right,
-          float bottom,
-          float top,
-          float nearVal,
-          float farVal,
-          mat4  dest) {
-  float rl, tb, fn;
-
-  glm__memzero(float, dest, sizeof(mat4));
-
-  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[3][3] = 1.0f;
-}
-
-/*!
- * @brief set up unit orthographic projection matrix
- *
- * @param[in]  aspect aspect ration ( width / height )
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_ortho_default(float aspect,
-                  mat4  dest) {
-  if (aspect >= 1.0f) {
-    glm_ortho(-1.0f * aspect,
-               1.0f * aspect,
-              -1.0f,
-               1.0f,
-              -100.0f,
-               100.0f,
-               dest);
-	return;
-  }
-
-  glm_ortho(-1.0f,
-             1.0f,
-            -1.0f / aspect,
-             1.0f / aspect,
-            -100.0f,
-             100.0f,
-             dest);
-}
-
-/*!
- * @brief set up orthographic projection matrix with given CUBE size
- *
- * @param[in]  aspect aspect ratio ( width / height )
- * @param[in]  size   cube size
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_ortho_default_s(float aspect,
-                    float size,
-                    mat4  dest) {
-  if (aspect >= 1.0f) {
-    glm_ortho(-size * aspect,
-               size * aspect,
-              -size,
-               size,
-              -size - 100.0f,
-               size + 100.0f,
-               dest);
-	return;
-  }
-
-  glm_ortho(-size,
-             size,
-            -size / aspect,
-             size / aspect,
-            -size - 100.0f,
-             size + 100.0f,
-             dest);
-}
-
-/*!
- * @brief set up perspective projection matrix
- *
- * @param[in]  fovy    field of view angle
- * @param[in]  aspect  aspect ratio ( width / height )
- * @param[in]  nearVal near clipping plane
- * @param[in]  farVal  far clipping planes
- * @param[out] dest    result matrix
- */
-CGLM_INLINE
-void
-glm_perspective(float fovy,
-                float aspect,
-                float nearVal,
-                float farVal,
-                mat4  dest) {
-  float f, fn;
-
-  glm__memzero(float, dest, sizeof(mat4));
-
-  f  = cosf(fovy * 0.5f) / sinf(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;
-}
-
-/*!
- * @brief set up perspective projection matrix with default near/far
- *        and angle values
- *
- * @param[in]  aspect aspect ratio ( width / height )
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_perspective_default(float aspect,
-                        mat4  dest) {
-  glm_perspective((float)CGLM_PI_4,
-                  aspect,
-                  0.01f,
-                  100.0f,
-                  dest);
-}
-
-/*!
- * @brief resize perspective matrix by aspect ratio ( width / height )
- *        this very make easy to resize proj matrix when window, viewport
- *        reized
- *
- * @param[in]      aspect aspect ratio ( width / height )
- * @param[in, out] proj   perspective projection matrix
- */
-CGLM_INLINE
-void
-glm_perspective_resize(float aspect,
-                       mat4  proj) {
-  if (proj[0][0] == 0)
-    return;
-
-  proj[0][0] = proj[1][1] / aspect;
-}
-
-/*!
- * @brief set up view matrix
- *
- * @param[in]  eye    eye vector
- * @param[in]  center center vector
- * @param[in]  up     up vector
- * @param[out] dest   result matrix
- */
-CGLM_INLINE
-void
-glm_lookat(vec3 eye,
-           vec3 center,
-           vec3 up,
-           mat4 dest) {
-  vec3 f, u, s;
-
-  glm_vec_sub(center, eye, f);
-  glm_vec_normalize(f);
-
-  glm_vec_cross(f, up, s);
-  glm_vec_normalize(s);
-
-  glm_vec_cross(s, f, u);
-
-  dest[0][0] = s[0];
-  dest[0][1] = u[0];
-  dest[0][2] =-f[0];
-  dest[1][0] = s[1];
-  dest[1][1] = u[1];
-  dest[1][2] =-f[1];
-  dest[2][0] = s[2];
-  dest[2][1] = u[2];
-  dest[2][2] =-f[2];
-  dest[3][0] =-glm_vec_dot(s, eye);
-  dest[3][1] =-glm_vec_dot(u, eye);
-  dest[3][2] = glm_vec_dot(f, eye);
-  dest[0][3] = dest[1][3] = dest[2][3] = 0.0f;
-  dest[3][3] = 1.0f;
-}
-
-#endif /* cglm_vcam_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 "common.h"
-#include "cglm-mat.h"
+#include "mat4.h"
-#include "cglm-mat3.h"
+
-#include "arch/simd/cglm-affine-mat-sse2.h"
+#ifdef CGLM_SSE_FP
-#include "arch/simd/cglm-affine-mat-avx.h"
+#  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,
+  float a00 = m1[0][0], a01 = m1[0][1], a02 = m1[0][2], a03 = m1[0][3],
-        a10, a11, a12, a13,    b10, b11, b12,
+        a10 = m1[1][0], a11 = m1[1][1], a12 = m1[1][2], a13 = m1[1][3],
-        a20, a21, a22, a23,    b20, b21, b22,
+        a20 = m1[2][0], a21 = m1[2][1], a22 = m1[2][2], a23 = m1[2][3],
-        a30, a31, a32, a33,    b30, b31, b32, b33;
+        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],
+        b00 = m2[0][0], b01 = m2[0][1], b02 = m2[0][2],
-  a10 = m1[1][0], a11 = m1[1][1], a12 = m1[1][2], a13 = m1[1][3],
+        b10 = m2[1][0], b11 = m2[1][1], b12 = m2[1][2],
-  a20 = m1[2][0], a21 = m1[2][1], a22 = m1[2][2], a23 = m1[2][3],
+        b20 = m2[2][0], b21 = m2[2][1], b22 = m2[2][2],
-  a30 = m1[3][0], a31 = m1[3][1], a32 = m1[3][2], a33 = m1[3][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],
-  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 "common.h"
-#include "cglm-vec.h"
+#include "vec4.h"
-#include "cglm-affine-mat.h"
+#include "affine-mat.h"
-#include "cglm-util.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_flipsign(r[0]);
-    glm_vec4_scale(r[1], -1.0f, r[1]);
+    glm_vec4_flipsign(r[1]);
-    glm_vec4_scale(r[2], -1.0f, r[2]);
+    glm_vec4_flipsign(r[2]);
-
+    glm_vec_flipsign(s);
-    glm_vec_scale(s, -1.0f, 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/vec3.h"
-#include "call/cglmc-mat.h"
+#include "call/vec4.h"
-#include "call/cglmc-mat3.h"
+#include "call/mat4.h"
-#include "call/cglmc-affine.h"
+#include "call/mat3.h"
-#include "call/cglmc-cam.h"
+#include "call/affine.h"
-#include "call/cglmc-quat.h"
+#include "call/cam.h"
-#include "call/cglmc-euler.h"
+#include "call/quat.h"
-#include "call/cglmc-io.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
+#ifndef cglmc_euler_h
-#define glmc_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

@@ -13,10 +13,17 @@ extern "C" {
 
 #include "../cglm.h"
 
+/* DEPRECATED! use _copy, _ucopy versions */
+#define glmc_mat3_dup(mat, dest)  glmc_mat3_copy(mat, dest)
+
 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

@@ -13,6 +13,10 @@ extern "C" {
 
 #include "../cglm.h"
 
+/* DEPRECATED! use _copy, _ucopy versions */
+#define glmc_mat4_udup(mat, dest) glmc_mat4_ucopy(mat, dest)
+#define glmc_mat4_dup(mat, dest)  glmc_mat4_copy(mat, dest)
+
 CGLM_EXPORT
 void
 glmc_mat4_ucopy(mat4 mat, mat4 dest);
@@ -21,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,34 +5,25 @@
  * Full license can be found in the LICENSE file
  */
 
-#ifndef cglm_vec_h
+#ifndef cglmc_vec3_h
-#define cglm_vec_h
+#define cglmc_vec3_h
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 #include "../cglm.h"
 
+/* DEPRECATED! use _copy, _ucopy versions */
+#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);
@@ -41,69 +32,49 @@ 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);
+glmc_vec_inv(vec3 v);
 
 CGLM_EXPORT
 void
-glmc_vec4_scale(vec4 v, float s, vec4 dest);
+glmc_vec_inv_to(vec3 v, vec3 dest);
-
+  
 CGLM_EXPORT
 float
-glmc_vec_angle(vec3 v1, vec3 v2)
+glmc_vec_angle(vec3 v1, vec3 v2);
 
 CGLM_EXPORT
 void
@@ -117,7 +88,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);
 
@@ -125,11 +96,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,84 @@
+/*
+ * 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
+void
+glmc_vec4_inv(vec4 v);
+
+CGLM_EXPORT
+void
+glmc_vec4_inv_to(vec4 v, vec4 dest);
+
+CGLM_EXPORT
+float
+glmc_vec4_distance(vec4 v1, vec4 v2);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_vec4_h */
+

include/cglm/cam.h

@@ -0,0 +1,425 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * 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);
+   CGLM_INLINE void glm_persp_decomp(mat4 proj,
+                                     float * __restrict near,
+                                     float * __restrict far,
+                                     float * __restrict top,
+                                     float * __restrict bottom,
+                                     float * __restrict left,
+                                     float * __restrict right);
+   CGLM_INLINE void glm_persp_decompv(mat4  proj, float dest[6]);
+   CGLM_INLINE void glm_persp_decomp_x(mat4 proj,
+                                       float * __restrict left,
+                                       float * __restrict right);
+   CGLM_INLINE void glm_persp_decomp_y(mat4 proj,
+                                       float * __restrict top,
+                                       float * __restrict bottom);
+   CGLM_INLINE void glm_persp_decomp_z(mat4 proj,
+                                       float * __restrict near,
+                                       float * __restrict far);
+   CGLM_INLINE void glm_persp_decomp_far(mat4 proj, float * __restrict far);
+   CGLM_INLINE void glm_persp_decomp_near(mat4 proj, float * __restrict near);
+ */
+
+#ifndef cglm_vcam_h
+#define cglm_vcam_h
+
+#include "common.h"
+
+/*!
+ * @brief set up perspective peprojection matrix
+ *
+ * @param[in]  left    viewport.left
+ * @param[in]  right   viewport.right
+ * @param[in]  bottom  viewport.bottom
+ * @param[in]  top     viewport.top
+ * @param[in]  nearVal near clipping plane
+ * @param[in]  farVal  far clipping plane
+ * @param[out] dest    result matrix
+ */
+CGLM_INLINE
+void
+glm_frustum(float left,
+            float right,
+            float bottom,
+            float top,
+            float nearVal,
+            float farVal,
+            mat4  dest) {
+  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);
+  nv = 2.0f * nearVal;
+
+  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;
+}
+
+/*!
+ * @brief set up orthographic projection matrix
+ *
+ * @param[in]  left    viewport.left
+ * @param[in]  right   viewport.right
+ * @param[in]  bottom  viewport.bottom
+ * @param[in]  top     viewport.top
+ * @param[in]  nearVal near clipping plane
+ * @param[in]  farVal  far clipping plane
+ * @param[out] dest    result matrix
+ */
+CGLM_INLINE
+void
+glm_ortho(float left,
+          float right,
+          float bottom,
+          float top,
+          float nearVal,
+          float farVal,
+          mat4  dest) {
+  float rl, tb, fn;
+
+  glm__memzero(float, dest, sizeof(mat4));
+
+  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[3][3] = 1.0f;
+}
+
+/*!
+ * @brief set up unit orthographic projection matrix
+ *
+ * @param[in]  aspect aspect ration ( width / height )
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_ortho_default(float aspect,
+                  mat4  dest) {
+  if (aspect >= 1.0f) {
+    glm_ortho(-1.0f * aspect,
+               1.0f * aspect,
+              -1.0f,
+               1.0f,
+              -100.0f,
+               100.0f,
+               dest);
+	  return;
+  }
+
+  glm_ortho(-1.0f,
+             1.0f,
+            -1.0f / aspect,
+             1.0f / aspect,
+            -100.0f,
+             100.0f,
+             dest);
+}
+
+/*!
+ * @brief set up orthographic projection matrix with given CUBE size
+ *
+ * @param[in]  aspect aspect ratio ( width / height )
+ * @param[in]  size   cube size
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_ortho_default_s(float aspect,
+                    float size,
+                    mat4  dest) {
+  if (aspect >= 1.0f) {
+    glm_ortho(-size * aspect,
+               size * aspect,
+              -size,
+               size,
+              -size - 100.0f,
+               size + 100.0f,
+               dest);
+	  return;
+  }
+
+  glm_ortho(-size,
+             size,
+            -size / aspect,
+             size / aspect,
+            -size - 100.0f,
+             size + 100.0f,
+             dest);
+}
+
+/*!
+ * @brief set up perspective projection matrix
+ *
+ * @param[in]  fovy    field of view angle
+ * @param[in]  aspect  aspect ratio ( width / height )
+ * @param[in]  nearVal near clipping plane
+ * @param[in]  farVal  far clipping planes
+ * @param[out] dest    result matrix
+ */
+CGLM_INLINE
+void
+glm_perspective(float fovy,
+                float aspect,
+                float nearVal,
+                float farVal,
+                mat4  dest) {
+  float f, fn;
+
+  glm__memzero(float, dest, sizeof(mat4));
+
+  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.0f * nearVal * farVal * fn;
+}
+
+/*!
+ * @brief set up perspective projection matrix with default near/far
+ *        and angle values
+ *
+ * @param[in]  aspect aspect ratio ( width / height )
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_perspective_default(float aspect,
+                        mat4  dest) {
+  glm_perspective((float)CGLM_PI_4,
+                  aspect,
+                  0.01f,
+                  100.0f,
+                  dest);
+}
+
+/*!
+ * @brief resize perspective matrix by aspect ratio ( width / height )
+ *        this very make easy to resize proj matrix when window, viewport
+ *        reized
+ *
+ * @param[in]      aspect aspect ratio ( width / height )
+ * @param[in, out] proj   perspective projection matrix
+ */
+CGLM_INLINE
+void
+glm_perspective_resize(float aspect,
+                       mat4  proj) {
+  if (proj[0][0] == 0.0f)
+    return;
+
+  proj[0][0] = proj[1][1] / aspect;
+}
+
+/*!
+ * @brief set up view matrix
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  center center vector
+ * @param[in]  up     up vector
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_lookat(vec3 eye,
+           vec3 center,
+           vec3 up,
+           mat4 dest) {
+  vec3 f, u, s;
+
+  glm_vec_sub(center, eye, f);
+  glm_vec_normalize(f);
+
+  glm_vec_cross(f, up, s);
+  glm_vec_normalize(s);
+
+  glm_vec_cross(s, f, u);
+
+  dest[0][0] = s[0];
+  dest[0][1] = u[0];
+  dest[0][2] =-f[0];
+  dest[1][0] = s[1];
+  dest[1][1] = u[1];
+  dest[1][2] =-f[1];
+  dest[2][0] = s[2];
+  dest[2][1] = u[2];
+  dest[2][2] =-f[2];
+  dest[3][0] =-glm_vec_dot(s, eye);
+  dest[3][1] =-glm_vec_dot(u, eye);
+  dest[3][2] = glm_vec_dot(f, eye);
+  dest[0][3] = dest[1][3] = dest[2][3] = 0.0f;
+  dest[3][3] = 1.0f;
+}
+
+/*!
+ * @brief decomposes frustum values of perspective projection.
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] near   near
+ * @param[out] far    far
+ * @param[out] top    top
+ * @param[out] bottom bottom
+ * @param[out] left   left
+ * @param[out] right  right
+ */
+CGLM_INLINE
+void
+glm_persp_decomp(mat4 proj,
+                 float * __restrict near,
+                 float * __restrict far,
+                 float * __restrict top,
+                 float * __restrict bottom,
+                 float * __restrict left,
+                 float * __restrict right) {
+  *near   = proj[3][2] / (proj[2][2] - 1);
+  *far    = proj[3][2] / (proj[2][2] + 1);
+  *bottom = *near * (proj[2][1] - 1) / proj[1][1];
+  *top    = *near * (proj[2][1] + 1) / proj[1][1];
+  *left   = *near * (proj[2][0] - 1) / proj[0][0];
+  *right  = *near * (proj[2][0] + 1) / proj[0][0];
+}
+
+/*!
+ * @brief decomposes frustum values of perspective projection.
+ *        this makes easy to get all values at once
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] dest   array
+ */
+CGLM_INLINE
+void
+glm_persp_decompv(mat4  proj, float dest[6]) {
+  glm_persp_decomp(proj, &dest[0], &dest[1], &dest[2],
+                         &dest[3], &dest[4], &dest[5]);
+}
+
+/*!
+ * @brief decomposes left and right values of perspective projection.
+ *        x stands for x axis (left / right axis)
+ *
+ * @param[in]  proj perspective projection matrix
+ * @param[out] left  left
+ * @param[out] right right
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_x(mat4 proj,
+                   float * __restrict left,
+                   float * __restrict right) {
+  float near;
+
+  near    = proj[3][2] / (proj[3][3] - 1);
+  *left   = near * (proj[2][0] - 1) / proj[0][0];
+  *right  = near * (proj[2][0] + 1) / proj[0][0];
+}
+
+/*!
+ * @brief decomposes top and bottom values of perspective projection.
+ *        y stands for y axis (top / botom axis)
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] top    top
+ * @param[out] bottom bottom
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_y(mat4 proj,
+                   float * __restrict top,
+                   float * __restrict bottom) {
+  float near;
+
+  near    = proj[3][2] / (proj[3][3] - 1);
+  *bottom = near * (proj[2][1] - 1) / proj[1][1];
+  *top    = near * (proj[2][1] + 1) / proj[1][1];
+}
+
+/*!
+ * @brief decomposes near and far values of perspective projection.
+ *        z stands for z axis (near / far axis)
+ *
+ * @param[in]  proj perspective projection matrix
+ * @param[out] near near
+ * @param[out] far  far
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_z(mat4 proj,
+                   float * __restrict near,
+                   float * __restrict far) {
+  *near = proj[3][2] / (proj[2][2] - 1);
+  *far  = proj[3][2] / (proj[2][2] + 1);
+}
+
+/*!
+ * @brief decomposes far value of perspective projection.
+ *
+ * @param[in]  proj perspective projection matrix
+ * @param[out] far  far
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_far(mat4 proj, float * __restrict far) {
+  *far = proj[3][2] / (proj[2][2] + 1);
+}
+
+/*!
+ * @brief decomposes near value of perspective projection.
+ *
+ * @param[in]  proj perspective projection matrix
+ * @param[out] near near
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_near(mat4 proj, float * __restrict near) {
+  *near = proj[3][2] / (proj[2][2] - 1);
+}
+#endif /* cglm_vcam_h */

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[in]  m    affine transform
- * @param[out] v angles vector [x, y, z]
+ * @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 "common.h"
-#include "arch/simd/cglm-mat3-simd-sse2.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},                          \
@@ -23,6 +48,9 @@
 #define GLM_MAT3_IDENTITY (mat3)GLM_MAT3_IDENTITY_INIT
 #define GLM_MAT3_ZERO     (mat3)GLM_MAT3_ZERO_INIT
 
+/* DEPRECATED! use _copy, _ucopy versions */
+#define glm_mat3_dup(mat, dest) glm_mat3_copy(mat, dest)
+
 /*!
  * @brief copy all members of [mat] to [dest]
  *
@@ -35,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
  *
@@ -55,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,
+  float a00 = m1[0][0], a01 = m1[0][1], a02 = m1[0][2],
-        a10, a11, a12,    b10, b11, b12,
+        a10 = m1[1][0], a11 = m1[1][1], a12 = m1[1][2],
-        a20, a21, a22,    b20, b21, b22;
+        a20 = m1[2][0], a21 = m1[2][1], a22 = m1[2][2],
 
-  a00 = m1[0][0], a01 = m1[0][1], a02 = m1[0][2],
+        b00 = m2[0][0], b01 = m2[0][1], b02 = m2[0][2],
-  a10 = m1[1][0], a11 = m1[1][1], a12 = m1[1][2],
+        b10 = m2[1][0], b11 = m2[1][1], b12 = m2[1][2],
-  a20 = m1[2][0], a21 = m1[2][1], a22 = m1[2][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;
@@ -84,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[in]  m     matrix
- * @param dest[out] result
+ * @param[out] dest  result
  */
 CGLM_INLINE
 void
@@ -167,13 +212,9 @@ glm_mat3_scale(mat3 m, float s) {
 CGLM_INLINE
 float
 glm_mat3_det(mat3 mat) {
-  float a, b, c,
+  float a = mat[0][0], b = mat[0][1], c = mat[0][2],
-        d, e, f,
+        d = mat[1][0], e = mat[1][1], f = mat[1][2],
-        g, h, i;
+        g = mat[2][0], h = mat[2][1], i = mat[2][2];
-
-  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);
 }
@@ -188,13 +229,9 @@ CGLM_INLINE
 void
 glm_mat3_inv(mat3 mat, mat3 dest) {
   float det;
-  float a, b, c,
+  float a = mat[0][0], b = mat[0][1], c = mat[0][2],
-        d, e, f,
+        d = mat[1][0], e = mat[1][1], f = mat[1][2],
-        g, h, i;
+        g = mat[2][0], h = mat[2][1], i = mat[2][2];
-
-  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);
@@ -231,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]     row1 row1
- * @param[in]     col2 col2
+ * @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_fast(mat4 mat, mat4 dest);
+   CGLM_INLINE void  glm_mat4_swap_col(mat4 mat, int col1, int col2);
+   CGLM_INLINE void  glm_mat4_swap_row(mat4 mat, int row1, int row2);
+ */
+
 #ifndef cglm_mat_h
 #define cglm_mat_h
 
-#include "cglm-common.h"
+#include "common.h"
-#include "arch/simd/cglm-mat-simd-sse2.h"
+
-#include "arch/simd/cglm-mat-simd-avx.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>
 
@@ -33,6 +74,13 @@
 #define GLM_MAT4_IDENTITY (mat4)GLM_MAT4_IDENTITY_INIT
 #define GLM_MAT4_ZERO     (mat4)GLM_MAT4_ZERO_INIT
 
+/* DEPRECATED! use _copy, _ucopy versions */
+#define glm_mat4_udup(mat, dest) glm_mat4_ucopy(mat, dest)
+#define glm_mat4_dup(mat, dest)  glm_mat4_copy(mat, dest)
+
+/* DEPRECATED! default is precise now. */
+#define glm_mat4_inv_precise(mat, dest) glm_mat4_inv(mat, dest)
+
 /*!
  * @brief copy all members of [mat] to [dest]
  *
@@ -70,6 +118,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
  *
@@ -159,21 +228,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,
+  float a00 = m1[0][0], a01 = m1[0][1], a02 = m1[0][2], a03 = m1[0][3],
-        a10, a11, a12, a13,    b10, b11, b12, b13,
+        a10 = m1[1][0], a11 = m1[1][1], a12 = m1[1][2], a13 = m1[1][3],
-        a20, a21, a22, a23,    b20, b21, b22, b23,
+        a20 = m1[2][0], a21 = m1[2][1], a22 = m1[2][2], a23 = m1[2][3],
-        a30, a31, a32, a33,    b30, b31, b32, b33;
+        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],
+        b00 = m2[0][0], b01 = m2[0][1], b02 = m2[0][2], b03 = m2[0][3],
-  a10 = m1[1][0], a11 = m1[1][1], a12 = m1[1][2], a13 = m1[1][3],
+        b10 = m2[1][0], b11 = m2[1][1], b12 = m2[1][2], b13 = m2[1][3],
-  a20 = m1[2][0], a21 = m1[2][1], a22 = m1[2][2], a23 = m1[2][3],
+        b20 = m2[2][0], b21 = m2[2][1], b22 = m2[2][2], b23 = m2[2][3],
-  a30 = m1[3][0], a31 = m1[3][1], a32 = m1[3][2], a33 = m1[3][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;
@@ -274,8 +340,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[in]  m    matrix
- * @param dest[out] result
+ * @param[out] dest result
  */
 CGLM_INLINE
 void
@@ -363,15 +429,10 @@ glm_mat4_det(mat4 mat) {
 #else
   /* [square] det(A) = det(At) */
   float t[6];
-  float a, b, c, d,
+  float a = mat[0][0], b = mat[0][1], c = mat[0][2], d = mat[0][3],
-        e, f, g, h,
+        e = mat[1][0], f = mat[1][1], g = mat[1][2], h = mat[1][3],
-        i, j, k, l,
+        i = mat[2][0], j = mat[2][1], k = mat[2][2], l = mat[2][3],
-        m, n, o, p;
+        m = mat[3][0], n = mat[3][1], o = mat[3][2], p = mat[3][3];
-
-  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;
@@ -390,10 +451,6 @@ glm_mat4_det(mat4 mat) {
 /*!
  * @brief inverse mat4 and store in dest
  *
- * this func uses reciprocal approximation without extra corrections 
- * e.g Newton-Raphson. this should work faster than _precise, 
- * to get precise value use _precise version
- *
  * @param[in]  mat  matrix
  * @param[out] dest inverse matrix
  */
@@ -405,15 +462,10 @@ glm_mat4_inv(mat4 mat, mat4 dest) {
 #else
   float t[6];
   float det;
-  float a, b, c, d,
+  float a = mat[0][0], b = mat[0][1], c = mat[0][2], d = mat[0][3],
-        e, f, g, h,
+        e = mat[1][0], f = mat[1][1], g = mat[1][2], h = mat[1][3],
-        i, j, k, l,
+        i = mat[2][0], j = mat[2][1], k = mat[2][2], l = mat[2][3],
-        m, n, o, p;
+        m = mat[3][0], n = mat[3][1], o = mat[3][2], p = mat[3][3];
-
-  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;
@@ -451,24 +503,25 @@ glm_mat4_inv(mat4 mat, mat4 dest) {
 #endif
 }
 
-
 /*!
- * @brief inverse mat4 precisely and store in dest
+ * @brief inverse mat4 and store in dest
  *
- * this do same thing as glm_mat4_inv did. the only diff is this func uses
+ * this func uses reciprocal approximation without extra corrections
- * division instead of reciprocal approximation. Due to division this might
+ * e.g Newton-Raphson. this should work faster than normal,
- * work slower than glm_mat4_inv
+ * to get more precise use glm_mat4_inv version.
+ *
+ * NOTE: You will lose precision, glm_mat4_inv is more accurate
  *
  * @param[in]  mat  matrix
  * @param[out] dest inverse matrix
  */
 CGLM_INLINE
 void
-glm_mat4_inv_precise(mat4 mat, mat4 dest) {
+glm_mat4_inv_fast(mat4 mat, mat4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
-  glm_mat4_inv_precise_sse2(mat, dest);
+  glm_mat4_inv_fast_sse2(mat, dest);
 #else
-  glm_mat4_inv_precise(mat, dest);
+  glm_mat4_inv(mat, dest);
 #endif
 }
 
@@ -492,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]     row1 row1
- * @param[in]     col2 col2
+ * @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 "common.h"
-#include "cglm-vec.h"
+#include "vec4.h"
-#include "arch/simd/cglm-intrin.h"
+
-#include "arch/simd/cglm-quat-simd.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 "../../common.h"
-#include "cglm-intrin.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 "../../common.h"
-#include "cglm-intrin.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 "../../common.h"
-#include "cglm-intrin.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 "../../common.h"
-#include "cglm-intrin.h"
+#include "../intrin.h"
 
 CGLM_INLINE
 void

include/cglm/simd/sse2/mat4.h

@@ -9,8 +9,10 @@
 #define cglm_mat_sse_h
 #if defined( __SSE__ ) || defined( __SSE2__ )
 
-#include "../../cglm-common.h"
+#include "../../common.h"
-#include "cglm-intrin.h"
+#include "../intrin.h"
+
+#define glm_mat4_inv_precise_sse2(mat, dest) glm_mat4_inv_sse2(mat, dest)
 
 CGLM_INLINE
 void
@@ -157,7 +159,7 @@ glm_mat4_det_sse2(mat4 mat) {
 
 CGLM_INLINE
 void
-glm_mat4_inv_sse2(mat4 mat, mat4 dest) {
+glm_mat4_inv_fast_sse2(mat4 mat, mat4 dest) {
   __m128 r0, r1, r2, r3,
          v0, v1, v2, v3,
          t0, t1, t2, t3, t4, t5,
@@ -281,7 +283,7 @@ glm_mat4_inv_sse2(mat4 mat, mat4 dest) {
 
 CGLM_INLINE
 void
-glm_mat4_inv_precise_sse2(mat4 mat, mat4 dest) {
+glm_mat4_inv_sse2(mat4 mat, mat4 dest) {
   __m128 r0, r1, r2, r3,
          v0, v1, v2, v3,
          t0, t1, t2, t3, t4, t5,

include/cglm/simd/sse2/quat.h

@@ -7,9 +7,10 @@
 
 #ifndef cglm_quat_simd_h
 #define cglm_quat_simd_h
+#if defined( __SSE__ ) || defined( __SSE2__ )
 
-#include "../../cglm-common.h"
+#include "../../common.h"
-#include "cglm-intrin.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/types.h

@@ -8,7 +8,7 @@
 #ifndef cglm_types_h
 #define cglm_types_h
 
-#if defined(_WIN32)
+#if defined(_MSC_VER)
 #  define CGLM_ALIGN(X) /* __declspec(align(X)) */
 #else
 #  define CGLM_ALIGN(X) __attribute((aligned(X)))

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,13 +10,54 @@
  * all functions without suffix are vec3 functions
  */
 
-#ifndef cglm_vec_h
+/*
-#define cglm_vec_h
+ Macros:
+   glm_vec_dup(v, dest)
+   GLM_VEC3_ONE_INIT
+   GLM_VEC3_ONE
+   GLM_YUP
+   GLM_ZUP
+   GLM_XUP
 
-#include "cglm-common.h"
+ Functions:
-#include "cglm-vec-ext.h"
+   CGLM_INLINE void  glm_vec_copy(vec3 a, vec3 dest);
-#include "arch/simd/cglm-intrin.h"
+   CGLM_INLINE float glm_vec_dot(vec3 a, vec3 b);
-#include "cglm-util.h"
+   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_inv(vec3 v);
+   CGLM_INLINE void  glm_vec_inv_to(vec3 v, vec3 dest);
+   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_VEC3_ONE_INIT  {1.0f, 1.0f, 1.0f}
+#define GLM_VEC3_ONE  (vec3)GLM_VEC3_ONE_INIT
+
+#define GLM_YUP  (vec3){0.0f, 1.0f, 0.0f}
+#define GLM_ZUP  (vec3){0.0f, 0.0f, 1.0f}
+#define GLM_XUP  (vec3){1.0f, 0.0f, 0.0f}
 
 /*!
  * @brief copy all members of [a] to [dest]
@@ -32,44 +73,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] a vector1
- * @param[in] b
+ * @param[in] b vector2
  *
  * @return dot product
  */
@@ -79,20 +87,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
  *
@@ -116,7 +110,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
  */
@@ -129,7 +123,7 @@ glm_vec_norm2(vec3 v) {
 /*!
  * @brief norm (magnitude) of vec3
  *
- * @param[in] vec
+ * @param[in] vec vector
  *
  * @return norm
  */
@@ -139,41 +133,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]  v1 vector1
- * @param[in]  v2
+ * @param[in]  v2 vector2
  * @param[out] dest destination vector
  */
 CGLM_INLINE
@@ -184,33 +148,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]  v1 vector1
- * @param[in]  v2
+ * @param[in]  v2 vector2
  * @param[out] dest destination vector
  */
 CGLM_INLINE
@@ -222,29 +164,7 @@ glm_vec_sub(vec3 v1, vec3 v2, vec3 dest) {
 }
 
 /*!
- * @brief subtract v2 vector from v1 vector store result in dest
+ * @brief multiply/scale vec3 vector with scalar: result = v * s
- *
- * @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
  *
  * @param[in]  v    vector
  * @param[in]  s    scalar
@@ -259,7 +179,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
@@ -267,6 +187,25 @@ 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];
@@ -274,46 +213,27 @@ glm_vec_flipsign(vec3 v) {
 }
 
 /*!
- * @brief flip sign of all vec4 members
+ * @brief make vector as inverse/opposite of itself
  *
- * @param[in]  v    vector
+ * @param[in, out]  v  vector
- * @param[in]  s    scalar
- * @param[out] dest destination vector
  */
 CGLM_INLINE
 void
-glm_vec4_flipsign(vec4 v) {
+glm_vec_inv(vec3 v) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+  glm_vec_flipsign(v);
-  _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
+ * @brief inverse/opposite vector
  *
- * @param[in]  v    vector
+ * @param[in]  v    source
- * @param[in]  s    scalar
+ * @param[out] dest destination
- * @param[out] dest destination vector
  */
 CGLM_INLINE
 void
-glm_vec4_scale(vec4 v, float s, vec4 dest) {
+glm_vec_inv_to(vec3 v, vec3 dest) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+  glm_vec_copy(v, dest);
-  _mm_store_ps(dest,
+  glm_vec_flipsign(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
 }
 
 /*!
@@ -336,26 +256,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
  *
@@ -377,27 +277,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
  *
@@ -482,8 +361,8 @@ glm_vec_rotate_m4(mat4 m, vec3 v, vec3 dest) {
 /*!
  * @brief project a vector onto b vector
  *
- * @param[in]  a
+ * @param[in]  a vector1
- * @param[in]  b
+ * @param[in]  b vector2
  * @param[out] dest projected vector
  */
 CGLM_INLINE
@@ -497,8 +376,8 @@ glm_vec_proj(vec3 a, vec3 b, vec3 dest) {
 /**
  * @brief find center point of two vector
  *
- * @param[in]  v1
+ * @param[in]  v1 vector1
- * @param[in]  v2
+ * @param[in]  v2 vector2
  * @param[out] dest center point
  */
 CGLM_INLINE
@@ -511,8 +390,8 @@ glm_vec_center(vec3 v1, vec3 v2, vec3 dest) {
 /**
  * @brief distance between two vectors
  *
- * @param[in] v1
+ * @param[in] v1 vector1
- * @param[in] v2
+ * @param[in] v2 vector2
  * @return returns distance
  */
 CGLM_INLINE
@@ -523,20 +402,4 @@ glm_vec_distance(vec3 v1, vec3 v2) {
                + glm_pow2(v2[2] - v1[2]));
 }
 
-/**
+#endif /* cglm_vec3_h */
- * @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 */

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,321 @@
+/*
+ * 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)
+   GLM_VEC4_ONE_INIT
+   GLM_VEC4_BLACK_INIT
+   GLM_VEC4_ONE
+   GLM_VEC4_BLACK
+ 
+ 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_inv(vec4 v);
+   CGLM_INLINE void  glm_vec4_inv_to(vec4 v, vec4 dest);
+   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)
+
+#define GLM_VEC4_ONE_INIT   {1.0f, 1.0f, 1.0f, 1.0f}
+#define GLM_VEC4_BLACK_INIT {0.0f, 0.0f, 0.0f, 1.0f}
+
+#define GLM_VEC4_ONE        (vec4)GLM_VEC4_ONE_INIT
+#define GLM_VEC4_BLACK      (vec4)GLM_VEC4_BLACK_INIT
+
+/*!
+ * @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 make vector as inverse/opposite of itself
+ *
+ * @param[in, out]  v  vector
+ */
+CGLM_INLINE
+void
+glm_vec4_inv(vec4 v) {
+  glm_vec4_flipsign(v);
+}
+
+/*!
+ * @brief inverse/opposite vector
+ *
+ * @param[in]  v    source
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_vec4_inv_to(vec4 v, vec4 dest) {
+  glm_vec4_copy(v, dest);
+  glm_vec4_flipsign(dest);
+}
+
+/*!
+ * @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 */

include/cglm/version.h

@@ -9,7 +9,7 @@
 #define cglm_version_h
 
 #define CGLM_VERSION_MAJOR 0
-#define CGLM_VERSION_MINOR 2
+#define CGLM_VERSION_MINOR 3
-#define CGLM_VERSION_PATCH 0
+#define CGLM_VERSION_PATCH 1
 
 #endif /* cglm_version_h */

makefile.am

@@ -26,54 +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_tests_LDFLAGS = $(checkLDFLAGS)
-test_test_mat4_CFLAGS  = $(checkCFLAGS)
+test_tests_CFLAGS  = $(checkCFLAGS)
 
-nobase_include_HEADERS = include/cglm-version.h \
+cglmdir=$(includedir)/cglm
-                         include/cglm.h \
+cglm_HEADERS = include/cglm/version.h \
-                         include/cglm-call.h \
+                  include/cglm/cglm.h \
-                         include/cglm-cam.h \
+                  include/cglm/call.h \
-                         include/cglm-io.h \
+                  include/cglm/cam.h \
-                         include/cglm-mat3.h \
+                  include/cglm/io.h \
-                         include/cglm-types.h \
+                  include/cglm/mat4.h \
-                         include/cglm-common.h \
+                  include/cglm/mat3.h \
-                         include/cglm-affine.h \
+                  include/cglm/types.h \
-                         include/cglm-vec.h \
+                  include/cglm/common.h \
-                         include/cglm-euler.h \
+                  include/cglm/affine.h \
-                         include/cglm-util.h \
+                  include/cglm/vec3.h \
-                         include/cglm-quat.h \
+                  include/cglm/vec3-ext.h \
-                         include/cglm-mat.h \
+                  include/cglm/vec4.h \
-                         include/cglm-affine-mat.h \
+                  include/cglm/vec4-ext.h \
-                         include/arch/simd/cglm-mat-simd-avx.h \
+                  include/cglm/euler.h \
-                         include/arch/simd/cglm-affine-mat-avx.h \
+                  include/cglm/util.h \
-                         include/arch/simd/cglm-quat-simd.h \
+                  include/cglm/quat.h \
-                         include/arch/simd/cglm-affine-mat-sse2.h \
+                  include/cglm/affine-mat.h
-                         include/arch/simd/cglm-mat3-simd-sse2.h \
+
-                         include/arch/simd/cglm-mat-simd-sse2.h \
+cglm_calldir=$(includedir)/cglm/call
-                         include/arch/simd/cglm-intrin.h \
+cglm_call_HEADERS = include/cglm/call/mat4.h \
-                         include/call/cglmc-euler.h \
+                    include/cglm/call/mat3.h \
-                         include/call/cglmc-quat.h \
+                    include/cglm/call/vec3.h \
-                         include/call/cglmc-cam.h \
+                    include/cglm/call/vec4.h \
-                         include/call/cglmc-io.h \
+                    include/cglm/call/affine.h \
-                         include/call/cglmc-affine.h \
+                    include/cglm/call/io.h \
-                         include/call/cglmc-vec.h \
+                    include/cglm/call/cam.h \
-                         include/call/cglmc-mat3.h \
+                    include/cglm/call/quat.h \
-                         include/call/cglmc-mat.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/euler.c \
-    src/clgm-affine.c \
+    src/affine.c \
-    src/cglm-io.c \
+    src/io.c \
-    src/cglm-quat.c \
+    src/quat.c \
-    src/cglm-cam.c \
+    src/cam.c \
-    src/cglm-vec.c \
+    src/vec3.c \
-    src/cglm-mat3.c \
+    src/vec4.c \
-    src/cglm-mat.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,78 +32,48 @@ 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) {
@@ -129,14 +82,14 @@ glmc_vec_flipsign(vec3 v) {
 
 CGLM_EXPORT
 void
-glmc_vec4_flipsign(vec4 v) {
+glmc_vec_inv(vec3 v) {
-  glm_vec4_flipsign(v);
+  glm_vec_inv(v);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_scale(vec4 v, float s, vec4 dest) {
+glmc_vec_inv_to(vec3 v, vec3 dest) {
-  glm_vec4_scale(v, s, dest);
+  glm_vec_inv_to(v, dest);
 }
 
 CGLM_EXPORT
@@ -174,9 +127,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,99 @@
+/*
+ * 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
+void
+glmc_vec4_inv(vec4 v) {
+  glm_vec4_inv(v);
+}
+
+CGLM_EXPORT
+void
+glmc_vec4_inv_to(vec4 v, vec4 dest) {
+  glm_vec4_inv_to(v, dest);
+}
+
+CGLM_EXPORT
+float
+glmc_vec4_distance(vec4 v1, vec4 v2) {
+  return glm_vec4_distance(v1, v2);
+}

test/src/test_common.c

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ */
+
+#include "test_common.h"
+#include <stdlib.h>
+
+#define m 4
+#define n 4
+
+void
+test_rand_mat4(mat4 dest) {
+  glm_mat4_copy(GLM_MAT4_IDENTITY, dest);
+  
+  srand((unsigned int)time(NULL));
+
+  /* random position */
+  dest[3][0] = drand48();
+  dest[3][1] = drand48();
+  dest[3][2] = drand48();
+  
+  /* random rotatation around random axis with random angle */
+  glm_rotate(dest, drand48(), (vec3){drand48(), drand48(), drand48()});
+  
+  /* random scale */
+  /* glm_scale(dest, (vec3){drand48(), drand48(), drand48()}); */
+}
+
+void
+test_assert_mat4_eq(mat4 m1, mat4 m2) {
+  int i, j, k;
+
+  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]) <= 0.0000009);
+    }
+  }
+}
+
+void
+test_assert_mat4_eq2(mat4 m1, mat4 m2, float eps) {
+  int i, j, k;
+  
+  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]) <= eps);
+    }
+  }
+}

test/src/test_common.h

@@ -14,27 +14,21 @@
 #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/cglm.h>
-#include <cglm-call.h>
+#include <cglm/call.h>
 
-#define precision 0.00001f
-
-static
 void
 test_rand_mat4(mat4 dest);
 
-static
 void
-test_rand_mat4(mat4 dest) {
+test_assert_mat4_eq(mat4 m1, mat4 m2);
-  int i, j;
 
-  srand((unsigned int)time(NULL));
+void
-  for (i = 0; i < 4; i++) {
+test_assert_mat4_eq2(mat4 m1, mat4 m2, float eps);
-    for (j = 0; j < 4; j++) {
-      dest[i][j] = drand48();
-    }
-  }
-}
 
 #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,22 +5,18 @@
  * 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;
   mat4  m4 = GLM_MAT4_ZERO_INIT;
+  mat4  m5;
   int   i, j, k;
 
   /* test identity matrix multiplication */
@@ -48,30 +44,51 @@ test_mat4_mul(void **state) {
     }
   }
 
-  for (i = 0; i < m; i++) {
+  test_assert_mat4_eq(m3, m4);
-    for (j = 0; j < n; j++) {
-      for (k = 0; k < m; k++)
-        assert_true(fabsf(m3[i][j] - m4[i][j]) <= FLT_EPSILON);
-    }
-  }
 
   /* test pre compiled */
   glmc_mat4_mul(m1, m2, m3);
-  for (i = 0; i < m; i++) {
+  test_assert_mat4_eq(m3, m4);
-    for (j = 0; j < n; j++) {
+
-      for (k = 0; k < m; k++)
+  for (i = 0; i < 100000; i++) {
-        assert_true(fabsf(m3[i][j] - m4[i][j]) <= FLT_EPSILON);
+    test_rand_mat4(m3);
-    }
+    test_rand_mat4(m4);
+    
+    /* test inverse precise */
+    glm_mat4_inv_precise(m3, m4);
+    glm_mat4_inv_precise(m4, m5);
+    test_assert_mat4_eq(m3, m5);
+    
+    test_rand_mat4(m3);
+    test_rand_mat4(m4);
+
+    glmc_mat4_inv_precise(m3, m4);
+    glmc_mat4_inv_precise(m4, m5);
+    test_assert_mat4_eq(m3, m5);
+    
+    /* test inverse rcp */
+    test_rand_mat4(m3);
+    test_rand_mat4(m4);
+    
+    glm_mat4_inv_fast(m3, m4);
+    glm_mat4_inv_fast(m4, m5);
+    test_assert_mat4_eq2(m3, m5, 0.0009f);
+    
+    test_rand_mat4(m3);
+    test_rand_mat4(m4);
+    
+    glmc_mat4_inv(m3, m4);
+    glmc_mat4_inv(m4, m5);
+    test_assert_mat4_eq2(m3, m5, 0.0009f);
   }
-}
 
-int
+  /* print */
-main(int argc, const char * argv[]) {
+  glm_mat4_print(m3, stderr);
-  const struct CMUnitTest tests[] = {
+  glm_mat4_print(m4, stderr);
-    cmocka_unit_test(test_mat4_mul)
-  };
 
-  return cmocka_run_group_tests(tests,
+  /* test determinant */
-                                NULL,
+  assert_int_equal(glm_mat4_det(m1), glmc_mat4_det(m1));
-                                NULL);
+#if defined( __SSE2__ )
+  assert_int_equal(glmc_mat4_det(m1), glm_mat4_det_sse2(m1));
+#endif
 }

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,50 +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.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,138 +16,165 @@
     <Filter Include="include">
       <UniqueIdentifier>{f46634e5-c098-41a0-afb3-45afb6a53593}</UniqueIdentifier>
     </Filter>
-    <Filter Include="include\call">
+    <Filter Include="include\cglm">
-      <UniqueIdentifier>{496b3b53-1258-4efa-87b2-4280ea82f87e}</UniqueIdentifier>
+      <UniqueIdentifier>{b982cbd3-03d9-4557-bed8-8224e4d95945}</UniqueIdentifier>
     </Filter>
-    <Filter Include="include\arch">
+    <Filter Include="include\cglm\call">
-      <UniqueIdentifier>{28919415-29bd-4edd-8ab1-1ec9a16e46f0}</UniqueIdentifier>
+      <UniqueIdentifier>{6a2a4ebb-ac68-4ed6-a4a1-f6d2243814e9}</UniqueIdentifier>
     </Filter>
-    <Filter Include="include\arch\simd">
+    <Filter Include="include\cglm\simd">
-      <UniqueIdentifier>{792cb1a9-bdc8-4f00-bfde-067750b0ab41}</UniqueIdentifier>
+      <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">
+    <ClCompile Include="..\src\affine.c">
-      <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>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="..\src\cglm-cam.c">
       <Filter>src</Filter>
     </ClCompile>
-    <ClCompile Include="..\src\cglm-euler.c">
+    <ClCompile Include="..\src\cam.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">
       <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>