drop pedantic from C Flags and allow extensions

this will also suppress warnings on test target

.gitattributes

@@ -0,0 +1 @@
+*.h linguist-language=C

.github/workflows/ccpp.yml

@@ -1,24 +0,0 @@
-name: C/C++ CI
-
-on: [push]
-
-jobs:
-  build:
-
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest, macOS-latest]
-    
-    steps:
-    - uses: actions/checkout@v1
-    - name: dependencies
-      run: sh ./build-deps.sh
-    - name: autogen
-      run: sh autogen.sh
-    - name: configure
-      run: ./configure
-    - name: make
-      run: make
-    - name: make check
-      run: make check

.gitignore

@@ -51,7 +51,6 @@ cscope.*
 test/*.trs
 test/test_*
 *.log
-test-*
 test/.libs/*
 test/tests
 cglm_arm/*
@@ -71,3 +70,8 @@ win/x85
 win/Debug
 cglm-test-ios*
 /cglm.pc
+test-driver
+Default-568h@2x.png
+build/
+conftest.dir/*
+confdefs.h

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "test/lib/cmocka"]
-	path = test/lib/cmocka
-	url = git://git.cryptomilk.org/projects/cmocka.git

.travis.yml

@@ -4,6 +4,12 @@ os:
   - linux
   - osx
 
+arch:
+  - amd64
+  - ppc64le
+  - s390x
+  - arm64
+
 sudo: required
 dist: trusty
 
@@ -37,10 +43,9 @@ branches:
     - master
 
 script:
-  - sh ./build-deps.sh
   - sh ./autogen.sh
   - if [[ "$CC" == "gcc" && "$CODE_COVERAGE" == "ON" ]]; then
-      ./configure CFLAGS="-ftest-coverage -fprofile-arcs";
+      ./configure CFLAGS="-ftest-coverage -fprofile-arcs -coverage";
     else
       ./configure;
     fi
@@ -49,14 +54,15 @@ script:
 
 after_success:
   - if [[ "$CC" == "gcc" && "$CODE_COVERAGE" == "ON" ]]; then
-      pip install --user cpp-coveralls && 
+      pip install --user cpp-coveralls &&
       coveralls
         --build-root .
         --exclude lib
         --exclude test
         --gcov-options '\-lp'
-        --verbose;
+        --verbose &&
+      bash <(curl -s https://codecov.io/bash);
     fi
 
-after_failure:
-  - cat ./test-suite.log
+# after_failure:
+#   - cat ./test-suite.log

.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+  "C_Cpp.default.configurationProvider": "vector-of-bool.cmake-tools",
+  "restructuredtext.confPath": "${workspaceFolder}/docs/source"
+}

CMakeLists.txt

@@ -0,0 +1,107 @@
+cmake_minimum_required(VERSION 3.8.2)
+project(cglm VERSION 0.7.6 LANGUAGES C)
+
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_C_STANDARD_REQUIRED YES)
+set(DEFAULT_BUILD_TYPE "Release")
+
+set(CGLM_BUILD)
+option(CGLM_SHARED "Shared build" ON)
+option(CGLM_STATIC "Static build" OFF)
+option(CGLM_USE_C99 "" OFF)
+option(CGLM_USE_TEST "Enable Tests" OFF)
+
+if(NOT CGLM_STATIC AND CGLM_SHARED)
+  set(CGLM_BUILD SHARED)
+else(CGLM_STATIC)
+  set(CGLM_BUILD STATIC)
+endif()
+
+if(CGLM_USE_C99)
+  set(C_STANDARD 99)
+endif()
+
+if(MSVC)
+	add_definitions(-DNDEBUG -D_WINDOWS -D_USRDLL -DCGLM_EXPORTS -DCGLM_DLL)
+	add_compile_options(/W3 /Ox /Gy /Oi /TC)
+else()
+  add_compile_options(-Wall -Werror -O3)
+endif()
+
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+  message(STATUS "Setting build type to '${DEFAULT_BUILD_TYPE}' as none was specified.")
+  set(CMAKE_BUILD_TYPE "${DEFAULT_BUILD_TYPE}" CACHE STRING "Choose the type of build." FORCE)
+  # Set the possible values of build type for cmake-gui
+  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
+endif()
+
+include(GNUInstallDirs)
+
+set(CPACK_PROJECT_NAME ${PROJECT_NAME})
+set(CPACK_PROJECT_VERSION ${PROJECT_VERSION})
+include(CPack)
+
+# Target Start
+add_library(${PROJECT_NAME}
+  ${CGLM_BUILD}
+  src/euler.c
+  src/affine.c
+  src/io.c
+  src/quat.c
+  src/cam.c
+  src/vec2.c
+  src/vec3.c
+  src/vec4.c
+  src/mat2.c
+  src/mat3.c
+  src/mat4.c
+  src/plane.c
+  src/frustum.c
+  src/box.c
+  src/project.c
+  src/sphere.c
+  src/ease.c
+  src/curve.c
+  src/bezier.c
+  src/ray.c
+  )
+
+set_target_properties(${PROJECT_NAME} PROPERTIES
+                              VERSION ${PROJECT_VERSION} 
+                            SOVERSION ${PROJECT_VERSION_MAJOR})
+
+target_include_directories(${PROJECT_NAME}
+    PUBLIC 
+        $<INSTALL_INTERFACE:include>    
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    PRIVATE
+        ${CMAKE_CURRENT_SOURCE_DIR}/src
+)
+
+# Test Configuration
+if(CGLM_USE_TEST)
+  include(CTest)
+  enable_testing()
+  add_subdirectory(test)
+endif()
+
+# Install 
+install(TARGETS ${PROJECT_NAME}
+        EXPORT  ${PROJECT_NAME}
+        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+install(DIRECTORY include/${PROJECT_NAME} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+        PATTERN ".*" EXCLUDE)
+
+# Config
+export(TARGETS ${PROJECT_NAME}
+       NAMESPACE ${PROJECT_NAME}::
+       FILE "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
+)
+
+install(EXPORT      ${PROJECT_NAME}
+        NAMESPACE   ${PROJECT_NAME}::
+        DESTINATION ${CMAKE_INSTALL_LIBDIR}/${PROJECT_NAME}/cmake)
+

CONTRIBUTING.md

@@ -1,11 +1,11 @@
 # CONTRIBUTING
 
-Any contributions (code, documentation, ...) are welcome. This project uses [cmocka](http://cmocka.org) for testing, you may need to check their documentation 
+Any contributions (code, documentation, ...) are welcome.
 
 # 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
+- The feature must be compiled on 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),

CREDITS

@@ -61,3 +61,13 @@ https://forums.khronos.org/showthread.php/10264-Animations-in-1-4-1-release-note
 https://forums.khronos.org/showthread.php/10644-Animation-Bezier-interpolation
 https://forums.khronos.org/showthread.php/10387-2D-Tangents-in-Bezier-Splines?p=34164&viewfull=1#post34164
 https://forums.khronos.org/showthread.php/10651-Animation-TCB-Spline-Interpolation-in-COLLADA?highlight=bezier
+
+12. vec2 cross product
+http://allenchou.net/2013/07/cross-product-of-2d-vectors/
+
+13. Ray triangle intersect
+Möller–Trumbore ray-triangle intersection algorithm, from "Fast, Minimum Storage Ray/Triangle Intersection"
+Authors:
+  Thomas Möller (tompa@clarus.se)
+  Ben Trumbore (wbt@graphics.cornell.edu)
+Link to paper: http://webserver2.tecgraf.puc-rio.br/~mgattass/cg/trbRR/Fast%20MinimumStorage%20RayTriangle%20Intersection.pdf

Makefile.am

@@ -7,23 +7,20 @@
 #******************************************************************************
 
 ACLOCAL_AMFLAGS = -I m4
-
 AM_CFLAGS = -Wall \
-            -std=gnu99 \
+            -std=gnu11 \
             -O3 \
             -Wstrict-aliasing=2 \
             -fstrict-aliasing \
-            -pedantic
+            -Werror=strict-prototypes
 
 lib_LTLIBRARIES = libcglm.la
 libcglm_la_LDFLAGS = -no-undefined -version-info 0:1:0
 
 checkLDFLAGS = -L./.libs \
-               -L./test/lib/cmocka/build/src \
-               -lcmocka \
                -lm \
                -lcglm
-checkCFLAGS = -I./test/lib/cmocka/include \
+checkCFLAGS = $(AM_CFLAGS) \
               -I./include
 
 check_PROGRAMS = test/tests
@@ -34,15 +31,20 @@ test_tests_CFLAGS  = $(checkCFLAGS)
 
 cglmdir=$(includedir)/cglm
 cglm_HEADERS = include/cglm/version.h \
+               include/cglm/common.h \
+               include/cglm/types.h \
+               include/cglm/types-struct.h \
                include/cglm/cglm.h \
                include/cglm/call.h \
+               include/cglm/struct.h \
                include/cglm/cam.h \
                include/cglm/io.h \
                include/cglm/mat4.h \
                include/cglm/mat3.h \
-               include/cglm/types.h \
-               include/cglm/common.h \
+               include/cglm/mat2.h \
                include/cglm/affine.h \
+               include/cglm/vec2.h \
+               include/cglm/vec2-ext.h \
                include/cglm/vec3.h \
                include/cglm/vec3-ext.h \
                include/cglm/vec4.h \
@@ -60,12 +62,14 @@ cglm_HEADERS = include/cglm/version.h \
                include/cglm/ease.h \
                include/cglm/curve.h \
                include/cglm/bezier.h \
-               include/cglm/types-struct.h \
-               include/cglm/struct.h
+               include/cglm/applesimd.h \
+               include/cglm/ray.h
 
 cglm_calldir=$(includedir)/cglm/call
 cglm_call_HEADERS = include/cglm/call/mat4.h \
                     include/cglm/call/mat3.h \
+                    include/cglm/call/mat2.h \
+                    include/cglm/call/vec2.h \
                     include/cglm/call/vec3.h \
                     include/cglm/call/vec4.h \
                     include/cglm/call/affine.h \
@@ -80,7 +84,8 @@ cglm_call_HEADERS = include/cglm/call/mat4.h \
                     include/cglm/call/sphere.h \
                     include/cglm/call/ease.h \
                     include/cglm/call/curve.h \
-                    include/cglm/call/bezier.h
+                    include/cglm/call/bezier.h \
+                    include/cglm/call/ray.h
 
 cglm_simddir=$(includedir)/cglm/simd
 cglm_simd_HEADERS = include/cglm/simd/intrin.h \
@@ -91,6 +96,7 @@ 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/mat2.h \
                          include/cglm/simd/sse2/quat.h
 
 cglm_simd_avxdir=$(includedir)/cglm/simd/avx
@@ -103,6 +109,9 @@ cglm_simd_neon_HEADERS = include/cglm/simd/neon/mat4.h
 cglm_structdir=$(includedir)/cglm/struct
 cglm_struct_HEADERS = include/cglm/struct/mat4.h \
                       include/cglm/struct/mat3.h \
+                      include/cglm/struct/mat2.h \
+                      include/cglm/struct/vec2.h \
+                      include/cglm/struct/vec2-ext.h \
                       include/cglm/struct/vec3.h \
                       include/cglm/struct/vec3-ext.h \
                       include/cglm/struct/vec4.h \
@@ -126,8 +135,10 @@ libcglm_la_SOURCES=\
     src/io.c \
     src/quat.c \
     src/cam.c \
+    src/vec2.c \
     src/vec3.c \
     src/vec4.c \
+    src/mat2.c \
     src/mat3.c \
     src/mat4.c \
     src/plane.c \
@@ -137,22 +148,18 @@ libcglm_la_SOURCES=\
     src/sphere.c \
     src/ease.c \
     src/curve.c \
-    src/bezier.c
+    src/bezier.c \
+    src/ray.c
 
 test_tests_SOURCES=\
+    test/runner.c \
     test/src/test_common.c \
-    test/src/test_main.c \
-    test/src/test_mat4.c \
+    test/src/tests.c \
     test/src/test_cam.c \
-    test/src/test_project.c \
     test/src/test_clamp.c \
     test/src/test_euler.c \
-    test/src/test_quat.c \
-    test/src/test_vec4.c \
-    test/src/test_vec3.c \
-    test/src/test_mat3.c \
-    test/src/test_affine.c \
-    test/src/test_bezier.c
+    test/src/test_bezier.c \
+    test/src/test_struct.c
 
 pkgconfig_DATA=cglm.pc
 
@@ -160,7 +167,7 @@ pkgconfig_DATA=cglm.pc
 # the source directory that post-build.sh is in. When not
 # using a prefix, $VPATH will be unset, so we need to fall
 # back to using . to run the script.
-export VPATH
+#export VPATH
 
-all-local:
-	sh $${VPATH:-.}/post-build.sh
+# all-local:
+#	sh $${VPATH:-.}/post-build.sh

README.md

@@ -3,6 +3,7 @@
  [![Build status](https://ci.appveyor.com/api/projects/status/av7l3gc0yhfex8y4/branch/master?svg=true)](https://ci.appveyor.com/project/recp/cglm/branch/master)
 [![Documentation Status](https://readthedocs.org/projects/cglm/badge/?version=latest)](http://cglm.readthedocs.io/en/latest/?badge=latest)
 [![Coverage Status](https://coveralls.io/repos/github/recp/cglm/badge.svg?branch=master)](https://coveralls.io/github/recp/cglm?branch=master)
+[![codecov](https://codecov.io/gh/recp/cglm/branch/master/graph/badge.svg)](https://codecov.io/gh/recp/cglm)
 [![Codacy Badge](https://api.codacy.com/project/badge/Grade/6a62b37d5f214f178ebef269dc4a6bf1)](https://www.codacy.com/app/recp/cglm?utm_source=github.com&utm_medium=referral&utm_content=recp/cglm&utm_campaign=Badge_Grade)
 [![Backers on Open Collective](https://opencollective.com/cglm/backers/badge.svg)](#backers)
 [![Sponsors on Open Collective](https://opencollective.com/cglm/sponsors/badge.svg)](#sponsors)
@@ -32,7 +33,7 @@ https://github.com/g-truc/glm
 #### Note for new comers (Important):
 - `vec4` and `mat4` variables must be aligned. (There will be unaligned versions later)
 - **in** and **[in, out]** parameters must be initialized (please). But **[out]** parameters not, initializing out param is  also redundant
-- All functions are inline if you don't want to use pre-compiled versions with glmc_ prefix, you can ignore build process. Just incliude headers.
+- All functions are inline if you don't want to use pre-compiled versions with glmc_ prefix, you can ignore build process. Just include headers.
 - if your debugger takes you to cglm headers then make sure you are not trying to copy vec4 to vec3 or alig issues...
 - Welcome!
 
@@ -87,6 +88,8 @@ Currently *cglm* uses default clip space configuration (-1, 1) for camera functi
 - easing functions
 - curves
 - curve interpolation helpers (S*M*C, deCasteljau...)
+- helpers to convert cglm types to Apple's simd library to pass cglm types to Metal GL without packing them on both sides
+- ray intersection helpers
 - and others...
 
 <hr />
@@ -129,20 +132,65 @@ glm_mul(T, R, modelMat);
 glm_inv_tr(modelMat);
 ```
 
+### Struct API
+
+The struct API works as follows, note the `s` suffix on types, the `glms_` prefix on functions and the `GLMS_` prefix on constants:
+
+```C
+#include <cglm/struct.h>
+
+mat4s mat = GLMS_MAT4_IDENTITY_INIT;
+mat4s inv = glms_mat4_inv(mat);
+```
+
+Struct functions generally take their parameters as *values* and *return* their results, rather than taking pointers and writing to out parameters. That means your parameters can usually be `const`, if you're into that.
+
+The types used are actually unions that allow access to the same data multiple ways. One of those ways involves anonymous structures, available since C11. MSVC also supports it for earlier C versions out of the box and GCC/Clang do if you enable `-fms-extensions`. To explicitly enable these anonymous structures, `#define CGLM_USE_ANONYMOUS_STRUCT` to `1`, to disable them, to `0`. For backward compatibility, you can also `#define CGLM_NO_ANONYMOUS_STRUCT` (value is irrelevant) to disable them. If you don't specify explicitly, cglm will do a best guess based on your compiler and the C version you're using.
+
 ## Build
 
+### CMake (All platforms)
+```bash
+$ mkdir build
+$ cd build
+$ cmake .. # [Optional] -DCGLM_SHARED=ON
+$ make
+$ sudo make install # [Optional]
+```
+
+##### Cmake options with Defaults:
+
+```CMake
+option(CGLM_SHARED "Shared build" ON)
+option(CGLM_STATIC "Static build" OFF)
+option(CGLM_USE_C99 "" OFF) # C11 
+option(CGLM_USE_TEST "Enable Tests" OFF) # for make check - make test
+```
+
+#### Use with your CMake project
+* Example:
+```cmake
+cmake_minimum_required(VERSION 3.8.2)
+
+project(<Your Project Name>)
+
+add_executable(${PROJECT_NAME} src/main.c)
+target_link_libraries(${LIBRARY_NAME} PRIVATE
+  cglm)
+
+add_subdirectory(external/cglm/)
+
+# or you can use find_package to configure cglm
+```
+
 ### Unix (Autotools)
 
 ```bash
-$ sh ./build-deps.sh # run only once (dependencies) [Optional].
-$ # You can pass this step if you don't want to run `make check` for tests.
-$ # cglm uses cmocka for tests and it may reqiure cmake for building it
-$
 $ sh autogen.sh
 $ ./configure
 $ make
-$ make check # [Optional] (if you run `sh ./build-deps.sh`)
-$ [sudo] make install
+$ make check # [Optional]
+$ [sudo] make install # [Optional]
 ```
 
 This will also install pkg-config files so you can use
@@ -170,6 +218,10 @@ if `msbuild` won't work (because of multi version VS) then try to build with `de
 $ devenv cglm.sln /Build Release
 ```
 
+#### Running Tests on Windows
+
+You can see test project in same visual studio solution file. It is enough to run that project to run tests.
+
 ### Building Docs
 First you need install Sphinx: http://www.sphinx-doc.org/en/master/usage/installation.html
 then:
@@ -274,7 +326,7 @@ You can pass matrices the same way to other APIs e.g. Vulkan, DX...
 ## Contributors
 
 This project exists thanks to all the people who contribute. [[Contribute](CONTRIBUTING.md)].
-<a href="graphs/contributors"><img src="https://opencollective.com/cglm/contributors.svg?width=890&button=false" /></a>
+<a href="https://github.com/recp/cglm/graphs/contributors"><img src="https://opencollective.com/cglm/contributors.svg?width=890&button=false" /></a>
 
 
 ## Backers

build-deps.sh

@@ -1,23 +0,0 @@
-#! /bin/sh
-#
-# Copyright (c), Recep Aslantas.
-#
-# MIT License (MIT), http://opensource.org/licenses/MIT
-# Full license can be found in the LICENSE file
-#
-
-# check if deps are pulled
-git submodule update --init --recursive
-
-cd $(dirname "$0")
-
-# general deps: gcc make autoconf automake libtool cmake
-
-# test - cmocka
-cd ./test/lib/cmocka
-rm -rf build
-mkdir -p build
-cd build
-cmake -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=Debug ..
-make -j8
-cd ../../../../

cglm.podspec

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

configure.ac

@@ -7,8 +7,11 @@
 #*****************************************************************************
 
 AC_PREREQ([2.69])
-AC_INIT([cglm], [0.6.0], [info@recp.me])
-AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects])
+AC_INIT([cglm], [0.7.6], [info@recp.me])
+AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects serial-tests])
+
+# Don't use the default cflags (-O2 -g), we set ours manually in Makefile.am.
+: ${CFLAGS=""}
 
 AC_CONFIG_MACRO_DIR([m4])
 AC_CONFIG_SRCDIR([src/])

docs/source/api.rst

@@ -35,10 +35,13 @@ Follow the :doc:`build` documentation for this
    euler
    mat4
    mat3
+   mat2
    vec3
    vec3-ext
    vec4
    vec4-ext
+   vec2
+   vec2-ext
    color
    plane
    project
@@ -48,3 +51,5 @@ Follow the :doc:`build` documentation for this
    sphere
    curve
    bezier
+   version
+   ray

docs/source/build.rst

@@ -1,23 +1,58 @@
 Build cglm
 ================================
 
-| **cglm** does not have external dependencies except for unit testing. When you pulled **cglm** repo with submodules all dependencies will be pulled too. `build-deps.sh` will pull all dependencies/submodules and build for you.
-
-External dependencies:
-  * cmocka - for unit testing
+| **cglm** does not have any external dependencies.
 
 **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
 
+CMake (All platforms):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. code-block:: bash
+  :linenos:
+
+  $ mkdir build
+  $ cd build
+  $ cmake .. # [Optional] -DCGLM_SHARED=ON
+  $ make
+  $ sudo make install # [Optional]
+
+**make** will build cglm to **build** folder.
+If you don't want to install **cglm** to your system's folder you can get static and dynamic libs in this folder.
+
+**CMake Options:**
+
+.. code-block:: CMake
+  :linenos:
+
+  option(CGLM_SHARED "Shared build" ON)
+  option(CGLM_STATIC "Static build" OFF)
+  option(CGLM_USE_C99 "" OFF) # C11 
+  option(CGLM_USE_TEST "Enable Tests" OFF) # for make check - make test
+
+**Use with your CMake project example**
+
+.. code-block:: CMake
+  :linenos:
+
+  cmake_minimum_required(VERSION 3.8.2)
+  
+  project(<Your Project Name>)
+  
+  add_executable(${PROJECT_NAME} src/main.c)
+  target_link_libraries(${LIBRARY_NAME} PRIVATE
+    cglm)
+  
+  add_subdirectory(external/cglm/)
+
 Unix (Autotools):
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 .. code-block:: bash
   :linenos:
 
-  $ sh ./build-deps.sh    # run this only once (dependencies)
-
   $ sh autogen.sh
   $ ./configure
   $ make
@@ -65,4 +100,3 @@ Example build:
 
   $ cd cglm/docs
   $ sphinx-build source build
-

docs/source/cam.rst

@@ -198,7 +198,7 @@ Functions documentation
 
     Parameters:
       | *[in]*  **eye**     eye vector
-      | *[in]*  **center**  direction vector
+      | *[in]*  **dir**     direction vector
       | *[in]*  **up**      up vector
       | *[out]* **dest**    result matrix
 
@@ -212,7 +212,7 @@ Functions documentation
 
     Parameters:
       | *[in]*  **eye**     eye vector
-      | *[in]*  **center**  direction vector
+      | *[in]*  **dir**     direction vector
       | *[out]* **dest**    result matrix
 
 .. c:function:: void  glm_persp_decomp(mat4 proj, float *nearVal, float *farVal, float *top, float *bottom, float *left, float *right)

docs/source/conf.py

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

docs/source/features.rst

@@ -1,10 +1,11 @@
 Features
 ================================================================================
 
+* array api and struct api, you can use arrays or structs.
 * general purpose matrix operations (mat4, mat3)
 * chain matrix multiplication (square only)
 * general purpose vector operations (cross, dot, rotate, proj, angle...)
-* affine transforms
+* affine transformations
 * matrix decomposition (extract rotation, scaling factor)
 * optimized affine transform matrices (mul, rigid-body inverse)
 * camera (lookat)
@@ -20,4 +21,6 @@ Features
 * easing functions
 * curves
 * curve interpolation helpers (SMC, deCasteljau...)
-* and other...
+* helpers to convert cglm types to Apple's simd library to pass cglm types to Metal GL without packing them on both sides
+* ray intersection helpers
+* and others...

docs/source/io.rst

@@ -28,6 +28,23 @@ Example to print mat4 matrix:
 (you probably will in some cases), you can change it temporary.
 cglm may provide precision parameter in the future
 
+Changes since **v0.7.3**:
+* Now mis-alignment of columns are fixed: larger numbers are printed via %g and others are printed via %f. Column withs are calculated before print.
+* Now values are colorful ;)
+* Some print improvements
+* New options with default values:
+
+.. code-block:: c
+
+    #define CGLM_PRINT_PRECISION    5
+    #define CGLM_PRINT_MAX_TO_SHORT 1e5
+    #define CGLM_PRINT_COLOR        "\033[36m"
+    #define CGLM_PRINT_COLOR_RESET  "\033[0m"
+
+* Inline prints are only enabled in DEBUG mode and if **CGLM_DEFINE_PRINTS** is defined.
+
+Check options page.
+
 Table of contents (click to go):
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

docs/source/mat2.rst

@@ -0,0 +1,179 @@
+.. default-domain:: C
+
+mat2
+====
+
+Header: cglm/mat2.h
+
+Table of contents (click to go):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Macros:
+
+1. GLM_mat2_IDENTITY_INIT
+#. GLM_mat2_ZERO_INIT
+#. GLM_mat2_IDENTITY
+#. GLM_mat2_ZERO
+
+Functions:
+
+1. :c:func:`glm_mat2_copy`
+#. :c:func:`glm_mat2_identity`
+#. :c:func:`glm_mat2_identity_array`
+#. :c:func:`glm_mat2_zero`
+#. :c:func:`glm_mat2_mul`
+#. :c:func:`glm_mat2_transpose_to`
+#. :c:func:`glm_mat2_transpose`
+#. :c:func:`glm_mat2_mulv`
+#. :c:func:`glm_mat2_scale`
+#. :c:func:`glm_mat2_det`
+#. :c:func:`glm_mat2_inv`
+#. :c:func:`glm_mat2_trace`
+#. :c:func:`glm_mat2_swap_col`
+#. :c:func:`glm_mat2_swap_row`
+#. :c:func:`glm_mat2_rmc`
+
+Functions documentation
+~~~~~~~~~~~~~~~~~~~~~~~
+
+.. c:function:: void glm_mat2_copy(mat2 mat, mat2 dest)
+
+    copy mat2 to another one (dest).
+
+    Parameters:
+      | *[in]*  **mat**   source
+      | *[out]* **dest**  destination
+
+.. c:function:: void glm_mat2_identity(mat2 mat)
+
+    copy identity mat2 to mat, or makes mat to identiy
+
+    Parameters:
+      | *[out]* **mat**  matrix
+
+.. c:function:: void glm_mat2_identity_array(mat2 * __restrict mat, size_t count)
+
+    make given matrix array's each element identity matrix
+
+    Parameters:
+      | *[in,out]* **mat**  matrix array (must be aligned (16/32) if alignment is not disabled)
+      | *[in]* **count**  count of matrices
+
+.. c:function:: void glm_mat2_zero(mat2 mat)
+
+    make given matrix zero
+
+    Parameters:
+      | *[in,out]* **mat**  matrix to
+
+.. c:function:: void glm_mat2_mul(mat2 m1, mat2 m2, mat2 dest)
+
+    multiply m1 and m2 to dest
+    m1, m2 and dest matrices can be same matrix, it is possible to write this:
+
+    .. code-block:: c
+
+       mat2 m = GLM_mat2_IDENTITY_INIT;
+       glm_mat2_mul(m, m, m);
+
+    Parameters:
+      | *[in]*  **m1**    left matrix
+      | *[in]*  **m2**    right matrix
+      | *[out]* **dest**  destination matrix
+
+.. c:function:: void glm_mat2_transpose_to(mat2 m, mat2 dest)
+
+    transpose mat4 and store in dest
+    source matrix will not be transposed unless dest is m
+
+    Parameters:
+      | *[in]*  **mat**   source
+      | *[out]* **dest**  destination
+
+.. c:function:: void glm_mat2_transpose(mat2 m)
+
+    tranpose mat2 and store result in same matrix
+
+    Parameters:
+      | *[in]*  **mat**   source
+      | *[out]* **dest**  destination
+
+.. c:function:: void glm_mat2_mulv(mat2 m, vec2 v, vec2 dest)
+
+    multiply mat4 with vec4 (column vector) and store in dest vector
+
+    Parameters:
+      | *[in]*  **mat**   mat2 (left)
+      | *[in]*  **v**     vec2 (right, column vector)
+      | *[out]* **dest**  destination (result, column vector)
+
+.. c:function:: void  glm_mat2_scale(mat2 m, float s)
+
+    multiply matrix with scalar
+
+    Parameters:
+      | *[in, out]* **mat**   matrix
+      | *[in]*      **dest**  scalar
+
+.. c:function:: float  glm_mat2_det(mat2 mat)
+
+    returns mat2 determinant
+
+    Parameters:
+      | *[in]*  **mat**   matrix
+
+    Returns:
+        mat2 determinant
+
+.. c:function:: void glm_mat2_inv(mat2 mat, mat2 dest)
+
+    inverse mat2 and store in dest
+
+    Parameters:
+      | *[in]*  **mat**  matrix
+      | *[out]* **dest** destination (inverse matrix)
+
+.. c:function:: void glm_mat2_trace(mat2 m)
+
+    | sum of the elements on the main diagonal from upper left to the lower right
+
+    Parameters:
+      | *[in]*  **m**  matrix
+
+    Returns:
+        trace of matrix
+
+.. c:function:: void glm_mat2_swap_col(mat2 mat, int col1, int col2)
+
+    swap two matrix columns
+
+    Parameters:
+      | *[in, out]*  **mat**   matrix
+      | *[in]*       **col1**  col1
+      | *[in]*       **col2**  col2
+
+.. c:function:: void glm_mat2_swap_row(mat2 mat, int row1, int row2)
+
+    swap two matrix rows
+
+    Parameters:
+      | *[in, out]*  **mat**   matrix
+      | *[in]*       **row1**  row1
+      | *[in]*       **row2**  row2
+
+.. c:function:: float glm_mat2_rmc(vec2 r, mat2 m, vec2 c)
+
+    | **rmc** stands for **Row** * **Matrix** * **Column**
+
+    | helper for  R (row vector) * M (matrix) * C (column vector)
+
+    | the result is scalar because R * M = Matrix1x2 (row vector),
+    | then Matrix1x2 * Vec2 (column vector) = Matrix1x1 (Scalar)
+
+    Parameters:
+      | *[in]*  **r**  row vector or matrix1x2
+      | *[in]*  **m**  matrix2x2
+      | *[in]*  **c**  column vector or matrix2x1
+
+    Returns:
+        scalar value e.g. Matrix1x1

docs/source/opt.rst

@@ -50,3 +50,24 @@ You have to extra options for dot product: **CGLM_SSE4_DOT** and **CGLM_SSE3_DOT
 - If **SSE3** is enabled then you can define **CGLM_SSE3_DOT** to force cglm to use **_mm_hadd_ps** instructions.
 
 otherwise cglm will use custom cglm's hadd functions which are optimized too.
+
+Print Options
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+1. **CGLM_DEFINE_PRINTS**
+2. **CGLM_NO_PRINTS_NOOP**
+
+Inline prints are only enabled in DEBUG mode and if **CGLM_DEFINE_PRINTS** is defined.
+If DEBUG is not enabled then print function bodies will be emptied to eliminate print function calls.
+You can disable this feature too by defining **CGLM_NO_PRINTS_NOOP** macro top of cglm headers.
+
+3. **CGLM_PRINT_PRECISION**    5
+
+precision.
+
+4. **CGLM_PRINT_MAX_TO_SHORT** 1e5
+
+if a number is greater than this value then %g will be used, since this is shorten print you won't be able to see high precision.
+
+5. **CGLM_PRINT_COLOR**        "\033[36m"
+6. **CGLM_PRINT_COLOR_RESET**  "\033[0m"

docs/source/quat.rst

@@ -324,26 +324,24 @@ Functions documentation
       | *[in]*  **ori**   orientation in world space as quaternion
       | *[out]* **dest**  result matrix
 
-.. c:function:: void  glm_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest)
+.. c:function:: void  glm_quat_for(vec3 dir, vec3 up, versor dest)
 
     | creates look rotation quaternion
 
     Parameters:
       | *[in]*  **dir**   direction to look
-      | *[in]*  **fwd**   forward vector
       | *[in]*  **up**    up vector
       | *[out]* **dest**  result matrix
 
-.. c:function:: void  glm_quat_forp(vec3 from, vec3 to, vec3 fwd, vec3 up, versor dest)
+.. c:function:: void  glm_quat_forp(vec3 from, vec3 to, vec3 up, versor dest)
 
-    | creates look rotation quaternion using source and  destination positions p suffix stands for position
+    | creates look rotation quaternion using source and destination positions p suffix stands for position
 
     | this is similar to glm_quat_for except this computes direction for glm_quat_for for you.
 
     Parameters:
       | *[in]*  **from**  source point
       | *[in]*  **to**    destination point
-      | *[in]*  **fwd**   forward vector
       | *[in]*  **up**    up vector
       | *[out]* **dest**  result matrix
 

docs/source/ray.rst

@@ -0,0 +1,31 @@
+.. default-domain:: C
+
+ray
+====
+
+Header: cglm/ray.h
+
+This is for collision-checks used by ray-tracers and the like.
+
+Table of contents (click to go):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Functions:
+
+1. :c:func:`glm_ray_triangle`
+
+Functions documentation
+~~~~~~~~~~~~~~~~~~~~~~~
+
+.. c:function:: bool  glm_ray_triangle(vec3 origin, vec3 direction, vec3 v0, vec3 v1, vec3 v2, float *d)
+
+    Möller–Trumbore ray-triangle intersection algorithm
+
+    Parameters:
+      | *[in]*       **origin**        origin of ray
+      | *[in]*       **direction**     direction of ray
+      | *[in]*       **v0**            first vertex of triangle
+      | *[in]*       **v1**            second vertex of triangle
+      | *[in]*       **v2**            third vertex of triangle
+      | *[in, out]*  **d**             float pointer to save distance to intersection
+      | *[out]*      **intersection**  whether there is intersection

docs/source/troubleshooting.rst

@@ -57,6 +57,13 @@ For instance you may called **glm_vec4_** functions for **vec3** data type.
 It will try to write 32 byte but since **vec3** is 24 byte it should throw
 memory access error or exit the app without saying anything.
 
+**UPDATE - IMPORTANT:** 
+
+  | On MSVC or some other compilers, if alignment is enabled (default) then double check alignment requirements if you got a crash.
+
+  | If you send GLM_VEC4_ONE or similar macros directly to a function, it may be crashed.
+  | Because compiler may not apply alignment as defined on **typedef** to that macro while passing it (on stack) to a function.
+
 Wrong Results:
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -73,6 +80,19 @@ So be carefull, when your IDE (Xcode, Visual Studio ...) tried to autocomplete f
 
 **Also implementation may be wrong please let us know by creating an issue on Github.**
 
+BAD_ACCESS : Thread 1: EXC_BAD_ACCESS (code=EXC_I386_GPFLT) or Similar Errors/Crashes
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+This is similar issue with alignment. For instance if you compiled **cglm** with 
+AVX (**-mavx**, intentionally or not) and if you use **cglm** in an environment that doesn't 
+support AVX (or if AVX is disabled intentionally) e.g. environment that max support SSE2/3/4, 
+then you probably get **BAD ACCESS** or similar...
+
+Because if you compile **cglm** with AVX it aligns **mat4** with 32 byte boundary, 
+and your project aligns that as 16 byte boundary...
+
+Check alignment, supported vector extension or simd in **cglm** and linked projects...
+
 Other Issues?
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

docs/source/util.rst

@@ -23,6 +23,7 @@ Functions:
 #. :c:func:`glm_max`
 #. :c:func:`glm_clamp`
 #. :c:func:`glm_lerp`
+#. :c:func:`glm_swapf`
 
 Functions documentation
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -146,7 +147,7 @@ Functions documentation
       | *[in]*  **b**   b
 
     Returns:
-       true if a and b equals
+       true if a and b are equal
 
 .. c:function:: float glm_percent(float from, float to, float current)
 
@@ -158,7 +159,7 @@ Functions documentation
       | *[in]*  **current**   value between from and to values
 
     Returns:
-       clamped normalized percent (0-100 in 0-1)
+       percentage of current value
 
 .. c:function:: float glm_percentc(float from, float to, float current)
 
@@ -171,3 +172,11 @@ Functions documentation
 
     Returns:
        clamped normalized percent (0-100 in 0-1)
+
+.. c:function:: void glm_swapf(float *a, float *b) 
+
+    swap two float values
+
+    Parameters:
+      | *[in]*  **a**      float 1
+      | *[in]*  **b**      float 2

docs/source/vec2-ext.rst

@@ -0,0 +1,134 @@
+.. default-domain:: C
+
+vec2 extra
+==========
+
+Header: cglm/vec2-ext.h
+
+There are some functions are in called in extra header. These are called extra
+because they are not used like other functions in vec2.h in the future some of
+these functions ma be moved to vec2 header.
+
+Table of contents (click to go):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Functions:
+
+1. :c:func:`glm_vec2_fill`
+#. :c:func:`glm_vec2_eq`
+#. :c:func:`glm_vec2_eq_eps`
+#. :c:func:`glm_vec2_eq_all`
+#. :c:func:`glm_vec2_eqv`
+#. :c:func:`glm_vec2_eqv_eps`
+#. :c:func:`glm_vec2_max`
+#. :c:func:`glm_vec2_min`
+#. :c:func:`glm_vec2_isnan`
+#. :c:func:`glm_vec2_isinf`
+#. :c:func:`glm_vec2_isvalid`
+#. :c:func:`glm_vec2_sign`
+#. :c:func:`glm_vec2_sqrt`
+
+Functions documentation
+~~~~~~~~~~~~~~~~~~~~~~~
+
+.. c:function:: void glm_vec2_fill(vec2 v, float val)
+
+    fill a vector with specified value
+
+    Parameters:
+      | *[in,out]* **dest**  destination
+      | *[in]*     **val**   value
+      
+
+.. c:function:: bool glm_vec2_eq(vec2 v, float val)
+
+    check if vector is equal to value (without epsilon)
+
+    Parameters:
+      | *[in]*  **v**    vector
+      | *[in]*  **val**  value
+
+.. c:function:: bool glm_vec2_eq_eps(vec2 v, float val)
+
+    check if vector is equal to value (with epsilon)
+
+    Parameters:
+      | *[in]*  **v**    vector
+      | *[in]*  **val**  value
+
+.. c:function:: bool glm_vec2_eq_all(vec2 v)
+
+    check if vectors members are equal (without epsilon)
+
+    Parameters:
+      | *[in]*  **v**   vector
+
+.. c:function:: bool glm_vec2_eqv(vec2 v1, vec2 v2)
+
+    check if vector is equal to another (without epsilon) vector
+
+    Parameters:
+      | *[in]*  **vec**   vector 1
+      | *[in]*  **vec**   vector 2
+
+.. c:function:: bool glm_vec2_eqv_eps(vec2 v1, vec2 v2)
+
+    check if vector is equal to another (with epsilon)
+
+    Parameters:
+      | *[in]*  **v1**    vector1
+      | *[in]*  **v2**    vector2
+
+.. c:function:: float glm_vec2_max(vec2 v)
+
+    max value of vector
+
+    Parameters:
+      | *[in]*  **v**    vector
+
+.. c:function:: float glm_vec2_min(vec2 v)
+
+     min value of vector
+
+    Parameters:
+      | *[in]*  **v**  vector
+
+.. c:function:: bool glm_vec2_isnan(vec2 v)
+
+    | check if one of items is NaN (not a number)
+    | you should only use this in DEBUG mode or very critical asserts
+
+    Parameters:
+      | *[in]*  **v**  vector
+
+.. c:function:: bool glm_vec2_isinf(vec2 v)
+
+    | check if one of items is INFINITY
+    | you should only use this in DEBUG mode or very critical asserts
+
+    Parameters:
+      | *[in]*  **v**  vector
+
+.. c:function:: bool glm_vec2_isvalid(vec2 v)
+
+    | check if all items are valid number
+    | you should only use this in DEBUG mode or very critical asserts
+
+    Parameters:
+      | *[in]*  **v**  vector
+
+.. c:function:: void glm_vec2_sign(vec2 v, vec2 dest)
+
+    get sign of 32 bit float as +1, -1, 0
+
+    Parameters:
+      | *[in]*   **v**     vector
+      | *[out]*  **dest**  sign vector (only keeps signs as -1, 0, -1)
+
+.. c:function:: void glm_vec2_sqrt(vec2 v, vec2 dest)
+
+    square root of each vector item
+
+    Parameters:
+      | *[in]*   **v**     vector
+      | *[out]*  **dest**  destination vector (sqrt(v))

docs/source/vec2.rst

@@ -0,0 +1,375 @@
+.. default-domain:: C
+
+vec2
+====
+
+Header: cglm/vec2.h
+
+Table of contents (click to go):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Macros:
+
+1. GLM_vec2_ONE_INIT
+#. GLM_vec2_ZERO_INIT
+#. GLM_vec2_ONE
+#. GLM_vec2_ZERO
+
+Functions:
+
+1. :c:func:`glm_vec2`
+#. :c:func:`glm_vec2_copy`
+#. :c:func:`glm_vec2_zero`
+#. :c:func:`glm_vec2_one`
+#. :c:func:`glm_vec2_dot`
+#. :c:func:`glm_vec2_cross`
+#. :c:func:`glm_vec2_norm2`
+#. :c:func:`glm_vec2_norm`
+#. :c:func:`glm_vec2_add`
+#. :c:func:`glm_vec2_adds`
+#. :c:func:`glm_vec2_sub`
+#. :c:func:`glm_vec2_subs`
+#. :c:func:`glm_vec2_mul`
+#. :c:func:`glm_vec2_scale`
+#. :c:func:`glm_vec2_scale_as`
+#. :c:func:`glm_vec2_div`
+#. :c:func:`glm_vec2_divs`
+#. :c:func:`glm_vec2_addadd`
+#. :c:func:`glm_vec2_subadd`
+#. :c:func:`glm_vec2_muladd`
+#. :c:func:`glm_vec2_muladds`
+#. :c:func:`glm_vec2_maxadd`
+#. :c:func:`glm_vec2_minadd`
+#. :c:func:`glm_vec2_negate`
+#. :c:func:`glm_vec2_negate_to`
+#. :c:func:`glm_vec2_normalize`
+#. :c:func:`glm_vec2_normalize_to`
+#. :c:func:`glm_vec2_rotate`
+#. :c:func:`glm_vec2_distance2`
+#. :c:func:`glm_vec2_distance`
+#. :c:func:`glm_vec2_maxv`
+#. :c:func:`glm_vec2_minv`
+#. :c:func:`glm_vec2_clamp`
+#. :c:func:`glm_vec2_lerp`
+
+Functions documentation
+~~~~~~~~~~~~~~~~~~~~~~~
+
+.. c:function:: void glm_vec2(vec4 v4, vec2 dest)
+
+    init vec2 using vec3
+
+    Parameters:
+      | *[in]*  **v3**    vector3
+      | *[out]* **dest**  destination
+
+.. c:function:: void glm_vec2_copy(vec2 a, vec2 dest)
+
+    copy all members of [a] to [dest]
+
+    Parameters:
+      | *[in]*  **a**     source
+      | *[out]* **dest**  destination
+
+.. c:function:: void glm_vec2_zero(vec2 v)
+
+    makes all members 0.0f (zero)
+
+    Parameters:
+      | *[in, out]*  **v**     vector
+
+.. c:function:: void  glm_vec2_one(vec2 v)
+
+    makes all members 1.0f (one)
+
+    Parameters:
+      | *[in, out]*  **v**     vector
+
+.. c:function:: float glm_vec2_dot(vec2 a, vec2 b)
+
+    dot product of vec2
+
+    Parameters:
+      | *[in]*  **a**  vector1
+      | *[in]*  **b**  vector2
+
+    Returns:
+      dot product
+
+.. c:function:: void glm_vec2_cross(vec2 a, vec2 b, vec2 d)
+
+    cross product of two vector (RH)
+
+    | ref: http://allenchou.net/2013/07/cross-product-of-2d-vectors/
+
+    Parameters:
+      | *[in]*  **a**     vector 1
+      | *[in]*  **b**     vector 2
+      | *[out]* **dest**  destination
+
+    Returns:
+      Z component of cross product
+
+.. c:function:: float glm_vec2_norm2(vec2 v)
+
+    norm * norm (magnitude) of vector
+
+    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
+
+    Parameters:
+      | *[in]*  **v**   vector
+
+    Returns:
+      square of norm / magnitude
+
+.. c:function:: float glm_vec2_norm(vec2 vec)
+
+    | euclidean norm (magnitude), also called L2 norm
+    | this will give magnitude of vector in euclidean space
+
+    Parameters:
+      | *[in]*  **vec**   vector
+
+.. c:function:: void glm_vec2_add(vec2 a, vec2 b, vec2 dest)
+
+    add a vector to b vector store result in dest
+
+    Parameters:
+      | *[in]*  **a**     vector1
+      | *[in]*  **b**     vector2
+      | *[out]* **dest**  destination vector
+
+.. c:function:: void glm_vec2_adds(vec2 a, float s, vec2 dest)
+
+    add scalar to v vector store result in dest (d = v + vec(s))
+
+    Parameters:
+      | *[in]*  **v**     vector
+      | *[in]*  **s**     scalar
+      | *[out]* **dest**  destination vector
+
+.. c:function:: void glm_vec2_sub(vec2 v1, vec2 v2, vec2 dest)
+
+    subtract b vector from a vector store result in dest (d = v1 - v2)
+
+    Parameters:
+      | *[in]*  **a**     vector1
+      | *[in]*  **b**     vector2
+      | *[out]* **dest**  destination vector
+
+.. c:function:: void glm_vec2_subs(vec2 v, float s, vec2 dest)
+
+    subtract scalar from v vector store result in dest (d = v - vec(s))
+
+    Parameters:
+      | *[in]*  **v**     vector
+      | *[in]*  **s**     scalar
+      | *[out]* **dest**  destination vector
+
+.. c:function:: void glm_vec2_mul(vec2 a, vec2 b, vec2 d)
+
+    multiply two vector (component-wise multiplication)
+
+    Parameters:
+      | *[in]*  **a**     vector
+      | *[in]*  **b**     scalar
+      | *[out]* **d**     result = (a[0] * b[0], a[1] * b[1], a[2] * b[2])
+
+.. c:function:: void glm_vec2_scale(vec2 v, float s, vec2 dest)
+
+     multiply/scale vec2 vector with scalar: result = v * s
+
+
+    Parameters:
+      | *[in]*  **v**     vector
+      | *[in]*  **s**     scalar
+      | *[out]* **dest**  destination vector
+
+.. c:function:: void glm_vec2_scale_as(vec2 v, float s, vec2 dest)
+
+    make vec2 vector scale as specified: result = unit(v) * s
+
+    Parameters:
+      | *[in]*  **v**     vector
+      | *[in]*  **s**     scalar
+      | *[out]* **dest**  destination vector
+
+.. c:function:: void glm_vec2_div(vec2 a, vec2 b, vec2 dest)
+
+    div vector with another component-wise division: d = a / b
+
+    Parameters:
+      | *[in]*  **a**     vector 1
+      | *[in]*  **b**     vector 2
+      | *[out]* **dest**  result = (a[0] / b[0], a[1] / b[1], a[2] / b[2])
+
+.. c:function:: void glm_vec2_divs(vec2 v, float s, vec2 dest)
+
+    div vector with scalar: d = v / s
+
+    Parameters:
+      | *[in]*  **v**     vector
+      | *[in]*  **s**     scalar
+      | *[out]* **dest**  result = (a[0] / s, a[1] / s, a[2] / s])
+
+.. c:function:: void glm_vec2_addadd(vec2 a, vec2 b, vec2 dest)
+
+    | add two vectors and add result to sum
+    | it applies += operator so dest must be initialized
+
+    Parameters:
+      | *[in]*  **a**     vector 1
+      | *[in]*  **b**     vector 2
+      | *[out]* **dest**  dest += (a + b)
+
+.. c:function:: void glm_vec2_subadd(vec2 a, vec2 b, vec2 dest)
+
+    | sub two vectors and add result to sum
+    | it applies += operator so dest must be initialized
+
+    Parameters:
+      | *[in]*  **a**     vector 1
+      | *[in]*  **b**     vector 2
+      | *[out]* **dest**  dest += (a - b)
+
+.. c:function:: void glm_vec2_muladd(vec2 a, vec2 b, vec2 dest)
+
+    | mul two vectors and add result to sum
+    | it applies += operator so dest must be initialized
+
+    Parameters:
+      | *[in]*  **a**     vector 1
+      | *[in]*  **b**     vector 2
+      | *[out]* **dest**  dest += (a * b)
+
+.. c:function:: void glm_vec2_muladds(vec2 a, float s, vec2 dest)
+
+    | mul vector with scalar and add result to sum
+    | it applies += operator so dest must be initialized
+
+    Parameters:
+      | *[in]*  **a**     vector
+      | *[in]*  **s**     scalar
+      | *[out]* **dest**  dest += (a * b)
+
+.. c:function:: void glm_vec2_maxadd(vec2 a, vec2 b, vec2 dest)
+
+    | add max of two vector to result/dest
+    | it applies += operator so dest must be initialized
+
+    Parameters:
+      | *[in]*  **a**     vector 1
+      | *[in]*  **b**     vector 2
+      | *[out]* **dest**  dest += (a * b)
+
+.. c:function:: void glm_vec2_minadd(vec2 a, vec2 b, vec2 dest)
+
+    | add min of two vector to result/dest
+    | it applies += operator so dest must be initialized
+
+    Parameters:
+      | *[in]*  **a**     vector 1
+      | *[in]*  **b**     vector 2
+      | *[out]* **dest**  dest += (a * b)
+
+.. c:function:: void glm_vec2_negate(vec2 v)
+
+    negate vector components
+
+    Parameters:
+      | *[in, out]*  **v**    vector
+
+.. c:function:: void glm_vec2_negate_to(vec2 v, vec2 dest)
+
+    negate vector components and store result in dest
+
+    Parameters:
+      | *[in]*  **v**       vector
+      | *[out]* **dest**    negated vector
+
+.. c:function:: void glm_vec2_normalize(vec2 v)
+
+    normalize vec2 and store result in same vec
+
+    Parameters:
+      | *[in, out]*  **v**    vector
+
+.. c:function:: void glm_vec2_normalize_to(vec2 vec, vec2 dest)
+
+     normalize vec2 to dest
+
+    Parameters:
+      | *[in]*   **vec**   source
+      | *[out]*  **dest**  destination
+
+.. c:function:: void glm_vec2_rotate(vec2 v, float angle, vec2 dest)
+
+     rotate vec2 around axis by angle using Rodrigues' rotation formula
+
+    Parameters:
+      | *[in]*  **v**      vector
+      | *[in]*  **axis**   axis vector
+      | *[out]* **dest**   destination
+
+.. c:function:: float glm_vec2_distance2(vec2 v1, vec2 v2)
+
+    squared distance between two vectors
+
+    Parameters:
+      | *[in]*  **mat**   vector1
+      | *[in]*  **row1**  vector2
+
+    Returns:
+      | squared distance (distance * distance)
+
+.. c:function:: float glm_vec2_distance(vec2 v1, vec2 v2)
+
+    distance between two vectors
+
+    Parameters:
+      | *[in]*  **mat**   vector1
+      | *[in]*  **row1**  vector2
+
+    Returns:
+      | distance
+
+.. c:function:: void glm_vec2_maxv(vec2 v1, vec2 v2, vec2 dest)
+
+    max values of vectors
+
+    Parameters:
+      | *[in]*  **v1**    vector1
+      | *[in]*  **v2**    vector2
+      | *[out]* **dest**  destination
+
+.. c:function:: void glm_vec2_minv(vec2 v1, vec2 v2, vec2 dest)
+
+    min values of vectors
+
+    Parameters:
+      | *[in]*  **v1**    vector1
+      | *[in]*  **v2**    vector2
+      | *[out]* **dest**  destination
+
+.. c:function:: void glm_vec2_clamp(vec2 v, float minVal, float maxVal)
+
+    constrain a value to lie between two further values
+
+    Parameters:
+      | *[in, out]*  **v**       vector
+      | *[in]*       **minVal**  minimum value
+      | *[in]*       **maxVal**  maximum value
+
+.. c:function:: void glm_vec2_lerp(vec2 from, vec2 to, float t, vec2 dest)
+
+    linear interpolation between two vector
+
+    | formula:  from + s * (to - from)
+
+    Parameters:
+      | *[in]*  **from**   from value
+      | *[in]*  **to**     to value
+      | *[in]*  **t**      interpolant (amount) clamped between 0 and 1
+      | *[out]* **dest**   destination

docs/source/vec3.rst

@@ -392,7 +392,7 @@ Functions documentation
     Parameters:
       | *[in, out]*  **v**      vector
       | *[in]*       **axis**   axis vector (will be normalized)
-      | *[out]*      **angle**  angle (radians)
+      | *[in]*       **angle**  angle (radians)
 
 .. c:function:: void  glm_vec3_rotate_m4(mat4 m, vec3 v, vec3 dest)
 
@@ -435,8 +435,8 @@ Functions documentation
     squared distance between two vectors
 
     Parameters:
-      | *[in]*  **mat**   vector1
-      | *[in]*  **row1**  vector2
+      | *[in]*  **v1**  vector1
+      | *[in]*  **v2**  vector2
 
     Returns:
       | squared distance (distance * distance)
@@ -446,8 +446,8 @@ Functions documentation
     distance between two vectors
 
     Parameters:
-      | *[in]*  **mat**   vector1
-      | *[in]*  **row1**  vector2
+      | *[in]*  **v1**  vector1
+      | *[in]*  **v2**  vector2
 
     Returns:
       | distance
@@ -475,7 +475,7 @@ Functions documentation
     possible orthogonal/perpendicular vector
 
     Parameters:
-      | *[in]*  **mat**   vector
+      | *[in]*  **v**     vector
       | *[out]* **dest**  orthogonal/perpendicular vector
 
 .. c:function:: void  glm_vec3_clamp(vec3 v, float minVal, float maxVal)

docs/source/version.rst

@@ -0,0 +1,15 @@
+.. default-domain:: C
+
+version
+================================================================================
+
+Header: cglm/version.h
+
+**cglm** uses semantic versioning (http://semver.org) which is MAJOR.MINOR.PATCH 
+
+| **CGLM_VERSION_MAJOR** is major number of the version.
+| **CGLM_VERSION_MINOR** is minor number of the version.
+| **CGLM_VERSION_PATCH** is patch number of the version.
+
+every release increases these numbers. You can check existing version by 
+including `cglm/version.h`

include/cglm/affine.h

@@ -40,10 +40,6 @@
 #include "mat4.h"
 #include "affine-mat.h"
 
-CGLM_INLINE
-void
-glm_mat4_mul(mat4 m1, mat4 m2, mat4 dest);
-
 /*!
  * @brief translate existing transform matrix by v vector
  *        and stores result in same matrix

include/cglm/applesimd.h

@@ -0,0 +1,95 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglm_applesimd_h
+#define cglm_applesimd_h
+#if defined(__APPLE__)                                                        \
+    && defined(SIMD_COMPILER_HAS_REQUIRED_FEATURES)                           \
+    && defined(SIMD_BASE)                                                     \
+    && defined(SIMD_TYPES)                                                    \
+    && defined(SIMD_VECTOR_TYPES)
+
+#include "common.h"
+
+/*!
+* @brief converts mat4 to Apple's simd type simd_float4x4
+* @return simd_float4x4
+*/
+CGLM_INLINE
+simd_float4x4
+glm_mat4_applesimd(mat4 m) {
+  simd_float4x4 t;
+  
+  t.columns[0][0] = m[0][0];
+  t.columns[0][1] = m[0][1];
+  t.columns[0][2] = m[0][2];
+  t.columns[0][3] = m[0][3];
+
+  t.columns[1][0] = m[1][0];
+  t.columns[1][1] = m[1][1];
+  t.columns[1][2] = m[1][2];
+  t.columns[1][3] = m[1][3];
+
+  t.columns[2][0] = m[2][0];
+  t.columns[2][1] = m[2][1];
+  t.columns[2][2] = m[2][2];
+  t.columns[2][3] = m[2][3];
+
+  t.columns[3][0] = m[3][0];
+  t.columns[3][1] = m[3][1];
+  t.columns[3][2] = m[3][2];
+  t.columns[3][3] = m[3][3];
+
+  return t;
+}
+
+/*!
+* @brief converts mat3 to Apple's simd type simd_float3x3
+* @return simd_float3x3
+*/
+CGLM_INLINE
+simd_float3x3
+glm_mat3_applesimd(mat3 m) {
+  simd_float3x3 t;
+  
+  t.columns[0][0] = m[0][0];
+  t.columns[0][1] = m[0][1];
+  t.columns[0][2] = m[0][2];
+
+  t.columns[1][0] = m[1][0];
+  t.columns[1][1] = m[1][1];
+  t.columns[1][2] = m[1][2];
+
+  t.columns[2][0] = m[2][0];
+  t.columns[2][1] = m[2][1];
+  t.columns[2][2] = m[2][2];
+
+  return t;
+}
+
+/*!
+* @brief converts vec4 to Apple's simd type simd_float4
+* @return simd_float4
+*/
+CGLM_INLINE
+simd_float4
+glm_vec4_applesimd(vec4 v) {
+  return (simd_float4){v[0], v[1], v[2], v[3]};
+}
+
+/*!
+* @brief converts vec3 to Apple's simd type simd_float3
+* @return v
+*/
+CGLM_INLINE
+simd_float3
+glm_vec3_applesimd(vec3 v) {
+  return (simd_float3){v[0], v[1], v[2]};
+}
+
+#endif
+#endif /* cglm_applesimd_h */

include/cglm/bezier.h

@@ -22,9 +22,9 @@
 #define GLM_BEZIER_MAT  ((mat4)GLM_BEZIER_MAT_INIT)
 #define GLM_HERMITE_MAT ((mat4)GLM_HERMITE_MAT_INIT)
 
-#define CGLM_DECASTEL_EPS   1e-9
-#define CGLM_DECASTEL_MAX   1000
-#define CGLM_DECASTEL_SMALL 1e-20
+#define CGLM_DECASTEL_EPS   1e-9f
+#define CGLM_DECASTEL_MAX   1000.0f
+#define CGLM_DECASTEL_SMALL 1e-20f
 
 /*!
  * @brief cubic bezier interpolation

include/cglm/call.h

@@ -12,10 +12,12 @@ extern "C" {
 #endif
 
 #include "cglm.h"
+#include "call/vec2.h"
 #include "call/vec3.h"
 #include "call/vec4.h"
-#include "call/mat4.h"
+#include "call/mat2.h"
 #include "call/mat3.h"
+#include "call/mat4.h"
 #include "call/affine.h"
 #include "call/cam.h"
 #include "call/quat.h"
@@ -29,6 +31,7 @@ extern "C" {
 #include "call/ease.h"
 #include "call/curve.h"
 #include "call/bezier.h"
+#include "call/ray.h"
 
 #ifdef __cplusplus
 }

include/cglm/call/io.h

@@ -7,6 +7,7 @@
 
 #ifndef cglmc_io_h
 #define cglmc_io_h
+
 #ifdef __cplusplus
 extern "C" {
 #endif

include/cglm/call/mat2.h

@@ -0,0 +1,79 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_mat2_h
+#define cglmc_mat2_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_mat2_copy(mat2 mat, mat2 dest);
+
+CGLM_EXPORT
+void
+glmc_mat2_identity(mat2 mat);
+
+CGLM_EXPORT
+void
+glmc_mat2_identity_array(mat2 * __restrict mat, size_t count);
+
+CGLM_EXPORT
+void
+glmc_mat2_zero(mat2 mat);
+
+CGLM_EXPORT
+void
+glmc_mat2_mul(mat2 m1, mat2 m2, mat2 dest);
+
+CGLM_EXPORT
+void
+glmc_mat2_transpose_to(mat2 m, mat2 dest);
+
+CGLM_EXPORT
+void
+glmc_mat2_transpose(mat2 m);
+
+CGLM_EXPORT
+void
+glmc_mat2_mulv(mat2 m, vec2 v, vec2 dest);
+
+CGLM_EXPORT
+float
+glmc_mat2_trace(mat2 m);
+
+CGLM_EXPORT
+void
+glmc_mat2_scale(mat2 m, float s);
+
+CGLM_EXPORT
+float
+glmc_mat2_det(mat2 mat);
+
+CGLM_EXPORT
+void
+glmc_mat2_inv(mat2 mat, mat2 dest);
+
+CGLM_EXPORT
+void
+glmc_mat2_swap_col(mat2 mat, int col1, int col2);
+
+CGLM_EXPORT
+void
+glmc_mat2_swap_row(mat2 mat, int row1, int row2);
+
+CGLM_EXPORT
+float
+glmc_mat2_rmc(vec2 r, mat2 m, vec2 c);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_mat2_h */

include/cglm/call/mat3.h

@@ -24,6 +24,10 @@ CGLM_EXPORT
 void
 glmc_mat3_identity(mat3 mat);
 
+CGLM_EXPORT
+void
+glmc_mat3_zero(mat3 mat);
+
 CGLM_EXPORT
 void
 glmc_mat3_identity_array(mat3 * __restrict mat, size_t count);

include/cglm/call/mat4.h

@@ -33,6 +33,10 @@ CGLM_EXPORT
 void
 glmc_mat4_identity_array(mat4 * __restrict mat, size_t count);
 
+CGLM_EXPORT
+void
+glmc_mat4_zero(mat4 mat);
+
 CGLM_EXPORT
 void
 glmc_mat4_pick3(mat4 mat, mat3 dest);

include/cglm/call/quat.h

@@ -131,11 +131,11 @@ glmc_quat_look(vec3 eye, versor ori, mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest);
+glmc_quat_for(vec3 dir, vec3 up, versor dest);
 
 CGLM_EXPORT
 void
-glmc_quat_forp(vec3 from, vec3 to, vec3 fwd, vec3 up, versor dest);
+glmc_quat_forp(vec3 from, vec3 to, vec3 up, versor dest);
 
 CGLM_EXPORT
 void

include/cglm/call/ray.h

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_ray_h
+#define cglmc_ray_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "../cglm.h"
+
+CGLM_EXPORT
+bool
+glmc_ray_triangle(vec3   origin,
+                  vec3   direction,
+                  vec3   v0,
+                  vec3   v1,
+                  vec3   v2,
+                  float *d);
+    
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_ray_h */

include/cglm/call/vec2.h

@@ -0,0 +1,155 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_vec2_h
+#define cglmc_vec2_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_vec2(float * __restrict v, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_copy(vec2 a, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_zero(vec2 v);
+
+CGLM_EXPORT
+void
+glmc_vec2_one(vec2 v);
+
+CGLM_EXPORT
+float
+glmc_vec2_dot(vec2 a, vec2 b);
+
+CGLM_EXPORT
+float
+glmc_vec2_cross(vec2 a, vec2 b);
+
+CGLM_EXPORT
+float
+glmc_vec2_norm2(vec2 v);
+
+CGLM_EXPORT
+float
+glmc_vec2_norm(vec2 v);
+
+CGLM_EXPORT
+void
+glmc_vec2_add(vec2 a, vec2 b, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_adds(vec2 v, float s, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_sub(vec2 a, vec2 b, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_subs(vec2 v, float s, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_mul(vec2 a, vec2 b, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_scale(vec2 v, float s, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_scale_as(vec2 v, float s, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_div(vec2 a, vec2 b, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_divs(vec2 v, float s, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_addadd(vec2 a, vec2 b, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_subadd(vec2 a, vec2 b, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_muladd(vec2 a, vec2 b, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_muladds(vec2 a, float s, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_maxadd(vec2 a, vec2 b, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_minadd(vec2 a, vec2 b, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_negate_to(vec2 v, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_negate(vec2 v);
+
+CGLM_EXPORT
+void
+glmc_vec2_normalize(vec2 v);
+
+CGLM_EXPORT
+void
+glmc_vec2_normalize_to(vec2 v, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_rotate(vec2 v, float angle, vec2 dest);
+
+CGLM_EXPORT
+float
+glmc_vec2_distance2(vec2 a, vec2 b);
+
+CGLM_EXPORT
+float
+glmc_vec2_distance(vec2 a, vec2 b);
+
+CGLM_EXPORT
+void
+glmc_vec2_maxv(vec2 a, vec2 b, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_minv(vec2 a, vec2 b, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_clamp(vec2 v, float minval, float maxval);
+
+CGLM_EXPORT
+void
+glmc_vec2_lerp(vec2 from, vec2 to, float t, vec2 dest);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_vec2_h */

include/cglm/cam.h

@@ -319,10 +319,7 @@ glm_perspective_resize(float aspect, mat4 proj) {
  */
 CGLM_INLINE
 void
-glm_lookat(vec3 eye,
-           vec3 center,
-           vec3 up,
-           mat4 dest) {
+glm_lookat(vec3 eye, vec3 center, vec3 up, mat4 dest) {
   CGLM_ALIGN(8) vec3 f, u, s;
 
   glm_vec3_sub(center, eye, f);

include/cglm/cglm.h

@@ -9,10 +9,12 @@
 #define cglm_h
 
 #include "common.h"
+#include "vec2.h"
 #include "vec3.h"
 #include "vec4.h"
 #include "mat4.h"
 #include "mat3.h"
+#include "mat2.h"
 #include "affine.h"
 #include "cam.h"
 #include "frustum.h"
@@ -28,5 +30,6 @@
 #include "ease.h"
 #include "curve.h"
 #include "bezier.h"
+#include "ray.h"
 
 #endif /* cglm_h */

include/cglm/common.h

@@ -8,7 +8,13 @@
 #ifndef cglm_common_h
 #define cglm_common_h
 
-#define _USE_MATH_DEFINES /* for windows */
+#ifndef _USE_MATH_DEFINES
+#  define _USE_MATH_DEFINES       /* for windows */
+#endif
+
+#ifndef _CRT_SECURE_NO_WARNINGS
+#  define _CRT_SECURE_NO_WARNINGS /* for windows */
+#endif
 
 #include <stdint.h>
 #include <stddef.h>
@@ -34,4 +40,12 @@
 #include "types.h"
 #include "simd/intrin.h"
 
+#ifndef CGLM_USE_DEFAULT_EPSILON
+#  ifndef GLM_FLT_EPSILON
+#    define GLM_FLT_EPSILON 1e-6
+#  endif
+#else
+#  define GLM_FLT_EPSILON FLT_EPSILON
+#endif
+
 #endif /* cglm_common_h */

include/cglm/euler.h

@@ -55,8 +55,6 @@ typedef enum glm_euler_seq {
   GLM_EULER_ZYX = 2 << 0 | 1 << 2 | 0 << 4
 } glm_euler_seq;
 
-typedef glm_euler_seq glm_euler_sq;
-
 CGLM_INLINE
 glm_euler_seq
 glm_euler_order(int ord[3]) {

include/cglm/io.h

@@ -17,37 +17,99 @@
 
 #ifndef cglm_io_h
 #define cglm_io_h
+#if defined(DEBUG) || defined(_DEBUG) \
+   || defined(CGLM_DEFINE_PRINTS) || defined(CGLM_LIB_SRC)
 
 #include "common.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 
+#define CGLM_PRINT_PRECISION    5
+#define CGLM_PRINT_MAX_TO_SHORT 1e5
+#define CGLM_PRINT_COLOR        "\033[36m"
+#define CGLM_PRINT_COLOR_RESET  "\033[0m"
+
 CGLM_INLINE
 void
 glm_mat4_print(mat4              matrix,
                FILE * __restrict ostream) {
-  int i;
-  int j;
+  char buff[16];
+  int  i, j, cw[4], cwi;
 
 #define m 4
 #define n 4
 
-  fprintf(ostream, "Matrix (float%dx%d):\n", m, n);
+  fprintf(ostream, "Matrix (float%dx%d): " CGLM_PRINT_COLOR "\n" , m, n);
+
+  cw[0] = cw[1] = cw[2] = cw[3] = 0;
 
   for (i = 0; i < m; i++) {
-    fprintf(ostream, "\t|");
     for (j = 0; j < n; j++) {
-      fprintf(ostream, "%0.4f", matrix[j][i]);;
-
-      if (j != n - 1)
-        fprintf(ostream, "\t");
+      if (matrix[i][j] < CGLM_PRINT_MAX_TO_SHORT)
+        cwi = sprintf(buff, "% .*f", CGLM_PRINT_PRECISION, matrix[i][j]);
+      else
+        cwi = sprintf(buff, "% g", matrix[i][j]);
+      cw[i] = GLM_MAX(cw[i], cwi);
     }
-
-    fprintf(ostream, "|\n");
   }
 
-  fprintf(ostream, "\n");
+  for (i = 0; i < m; i++) {
+    fprintf(ostream, "  |");
+
+    for (j = 0; j < n; j++)
+      if (matrix[i][j] < CGLM_PRINT_MAX_TO_SHORT)
+        fprintf(ostream, " % *.*f", cw[j], CGLM_PRINT_PRECISION, matrix[j][i]);
+      else
+        fprintf(ostream, " % *g", cw[j], matrix[j][i]);
+
+    fprintf(ostream, "  |\n");
+  }
+
+  fprintf(ostream, CGLM_PRINT_COLOR_RESET "\n");
+
+#undef m
+#undef n
+}
+
+
+CGLM_INLINE
+void
+glm_mat3_print(mat3              matrix,
+               FILE * __restrict ostream) {
+  char buff[16];
+  int  i, j, cw[4], cwi;
+
+#define m 3
+#define n 3
+
+  fprintf(ostream, "Matrix (float%dx%d): " CGLM_PRINT_COLOR "\n", m, n);
+
+  cw[0] = cw[1] = cw[2] = 0;
+
+  for (i = 0; i < m; i++) {
+    for (j = 0; j < n; j++) {
+      if (matrix[i][j] < CGLM_PRINT_MAX_TO_SHORT)
+        cwi = sprintf(buff, "% .*f", CGLM_PRINT_PRECISION, matrix[i][j]);
+      else
+        cwi = sprintf(buff, "% g", matrix[i][j]);
+      cw[i] = GLM_MAX(cw[i], cwi);
+    }
+  }
+
+  for (i = 0; i < m; i++) {
+    fprintf(ostream, "  |");
+    
+    for (j = 0; j < n; j++)
+      if (matrix[i][j] < CGLM_PRINT_MAX_TO_SHORT)
+        fprintf(ostream, " % *.*f", cw[j], CGLM_PRINT_PRECISION, matrix[j][i]);
+      else
+        fprintf(ostream, " % *g", cw[j], matrix[j][i]);
+    
+    fprintf(ostream, "  |\n");
+  }
+
+  fprintf(ostream, CGLM_PRINT_COLOR_RESET "\n");
 
 #undef m
 #undef n
@@ -55,29 +117,41 @@ glm_mat4_print(mat4              matrix,
 
 CGLM_INLINE
 void
-glm_mat3_print(mat3              matrix,
+glm_mat2_print(mat2              matrix,
                FILE * __restrict ostream) {
-  int i;
-  int j;
+  char buff[16];
+  int  i, j, cw[4], cwi;
 
-#define m 3
-#define n 3
+#define m 2
+#define n 2
 
-  fprintf(ostream, "Matrix (float%dx%d):\n", m, n);
+  fprintf(ostream, "Matrix (float%dx%d): " CGLM_PRINT_COLOR "\n", m, n);
+
+  cw[0] = cw[1] = 0;
 
   for (i = 0; i < m; i++) {
-    fprintf(ostream, "\t|");
     for (j = 0; j < n; j++) {
-      fprintf(ostream, "%0.4f", matrix[j][i]);;
-
-      if (j != n - 1)
-        fprintf(ostream, "\t");
+      if (matrix[i][j] < CGLM_PRINT_MAX_TO_SHORT)
+        cwi = sprintf(buff, "% .*f", CGLM_PRINT_PRECISION, matrix[i][j]);
+      else
+        cwi = sprintf(buff, "% g", matrix[i][j]);
+      cw[i] = GLM_MAX(cw[i], cwi);
     }
-
-    fprintf(ostream, "|\n");
   }
 
-  fprintf(ostream, "\n");
+  for (i = 0; i < m; i++) {
+    fprintf(ostream, "  |");
+    
+    for (j = 0; j < n; j++)
+      if (matrix[i][j] < CGLM_PRINT_MAX_TO_SHORT)
+        fprintf(ostream, " % *.*f", cw[j], CGLM_PRINT_PRECISION, matrix[j][i]);
+      else
+        fprintf(ostream, " % *g", cw[j], matrix[j][i]);
+    
+    fprintf(ostream, "  |\n");
+  }
+
+  fprintf(ostream, CGLM_PRINT_COLOR_RESET "\n");
 
 #undef m
 #undef n
@@ -91,16 +165,16 @@ glm_vec4_print(vec4              vec,
 
 #define m 4
 
-  fprintf(ostream, "Vector (float%d):\n\t|", m);
+  fprintf(ostream, "Vector (float%d): " CGLM_PRINT_COLOR "\n  (", m);
 
   for (i = 0; i < m; i++) {
-    fprintf(ostream, "%0.4f", vec[i]);
-
-    if (i != m - 1)
-      fprintf(ostream, "\t");
+    if (vec[i] < CGLM_PRINT_MAX_TO_SHORT)
+      fprintf(ostream, " % .*f", CGLM_PRINT_PRECISION, vec[i]);
+    else
+      fprintf(ostream, " % g", vec[i]);
   }
 
-  fprintf(ostream, "|\n\n");
+  fprintf(ostream, "  )" CGLM_PRINT_COLOR_RESET "\n\n");
 
 #undef m
 }
@@ -113,16 +187,16 @@ glm_vec3_print(vec3              vec,
 
 #define m 3
 
-  fprintf(ostream, "Vector (float%d):\n\t|", m);
+  fprintf(ostream, "Vector (float%d): " CGLM_PRINT_COLOR "\n  (", m);
 
   for (i = 0; i < m; i++) {
-    fprintf(ostream, "%0.4f", vec[i]);
-
-    if (i != m - 1)
-      fprintf(ostream, "\t");
+    if (vec[i] < CGLM_PRINT_MAX_TO_SHORT)
+      fprintf(ostream, " % .*f", CGLM_PRINT_PRECISION, vec[i]);
+    else
+      fprintf(ostream, " % g", vec[i]);
   }
 
-  fprintf(ostream, "|\n\n");
+  fprintf(ostream, "  )" CGLM_PRINT_COLOR_RESET "\n\n");
 
 #undef m
 }
@@ -135,17 +209,35 @@ glm_ivec3_print(ivec3             vec,
 
 #define m 3
 
-  fprintf(ostream, "Vector (int%d):\n\t|", m);
+  fprintf(ostream, "Vector (int%d): " CGLM_PRINT_COLOR "\n  (", m);
+
+  for (i = 0; i < m; i++)
+    fprintf(ostream, " % d", vec[i]);
+
+  fprintf(ostream, "  )" CGLM_PRINT_COLOR_RESET "\n\n");
+  
+#undef m
+}
+
+CGLM_INLINE
+void
+glm_vec2_print(vec2              vec,
+               FILE * __restrict ostream) {
+  int i;
+
+#define m 2
+
+  fprintf(ostream, "Vector (float%d): " CGLM_PRINT_COLOR "\n  (", m);
 
   for (i = 0; i < m; i++) {
-    fprintf(ostream, "%d", vec[i]);
-
-    if (i != m - 1)
-      fprintf(ostream, "\t");
+    if (vec[i] < CGLM_PRINT_MAX_TO_SHORT)
+      fprintf(ostream, " % .*f", CGLM_PRINT_PRECISION, vec[i]);
+    else
+      fprintf(ostream, " % g", vec[i]);
   }
 
-  fprintf(ostream, "|\n\n");
-  
+  fprintf(ostream, "  )" CGLM_PRINT_COLOR_RESET "\n\n");
+
 #undef m
 }
 
@@ -157,16 +249,17 @@ glm_versor_print(versor            vec,
 
 #define m 4
 
-  fprintf(ostream, "Versor (float%d):\n\t|", m);
+  fprintf(ostream, "Quaternion (float%d): " CGLM_PRINT_COLOR "\n  (", m);
 
   for (i = 0; i < m; i++) {
-    fprintf(ostream, "%0.4f", vec[i]);
-
-    if (i != m - 1)
-      fprintf(ostream, "\t");
+    if (vec[i] < CGLM_PRINT_MAX_TO_SHORT)
+      fprintf(ostream, " % .*f", CGLM_PRINT_PRECISION, vec[i]);
+    else
+      fprintf(ostream, " % g", vec[i]);
   }
 
-  fprintf(ostream, "|\n\n");
+
+  fprintf(ostream, "  )" CGLM_PRINT_COLOR_RESET "\n\n");
 
 #undef m
 }
@@ -180,24 +273,43 @@ glm_aabb_print(vec3                    bbox[2],
 
 #define m 3
 
-  fprintf(ostream, "AABB (%s):\n", tag ? tag: "float");
+  fprintf(ostream, "AABB (%s): " CGLM_PRINT_COLOR "\n", tag ? tag: "float");
 
   for (i = 0; i < 2; i++) {
-    fprintf(ostream, "\t|");
-
+    fprintf(ostream, "  (");
+    
     for (j = 0; j < m; j++) {
-      fprintf(ostream, "%0.4f", bbox[i][j]);
-
-      if (j != m - 1)
-        fprintf(ostream, "\t");
+      if (bbox[i][j] < CGLM_PRINT_MAX_TO_SHORT)
+        fprintf(ostream, " % .*f", CGLM_PRINT_PRECISION, bbox[i][j]);
+      else
+        fprintf(ostream, " % g", bbox[i][j]);
     }
 
-    fprintf(ostream, "|\n");
+    fprintf(ostream, "  )\n");
   }
 
-  fprintf(ostream, "\n");
+  fprintf(ostream, CGLM_PRINT_COLOR_RESET "\n");
 
 #undef m
 }
 
+#elif !defined(CGLM_NO_PRINTS_NOOP)
+
+#include "common.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+/* NOOP: Remove print from DEBUG */
+#define glm_mat4_print(...)
+#define glm_mat3_print(...)
+#define glm_mat2_print(...)
+#define glm_vec4_print(...)
+#define glm_vec3_print(...)
+#define glm_ivec3_print(...)
+#define glm_vec2_print(...)
+#define glm_versor_print(...)
+#define glm_aabb_print(...)
+
+#endif
 #endif /* cglm_io_h */

include/cglm/mat2.h

@@ -0,0 +1,322 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   GLM_MAT2_IDENTITY_INIT
+   GLM_MAT2_ZERO_INIT
+   GLM_MAT2_IDENTITY
+   GLM_MAT2_ZERO
+
+ Functions:
+   CGLM_INLINE void  glm_mat2_copy(mat2 mat, mat2 dest)
+   CGLM_INLINE void  glm_mat2_identity(mat2 mat)
+   CGLM_INLINE void  glm_mat2_identity_array(mat2 * restrict mat, size_t count)
+   CGLM_INLINE void  glm_mat2_zero(mat2 mat)
+   CGLM_INLINE void  glm_mat2_mul(mat2 m1, mat2 m2, mat2 dest)
+   CGLM_INLINE void  glm_mat2_transpose_to(mat2 m, mat2 dest)
+   CGLM_INLINE void  glm_mat2_transpose(mat2 m)
+   CGLM_INLINE void  glm_mat2_mulv(mat2 m, vec2 v, vec2 dest)
+   CGLM_INLINE float glm_mat2_trace(mat2 m)
+   CGLM_INLINE void  glm_mat2_scale(mat2 m, float s)
+   CGLM_INLINE float glm_mat2_det(mat2 mat)
+   CGLM_INLINE void  glm_mat2_inv(mat2 mat, mat2 dest)
+   CGLM_INLINE void  glm_mat2_swap_col(mat2 mat, int col1, int col2)
+   CGLM_INLINE void  glm_mat2_swap_row(mat2 mat, int row1, int row2)
+   CGLM_INLINE float glm_mat2_rmc(vec2 r, mat2 m, vec2 c)
+ */
+
+#ifndef cglm_mat2_h
+#define cglm_mat2_h
+
+#include "common.h"
+#include "vec2.h"
+
+#ifdef CGLM_SSE_FP
+#  include "simd/sse2/mat2.h"
+#endif
+
+#define GLM_MAT2_IDENTITY_INIT  {{1.0f, 0.0f}, {0.0f, 1.0f}}
+#define GLM_MAT2_ZERO_INIT      {{0.0f, 0.0f}, {0.0f, 0.0f}}
+
+/* for C only */
+#define GLM_MAT2_IDENTITY ((mat2)GLM_MAT2_IDENTITY_INIT)
+#define GLM_MAT2_ZERO     ((mat2)GLM_MAT2_ZERO_INIT)
+
+/*!
+ * @brief copy all members of [mat] to [dest]
+ *
+ * @param[in]  mat  source
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_mat2_copy(mat2 mat, mat2 dest) {
+  glm_vec4_copy(mat[0], dest[0]);
+}
+
+/*!
+ * @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_mat2_identity(aStruct->aMatrix);
+ *
+ * @code
+ * glm_mat2_copy(GLM_MAT2_IDENTITY, mat); // C only
+ *
+ * // or
+ * mat2 mat = GLM_MAT2_IDENTITY_INIT;
+ * @endcode
+ *
+ * @param[in, out]  mat  destination
+ */
+CGLM_INLINE
+void
+glm_mat2_identity(mat2 mat) {
+  CGLM_ALIGN_MAT mat2 t = GLM_MAT2_IDENTITY_INIT;
+  glm_mat2_copy(t, mat);
+}
+
+/*!
+ * @brief make given matrix array's each element identity matrix
+ *
+ * @param[in, out]  mat   matrix array (must be aligned (16)
+ *                        if alignment is not disabled)
+ *
+ * @param[in]       count count of matrices
+ */
+CGLM_INLINE
+void
+glm_mat2_identity_array(mat2 * __restrict mat, size_t count) {
+  CGLM_ALIGN_MAT mat2 t = GLM_MAT2_IDENTITY_INIT;
+  size_t i;
+
+  for (i = 0; i < count; i++) {
+    glm_mat2_copy(t, mat[i]);
+  }
+}
+
+/*!
+ * @brief make given matrix zero.
+ *
+ * @param[in, out]  mat  matrix
+ */
+CGLM_INLINE
+void
+glm_mat2_zero(mat2 mat) {
+  CGLM_ALIGN_MAT mat2 t = GLM_MAT2_ZERO_INIT;
+  glm_mat2_copy(t, mat);
+}
+
+/*!
+ * @brief multiply m1 and m2 to dest
+ *
+ * m1, m2 and dest matrices can be same matrix, it is possible to write this:
+ *
+ * @code
+ * mat2 m = GLM_MAT2_IDENTITY_INIT;
+ * glm_mat2_mul(m, m, m);
+ * @endcode
+ *
+ * @param[in]  m1   left matrix
+ * @param[in]  m2   right matrix
+ * @param[out] dest destination matrix
+ */
+CGLM_INLINE
+void
+glm_mat2_mul(mat2 m1, mat2 m2, mat2 dest) {
+#if defined( __SSE__ ) || defined( __SSE2__ )
+  glm_mat2_mul_sse2(m1, m2, dest);
+#else
+  float a00 = m1[0][0], a01 = m1[0][1],
+        a10 = m1[1][0], a11 = m1[1][1],
+        b00 = m2[0][0], b01 = m2[0][1],
+        b10 = m2[1][0], b11 = m2[1][1];
+
+  dest[0][0] = a00 * b00 + a10 * b01;
+  dest[0][1] = a01 * b00 + a11 * b01;
+  dest[1][0] = a00 * b10 + a10 * b11;
+  dest[1][1] = a01 * b10 + a11 * b11;
+#endif
+}
+
+/*!
+ * @brief transpose mat2 and store in dest
+ *
+ * source matrix will not be transposed unless dest is m
+ *
+ * @param[in]  m     matrix
+ * @param[out] dest  result
+ */
+CGLM_INLINE
+void
+glm_mat2_transpose_to(mat2 m, mat2 dest) {
+#if defined( __SSE__ ) || defined( __SSE2__ )
+  glm_mat2_transp_sse2(m, dest);
+#else
+  dest[0][0] = m[0][0];
+  dest[0][1] = m[1][0];
+  dest[1][0] = m[0][1];
+  dest[1][1] = m[1][1];
+#endif
+}
+
+/*!
+ * @brief tranpose mat2 and store result in same matrix
+ *
+ * @param[in, out] m source and dest
+ */
+CGLM_INLINE
+void
+glm_mat2_transpose(mat2 m) {
+  float tmp;
+  tmp     = m[0][1];
+  m[0][1] = m[1][0];
+  m[1][0] = tmp;
+}
+
+/*!
+ * @brief multiply mat2 with vec2 (column vector) and store in dest vector
+ *
+ * @param[in]  m    mat2 (left)
+ * @param[in]  v    vec2 (right, column vector)
+ * @param[out] dest vec2 (result, column vector)
+ */
+CGLM_INLINE
+void
+glm_mat2_mulv(mat2 m, vec2 v, vec2 dest) {
+  dest[0] = m[0][0] * v[0] + m[1][0] * v[1];
+  dest[1] = m[0][1] * v[0] + m[1][1] * v[1];
+}
+
+/*!
+ * @brief trace of matrix
+ *
+ * sum of the elements on the main diagonal from upper left to the lower right
+ *
+ * @param[in]  m matrix
+ */
+CGLM_INLINE
+float
+glm_mat2_trace(mat2 m) {
+  return m[0][0] + m[1][1];
+}
+
+/*!
+ * @brief scale (multiply with scalar) matrix
+ *
+ * multiply matrix with scalar
+ *
+ * @param[in, out] m matrix
+ * @param[in]      s scalar
+ */
+CGLM_INLINE
+void
+glm_mat2_scale(mat2 m, float s) {
+  glm_vec4_scale(m[0], s, m[0]);
+}
+
+/*!
+ * @brief mat2 determinant
+ *
+ * @param[in] mat matrix
+ *
+ * @return determinant
+ */
+CGLM_INLINE
+float
+glm_mat2_det(mat2 mat) {
+  return mat[0][0] * mat[1][1] - mat[1][0] * mat[0][1];
+}
+
+/*!
+ * @brief inverse mat2 and store in dest
+ *
+ * @param[in]  mat  matrix
+ * @param[out] dest inverse matrix
+ */
+CGLM_INLINE
+void
+glm_mat2_inv(mat2 mat, mat2 dest) {
+  float det;
+  float a = mat[0][0], b = mat[0][1],
+        c = mat[1][0], d = mat[1][1];
+
+  det = 1.0f / (a * d - b * c);
+
+  dest[0][0] =  d * det;
+  dest[0][1] = -b * det;
+  dest[1][0] = -c * det;
+  dest[1][1] =  a * det;
+}
+
+/*!
+ * @brief swap two matrix columns
+ *
+ * @param[in,out] mat  matrix
+ * @param[in]     col1 col1
+ * @param[in]     col2 col2
+ */
+CGLM_INLINE
+void
+glm_mat2_swap_col(mat2 mat, int col1, int col2) {
+  float a, b;
+
+  a = mat[col1][0];
+  b = mat[col1][1];
+
+  mat[col1][0] = mat[col2][0];
+  mat[col1][1] = mat[col2][1];
+
+  mat[col2][0] = a;
+  mat[col2][1] = b;
+}
+
+/*!
+ * @brief swap two matrix rows
+ *
+ * @param[in,out] mat  matrix
+ * @param[in]     row1 row1
+ * @param[in]     row2 row2
+ */
+CGLM_INLINE
+void
+glm_mat2_swap_row(mat2 mat, int row1, int row2) {
+  float a, b;
+
+  a = mat[0][row1];
+  b = mat[1][row1];
+
+  mat[0][row1] = mat[0][row2];
+  mat[1][row1] = mat[1][row2];
+
+  mat[0][row2] = a;
+  mat[1][row2] = b;
+}
+
+/*!
+ * @brief helper for  R (row vector) * M (matrix) * C (column vector)
+ *
+ * rmc stands for Row * Matrix * Column
+ *
+ * the result is scalar because R * M = Matrix1x2 (row vector),
+ * then Matrix1x2 * Vec2 (column vector) = Matrix1x1 (Scalar)
+ *
+ * @param[in]  r   row vector or matrix1x2
+ * @param[in]  m   matrix2x2
+ * @param[in]  c   column vector or matrix2x1
+ *
+ * @return scalar value e.g. Matrix1x1
+ */
+CGLM_INLINE
+float
+glm_mat2_rmc(vec2 r, mat2 m, vec2 c) {
+  vec2 tmp;
+  glm_mat2_mulv(m, c, tmp);
+  return glm_vec2_dot(r, tmp);
+}
+
+#endif /* cglm_mat2_h */

include/cglm/mat4.h

@@ -446,6 +446,9 @@ glm_mat4_quat(mat4 m, versor dest) {
 /*!
  * @brief multiply vector with mat4
  *
+ * actually the result is vec4, after multiplication the last component
+ * is trimmed. if you need it don't use this func.
+ *
  * @param[in]  m    mat4(affine transform)
  * @param[in]  v    vec3
  * @param[in]  last 4th item to make it vec4

include/cglm/plane.h

@@ -30,7 +30,14 @@
 CGLM_INLINE
 void
 glm_plane_normalize(vec4 plane) {
-  glm_vec4_scale(plane, 1.0f / glm_vec3_norm(plane), plane);
+  float norm;
+  
+  if ((norm = glm_vec3_norm(plane)) == 0.0f) {
+    glm_vec4_zero(plane);
+    return;
+  }
+  
+  glm_vec4_scale(plane, 1.0f / norm, plane);
 }
 
 #endif /* cglm_plane_h */

include/cglm/quat.h

@@ -63,10 +63,6 @@
 #  include "simd/sse2/quat.h"
 #endif
 
-CGLM_INLINE
-void
-glm_mat4_identity(mat4 mat);
-
 CGLM_INLINE
 void
 glm_mat4_mulv(mat4 m, vec4 v, vec4 dest);
@@ -693,32 +689,23 @@ glm_quat_look(vec3 eye, versor ori, mat4 dest) {
  * @brief creates look rotation quaternion
  *
  * @param[in]   dir   direction to look
- * @param[in]   fwd   forward vector
  * @param[in]   up    up vector
  * @param[out]  dest  destination quaternion
  */
 CGLM_INLINE
 void
-glm_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest) {
-  CGLM_ALIGN(8) vec3 axis;
-  float dot, angle;
+glm_quat_for(vec3 dir, vec3 up, versor dest) {
+  CGLM_ALIGN_MAT mat3 m;
 
-  dot = glm_vec3_dot(dir, fwd);
-  if (fabsf(dot + 1.0f)  < 0.000001f) {
-    glm_quat_init(dest, up[0], up[1], up[2], GLM_PIf);
-    return;
-  }
+  glm_vec3_normalize_to(dir, m[2]); 
 
-  if (fabsf(dot - 1.0f) < 0.000001f) {
-    glm_quat_identity(dest);
-    return;
-  }
+  /* No need to negate in LH, but we use RH here */
+  glm_vec3_negate(m[2]);
+  
+  glm_vec3_crossn(up, m[2], m[0]);
+  glm_vec3_cross(m[2], m[0], m[1]);
 
-  angle = acosf(dot);
-  glm_cross(fwd, dir, axis);
-  glm_normalize(axis);
-
-  glm_quatv(dest, angle, axis);
+  glm_mat3_quat(m, dest);
 }
 
 /*!
@@ -727,16 +714,15 @@ glm_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest) {
  *
  * @param[in]   from  source point
  * @param[in]   to    destination point
- * @param[in]   fwd   forward vector
  * @param[in]   up    up vector
  * @param[out]  dest  destination quaternion
  */
 CGLM_INLINE
 void
-glm_quat_forp(vec3 from, vec3 to, vec3 fwd, vec3 up, versor dest) {
+glm_quat_forp(vec3 from, vec3 to, vec3 up, versor dest) {
   CGLM_ALIGN(8) vec3 dir;
   glm_vec3_sub(to, from, dir);
-  glm_quat_for(dir, fwd, up, dest);
+  glm_quat_for(dir, up, dest);
 }
 
 /*!

include/cglm/ray.h

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE bool glm_line_triangle_intersect(vec3   origin,
+                                                vec3   direction,
+                                                vec3   v0,
+                                                vec3   v1,
+                                                vec3   v2,
+                                                float *d);
+*/
+
+#ifndef cglm_ray_h
+#define cglm_ray_h
+
+#include "vec3.h"
+
+/*!
+ * @brief Möller–Trumbore ray-triangle intersection algorithm
+ * 
+ * @param[in] origin         origin of ray
+ * @param[in] direction      direction of ray
+ * @param[in] v0             first vertex of triangle
+ * @param[in] v1             second vertex of triangle
+ * @param[in] v2             third vertex of triangle
+ * @param[in, out] d         distance to intersection
+ * @return whether there is intersection
+ */
+
+CGLM_INLINE
+bool
+glm_ray_triangle(vec3   origin,
+                 vec3   direction,
+                 vec3   v0,
+                 vec3   v1,
+                 vec3   v2,
+                 float *d) {
+  vec3        edge1, edge2, p, t, q;
+  float       det, inv_det, u, v, dist;
+  const float epsilon = 0.000001f;
+
+  glm_vec3_sub(v1, v0, edge1);
+  glm_vec3_sub(v2, v0, edge2);
+  glm_vec3_cross(direction, edge2, p);
+
+  det = glm_vec3_dot(edge1, p);
+  if (det > -epsilon && det < epsilon)
+    return false;
+
+  inv_det = 1.0f / det;
+  
+  glm_vec3_sub(origin, v0, t);
+
+  u = inv_det * glm_vec3_dot(t, p);
+  if (u < 0.0f || u > 1.0f)
+    return false;
+
+  glm_vec3_cross(t, edge1, q);
+
+  v = inv_det * glm_vec3_dot(direction, q);
+  if (v < 0.0f || u + v > 1.0f)
+    return false;
+
+  dist = inv_det * glm_vec3_dot(edge2, q);
+
+  if (d)
+    *d = dist;
+
+  return dist > epsilon;
+}
+
+#endif

include/cglm/simd/arm.h

@@ -34,17 +34,19 @@ glmm_hadd(float32x4_t v) {
 static inline
 float
 glmm_hmin(float32x4_t v) {
-  v = vpmin_f32(vget_low_f32(v), vget_high_f32(v));
-  v = vpmin_f32(v, v);
-  return vget_lane_f32(v, 0);
+  float32x2_t t;
+  t = vpmin_f32(vget_low_f32(v), vget_high_f32(v));
+  t = vpmin_f32(t, t);
+  return vget_lane_f32(t, 0);
 }
 
 static inline
 float
 glmm_hmax(float32x4_t v) {
-  v = vpmax_f32(vget_low_f32(v), vget_high_f32(v));
-  v = vpmax_f32(v, v);
-  return vget_lane_f32(v, 0);
+  float32x2_t t;
+  t = vpmax_f32(vget_low_f32(v), vget_high_f32(v));
+  t = vpmax_f32(t, t);
+  return vget_lane_f32(t, 0);
 }
 
 static inline

include/cglm/simd/sse2/mat2.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglm_mat2_sse_h
+#define cglm_mat2_sse_h
+#if defined( __SSE__ ) || defined( __SSE2__ )
+
+#include "../../common.h"
+#include "../intrin.h"
+
+CGLM_INLINE
+void
+glm_mat2_mul_sse2(mat2 m1, mat2 m2, mat2 dest) {
+  __m128 x0, x1, x2;
+
+  x1 = glmm_load(m1[0]); /* d c b a */
+  x2 = glmm_load(m2[0]); /* h g f e */
+
+  /*
+   dest[0][0] = a * e + c * f;
+   dest[0][1] = b * e + d * f;
+   dest[1][0] = a * g + c * h;
+   dest[1][1] = b * g + d * h;
+   */
+  x0 = _mm_mul_ps(_mm_movelh_ps(x1, x1), glmm_shuff1(x2, 2, 2, 0, 0));
+  x1 = _mm_mul_ps(_mm_movehl_ps(x1, x1), glmm_shuff1(x2, 3, 3, 1, 1));
+  x1 = _mm_add_ps(x0, x1);
+
+  glmm_store(dest[0], x1);
+}
+
+CGLM_INLINE
+void
+glm_mat2_transp_sse2(mat2 m, mat2 dest) {
+  /* d c b a */
+  /* d b c a */
+  glmm_store(dest[0], glmm_shuff1(glmm_load(m[0]), 3, 1, 2, 0));
+}
+
+#endif
+#endif /* cglm_mat2_sse_h */

include/cglm/struct.h

@@ -13,8 +13,10 @@ extern "C" {
 
 #include "cglm.h"
 #include "types-struct.h"
+#include "struct/vec2.h"
 #include "struct/vec3.h"
 #include "struct/vec4.h"
+#include "struct/mat2.h"
 #include "struct/mat3.h"
 #include "struct/mat4.h"
 #include "struct/affine.h"

include/cglm/struct/affine.h

@@ -16,7 +16,7 @@
    CGLM_INLINE mat4s glms_scale_make(vec3s v);
    CGLM_INLINE mat4s glms_scale(mat4s m, vec3s v);
    CGLM_INLINE mat4s glms_scale_uni(mat4s m, float s);
-   CGLM_INLINE mat4s glmx_rotate_x(mat4s m, float angle);
+   CGLM_INLINE mat4s glms_rotate_x(mat4s m, float angle);
    CGLM_INLINE mat4s glms_rotate_y(mat4s m, float angle);
    CGLM_INLINE mat4s glms_rotate_z(mat4s m, float angle);
    CGLM_INLINE mat4s glms_rotate_make(float angle, vec3s axis);
@@ -39,10 +39,6 @@
 #include "vec4.h"
 #include "mat4.h"
 
-CGLM_INLINE
-mat4s
-glms_mat4_mul(mat4s m1, mat4s m2);
-
 /*!
  * @brief translate existing transform matrix by v vector
  *        and stores result in same matrix
@@ -169,7 +165,7 @@ glms_scale_uni(mat4s m, float s) {
  */
 CGLM_INLINE
 mat4s
-glmx_rotate_x(mat4s m, float angle) {
+glms_rotate_x(mat4s m, float angle) {
   mat4s r;
   glm_rotate_x(m.raw, angle, r.raw);
   return r;

include/cglm/struct/mat2.h

@@ -0,0 +1,258 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   GLM_MAT2_IDENTITY_INIT
+   GLM_MAT2_ZERO_INIT
+   GLM_MAT2_IDENTITY
+   GLM_MAT2_ZERO
+
+ Functions:
+   CGLM_INLINE void  glms_mat2_identity(mat2 mat)
+   CGLM_INLINE void  glms_mat2_identity_array(mat2 * restrict mat, size_t count)
+   CGLM_INLINE void  glms_mat2_zero(mat2 mat)
+   CGLM_INLINE void  glms_mat2_mul(mat2 m1, mat2 m2, mat2 dest)
+   CGLM_INLINE void  glms_mat2_transpose_to(mat2 m, mat2 dest)
+   CGLM_INLINE void  glms_mat2_transpose(mat2 m)
+   CGLM_INLINE void  glms_mat2_mulv(mat2 m, vec2 v, vec2 dest)
+   CGLM_INLINE float glms_mat2_trace(mat2 m)
+   CGLM_INLINE void  glms_mat2_scale(mat2 m, float s)
+   CGLM_INLINE float glms_mat2_det(mat2 mat)
+   CGLM_INLINE void  glms_mat2_inv(mat2 mat, mat2 dest)
+   CGLM_INLINE void  glms_mat2_swap_col(mat2 mat, int col1, int col2)
+   CGLM_INLINE void  glms_mat2_swap_row(mat2 mat, int row1, int row2)
+   CGLM_INLINE float glms_mat2_rmc(vec2 r, mat2 m, vec2 c)
+ */
+
+#ifndef cglms_mat2_h
+#define cglms_mat2_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../mat2.h"
+
+#define GLMS_MAT2_IDENTITY_INIT {GLM_MAT2_IDENTITY_INIT}
+#define GLMS_MAT2_ZERO_INIT     {GLM_MAT2_ZERO_INIT}
+
+/* for C only */
+#define GLMS_MAT2_IDENTITY ((mat3s)GLMS_MAT2_IDENTITY_INIT)
+#define GLMS_MAT2_ZERO     ((mat3s)GLMS_MAT2_ZERO_INIT)
+
+/*!
+ * @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_mat2_identity(aStruct->aMatrix);
+ *
+ * @code
+ * glm_mat2_copy(GLM_MAT2_IDENTITY, mat); // C only
+ *
+ * // or
+ * mat2 mat = GLM_MAT2_IDENTITY_INIT;
+ * @endcode
+ *
+ * @returns identity matrix
+ */
+CGLM_INLINE
+mat2s
+glms_mat2_identity(void) {
+  mat2s r;
+  glm_mat2_identity(r.raw);
+  return r;
+}
+
+/*!
+ * @brief make given matrix array's each element identity matrix
+ *
+ * @param[in, out]  mat   matrix array (must be aligned (16)
+ *                        if alignment is not disabled)
+ *
+ * @param[in]       count count of matrices
+ */
+CGLM_INLINE
+void
+glms_mat2_identity_array(mat2s * __restrict mat, size_t count) {
+  CGLM_ALIGN_MAT mat2s t = GLMS_MAT2_IDENTITY_INIT;
+  size_t i;
+
+  for (i = 0; i < count; i++) {
+    glm_mat2_copy(t.raw, mat[i].raw);
+  }
+}
+
+/*!
+ * @brief make given matrix zero.
+ *
+ * @returns  matrix
+ */
+CGLM_INLINE
+mat2s
+glms_mat2_zero(void) {
+  mat2s r;
+  glm_mat2_zero(r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply m1 and m2 to dest
+ *
+ * m1, m2 and dest matrices can be same matrix, it is possible to write this:
+ *
+ * @code
+ * mat2 m = GLM_MAT2_IDENTITY_INIT;
+ * glm_mat2_mul(m, m, m);
+ * @endcode
+ *
+ * @param[in]  m1   left matrix
+ * @param[in]  m2   right matrix
+ *
+ * @returns matrix
+ */
+CGLM_INLINE
+mat2s
+glms_mat2_mul(mat2s m1, mat2s m2) {
+  mat2s r;
+  glm_mat2_mul(m1.raw, m2.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief transpose mat2
+ *
+ * @param[in] m matrix to transpose
+ *
+ * @returns transposed matrix
+ */
+CGLM_INLINE
+mat2s
+glms_mat2_transpose(mat2s m) {
+  glm_mat2_transpose(m.raw);
+  return m;
+}
+
+/*!
+ * @brief multiply mat2 with vec2 (column vector) and store in dest vector
+ *
+ * @param[in]  m    mat2 (left)
+ * @param[in]  v    vec2 (right, column vector)
+ * @returns         vec2 (result, column vector)
+ */
+CGLM_INLINE
+vec2s
+glms_mat2_mulv(mat2s m, vec2s v) {
+  vec2s r;
+  glm_mat2_mulv(m.raw, v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief trace of matrix
+ *
+ * sum of the elements on the main diagonal from upper left to the lower right
+ *
+ * @param[in]  m matrix
+ */
+CGLM_INLINE
+float
+glms_mat2_trace(mat2s m) {
+  return glm_mat2_trace(m.raw);
+}
+
+/*!
+ * @brief scale (multiply with scalar) matrix
+ *
+ * multiply matrix with scalar
+ *
+ * @param[in, out] m matrix
+ * @param[in]      s scalar
+ * @returns matrix
+ */
+CGLM_INLINE
+mat2s
+glms_mat2_scale(mat2s m, float s) {
+  glm_mat2_scale(m.raw, s);
+  return m;
+}
+
+/*!
+ * @brief mat2 determinant
+ *
+ * @param[in] mat matrix
+ *
+ * @return determinant
+ */
+CGLM_INLINE
+float
+glms_mat2_det(mat2s mat) {
+  return glm_mat2_det(mat.raw);
+}
+
+/*!
+ * @brief inverse mat2 and store in dest
+ *
+ * @param[in]  mat  matrix
+ * @returns matrix
+ */
+CGLM_INLINE
+mat2s
+glms_mat2_inv(mat2s mat) {
+  mat2s r;
+  glm_mat2_inv(mat.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief swap two matrix columns
+ *
+ * @param[in] mat  matrix
+ * @param[in] col1 col1
+ * @param[in] col2 col2
+ * @returns matrix
+ */
+CGLM_INLINE
+mat2s
+glms_mat2_swap_col(mat2s mat, int col1, int col2) {
+  glm_mat2_swap_col(mat.raw, col1, col2);
+  return mat;
+}
+
+/*!
+ * @brief swap two matrix rows
+ *
+ * @param[in] mat  matrix
+ * @param[in] row1 row1
+ * @param[in] row2 row2
+ * @returns matrix
+ */
+CGLM_INLINE
+mat2s
+glms_mat2_swap_row(mat2s mat, int row1, int row2) {
+  glm_mat2_swap_row(mat.raw, row1, row2);
+  return mat;
+}
+
+/*!
+ * @brief helper for  R (row vector) * M (matrix) * C (column vector)
+ *
+ * rmc stands for Row * Matrix * Column
+ *
+ * the result is scalar because R * M = Matrix1x2 (row vector),
+ * then Matrix1x2 * Vec2 (column vector) = Matrix1x1 (Scalar)
+ *
+ * @param[in]  r   row vector or matrix1x2
+ * @param[in]  m   matrix2x2
+ * @param[in]  c   column vector or matrix2x1
+ *
+ * @return scalar value e.g. Matrix1x1
+ */
+CGLM_INLINE
+float
+glms_mat2_rmc(vec2s r, mat2s m, vec2s c) {
+  return glm_mat2_rmc(r.raw, m.raw, c.raw);
+}
+
+#endif /* cglms_mat2_h */

include/cglm/struct/mat3.h

@@ -14,9 +14,9 @@
 
  Functions:
    CGLM_INLINE mat3s  glms_mat3_copy(mat3s mat);
-   CGLM_INLINE mat3s  glms_mat3_identity();
+   CGLM_INLINE mat3s  glms_mat3_identity(void);
    CGLM_INLINE void   glms_mat3_identity_array(mat3s * __restrict mat, size_t count);
-   CGLM_INLINE mat3s  glms_mat3_zero();
+   CGLM_INLINE mat3s  glms_mat3_zero(void);
    CGLM_INLINE mat3s  glms_mat3_mul(mat3s m1, mat3s m2);
    CGLM_INLINE ma3s   glms_mat3_transpose(mat3s m);
    CGLM_INLINE vec3s  glms_mat3_mulv(mat3s m, vec3s v);
@@ -38,12 +38,8 @@
 #include "../mat3.h"
 #include "vec3.h"
 
-#define GLMS_MAT3_IDENTITY_INIT  {1.0f, 0.0f, 0.0f,                          \
-                                  0.0f, 1.0f, 0.0f,                          \
-                                  0.0f, 0.0f, 1.0f}
-#define GLMS_MAT3_ZERO_INIT      {0.0f, 0.0f, 0.0f,                          \
-                                  0.0f, 0.0f, 0.0f,                          \
-                                  0.0f, 0.0f, 0.0f}
+#define GLMS_MAT3_IDENTITY_INIT  {GLM_MAT3_IDENTITY_INIT}
+#define GLMS_MAT3_ZERO_INIT      {GLM_MAT3_ZERO_INIT}
 
 /* for C only */
 #define GLMS_MAT3_IDENTITY ((mat3s)GLMS_MAT3_IDENTITY_INIT)
@@ -79,7 +75,7 @@ glms_mat3_copy(mat3s mat) {
  */
 CGLM_INLINE
 mat3s
-glms_mat3_identity() {
+glms_mat3_identity(void) {
   mat3s r;
   glm_mat3_identity(r.raw);
   return r;
@@ -111,7 +107,7 @@ glms_mat3_identity_array(mat3s * __restrict mat, size_t count) {
  */
 CGLM_INLINE
 mat3s
-glms_mat3_zero() {
+glms_mat3_zero(void) {
   mat3s r;
   glm_mat3_zero(r.raw);
   return r;

include/cglm/struct/mat4.h

@@ -20,9 +20,9 @@
  Functions:
    CGLM_INLINE mat4s   glms_mat4_ucopy(mat4s mat);
    CGLM_INLINE mat4s   glms_mat4_copy(mat4s mat);
-   CGLM_INLINE mat4s   glms_mat4_identity();
+   CGLM_INLINE mat4s   glms_mat4_identity(void);
    CGLM_INLINE void    glms_mat4_identity_array(mat4s * __restrict mat, size_t count);
-   CGLM_INLINE mat4s   glms_mat4_zero();
+   CGLM_INLINE mat4s   glms_mat4_zero(void);
    CGLM_INLINE mat3s   glms_mat4_pick3(mat4s mat);
    CGLM_INLINE mat3s   glms_mat4_pick3t(mat4s mat);
    CGLM_INLINE mat4s   glms_mat4_ins3(mat3s mat);
@@ -53,15 +53,8 @@
 #include "vec4.h"
 #include "vec3.h"
 
-#define GLMS_MAT4_IDENTITY_INIT  {1.0f, 0.0f, 0.0f, 0.0f,                    \
-                                  0.0f, 1.0f, 0.0f, 0.0f,                    \
-                                  0.0f, 0.0f, 1.0f, 0.0f,                    \
-                                  0.0f, 0.0f, 0.0f, 1.0f}
-
-#define GLMS_MAT4_ZERO_INIT      {0.0f, 0.0f, 0.0f, 0.0f,                    \
-                                  0.0f, 0.0f, 0.0f, 0.0f,                    \
-                                  0.0f, 0.0f, 0.0f, 0.0f,                    \
-                                  0.0f, 0.0f, 0.0f, 0.0f}
+#define GLMS_MAT4_IDENTITY_INIT  {GLM_MAT4_IDENTITY_INIT}
+#define GLMS_MAT4_ZERO_INIT      {GLM_MAT4_ZERO_INIT}
 
 /* for C only */
 #define GLMS_MAT4_IDENTITY ((mat4s)GLMS_MAT4_IDENTITY_INIT)
@@ -114,7 +107,7 @@ glms_mat4_copy(mat4s mat) {
  */
 CGLM_INLINE
 mat4s
-glms_mat4_identity() {
+glms_mat4_identity(void) {
   mat4s r;
   glm_mat4_identity(r.raw);
   return r;
@@ -146,7 +139,7 @@ glms_mat4_identity_array(mat4s * __restrict mat, size_t count) {
  */
 CGLM_INLINE
 mat4s
-glms_mat4_zero() {
+glms_mat4_zero(void) {
   mat4s r;
   glm_mat4_zero(r.raw);
   return r;

include/cglm/struct/quat.h

@@ -11,7 +11,7 @@
    GLMS_QUAT_IDENTITY
 
  Functions:
-   CGLM_INLINE versors glms_quat_identity()
+   CGLM_INLINE versors glms_quat_identity(void)
    CGLM_INLINE void    glms_quat_identity_array(versor *q, size_t count)
    CGLM_INLINE versors glms_quat_init(float x, float y, float z, float w)
    CGLM_INLINE versors glms_quatv(float angle, vec3s axis)
@@ -62,7 +62,7 @@
  * ----------------------------------------------------------------------------
  */
 
-#define GLMS_QUAT_IDENTITY_INIT  GLM_QUAT_IDENTITY_INIT
+#define GLMS_QUAT_IDENTITY_INIT  {GLM_QUAT_IDENTITY_INIT}
 #define GLMS_QUAT_IDENTITY       ((versors)GLMS_QUAT_IDENTITY_INIT)
 
 /*!
@@ -72,7 +72,7 @@
  */
 CGLM_INLINE
 versors
-glms_quat_identity() {
+glms_quat_identity(void) {
   versors dest;
   glm_quat_identity(dest.raw);
   return dest;
@@ -251,7 +251,7 @@ CGLM_INLINE
 vec3s
 glms_quat_imagn(versors q) {
   vec3s dest;
-  glm_normalize_to(q.imag.raw, dest.raw);
+  glm_normalize_to(q.raw, dest.raw);
   return dest;
 }
 
@@ -437,15 +437,14 @@ glms_quat_look(vec3s eye, versors ori) {
  * @brief creates look rotation quaternion
  *
  * @param[in]   dir   direction to look
- * @param[in]   fwd   forward vector
  * @param[in]   up    up vector
  * @returns  destination quaternion
  */
 CGLM_INLINE
 versors
-glms_quat_for(vec3s dir, vec3s fwd, vec3s up) {
+glms_quat_for(vec3s dir, vec3s up) {
   versors dest;
-  glm_quat_for(dir.raw, fwd.raw, up.raw, dest.raw);
+  glm_quat_for(dir.raw, up.raw, dest.raw);
   return dest;
 }
 
@@ -455,15 +454,14 @@ glms_quat_for(vec3s dir, vec3s fwd, vec3s up) {
  *
  * @param[in]   from  source point
  * @param[in]   to    destination point
- * @param[in]   fwd   forward vector
  * @param[in]   up    up vector
  * @returns  destination quaternion
  */
 CGLM_INLINE
 versors
-glms_quat_forp(vec3s from, vec3s to, vec3s fwd, vec3s up) {
+glms_quat_forp(vec3s from, vec3s to, vec3s up) {
   versors dest;
-  glm_quat_forp(from.raw, to.raw, fwd.raw, up.raw, dest.raw);
+  glm_quat_forp(from.raw, to.raw, up.raw, dest.raw);
   return dest;
 }
 

include/cglm/struct/sphere.h

@@ -42,9 +42,9 @@ glms_sphere_radii(vec4s s) {
  */
 CGLM_INLINE
 vec4s
-glms_sphere_transform(vec4s s, mat4 m) {
+glms_sphere_transform(vec4s s, mat4s m) {
   vec4s r;
-  glm_sphere_transform(s.raw, m, r.raw);
+  glm_sphere_transform(s.raw, m.raw, r.raw);
   return r;
 }
 

include/cglm/struct/vec2-ext.h

@@ -0,0 +1,198 @@
+/*
+ * 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 vec2s glms_vec2_fill(float val)
+   CGLM_INLINE bool  glms_vec2_eq(vec2s v, float val)
+   CGLM_INLINE bool  glms_vec2_eq_eps(vec2s v, float val)
+   CGLM_INLINE bool  glms_vec2_eq_all(vec2s v)
+   CGLM_INLINE bool  glms_vec2_eqv(vec2s a, vec2s b)
+   CGLM_INLINE bool  glms_vec2_eqv_eps(vec2s a, vec2s b)
+   CGLM_INLINE float glms_vec2_max(vec2s v)
+   CGLM_INLINE float glms_vec2_min(vec2s v)
+   CGLM_INLINE bool  glms_vec2_isnan(vec2s v)
+   CGLM_INLINE bool  glms_vec2_isinf(vec2s v)
+   CGLM_INLINE bool  glms_vec2_isvalid(vec2s v)
+   CGLM_INLINE vec2s glms_vec2_sign(vec2s v)
+   CGLM_INLINE vec2s glms_vec2_sqrt(vec2s v)
+ */
+
+#ifndef cglms_vec2s_ext_h
+#define cglms_vec2s_ext_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../util.h"
+#include "../vec2-ext.h"
+
+/*!
+ * @brief fill a vector with specified value
+ *
+ * @param[in]  val  value
+ * @returns         dest
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_fill(float val) {
+  vec2s r;
+  glm_vec2_fill(r.raw, val);
+  return r;
+}
+
+/*!
+ * @brief check if vector is equal to value (without epsilon)
+ *
+ * @param[in] v   vector
+ * @param[in] val value
+ */
+CGLM_INLINE
+bool
+glms_vec2_eq(vec2s v, float val) {
+  return glm_vec2_eq(v.raw, val);
+}
+
+/*!
+ * @brief check if vector is equal to value (with epsilon)
+ *
+ * @param[in] v   vector
+ * @param[in] val value
+ */
+CGLM_INLINE
+bool
+glms_vec2_eq_eps(vec2s v, float val) {
+  return glm_vec2_eq_eps(v.raw, val);
+}
+
+/*!
+ * @brief check if vectors members are equal (without epsilon)
+ *
+ * @param[in] v   vector
+ */
+CGLM_INLINE
+bool
+glms_vec2_eq_all(vec2s v) {
+  return glm_vec2_eq_all(v.raw);
+}
+
+/*!
+ * @brief check if vector is equal to another (without epsilon)
+ *
+ * @param[in] a vector
+ * @param[in] b vector
+ */
+CGLM_INLINE
+bool
+glms_vec2_eqv(vec2s a, vec2s b) {
+  return glm_vec2_eqv(a.raw, b.raw);
+}
+
+/*!
+ * @brief check if vector is equal to another (with epsilon)
+ *
+ * @param[in] a vector
+ * @param[in] b vector
+ */
+CGLM_INLINE
+bool
+glms_vec2_eqv_eps(vec2s a, vec2s b) {
+  return glm_vec2_eqv_eps(a.raw, b.raw);
+}
+
+/*!
+ * @brief max value of vector
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+float
+glms_vec2_max(vec2s v) {
+  return glm_vec2_max(v.raw);
+}
+
+/*!
+ * @brief min value of vector
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+float
+glms_vec2_min(vec2s v) {
+  return glm_vec2_min(v.raw);
+}
+
+/*!
+ * @brief check if all items are NaN (not a number)
+ *        you should only use this in DEBUG mode or very critical asserts
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+bool
+glms_vec2_isnan(vec2s v) {
+  return glm_vec2_isnan(v.raw);
+}
+
+/*!
+ * @brief check if all items are INFINITY
+ *        you should only use this in DEBUG mode or very critical asserts
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+bool
+glms_vec2_isinf(vec2s v) {
+  return glm_vec2_isinf(v.raw);
+}
+
+/*!
+ * @brief check if all items are valid number
+ *        you should only use this in DEBUG mode or very critical asserts
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+bool
+glms_vec2_isvalid(vec2s v) {
+  return glm_vec2_isvalid(v.raw);
+}
+
+/*!
+ * @brief get sign of 32 bit float as +1, -1, 0
+ *
+ * Important: It returns 0 for zero/NaN input
+ *
+ * @param   v   vector
+ * @returns     sign vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_sign(vec2s v) {
+  vec2s r;
+  glm_vec2_sign(v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief square root of each vector item
+ *
+ * @param[in]  v    vector
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_sqrt(vec2s v) {
+  vec2s r;
+  glm_vec2_sqrt(v.raw, r.raw);
+  return r;
+}
+
+#endif /* cglms_vec2s_ext_h */

include/cglm/struct/vec2.h

@@ -0,0 +1,561 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   GLMS_VEC2_ONE_INIT
+   GLMS_VEC2_ZERO_INIT
+   GLMS_VEC2_ONE
+   GLMS_VEC2_ZERO
+
+ Functions:
+   CGLM_INLINE vec2s glms_vec2(vec3s v3)
+   CGLM_INLINE void  glms_vec2_pack(vec2s dst[], vec2 src[], size_t len)
+   CGLM_INLINE void  glms_vec2_unpack(vec2 dst[], vec2s src[], size_t len)
+   CGLM_INLINE vec2s glms_vec2_zero(void)
+   CGLM_INLINE vec2s glms_vec2_one(void)
+   CGLM_INLINE float glms_vec2_dot(vec2s a, vec2s b)
+   CGLM_INLINE float glms_vec2_cross(vec2s a, vec2s b)
+   CGLM_INLINE float glms_vec2_norm2(vec2s v)
+   CGLM_INLINE float glms_vec2_norm(vec2s v)
+   CGLM_INLINE vec2s glms_vec2_add(vec2s a, vec2s b)
+   CGLM_INLINE vec2s glms_vec2_adds(vec2s a, float s)
+   CGLM_INLINE vec2s glms_vec2_sub(vec2s a, vec2s b)
+   CGLM_INLINE vec2s glms_vec2_subs(vec2s a, float s)
+   CGLM_INLINE vec2s glms_vec2_mul(vec2s a, vec2s b)
+   CGLM_INLINE vec2s glms_vec2_scale(vec2s v, float s)
+   CGLM_INLINE vec2s glms_vec2_scale_as(vec2s v, float s)
+   CGLM_INLINE vec2s glms_vec2_div(vec2s a, vec2s b)
+   CGLM_INLINE vec2s glms_vec2_divs(vec2s a, float s)
+   CGLM_INLINE vec2s glms_vec2_addadd(vec2s a, vec2s b, vec2s dest)
+   CGLM_INLINE vec2s glms_vec2_subadd(vec2s a, vec2s b, vec2s dest)
+   CGLM_INLINE vec2s glms_vec2_muladd(vec2s a, vec2s b, vec2s dest)
+   CGLM_INLINE vec2s glms_vec2_muladds(vec2s a, float s, vec2s dest)
+   CGLM_INLINE vec2s glms_vec2_maxadd(vec2s a, vec2s b, vec2s dest)
+   CGLM_INLINE vec2s glms_vec2_minadd(vec2s a, vec2s b, vec2s dest)
+   CGLM_INLINE vec2s glms_vec2_negate(vec2s v)
+   CGLM_INLINE vec2s glms_vec2_normalize(vec2s v)
+   CGLM_INLINE vec2s glms_vec2_rotate(vec2s v, float angle, vec2s axis)
+   CGLM_INLINE float glms_vec2_distance(vec2s a, vec2s b)
+   CGLM_INLINE float glms_vec2_distance2(vec2s a, vec2s b)
+   CGLM_INLINE vec2s glms_vec2_maxv(vec2s a, vec2s b)
+   CGLM_INLINE vec2s glms_vec2_minv(vec2s a, vec2s b)
+   CGLM_INLINE vec2s glms_vec2_clamp(vec2s v, float minVal, float maxVal)
+   CGLM_INLINE vec2s glms_vec2_lerp(vec2s from, vec2s to, float t)
+ */
+
+#ifndef cglms_vec2s_h
+#define cglms_vec2s_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../util.h"
+#include "../vec2.h"
+#include "vec2-ext.h"
+
+#define GLMS_VEC2_ONE_INIT   {GLM_VEC2_ONE_INIT}
+#define GLMS_VEC2_ZERO_INIT  {GLM_VEC2_ZERO_INIT}
+
+#define GLMS_VEC2_ONE  ((vec2s)GLMS_VEC2_ONE_INIT)
+#define GLMS_VEC2_ZERO ((vec2s)GLMS_VEC2_ZERO_INIT)
+
+/*!
+ * @brief init vec2 using vec2
+ *
+ * @param[in]  v3   vector3
+ * @returns         destination
+ */
+CGLM_INLINE
+vec2s
+glms_vec2(vec3s v3) {
+  vec2s r;
+  glm_vec2(v3.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief pack an array of vec2 into an array of vec2s
+ *
+ * @param[out] dst array of vec2
+ * @param[in]  src array of vec2s
+ * @param[in]  len number of elements
+ */
+CGLM_INLINE
+void
+glms_vec2_pack(vec2s dst[], vec2 src[], size_t len) {
+  size_t i;
+
+  for (i = 0; i < len; i++) {
+    glm_vec2_copy(src[i], dst[i].raw);
+  }
+}
+
+/*!
+ * @brief unpack an array of vec2s into an array of vec2
+ *
+ * @param[out] dst array of vec2s
+ * @param[in]  src array of vec2
+ * @param[in]  len number of elements
+ */
+CGLM_INLINE
+void
+glms_vec2_unpack(vec2 dst[], vec2s src[], size_t len) {
+  size_t i;
+
+  for (i = 0; i < len; i++) {
+    glm_vec2_copy(src[i].raw, dst[i]);
+  }
+}
+
+/*!
+ * @brief make vector zero
+ *
+ * @returns zero vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_zero(void) {
+  vec2s r;
+  glm_vec2_zero(r.raw);
+  return r;
+}
+
+/*!
+ * @brief make vector one
+ *
+ * @returns one vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_one(void) {
+  vec2s r;
+  glm_vec2_one(r.raw);
+  return r;
+}
+
+/*!
+ * @brief vec2 dot product
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ *
+ * @return dot product
+ */
+CGLM_INLINE
+float
+glms_vec2_dot(vec2s a, vec2s b) {
+  return glm_vec2_dot(a.raw, b.raw);
+}
+
+/*!
+ * @brief vec2 cross product
+ *
+ * REF: http://allenchou.net/2013/07/cross-product-of-2d-vectors/
+ *
+ * @param[in]  a vector1
+ * @param[in]  b vector2
+ *
+ * @return Z component of cross product
+ */
+CGLM_INLINE
+float
+glms_vec2_cross(vec2s a, vec2s b) {
+  return glm_vec2_cross(a.raw, b.raw);
+}
+
+/*!
+ * @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 vector
+ *
+ * @return norm * norm
+ */
+CGLM_INLINE
+float
+glms_vec2_norm2(vec2s v) {
+  return glm_vec2_norm2(v.raw);
+}
+
+/*!
+ * @brief norm (magnitude) of vec2
+ *
+ * @param[in] v vector
+ *
+ * @return norm
+ */
+CGLM_INLINE
+float
+glms_vec2_norm(vec2s v) {
+  return glm_vec2_norm(v.raw);
+}
+
+/*!
+ * @brief add a vector to b vector store result in dest
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_add(vec2s a, vec2s b) {
+  vec2s r;
+  glm_vec2_add(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief add scalar to v vector store result in dest (d = v + s)
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_adds(vec2s a, float s) {
+  vec2s r;
+  glm_vec2_adds(a.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief subtract b vector from a vector store result in dest
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_sub(vec2s a, vec2s b) {
+  vec2s r;
+  glm_vec2_sub(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief subtract scalar from v vector store result in dest (d = v - s)
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_subs(vec2s a, float s) {
+  vec2s r;
+  glm_vec2_subs(a.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply two vector (component-wise multiplication)
+ *
+ * @param     a     vector1
+ * @param     b     vector2
+ * @returns         v3 = (a[0] * b[0], a[1] * b[1], a[2] * b[2])
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_mul(vec2s a, vec2s b) {
+  vec2s r;
+  glm_vec2_mul(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply/scale vec2 vector with scalar: result = v * s
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_scale(vec2s v, float s) {
+  vec2s r;
+  glm_vec2_scale(v.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief make vec2 vector scale as specified: result = unit(v) * s
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_scale_as(vec2s v, float s) {
+  vec2s r;
+  glm_vec2_scale_as(v.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief div vector with another component-wise division: d = a / b
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         result = (a[0]/b[0], a[1]/b[1], a[2]/b[2])
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_div(vec2s a, vec2s b) {
+  vec2s r;
+  glm_vec2_div(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief div vector with scalar: d = v / s
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @returns         result = (a[0]/s, a[1]/s, a[2]/s)
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_divs(vec2s a, float s) {
+  vec2s r;
+  glm_vec2_divs(a.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief add two vectors and add result to sum
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         dest += (a + b)
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_addadd(vec2s a, vec2s b, vec2s dest) {
+  glm_vec2_addadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief sub two vectors and add result to dest
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         dest += (a + b)
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_subadd(vec2s a, vec2s b, vec2s dest) {
+  glm_vec2_subadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief mul two vectors and add result to dest
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         dest += (a * b)
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_muladd(vec2s a, vec2s b, vec2s dest) {
+  glm_vec2_muladd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief mul vector with scalar and add result to sum
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @returns         dest += (a * b)
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_muladds(vec2s a, float s, vec2s dest) {
+  glm_vec2_muladds(a.raw, s, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief add max of two vector to result/dest
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         dest += max(a, b)
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_maxadd(vec2s a, vec2s b, vec2s dest) {
+  glm_vec2_maxadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief add min of two vector to result/dest
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         dest += min(a, b)
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_minadd(vec2s a, vec2s b, vec2s dest) {
+  glm_vec2_minadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief negate vector components
+ *
+ * @param[in]  v  vector
+ * @returns       negated vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_negate(vec2s v) {
+  glm_vec2_negate(v.raw);
+  return v;
+}
+
+/*!
+ * @brief normalize vec2 and store result in same vec
+ *
+ * @param[in] v vector
+ * @returns     normalized vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_normalize(vec2s v) {
+  glm_vec2_normalize(v.raw);
+  return v;
+}
+
+/*!
+ * @brief rotate vec2 by angle using Rodrigues' rotation formula
+ *
+ * @param[in]     v     vector
+ * @param[in]     angle angle by radians
+ * @returns             rotated vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_rotate(vec2s v, float angle) {
+  vec2s r;
+  glm_vec2_rotate(v.raw, angle, r.raw);
+  return r;
+}
+
+/**
+ * @brief distance between two vectors
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ * @return      distance
+ */
+CGLM_INLINE
+float
+glms_vec2_distance(vec2s a, vec2s b) {
+  return glm_vec2_distance(a.raw, b.raw);
+}
+
+/**
+ * @brief squared distance between two vectors
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ * @return      squared distance (distance * distance)
+ */
+CGLM_INLINE
+float
+glms_vec2_distance2(vec2s a, vec2s b) {
+  return glm_vec2_distance2(a.raw, b.raw);
+}
+
+/*!
+ * @brief max values of vectors
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @returns         destination
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_maxv(vec2s a, vec2s b) {
+  vec2s r;
+  glm_vec2_maxv(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief min values of vectors
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @returns         destination
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_minv(vec2s a, vec2s b) {
+  vec2s r;
+  glm_vec2_minv(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief clamp vector's individual members between min and max values
+ *
+ * @param[in]       v       vector
+ * @param[in]       minVal  minimum value
+ * @param[in]       maxVal  maximum value
+ * @returns                 clamped vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_clamp(vec2s v, float minVal, float maxVal) {
+  glm_vec2_clamp(v.raw, minVal, maxVal);
+  return v;
+}
+
+/*!
+ * @brief linear interpolation between two vectors
+ *
+ * formula:  from + s * (to - from)
+ *
+ * @param[in]   from  from value
+ * @param[in]   to    to value
+ * @param[in]   t     interpolant (amount)
+ * @returns           destination
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_lerp(vec2s from, vec2s to, float t) {
+  vec2s r;
+  glm_vec2_lerp(from.raw, to.raw, t, r.raw);
+  return r;
+}
+
+#endif /* cglms_vec2s_h */

include/cglm/struct/vec3.h

@@ -19,8 +19,8 @@
    CGLM_INLINE vec3s glms_vec3(vec4s v4);
    CGLM_INLINE void  glms_vec3_pack(vec3s dst[], vec3 src[], size_t len);
    CGLM_INLINE void  glms_vec3_unpack(vec3 dst[], vec3s src[], size_t len);
-   CGLM_INLINE vec3s glms_vec3_zero();
-   CGLM_INLINE vec3s glms_vec3_one();
+   CGLM_INLINE vec3s glms_vec3_zero(void);
+   CGLM_INLINE vec3s glms_vec3_one(void);
    CGLM_INLINE float glms_vec3_dot(vec3s a, vec3s b);
    CGLM_INLINE float glms_vec3_norm2(vec3s v);
    CGLM_INLINE float glms_vec3_norm(vec3s v);
@@ -86,15 +86,15 @@
 #include "../vec3.h"
 #include "vec3-ext.h"
 
-#define GLMS_VEC3_ONE_INIT   {1.0f, 1.0f, 1.0f}
-#define GLMS_VEC3_ZERO_INIT  {0.0f, 0.0f, 0.0f}
+#define GLMS_VEC3_ONE_INIT   {GLM_VEC3_ONE_INIT}
+#define GLMS_VEC3_ZERO_INIT  {GLM_VEC3_ZERO_INIT}
 
 #define GLMS_VEC3_ONE  ((vec3s)GLMS_VEC3_ONE_INIT)
 #define GLMS_VEC3_ZERO ((vec3s)GLMS_VEC3_ZERO_INIT)
 
-#define GLMS_YUP  ((vec3s){0.0f, 1.0f, 0.0f})
-#define GLMS_ZUP  ((vec3s){0.0f, 0.0f, 1.0f})
-#define GLMS_XUP  ((vec3s){1.0f, 0.0f, 0.0f})
+#define GLMS_YUP  ((vec3s){{0.0f, 1.0f, 0.0f}})
+#define GLMS_ZUP  ((vec3s){{0.0f, 0.0f, 1.0f}})
+#define GLMS_XUP  ((vec3s){{1.0f, 0.0f, 0.0f}})
 
 /*!
  * @brief init vec3 using vec4
@@ -151,7 +151,7 @@ glms_vec3_unpack(vec3 dst[], vec3s src[], size_t len) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_zero() {
+glms_vec3_zero(void) {
   vec3s r;
   glm_vec3_zero(r.raw);
   return r;
@@ -164,7 +164,7 @@ glms_vec3_zero() {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_one() {
+glms_vec3_one(void) {
   vec3s r;
   glm_vec3_one(r.raw);
   return r;

include/cglm/struct/vec4.h

@@ -7,12 +7,12 @@
 
 /*
  Macros:
-   GLM_VEC4_ONE_INIT
-   GLM_VEC4_BLACK_INIT
-   GLM_VEC4_ZERO_INIT
-   GLM_VEC4_ONE
-   GLM_VEC4_BLACK
-   GLM_VEC4_ZERO
+   GLMS_VEC4_ONE_INIT
+   GLMS_VEC4_BLACK_INIT
+   GLMS_VEC4_ZERO_INIT
+   GLMS_VEC4_ONE
+   GLMS_VEC4_BLACK
+   GLMS_VEC4_ZERO
 
  Functions:
    CGLM_INLINE vec4s glms_vec4(vec3s v3, float last);
@@ -72,9 +72,9 @@
 #include "../vec4.h"
 #include "vec4-ext.h"
 
-#define GLMS_VEC4_ONE_INIT   {1.0f, 1.0f, 1.0f, 1.0f}
-#define GLMS_VEC4_BLACK_INIT {0.0f, 0.0f, 0.0f, 1.0f}
-#define GLMS_VEC4_ZERO_INIT  {0.0f, 0.0f, 0.0f, 0.0f}
+#define GLMS_VEC4_ONE_INIT   {GLM_VEC4_ONE_INIT}
+#define GLMS_VEC4_BLACK_INIT {GLM_VEC4_BLACK_INIT}
+#define GLMS_VEC4_ZERO_INIT  {GLM_VEC4_ZERO_INIT}
 
 #define GLMS_VEC4_ONE        ((vec4s)GLM_VEC4_ONE_INIT)
 #define GLMS_VEC4_BLACK      ((vec4s)GLM_VEC4_BLACK_INIT)
@@ -180,7 +180,7 @@ glms_vec4_unpack(vec4 dst[], vec4s src[], size_t len) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_zero() {
+glms_vec4_zero(void) {
   vec4s r;
   glm_vec4_zero(r.raw);
   return r;
@@ -193,7 +193,7 @@ glms_vec4_zero() {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_one() {
+glms_vec4_one(void) {
   vec4s r;
   glm_vec4_one(r.raw);
   return r;

include/cglm/types-struct.h

@@ -10,30 +10,71 @@
 
 #include "types.h"
 
+/*
+ * Anonymous structs are available since C11, but we'd like to be compatible
+ * with C99 and C89 too. So let's figure out if we should be using them or not.
+ * It's simply a convenience feature, you can e.g. build the library with
+ * anonymous structs and your application without them and they'll still be
+ * compatible, cglm doesn't use the anonymous structs internally.
+ */
+#ifndef CGLM_USE_ANONYMOUS_STRUCT
+   /* If the user doesn't explicitly specify if they want anonymous structs or
+    * not, then we'll try to intuit an appropriate choice. */
+#  if defined(CGLM_NO_ANONYMOUS_STRUCT)
+     /* The user has defined CGLM_NO_ANONYMOUS_STRUCT. This used to be the
+      * only #define governing the use of anonymous structs, so for backward
+      * compatibility, we still honor that choice and disable them. */
+#    define CGLM_USE_ANONYMOUS_STRUCT 0
+#  elif __STDC_VERSION__ >= 20112L || defined(_MSVC_VER)
+     /* We're compiling for C11 or this is the MSVC compiler. In either
+      * case, anonymous structs are available, so use them. */
+#    define CGLM_USE_ANONYMOUS_STRUCT 1
+#  elif defined(_MSC_VER) && (_MSC_VER >= 1900) /*  Visual Studio 2015 */
+     /* We can support anonymous structs
+      * since Visual Studio 2015 or 2017 (1910) maybe? */
+#    define CGLM_USE_ANONYMOUS_STRUCT 1
+#  else
+     /* Otherwise, we're presumably building for C99 or C89 and can't rely
+      * on anonymous structs being available. Turn them off. */
+#    define CGLM_USE_ANONYMOUS_STRUCT 0
+#  endif
+#endif
+
+typedef union vec2s {
+  vec2 raw;
+#if CGLM_USE_ANONYMOUS_STRUCT
+  struct {
+    float x;
+    float y;
+  };
+#endif
+} vec2s;
+
 typedef union vec3s {
-#ifndef CGLM_NO_ANONYMOUS_STRUCT
+  vec3 raw;
+#if CGLM_USE_ANONYMOUS_STRUCT
   struct {
     float x;
     float y;
     float z;
   };
 #endif
-  vec3 raw;
 } vec3s;
 
 typedef union ivec3s {
-#ifndef CGLM_NO_ANONYMOUS_STRUCT
+  ivec3 raw;
+#if CGLM_USE_ANONYMOUS_STRUCT
   struct {
     int x;
     int y;
     int z;
   };
 #endif
-  ivec3 raw;
 } ivec3s;
 
 typedef union CGLM_ALIGN_IF(16) vec4s {
-#ifndef CGLM_NO_ANONYMOUS_STRUCT
+  vec4 raw;
+#if CGLM_USE_ANONYMOUS_STRUCT
   struct {
     float x;
     float y;
@@ -41,11 +82,11 @@ typedef union CGLM_ALIGN_IF(16) vec4s {
     float w;
   };
 #endif
-  vec4 raw;
 } vec4s;
 
 typedef union CGLM_ALIGN_IF(16) versors {
-#ifndef CGLM_NO_ANONYMOUS_STRUCT
+  vec4 raw;
+#if CGLM_USE_ANONYMOUS_STRUCT
   struct {
     float x;
     float y;
@@ -58,23 +99,35 @@ typedef union CGLM_ALIGN_IF(16) versors {
     float real;
   };
 #endif
-  vec4 raw;
 } versors;
 
+typedef union mat2s {
+  mat2  raw;
+  vec2s col[2];
+#if CGLM_USE_ANONYMOUS_STRUCT
+  struct {
+    float m00, m01;
+    float m10, m11;
+  };
+#endif
+} mat2s;
+
 typedef union mat3s {
-#ifndef CGLM_NO_ANONYMOUS_STRUCT
+  mat3  raw;
+  vec3s col[3];
+#if CGLM_USE_ANONYMOUS_STRUCT
   struct {
     float m00, m01, m02;
     float m10, m11, m12;
     float m20, m21, m22;
   };
 #endif
-  vec3s col[3];
-  mat3 raw;
 } mat3s;
 
 typedef union CGLM_ALIGN_MAT mat4s {
-#ifndef CGLM_NO_ANONYMOUS_STRUCT
+  mat4  raw;
+  vec4s col[4];
+#if CGLM_USE_ANONYMOUS_STRUCT
   struct {
     float m00, m01, m02, m03;
     float m10, m11, m12, m13;
@@ -82,8 +135,6 @@ typedef union CGLM_ALIGN_MAT mat4s {
     float m30, m31, m32, m33;
   };
 #endif
-  vec4s col[4];
-  mat4 raw;
 } mat4s;
 
 #endif /* cglm_types_struct_h */

include/cglm/types.h

@@ -36,9 +36,15 @@ typedef float                   vec2[2];
 typedef float                   vec3[3];
 typedef int                    ivec3[3];
 typedef CGLM_ALIGN_IF(16) float vec4[4];
-typedef vec4                    versor;
+typedef vec4                    versor;     /* |x, y, z, w| -> w is the last */
 typedef vec3                    mat3[3];
-typedef CGLM_ALIGN_MAT vec4     mat4[4];
+typedef CGLM_ALIGN_IF(16) vec2  mat2[2];
+typedef CGLM_ALIGN_MAT    vec4  mat4[4];
+
+/*
+  Important: cglm stores quaternion as [x, y, z, w] in memory since v0.4.0 
+  it was [w, x, y, z] before v0.4.0 ( v0.3.5 and earlier ). w is real part.
+*/
 
 #define GLM_E         2.71828182845904523536028747135266250   /* e           */
 #define GLM_LOG2E     1.44269504088896340735992468100189214   /* log2(e)     */

include/cglm/util.h

@@ -289,7 +289,7 @@ glm_smoothinterpc(float from, float to, float t) {
 CGLM_INLINE
 bool
 glm_eq(float a, float b) {
-  return fabsf(a - b) <= FLT_EPSILON;
+  return fabsf(a - b) <= GLM_FLT_EPSILON;
 }
 
 /*!
@@ -322,7 +322,22 @@ glm_percent(float from, float to, float current) {
 CGLM_INLINE
 float
 glm_percentc(float from, float to, float current) {
-  return glm_clamp(glm_percent(from, to, current), 0.0f, 1.0f);
+  return glm_clamp_zo(glm_percent(from, to, current));
+}
+
+/*!
+* @brief swap two float values
+*
+* @param[in]   a float value 1 (pointer)
+* @param[in]   b float value 2 (pointer)
+*/
+CGLM_INLINE
+void
+glm_swapf(float * __restrict a, float * __restrict b) {
+  float t;
+  t  = *a;
+  *a = *b;
+  *b = t;
 }
 
 #endif /* cglm_util_h */

include/cglm/vec2-ext.h

@@ -0,0 +1,189 @@
+/*
+ * 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_vec2_fill(vec2 v, float val)
+   CGLM_INLINE bool  glm_vec2_eq(vec2 v, float val);
+   CGLM_INLINE bool  glm_vec2_eq_eps(vec2 v, float val);
+   CGLM_INLINE bool  glm_vec2_eq_all(vec2 v);
+   CGLM_INLINE bool  glm_vec2_eqv(vec2 a, vec2 b);
+   CGLM_INLINE bool  glm_vec2_eqv_eps(vec2 a, vec2 b);
+   CGLM_INLINE float glm_vec2_max(vec2 v);
+   CGLM_INLINE float glm_vec2_min(vec2 v);
+   CGLM_INLINE bool  glm_vec2_isnan(vec2 v);
+   CGLM_INLINE bool  glm_vec2_isinf(vec2 v);
+   CGLM_INLINE bool  glm_vec2_isvalid(vec2 v);
+   CGLM_INLINE void  glm_vec2_sign(vec2 v, vec2 dest);
+   CGLM_INLINE void  glm_vec2_sqrt(vec2 v, vec2 dest);
+ */
+
+#ifndef cglm_vec2_ext_h
+#define cglm_vec2_ext_h
+
+#include "common.h"
+#include "util.h"
+
+/*!
+ * @brief fill a vector with specified value
+ *
+ * @param[out] v   dest
+ * @param[in]  val value
+ */
+CGLM_INLINE
+void
+glm_vec2_fill(vec2 v, float val) {
+  v[0] = v[1] = val;
+}
+
+/*!
+ * @brief check if vector is equal to value (without epsilon)
+ *
+ * @param[in] v   vector
+ * @param[in] val value
+ */
+CGLM_INLINE
+bool
+glm_vec2_eq(vec2 v, float val) {
+  return v[0] == val && v[0] == v[1];
+}
+
+/*!
+ * @brief check if vector is equal to value (with epsilon)
+ *
+ * @param[in] v   vector
+ * @param[in] val value
+ */
+CGLM_INLINE
+bool
+glm_vec2_eq_eps(vec2 v, float val) {
+  return fabsf(v[0] - val) <= GLM_FLT_EPSILON
+         && fabsf(v[1] - val) <= GLM_FLT_EPSILON;
+}
+
+/*!
+ * @brief check if vectors members are equal (without epsilon)
+ *
+ * @param[in] v   vector
+ */
+CGLM_INLINE
+bool
+glm_vec2_eq_all(vec2 v) {
+  return glm_vec2_eq_eps(v, v[0]);
+}
+
+/*!
+ * @brief check if vector is equal to another (without epsilon)
+ *
+ * @param[in] a vector
+ * @param[in] b vector
+ */
+CGLM_INLINE
+bool
+glm_vec2_eqv(vec2 a, vec2 b) {
+  return a[0] == b[0] && a[1] == b[1];
+}
+
+/*!
+ * @brief check if vector is equal to another (with epsilon)
+ *
+ * @param[in] a vector
+ * @param[in] b vector
+ */
+CGLM_INLINE
+bool
+glm_vec2_eqv_eps(vec2 a, vec2 b) {
+  return fabsf(a[0] - b[0]) <= GLM_FLT_EPSILON
+         && fabsf(a[1] - b[1]) <= GLM_FLT_EPSILON;
+}
+
+/*!
+ * @brief max value of vector
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+float
+glm_vec2_max(vec2 v) {
+  return glm_max(v[0], v[1]);
+}
+
+/*!
+ * @brief min value of vector
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+float
+glm_vec2_min(vec2 v) {
+  return glm_min(v[0], v[1]);
+}
+
+/*!
+ * @brief check if all items are NaN (not a number)
+ *        you should only use this in DEBUG mode or very critical asserts
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+bool
+glm_vec2_isnan(vec2 v) {
+  return isnan(v[0]) || isnan(v[1]);
+}
+
+/*!
+ * @brief check if all items are INFINITY
+ *        you should only use this in DEBUG mode or very critical asserts
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+bool
+glm_vec2_isinf(vec2 v) {
+  return isinf(v[0]) || isinf(v[1]);
+}
+
+/*!
+ * @brief check if all items are valid number
+ *        you should only use this in DEBUG mode or very critical asserts
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+bool
+glm_vec2_isvalid(vec2 v) {
+  return !glm_vec2_isnan(v) && !glm_vec2_isinf(v);
+}
+
+/*!
+ * @brief get sign of 32 bit float as +1, -1, 0
+ *
+ * Important: It returns 0 for zero/NaN input
+ *
+ * @param v vector
+ */
+CGLM_INLINE
+void
+glm_vec2_sign(vec2 v, vec2 dest) {
+  dest[0] = glm_signf(v[0]);
+  dest[1] = glm_signf(v[1]);
+}
+
+/*!
+ * @brief square root of each vector item
+ *
+ * @param[in]  v    vector
+ * @param[out] dest destination vector
+ */
+CGLM_INLINE
+void
+glm_vec2_sqrt(vec2 v, vec2 dest) {
+  dest[0] = sqrtf(v[0]);
+  dest[1] = sqrtf(v[1]);
+}
+
+#endif /* cglm_vec2_ext_h */

include/cglm/vec2.h

@@ -0,0 +1,585 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   GLM_VEC2_ONE_INIT
+   GLM_VEC2_ZERO_INIT
+   GLM_VEC2_ONE
+   GLM_VEC2_ZERO
+
+ Functions:
+   CGLM_INLINE void  glm_vec2(float * __restrict v, vec2 dest)
+   CGLM_INLINE void  glm_vec2_copy(vec2 a, vec2 dest)
+   CGLM_INLINE void  glm_vec2_zero(vec2 v)
+   CGLM_INLINE void  glm_vec2_one(vec2 v)
+   CGLM_INLINE float glm_vec2_dot(vec2 a, vec2 b)
+   CGLM_INLINE float glm_vec2_cross(vec2 a, vec2 b)
+   CGLM_INLINE float glm_vec2_norm2(vec2 v)
+   CGLM_INLINE float glm_vec2_norm(vec2 vec)
+   CGLM_INLINE void  glm_vec2_add(vec2 a, vec2 b, vec2 dest)
+   CGLM_INLINE void  glm_vec2_adds(vec2 v, float s, vec2 dest)
+   CGLM_INLINE void  glm_vec2_sub(vec2 a, vec2 b, vec2 dest)
+   CGLM_INLINE void  glm_vec2_subs(vec2 v, float s, vec2 dest)
+   CGLM_INLINE void  glm_vec2_mul(vec2 a, vec2 b, vec2 d)
+   CGLM_INLINE void  glm_vec2_scale(vec2 v, float s, vec2 dest)
+   CGLM_INLINE void  glm_vec2_scale_as(vec2 v, float s, vec2 dest)
+   CGLM_INLINE void  glm_vec2_div(vec2 a, vec2 b, vec2 dest)
+   CGLM_INLINE void  glm_vec2_divs(vec2 v, float s, vec2 dest)
+   CGLM_INLINE void  glm_vec2_addadd(vec2 a, vec2 b, vec2 dest)
+   CGLM_INLINE void  glm_vec2_subadd(vec2 a, vec2 b, vec2 dest)
+   CGLM_INLINE void  glm_vec2_muladd(vec2 a, vec2 b, vec2 dest)
+   CGLM_INLINE void  glm_vec2_muladds(vec2 a, float s, vec2 dest)
+   CGLM_INLINE void  glm_vec2_maxadd(vec2 a, vec2 b, vec2 dest)
+   CGLM_INLINE void  glm_vec2_minadd(vec2 a, vec2 b, vec2 dest)
+   CGLM_INLINE void  glm_vec2_negate_to(vec2 v, vec2 dest)
+   CGLM_INLINE void  glm_vec2_negate(vec2 v)
+   CGLM_INLINE void  glm_vec2_normalize(vec2 v)
+   CGLM_INLINE void  glm_vec2_normalize_to(vec2 vec, vec2 dest)
+   CGLM_INLINE void  glm_vec2_rotate(vec2 v, float angle, vec2 dest)
+   CGLM_INLINE float glm_vec2_distance2(vec2 a, vec2 b)
+   CGLM_INLINE float glm_vec2_distance(vec2 a, vec2 b)
+   CGLM_INLINE void  glm_vec2_maxv(vec2 v1, vec2 v2, vec2 dest)
+   CGLM_INLINE void  glm_vec2_minv(vec2 v1, vec2 v2, vec2 dest)
+   CGLM_INLINE void  glm_vec2_clamp(vec2 v, float minVal, float maxVal)
+   CGLM_INLINE void  glm_vec2_lerp(vec2 from, vec2 to, float t, vec2 dest)
+
+ */
+
+#ifndef cglm_vec2_h
+#define cglm_vec2_h
+
+#include "common.h"
+#include "util.h"
+#include "vec2-ext.h"
+
+#define GLM_VEC2_ONE_INIT   {1.0f, 1.0f}
+#define GLM_VEC2_ZERO_INIT  {0.0f, 0.0f}
+
+#define GLM_VEC2_ONE  ((vec2)GLM_VEC2_ONE_INIT)
+#define GLM_VEC2_ZERO ((vec2)GLM_VEC2_ZERO_INIT)
+
+/*!
+ * @brief init vec2 using another vector
+ *
+ * @param[in]  v    a vector
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_vec2(float * __restrict v, vec2 dest) {
+  dest[0] = v[0];
+  dest[1] = v[1];
+}
+
+/*!
+ * @brief copy all members of [a] to [dest]
+ *
+ * @param[in]  a    source
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_vec2_copy(vec2 a, vec2 dest) {
+  dest[0] = a[0];
+  dest[1] = a[1];
+}
+
+/*!
+ * @brief make vector zero
+ *
+ * @param[in, out]  v vector
+ */
+CGLM_INLINE
+void
+glm_vec2_zero(vec2 v) {
+  v[0] = v[1] = 0.0f;
+}
+
+/*!
+ * @brief make vector one
+ *
+ * @param[in, out]  v vector
+ */
+CGLM_INLINE
+void
+glm_vec2_one(vec2 v) {
+  v[0] = v[1] = 1.0f;
+}
+
+/*!
+ * @brief vec2 dot product
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ *
+ * @return dot product
+ */
+CGLM_INLINE
+float
+glm_vec2_dot(vec2 a, vec2 b) {
+  return a[0] * b[0] + a[1] * b[1];
+}
+
+/*!
+ * @brief vec2 cross product
+ *
+ * REF: http://allenchou.net/2013/07/cross-product-of-2d-vectors/
+ *
+ * @param[in]  a vector1
+ * @param[in]  b vector2
+ *
+ * @return Z component of cross product
+ */
+CGLM_INLINE
+float
+glm_vec2_cross(vec2 a, vec2 b) {
+  /* just calculate the z-component */
+  return a[0] * b[1] - a[1] * b[0];
+}
+
+/*!
+ * @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 vector
+ *
+ * @return norm * norm
+ */
+CGLM_INLINE
+float
+glm_vec2_norm2(vec2 v) {
+  return glm_vec2_dot(v, v);
+}
+
+/*!
+ * @brief norm (magnitude) of vec2
+ *
+ * @param[in] vec vector
+ *
+ * @return norm
+ */
+CGLM_INLINE
+float
+glm_vec2_norm(vec2 vec) {
+  return sqrtf(glm_vec2_norm2(vec));
+}
+
+/*!
+ * @brief add a vector to b vector store result in dest
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @param[out] dest destination vector
+ */
+CGLM_INLINE
+void
+glm_vec2_add(vec2 a, vec2 b, vec2 dest) {
+  dest[0] = a[0] + b[0];
+  dest[1] = a[1] + b[1];
+}
+
+/*!
+ * @brief add scalar to v vector store result in dest (d = v + s)
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @param[out] dest destination vector
+ */
+CGLM_INLINE
+void
+glm_vec2_adds(vec2 v, float s, vec2 dest) {
+  dest[0] = v[0] + s;
+  dest[1] = v[1] + s;
+}
+
+/*!
+ * @brief subtract b vector from a vector store result in dest
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @param[out] dest destination vector
+ */
+CGLM_INLINE
+void
+glm_vec2_sub(vec2 a, vec2 b, vec2 dest) {
+  dest[0] = a[0] - b[0];
+  dest[1] = a[1] - b[1];
+}
+
+/*!
+ * @brief subtract scalar from v vector store result in dest (d = v - s)
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @param[out] dest destination vector
+ */
+CGLM_INLINE
+void
+glm_vec2_subs(vec2 v, float s, vec2 dest) {
+  dest[0] = v[0] - s;
+  dest[1] = v[1] - s;
+}
+
+/*!
+ * @brief multiply two vector (component-wise multiplication)
+ *
+ * @param a    v1
+ * @param b    v2
+ * @param dest v3 = (a[0] * b[0], a[1] * b[1])
+ */
+CGLM_INLINE
+void
+glm_vec2_mul(vec2 a, vec2 b, vec2 dest) {
+  dest[0] = a[0] * b[0];
+  dest[1] = a[1] * b[1];
+}
+
+/*!
+ * @brief multiply/scale vector with scalar: result = v * s
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @param[out] dest destination vector
+ */
+CGLM_INLINE
+void
+glm_vec2_scale(vec2 v, float s, vec2 dest) {
+  dest[0] = v[0] * s;
+  dest[1] = v[1] * s;
+}
+
+/*!
+ * @brief scale as vector specified: result = unit(v) * s
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @param[out] dest destination vector
+ */
+CGLM_INLINE
+void
+glm_vec2_scale_as(vec2 v, float s, vec2 dest) {
+  float norm;
+  norm = glm_vec2_norm(v);
+
+  if (norm == 0.0f) {
+    glm_vec2_zero(dest);
+    return;
+  }
+
+  glm_vec2_scale(v, s / norm, dest);
+}
+
+/*!
+ * @brief div vector with another component-wise division: d = a / b
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @param[out] dest result = (a[0]/b[0], a[1]/b[1])
+ */
+CGLM_INLINE
+void
+glm_vec2_div(vec2 a, vec2 b, vec2 dest) {
+  dest[0] = a[0] / b[0];
+  dest[1] = a[1] / b[1];
+}
+
+/*!
+ * @brief div vector with scalar: d = v / s
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @param[out] dest result = (a[0]/s, a[1]/s)
+ */
+CGLM_INLINE
+void
+glm_vec2_divs(vec2 v, float s, vec2 dest) {
+  dest[0] = v[0] / s;
+  dest[1] = v[1] / s;
+}
+
+/*!
+ * @brief add two vectors and add result to sum
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @param[out] dest dest += (a + b)
+ */
+CGLM_INLINE
+void
+glm_vec2_addadd(vec2 a, vec2 b, vec2 dest) {
+  dest[0] += a[0] + b[0];
+  dest[1] += a[1] + b[1];
+}
+
+/*!
+ * @brief sub two vectors and add result to dest
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @param[out] dest dest += (a + b)
+ */
+CGLM_INLINE
+void
+glm_vec2_subadd(vec2 a, vec2 b, vec2 dest) {
+  dest[0] += a[0] - b[0];
+  dest[1] += a[1] - b[1];
+}
+
+/*!
+ * @brief mul two vectors and add result to dest
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @param[out] dest dest += (a * b)
+ */
+CGLM_INLINE
+void
+glm_vec2_muladd(vec2 a, vec2 b, vec2 dest) {
+  dest[0] += a[0] * b[0];
+  dest[1] += a[1] * b[1];
+}
+
+/*!
+ * @brief mul vector with scalar and add result to sum
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @param[out] dest dest += (a * b)
+ */
+CGLM_INLINE
+void
+glm_vec2_muladds(vec2 a, float s, vec2 dest) {
+  dest[0] += a[0] * s;
+  dest[1] += a[1] * s;
+}
+
+/*!
+ * @brief add max of two vector to result/dest
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @param[out] dest dest += max(a, b)
+ */
+CGLM_INLINE
+void
+glm_vec2_maxadd(vec2 a, vec2 b, vec2 dest) {
+  dest[0] += glm_max(a[0], b[0]);
+  dest[1] += glm_max(a[1], b[1]);
+}
+
+/*!
+ * @brief add min of two vector to result/dest
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @param[out] dest dest += min(a, b)
+ */
+CGLM_INLINE
+void
+glm_vec2_minadd(vec2 a, vec2 b, vec2 dest) {
+  dest[0] += glm_min(a[0], b[0]);
+  dest[1] += glm_min(a[1], b[1]);
+}
+
+/*!
+ * @brief negate vector components and store result in dest
+ *
+ * @param[in]   v     vector
+ * @param[out]  dest  result vector
+ */
+CGLM_INLINE
+void
+glm_vec2_negate_to(vec2 v, vec2 dest) {
+  dest[0] = -v[0];
+  dest[1] = -v[1];
+}
+
+/*!
+ * @brief negate vector components
+ *
+ * @param[in, out]  v  vector
+ */
+CGLM_INLINE
+void
+glm_vec2_negate(vec2 v) {
+  glm_vec2_negate_to(v, v);
+}
+
+/*!
+ * @brief normalize vector and store result in same vec
+ *
+ * @param[in, out] v vector
+ */
+CGLM_INLINE
+void
+glm_vec2_normalize(vec2 v) {
+  float norm;
+
+  norm = glm_vec2_norm(v);
+
+  if (norm == 0.0f) {
+    v[0] = v[1] = 0.0f;
+    return;
+  }
+
+  glm_vec2_scale(v, 1.0f / norm, v);
+}
+
+/*!
+ * @brief normalize vector to dest
+ *
+ * @param[in]  v    source
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_vec2_normalize_to(vec2 v, vec2 dest) {
+  float norm;
+
+  norm = glm_vec2_norm(v);
+
+  if (norm == 0.0f) {
+    glm_vec2_zero(dest);
+    return;
+  }
+
+  glm_vec2_scale(v, 1.0f / norm, dest);
+}
+
+/*!
+ * @brief rotate vec2 around origin by angle (CCW: counterclockwise)
+ *
+ * Formula:
+ *   𝑥2 = cos(a)𝑥1 − sin(a)𝑦1
+ *   𝑦2 = sin(a)𝑥1 + cos(a)𝑦1
+ *
+ * @param[in]  v     vector to rotate
+ * @param[in]  angle angle by radians
+ * @param[out] dest  destination vector
+ */
+CGLM_INLINE
+void
+glm_vec2_rotate(vec2 v, float angle, vec2 dest) {
+  float c, s, x1, y1;
+
+  c  = cosf(angle);
+  s  = sinf(angle);
+
+  x1 = v[0];
+  y1 = v[1];
+
+  dest[0] = c * x1 - s * y1;
+  dest[1] = s * x1 + c * y1;
+}
+
+/**
+ * @brief squared distance between two vectors
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ * @return returns squared distance (distance * distance)
+ */
+CGLM_INLINE
+float
+glm_vec2_distance2(vec2 a, vec2 b) {
+  return glm_pow2(b[0] - a[0]) + glm_pow2(b[1] - a[1]);
+}
+
+/**
+ * @brief distance between two vectors
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ * @return returns distance
+ */
+CGLM_INLINE
+float
+glm_vec2_distance(vec2 a, vec2 b) {
+  return sqrtf(glm_vec2_distance2(a, b));
+}
+
+/*!
+ * @brief max values of vectors
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_vec2_maxv(vec2 a, vec2 b, vec2 dest) {
+  dest[0] = glm_max(a[0], b[0]);
+  dest[1] = glm_max(a[1], b[1]);
+}
+
+/*!
+ * @brief min values of vectors
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_vec2_minv(vec2 a, vec2 b, vec2 dest) {
+  dest[0] = glm_min(a[0], b[0]);
+  dest[1] = glm_min(a[1], b[1]);
+}
+
+/*!
+ * @brief clamp vector's individual members between min and max values
+ *
+ * @param[in, out]  v      vector
+ * @param[in]       minval minimum value
+ * @param[in]       maxval maximum value
+ */
+CGLM_INLINE
+void
+glm_vec2_clamp(vec2 v, float minval, float maxval) {
+  v[0] = glm_clamp(v[0], minval, maxval);
+  v[1] = glm_clamp(v[1], minval, maxval);
+}
+
+/*!
+ * @brief linear interpolation between two vector
+ *
+ * formula:  from + s * (to - from)
+ *
+ * @param[in]   from from value
+ * @param[in]   to   to value
+ * @param[in]   t    interpolant (amount) clamped between 0 and 1
+ * @param[out]  dest destination
+ */
+CGLM_INLINE
+void
+glm_vec2_lerp(vec2 from, vec2 to, float t, vec2 dest) {
+  vec2 s, v;
+
+  /* from + s * (to - from) */
+  glm_vec2_fill(s, glm_clamp_zo(t));
+  glm_vec2_sub(to, from, v);
+  glm_vec2_mul(s, v, v);
+  glm_vec2_add(from, v, dest);
+}
+
+#endif /* cglm_vec2_h */

include/cglm/vec3-ext.h

@@ -81,9 +81,9 @@ glm_vec3_eq(vec3 v, float val) {
 CGLM_INLINE
 bool
 glm_vec3_eq_eps(vec3 v, float val) {
-  return fabsf(v[0] - val) <= FLT_EPSILON
-         && fabsf(v[1] - val) <= FLT_EPSILON
-         && fabsf(v[2] - val) <= FLT_EPSILON;
+  return fabsf(v[0] - val) <= GLM_FLT_EPSILON
+         && fabsf(v[1] - val) <= GLM_FLT_EPSILON
+         && fabsf(v[2] - val) <= GLM_FLT_EPSILON;
 }
 
 /*!
@@ -94,7 +94,7 @@ glm_vec3_eq_eps(vec3 v, float val) {
 CGLM_INLINE
 bool
 glm_vec3_eq_all(vec3 v) {
-  return v[0] == v[1] && v[0] == v[2];
+  return glm_vec3_eq_eps(v, v[0]);
 }
 
 /*!
@@ -120,9 +120,9 @@ glm_vec3_eqv(vec3 a, vec3 b) {
 CGLM_INLINE
 bool
 glm_vec3_eqv_eps(vec3 a, vec3 b) {
-  return fabsf(a[0] - b[0]) <= FLT_EPSILON
-         && fabsf(a[1] - b[1]) <= FLT_EPSILON
-         && fabsf(a[2] - b[2]) <= FLT_EPSILON;
+  return fabsf(a[0] - b[0]) <= GLM_FLT_EPSILON
+         && fabsf(a[1] - b[1]) <= GLM_FLT_EPSILON
+         && fabsf(a[2] - b[2]) <= GLM_FLT_EPSILON;
 }
 
 /*!

include/cglm/vec3.h

@@ -111,9 +111,10 @@
 #define GLM_VEC3_ONE  ((vec3)GLM_VEC3_ONE_INIT)
 #define GLM_VEC3_ZERO ((vec3)GLM_VEC3_ZERO_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})
+#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})
+#define GLM_FORWARD   ((vec3){0.0f,  0.0f, -1.0f})
 
 #define GLM_XXX GLM_SHUFFLE3(0, 0, 0)
 #define GLM_YYY GLM_SHUFFLE3(1, 1, 1)
@@ -996,6 +997,27 @@ glm_vec3_smoothinterpc(vec3 from, vec3 to, float t, vec3 dest) {
   glm_vec3_smoothinterp(from, to, glm_clamp_zo(t), dest);
 }
 
+/*!
+ * @brief swizzle vector components
+ *
+ * you can use existin masks e.g. GLM_XXX, GLM_ZYX
+ *
+ * @param[in]  v    source
+ * @param[in]  mask mask
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_vec3_swizzle(vec3 v, int mask, vec3 dest) {
+  vec3 t;
+
+  t[0] = v[(mask & (3 << 0))];
+  t[1] = v[(mask & (3 << 2)) >> 2];
+  t[2] = v[(mask & (3 << 4)) >> 4];
+
+  glm_vec3_copy(t, dest);
+}
+
 /*!
  * @brief vec3 cross product
  *
@@ -1054,25 +1076,4 @@ glm_normalize_to(vec3 v, vec3 dest) {
   glm_vec3_normalize_to(v, dest);
 }
 
-/*!
- * @brief swizzle vector components
- *
- * you can use existin masks e.g. GLM_XXX, GLM_ZYX
- *
- * @param[in]  v    source
- * @param[in]  mask mask
- * @param[out] dest destination
- */
-CGLM_INLINE
-void
-glm_vec3_swizzle(vec3 v, int mask, vec3 dest) {
-  vec3 t;
-
-  t[0] = v[(mask & (3 << 0))];
-  t[1] = v[(mask & (3 << 2)) >> 2];
-  t[2] = v[(mask & (3 << 4)) >> 4];
-
-  glm_vec3_copy(t, dest);
-}
-
 #endif /* cglm_vec3_h */

include/cglm/vec4-ext.h

@@ -92,10 +92,10 @@ glm_vec4_eq(vec4 v, float val) {
 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;
+  return fabsf(v[0] - val) <= GLM_FLT_EPSILON
+         && fabsf(v[1] - val) <= GLM_FLT_EPSILON
+         && fabsf(v[2] - val) <= GLM_FLT_EPSILON
+         && fabsf(v[3] - val) <= GLM_FLT_EPSILON;
 }
 
 /*!
@@ -106,9 +106,7 @@ glm_vec4_eq_eps(vec4 v, float val) {
 CGLM_INLINE
 bool
 glm_vec4_eq_all(vec4 v) {
-  return v[0] == v[1]
-         && v[0] == v[2]
-         && v[0] == v[3];
+  return glm_vec4_eq_eps(v, v[0]);
 }
 
 /*!
@@ -135,10 +133,10 @@ glm_vec4_eqv(vec4 a, vec4 b) {
 CGLM_INLINE
 bool
 glm_vec4_eqv_eps(vec4 a, vec4 b) {
-  return fabsf(a[0] - b[0]) <= FLT_EPSILON
-         && fabsf(a[1] - b[1]) <= FLT_EPSILON
-         && fabsf(a[2] - b[2]) <= FLT_EPSILON
-         && fabsf(a[3] - b[3]) <= FLT_EPSILON;
+  return fabsf(a[0] - b[0]) <= GLM_FLT_EPSILON
+         && fabsf(a[1] - b[1]) <= GLM_FLT_EPSILON
+         && fabsf(a[2] - b[2]) <= GLM_FLT_EPSILON
+         && fabsf(a[3] - b[3]) <= GLM_FLT_EPSILON;
 }
 
 /*!
@@ -252,7 +250,7 @@ glm_vec4_abs(vec4 v, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, glmm_abs(glmm_load(v)));
 #elif defined(CGLM_NEON_FP)
-  vst1q_f32(dest, vabsq_f32(vld1q_f32(a)));
+  vst1q_f32(dest, vabsq_f32(vld1q_f32(v)));
 #else
   dest[0] = fabsf(v[0]);
   dest[1] = fabsf(v[1]);

include/cglm/vec4.h

@@ -602,7 +602,7 @@ glm_vec4_muladds(vec4 a, float s, vec4 dest) {
                                          _mm_set1_ps(s))));
 #elif defined(CGLM_NEON_FP)
   vst1q_f32(dest, vaddq_f32(vld1q_f32(dest),
-                            vsubq_f32(vld1q_f32(a),
+                            vmulq_f32(vld1q_f32(a),
                                       vdupq_n_f32(s))));
 #else
   dest[0] += a[0] * s;
@@ -680,7 +680,7 @@ glm_vec4_negate_to(vec4 v, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_xor_ps(glmm_load(v), _mm_set1_ps(-0.0f)));
 #elif defined(CGLM_NEON_FP)
-  vst1q_f32(dest, veorq_s32(vld1q_f32(v), vdupq_n_f32(-0.0f)));
+  vst1q_f32(dest, vnegq_f32(vld1q_f32(v)));
 #else
   dest[0] = -v[0];
   dest[1] = -v[1];

include/cglm/version.h

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

post-build.sh

@@ -1,24 +0,0 @@
-#! /bin/sh
-#
-# Copyright (c), Recep Aslantas.
-#
-# MIT License (MIT), http://opensource.org/licenses/MIT
-# Full license can be found in the LICENSE file
-#
-
-cd $(dirname "$0")
-
-mkdir -p "$(pwd)/.libs"
-
-libmocka_folder=$(pwd)/test/lib/cmocka/build/src/
-
-if [ "$(uname)" = "Darwin" ]; then
-  libcmocka=libcmocka.0.dylib
-else
-  libcmocka=libcmocka.so.0
-fi
-
-libcmocka_path="$libmocka_folder$libcmocka"
-if [ -f "$libcmocka_path" ]; then
-  ln -sf "$libcmocka_path" "$(pwd)/.libs/$libcmocka";
-fi

src/config.h

@@ -1,9 +1,9 @@
 /*
-* Copyright (c), Recep Aslantas.
-*
-* MIT License (MIT), http://opensource.org/licenses/MIT
-* Full license can be found in the LICENSE file
-*/
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
 
 #ifndef cglm__config__h_
 #define cglm__config__h_

src/io.c

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

src/mat2.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_mat2_copy(mat2 mat, mat2 dest) {
+  glm_mat2_copy(mat, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2_identity(mat2 mat) {
+  glm_mat2_identity(mat);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2_identity_array(mat2 * __restrict mat, size_t count) {
+  glm_mat2_identity_array(mat, count);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2_zero(mat2 mat) {
+  glm_mat2_zero(mat);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2_mul(mat2 m1, mat2 m2, mat2 dest) {
+  glm_mat2_mul(m1, m2, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2_transpose_to(mat2 m, mat2 dest) {
+  glm_mat2_transpose_to(m, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2_transpose(mat2 m) {
+  glm_mat2_transpose(m);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2_mulv(mat2 m, vec2 v, vec2 dest) {
+  glm_mat2_mulv(m, v, dest);
+}
+
+CGLM_EXPORT
+float
+glmc_mat2_trace(mat2 m) {
+  return glm_mat2_trace(m);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2_scale(mat2 m, float s) {
+  glm_mat2_scale(m, s);
+}
+
+CGLM_EXPORT
+float
+glmc_mat2_det(mat2 mat) {
+  return glm_mat2_det(mat);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2_inv(mat2 mat, mat2 dest) {
+  glm_mat2_inv(mat, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2_swap_col(mat2 mat, int col1, int col2) {
+  glm_mat2_swap_col(mat, col1, col2);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2_swap_row(mat2 mat, int row1, int row2) {
+  glm_mat2_swap_row(mat, row1, row2);
+}
+
+CGLM_EXPORT
+float
+glmc_mat2_rmc(vec2 r, mat2 m, vec2 c) {
+  return glm_mat2_rmc(r, m, c);
+}

src/mat3.c

@@ -20,6 +20,12 @@ glmc_mat3_identity(mat3 mat) {
   glm_mat3_identity(mat);
 }
 
+CGLM_EXPORT
+void
+glmc_mat3_zero(mat3 mat) {
+  glm_mat3_zero(mat);
+}
+
 CGLM_EXPORT
 void
 glmc_mat3_identity_array(mat3 * __restrict mat, size_t count) {

src/mat4.c

@@ -32,6 +32,12 @@ glmc_mat4_identity_array(mat4 * __restrict mat, size_t count) {
   glm_mat4_identity_array(mat, count);
 }
 
+CGLM_EXPORT
+void
+glmc_mat4_zero(mat4 mat) {
+  glm_mat4_zero(mat);
+}
+
 CGLM_EXPORT
 void
 glmc_mat4_pick3(mat4 mat, mat3 dest) {

src/quat.c

@@ -59,7 +59,7 @@ glmc_quat_normalize_to(versor q, versor dest) {
 CGLM_EXPORT
 void
 glmc_quat_normalize(versor q) {
-  glm_quat_norm(q);
+  glm_quat_normalize(q);
 }
 
 CGLM_EXPORT
@@ -184,14 +184,14 @@ glmc_quat_look(vec3 eye, versor ori, mat4 dest) {
 
 CGLM_EXPORT
 void
-glmc_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest) {
-  glm_quat_for(dir, fwd, up, dest);
+glmc_quat_for(vec3 dir, vec3 up, versor dest) {
+  glm_quat_for(dir, up, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_quat_forp(vec3 from, vec3 to, vec3 fwd, vec3 up, versor dest) {
-  glm_quat_forp(from, to, fwd, up, dest);
+glmc_quat_forp(vec3 from, vec3 to, vec3 up, versor dest) {
+  glm_quat_forp(from, to, up, dest);
 }
 
 CGLM_EXPORT

src/ray.c

@@ -0,0 +1,13 @@
+#include "../include/cglm/cglm.h"
+#include "../include/cglm/call.h"
+
+CGLM_EXPORT
+bool
+glmc_ray_triangle(vec3   origin,
+                  vec3   direction,
+                  vec3   v0,
+                  vec3   v1,
+                  vec3   v2,
+                  float *d) {
+    return glm_ray_triangle(origin, direction, v0, v1, v2, d);
+}

src/vec2.c

@@ -0,0 +1,213 @@
+/*
+ * 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_vec2(float * __restrict v, vec2 dest) {
+  glm_vec2(v, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_copy(vec2 a, vec2 dest) {
+  glm_vec2_copy(a, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_zero(vec2 v) {
+  glm_vec2_zero(v);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_one(vec2 v) {
+  glm_vec2_one(v);
+}
+
+CGLM_EXPORT
+float
+glmc_vec2_dot(vec2 a, vec2 b) {
+  return glm_vec2_dot(a, b);
+}
+
+CGLM_EXPORT
+float
+glmc_vec2_cross(vec2 a, vec2 b) {
+  return glm_vec2_cross(a, b);
+}
+
+CGLM_EXPORT
+float
+glmc_vec2_norm2(vec2 v) {
+  return glm_vec2_norm2(v);
+}
+
+CGLM_EXPORT
+float
+glmc_vec2_norm(vec2 v) {
+  return glm_vec2_norm(v);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_add(vec2 a, vec2 b, vec2 dest) {
+  glm_vec2_add(a, b, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_adds(vec2 v, float s, vec2 dest) {
+  glm_vec2_adds(v, s, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_sub(vec2 a, vec2 b, vec2 dest) {
+  glm_vec2_sub(a, b, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_subs(vec2 v, float s, vec2 dest) {
+  glm_vec2_subs(v, s, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_mul(vec2 a, vec2 b, vec2 dest) {
+  glm_vec2_mul(a, b, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_scale(vec2 v, float s, vec2 dest) {
+  glm_vec2_scale(v, s, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_scale_as(vec2 v, float s, vec2 dest) {
+  glm_vec2_scale_as(v, s, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_div(vec2 a, vec2 b, vec2 dest) {
+  glm_vec2_div(a, b, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_divs(vec2 v, float s, vec2 dest) {
+  glm_vec2_divs(v, s, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_addadd(vec2 a, vec2 b, vec2 dest) {
+  glm_vec2_addadd(a, b, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_subadd(vec2 a, vec2 b, vec2 dest) {
+  glm_vec2_subadd(a, b, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_muladd(vec2 a, vec2 b, vec2 dest) {
+  glm_vec2_muladd(a, b, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_muladds(vec2 a, float s, vec2 dest) {
+  glm_vec2_muladds(a, s, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_maxadd(vec2 a, vec2 b, vec2 dest) {
+  glm_vec2_maxadd(a, b, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_minadd(vec2 a, vec2 b, vec2 dest) {
+  glm_vec2_minadd(a, b, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_negate_to(vec2 v, vec2 dest) {
+  glm_vec2_negate_to(v, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_negate(vec2 v) {
+  glm_vec2_negate(v);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_normalize(vec2 v) {
+  glm_vec2_normalize(v);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_normalize_to(vec2 v, vec2 dest) {
+  glm_vec2_normalize_to(v, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_rotate(vec2 v, float angle, vec2 dest) {
+  glm_vec2_rotate(v, angle, dest);
+}
+
+CGLM_EXPORT
+float
+glmc_vec2_distance2(vec2 a, vec2 b) {
+  return glm_vec2_distance2(a, b);
+}
+
+CGLM_EXPORT
+float
+glmc_vec2_distance(vec2 a, vec2 b) {
+  return glm_vec2_distance(a, b);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_maxv(vec2 a, vec2 b, vec2 dest) {
+  glm_vec2_maxv(a, b, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_minv(vec2 a, vec2 b, vec2 dest) {
+  glm_vec2_minv(a, b, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_clamp(vec2 v, float minval, float maxval) {
+  glm_vec2_clamp(v, minval, maxval);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_lerp(vec2 from, vec2 to, float t, vec2 dest) {
+  glm_vec2_lerp(from, to, t, dest);
+}

src/vec3.c

@@ -239,13 +239,13 @@ glmc_vec3_distance2(vec3 a, vec3 b) {
 CGLM_EXPORT
 void
 glmc_vec3_maxv(vec3 a, vec3 b, vec3 dest) {
-  glm_vec3_minv(a, b, dest);
+  glm_vec3_maxv(a, b, dest);
 }
 
 CGLM_EXPORT
 void
 glmc_vec3_minv(vec3 a, vec3 b, vec3 dest) {
-  glm_vec3_maxv(a, b, dest);
+  glm_vec3_minv(a, b, dest);
 }
 
 CGLM_EXPORT

src/vec4.c

@@ -203,13 +203,13 @@ glmc_vec4_distance2(vec4 a, vec4 b) {
 CGLM_EXPORT
 void
 glmc_vec4_maxv(vec4 a, vec4 b, vec4 dest) {
-  glm_vec4_minv(a, b, dest);
+  glm_vec4_maxv(a, b, dest);
 }
 
 CGLM_EXPORT
 void
 glmc_vec4_minv(vec4 a, vec4 b, vec4 dest) {
-  glm_vec4_maxv(a, b, dest);
+  glm_vec4_minv(a, b, dest);
 }
 
 CGLM_EXPORT

test/CMakeLists.txt

@@ -0,0 +1,39 @@
+cmake_minimum_required(VERSION 3.8.2)
+
+# List all files containing tests. (Change as needed)
+set(TESTFILES
+  runner.c
+  src/test_euler.c
+  src/test_bezier.c
+  src/test_cam.c
+  src/test_struct.c
+  src/test_clamp.c
+  src/test_common.c
+  src/tests.c
+  )
+
+set(TEST_MAIN tests)
+set(TEST_RUNNER_PARAMS "")
+
+add_executable(${TEST_MAIN} ${TESTFILES})
+
+target_link_libraries(${TEST_MAIN} PRIVATE cglm m)
+target_include_directories(${TEST_MAIN} PRIVATE
+  ${CMAKE_CURRENT_LIST_DIR}/include
+  ${CMAKE_CURRENT_LIST_DIR}/src
+  )
+
+set_target_properties(${TEST_MAIN} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR})
+
+if(LDFLAGS)
+  target_compile_options(${TEST_MAIN} PRIVATE ${LDFLAGS})
+endif()
+
+add_test(
+    NAME cglm.${TEST_MAIN}
+    COMMAND ${TEST_MAIN} ${TEST_RUNNER_PARAMS})
+
+add_custom_target(check
+  make
+  COMMAND ${CMAKE_CTEST_COMMAND} -V
+  DEPENDS cglm)

test/include/common.h

@@ -0,0 +1,151 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef tests_common_h
+#define tests_common_h
+
+#ifndef _USE_MATH_DEFINES
+#  define _USE_MATH_DEFINES       /* for windows */
+#endif
+
+#ifndef _CRT_SECURE_NO_WARNINGS
+#  define _CRT_SECURE_NO_WARNINGS /* for windows */
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <cglm/cglm.h>
+#include <cglm/struct.h>
+#include <cglm/call.h>
+
+typedef struct test_status_t {
+  const char *msg;
+  int         status;
+} test_status_t;
+
+typedef test_status_t (*fntest)(void);
+
+typedef struct test_entry_t {
+  char  *name;
+  fntest entry;
+  int    ret;
+  int    show_output;
+} test_entry_t;
+
+#ifndef GLM_TESTS_NO_COLORFUL_OUTPUT
+
+#define RESET       "\033[0m"
+#define BLACK       "\033[30m"             /* Black */
+#define RED         "\033[31m"             /* Red */
+#define GREEN       "\033[32m"             /* Green */
+#define YELLOW      "\033[33m"             /* Yellow */
+#define BLUE        "\033[34m"             /* Blue */
+#define MAGENTA     "\033[35m"             /* Magenta */
+#define CYAN        "\033[36m"             /* Cyan */
+#define WHITE       "\033[37m"             /* White */
+#define BOLDBLACK   "\033[1m\033[30m"      /* Bold Black */
+#define BOLDRED     "\033[1m\033[31m"      /* Bold Red */
+#define BOLDGREEN   "\033[1m\033[32m"      /* Bold Green */
+#define BOLDYELLOW  "\033[1m\033[33m"      /* Bold Yellow */
+#define BOLDBLUE    "\033[1m\033[34m"      /* Bold Blue */
+#define BOLDMAGENTA "\033[1m\033[35m"      /* Bold Magenta */
+#define BOLDCYAN    "\033[1m\033[36m"      /* Bold Cyan */
+#define BOLDWHITE   "\033[1m\033[37m"      /* Bold White */
+
+#else
+
+#define RESET
+#define BLACK
+#define RED
+#define GREEN
+#define YELLOW
+#define BLUE
+#define MAGENTA
+#define CYAN
+#define WHITE
+#define BOLDBLACK
+#define BOLDRED
+#define BOLDGREEN
+#define BOLDYELLOW
+#define BOLDBLUE
+#define BOLDMAGENTA
+#define BOLDCYAN
+#define BOLDWHITE
+
+#endif
+
+#define TEST_DECLARE(FUN) test_status_t test_ ## FUN(void);
+#define TEST_ENTRY(FUN)   { #FUN, test_ ## FUN, 0, 0 },
+#define TEST_LIST         static test_entry_t tests[] = 
+
+/* __VA_ARGS__ workaround for MSVC: https://stackoverflow.com/a/5134656 */
+#define EXPAND(x) x
+
+#define TEST_OK 1
+#define TEST_SUCCESS  return (test_status_t){NULL, TEST_OK};
+
+#define TEST_IMPL_ARG1(FUN) \
+  test_status_t test_ ## FUN (void);                                          \
+  test_status_t test_ ## FUN()
+
+#define TEST_IMPL_ARG2(PREFIX, FUN) TEST_IMPL_ARG1(PREFIX ## FUN)
+#define TEST_IMPL_ARG3(arg1, arg2, arg3, ...) arg3
+
+#define TEST_IMPL_CHOOSER(...)                                                \
+  EXPAND(TEST_IMPL_ARG3(__VA_ARGS__, TEST_IMPL_ARG2, TEST_IMPL_ARG1))
+
+#define TEST_IMPL(...) EXPAND(TEST_IMPL_CHOOSER(__VA_ARGS__)(__VA_ARGS__))
+
+#define ASSERT_EXT(expr, msg)                                                 \
+  if (!(expr)) {                                                              \
+    fprintf(stderr,                                                           \
+            RED "  assert fail" RESET                                         \
+            " in " BOLDCYAN "%s " RESET                                       \
+            "on " BOLDMAGENTA "line %d" RESET                                 \
+            " : " BOLDWHITE " ASSERT(%s)\n" RESET,                            \
+            __FILE__,                                                         \
+            __LINE__,                                                         \
+            #expr);                                                           \
+    return (test_status_t){msg, 0};                                           \
+  }
+
+#define ASSERT_ARG1(expr)                  ASSERT_EXT(expr, NULL)
+#define ASSERT_ARG2(expr, msg)             ASSERT_EXT(expr, msg)
+#define ASSERT_ARG3(arg1, arg2, arg3, ...) arg3
+
+#define ASSERT_CHOOSER(...) ASSERT_ARG3(__VA_ARGS__, ASSERT_ARG2, ASSERT_ARG1)
+#define ASSERT(...) do { ASSERT_CHOOSER(__VA_ARGS__)(__VA_ARGS__) } while(0);
+#define ASSERTIFY(expr) do {                                                  \
+    test_status_t ts; \
+    ts = expr; \
+    if (ts.status != TEST_OK) {                                               \
+      fprintf(stderr,                                                         \
+              RED "  assert fail" RESET                                       \
+              " in " BOLDCYAN "%s " RESET                                     \
+              "on " BOLDMAGENTA "line %d" RESET                               \
+              " : " BOLDWHITE " ASSERTIFY(%s)\n" RESET,                       \
+              __FILE__,                                                       \
+              __LINE__,                                                       \
+              #expr);                                                         \
+      return (test_status_t){ts.msg, 0};                                      \
+    } \
+  } while(0);
+
+#if defined(_WIN32)
+# define drand48()  ((float)(rand() / (RAND_MAX + 1.0)))
+# define OK_TEXT    "ok:"
+# define FAIL_TEXT  "fail:"
+# define FINAL_TEXT "^_^"
+#else
+# define OK_TEXT    "✔︎"
+# define FAIL_TEXT  "𐄂"
+# define FINAL_TEXT "🎉"
+#endif
+
+#endif /* common_h */

test/runner.c

@@ -0,0 +1,98 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "include/common.h"
+#include "tests.h"
+
+#include <stdlib.h>
+#include <time.h>
+#include <string.h>
+
+int
+main(int argc, const char * argv[]) {
+  test_entry_t *entry;
+  test_status_t st;
+  int32_t       i, count, passed, failed, maxlen;
+  double        start, end, elapsed, total;
+
+  passed = failed = maxlen  = 0;
+  total  = 0.0;
+  count  = sizeof(tests) / sizeof(tests[0]);
+
+  fprintf(stderr, CYAN "\nWelcome to cglm tests\n\n" RESET);
+
+  srand((unsigned int)time(NULL));
+
+  for (i = 0; i < count; i++) {
+    int32_t len;
+
+    entry = tests + i;
+    len   = (int32_t)strlen(entry->name);
+
+    maxlen = GLM_MAX(maxlen, len);
+  }
+
+  maxlen += 5;
+
+  fprintf(stderr,
+          BOLDWHITE  "  %-*s    %-*s\n",
+          maxlen, "Test Name", maxlen, "Elapsed Time");
+
+  for (i = 0; i < count; i++) {
+    entry   = tests + i;
+    start   = clock();
+    st      = entry->entry();
+    end     = clock();
+    elapsed = (end - start) / CLOCKS_PER_SEC;
+    total  += elapsed;
+
+    if (!st.status) {
+      fprintf(stderr,
+              BOLDRED  "  " FAIL_TEXT BOLDWHITE " %s " RESET, entry->name);
+      if (st.msg) {
+        fprintf(stderr,
+                YELLOW "- %s" RESET,
+                st.msg);
+      }
+
+      fprintf(stderr, "\n");
+
+      failed++;
+    } else {
+      fprintf(stderr, GREEN  "  " OK_TEXT RESET " %-*s  ", maxlen, entry->name);
+
+      if (elapsed > 0.01)
+        fprintf(stderr, YELLOW "%.2fs", elapsed);
+      else
+        fprintf(stderr, "0");
+
+      fprintf(stderr, "\n" RESET);
+      passed++;
+    }
+  }
+
+  if (failed == 0) {
+    fprintf(stderr,
+            BOLDGREEN "\n  All tests are passed " FINAL_TEXT "\n" RESET);
+  }
+
+  fprintf(stderr,
+          CYAN "\ncglm test results (%0.2fs):\n" RESET
+          "--------------------------\n"
+
+          MAGENTA "%d" RESET " tests are runned, "
+          GREEN   "%d" RESET " %s passed, "
+          RED     "%d" RESET " %s failed\n\n" RESET,
+          total,
+          count,
+          passed,
+          passed > 1 ? "are" : "is",
+          failed,
+          failed > 1 ? "are" : "is");
+
+  return failed;
+}

test/src/test_affine.c

@@ -1,113 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#include "test_common.h"
-
-void
-test_affine(void **state) {
-  mat4 t1, t2, t3, t4, t5;
-
-  /* test translate is postmultiplied */
-  glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
-  glm_translate_make(t2, (vec3){34, 57, 36});
-
-  glmc_mat4_mul(t1, t2, t3); /* R * T */
-
-  glm_translate(t1, (vec3){34, 57, 36});
-  test_assert_mat4_eq(t1, t3);
-
-  /* test rotate is postmultiplied */
-  glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
-  glm_translate_make(t2, (vec3){34, 57, 36});
-
-  glmc_mat4_mul(t2, t1, t3); /* T * R */
-
-  glm_rotate(t2, GLM_PI_4f, GLM_YUP);
-  test_assert_mat4_eq(t2, t3);
-
-  /* test scale is postmultiplied */
-  glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
-  glm_translate_make(t2, (vec3){34, 57, 36});
-  glm_scale_make(t4, (vec3){3, 5, 6});
-
-  glmc_mat4_mul(t2, t1, t3); /* T * R */
-  glmc_mat4_mul(t3, t4, t5); /* T * R * S */
-
-  glm_scale(t3, (vec3){3, 5, 6});
-  test_assert_mat4_eq(t3, t5);
-
-  /* test translate_x */
-  glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
-  glm_translate_make(t2, (vec3){34, 0, 0});
-
-  glmc_mat4_mul(t1, t2, t3); /* R * T */
-  glm_translate_x(t1, 34);
-  test_assert_mat4_eq(t1, t3);
-
-  /* test translate_y */
-  glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
-  glm_translate_make(t2, (vec3){0, 57, 0});
-
-  glmc_mat4_mul(t1, t2, t3); /* R * T */
-  glm_translate_y(t1, 57);
-  test_assert_mat4_eq(t1, t3);
-
-  /* test translate_z */
-  glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
-  glm_translate_make(t2, (vec3){0, 0, 36});
-
-  glmc_mat4_mul(t1, t2, t3); /* R * T */
-  glm_translate_z(t1, 36);
-  test_assert_mat4_eq(t1, t3);
-
-  /* test rotate_x */
-  glmc_rotate_make(t1, GLM_PI_4f, (vec3){1, 0, 0});
-  glm_translate_make(t2, (vec3){34, 57, 36});
-
-  glmc_mat4_mul(t2, t1, t3); /* T * R */
-
-  glm_rotate_x(t2, GLM_PI_4f, t2);
-  test_assert_mat4_eq(t2, t3);
-
-  /* test rotate_y */
-  glmc_rotate_make(t1, GLM_PI_4f, (vec3){0, 1, 0});
-  glm_translate_make(t2, (vec3){34, 57, 36});
-
-  glmc_mat4_mul(t2, t1, t3); /* T * R */
-
-  glm_rotate_y(t2, GLM_PI_4f, t2);
-  test_assert_mat4_eq(t2, t3);
-
-  /* test rotate_z */
-  glmc_rotate_make(t1, GLM_PI_4f, (vec3){0, 0, 1});
-  glm_translate_make(t2, (vec3){34, 57, 36});
-
-  glmc_mat4_mul(t2, t1, t3); /* T * R */
-
-  glm_rotate_z(t2, GLM_PI_4f, t2);
-  test_assert_mat4_eq(t2, t3);
-
-  /* test rotate */
-  glmc_rotate_make(t1, GLM_PI_4f, (vec3){0, 0, 1});
-  glm_translate_make(t2, (vec3){34, 57, 36});
-
-  glmc_mat4_mul(t2, t1, t3); /* T * R */
-  glmc_rotate(t2, GLM_PI_4f, (vec3){0, 0, 1});
-
-  test_assert_mat4_eq(t3, t2);
-
-  /* test scale_uni */
-  glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
-  glm_translate_make(t2, (vec3){34, 57, 36});
-  glm_scale_make(t4, (vec3){3, 3, 3});
-
-  glmc_mat4_mul(t2, t1, t3); /* T * R */
-  glmc_mat4_mul(t3, t4, t5); /* T * R * S */
-
-  glm_scale_uni(t3, 3);
-  test_assert_mat4_eq(t3, t5);
-}

test/src/test_affine.h

@@ -0,0 +1,634 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "test_common.h"
+
+TEST_IMPL(GLM_PREFIX, translate) {
+  mat4 m1;
+  vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat4_identity(m1);
+  GLM(translate)(m1, (vec3){13.0f, 11.0f, 7.0f});
+  glm_mat4_mulv(m1, v1, v2);
+
+  ASSERT(test_eq(v2[0], 14.0f))
+  ASSERT(test_eq(v2[1], 13.0f))
+  ASSERT(test_eq(v2[2], 10.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  glm_mat4_identity(m1);
+  GLM(translate)(m1, (vec3){1.0f, -1.0f, -5.0f});
+  glm_mat4_mulv(m1, v2, v2);
+
+  ASSERT(test_eq(v2[0], 15.0f))
+  ASSERT(test_eq(v2[1], 12.0f))
+  ASSERT(test_eq(v2[2], 5.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, translate_to) {
+  mat4 m1, m2;
+  vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat4_identity(m1);
+  GLM(translate_to)(m1, (vec3){13.0f, 11.0f, 7.0f}, m2);
+  glm_mat4_mulv(m2, v1, v2);
+
+  ASSERT(test_eq(v2[0], 14.0f))
+  ASSERT(test_eq(v2[1], 13.0f))
+  ASSERT(test_eq(v2[2], 10.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  glm_mat4_identity(m1);
+  GLM(translate_to)(m1, (vec3){1.0f, -1.0f, -5.0f}, m2);
+  glm_mat4_mulv(m2, v2, v2);
+
+  ASSERT(test_eq(v2[0], 15.0f))
+  ASSERT(test_eq(v2[1], 12.0f))
+  ASSERT(test_eq(v2[2], 5.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, translate_x) {
+  mat4 m1;
+  vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat4_identity(m1);
+  GLM(translate_x)(m1, 13.0f);
+  glm_mat4_mulv(m1, v1, v2);
+
+  ASSERT(test_eq(v2[0], 14.0f))
+  ASSERT(test_eq(v2[1], 2.0f))
+  ASSERT(test_eq(v2[2], 3.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  glm_mat4_identity(m1);
+  GLM(translate_x)(m1, -1.0f);
+  glm_mat4_mulv(m1, v2, v2);
+
+  ASSERT(test_eq(v2[0], 13.0f))
+  ASSERT(test_eq(v2[1], 2.0f))
+  ASSERT(test_eq(v2[2], 3.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, translate_y) {
+  mat4 m1;
+  vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat4_identity(m1);
+  GLM(translate_y)(m1, 11.0f);
+  glm_mat4_mulv(m1, v1, v2);
+
+  ASSERT(test_eq(v2[0], 1.0f))
+  ASSERT(test_eq(v2[1], 13.0f))
+  ASSERT(test_eq(v2[2], 3.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  glm_mat4_identity(m1);
+  GLM(translate_y)(m1, -1.0f);
+  glm_mat4_mulv(m1, v2, v2);
+
+  ASSERT(test_eq(v2[0], 1.0f))
+  ASSERT(test_eq(v2[1], 12.0f))
+  ASSERT(test_eq(v2[2], 3.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, translate_z) {
+  mat4 m1;
+  vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat4_identity(m1);
+  GLM(translate_z)(m1, 7.0f);
+  glm_mat4_mulv(m1, v1, v2);
+
+  ASSERT(test_eq(v2[0], 1.0f))
+  ASSERT(test_eq(v2[1], 2.0f))
+  ASSERT(test_eq(v2[2], 10.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  glm_mat4_identity(m1);
+  GLM(translate_z)(m1, -5.0f);
+  glm_mat4_mulv(m1, v2, v2);
+
+  ASSERT(test_eq(v2[0], 1.0f))
+  ASSERT(test_eq(v2[1], 2.0f))
+  ASSERT(test_eq(v2[2], 5.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, translate_make) {
+  mat4 m1;
+  vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat4_identity(m1);
+  GLM(translate_make)(m1, (vec3){13.0f, 11.0f, 7.0f});
+  glm_mat4_mulv(m1, v1, v2);
+
+  ASSERT(test_eq(v2[0], 14.0f))
+  ASSERT(test_eq(v2[1], 13.0f))
+  ASSERT(test_eq(v2[2], 10.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  glm_mat4_identity(m1);
+  GLM(translate_make)(m1, (vec3){1.0f, -1.0f, -5.0f});
+  glm_mat4_mulv(m1, v2, v2);
+
+  ASSERT(test_eq(v2[0], 15.0f))
+  ASSERT(test_eq(v2[1], 12.0f))
+  ASSERT(test_eq(v2[2], 5.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, scale_to) {
+  mat4 m1, m2;
+  vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat4_identity(m1);
+  GLM(scale_to)(m1, (vec3){13.0f, 11.0f, 7.0f}, m2);
+  glm_mat4_mulv(m2, v1, v2);
+
+  ASSERT(test_eq(v2[0], 13.0f))
+  ASSERT(test_eq(v2[1], 22.0f))
+  ASSERT(test_eq(v2[2], 21.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  glm_mat4_identity(m1);
+  GLM(scale_to)(m1, (vec3){1.0f, -1.0f, -5.0f}, m2);
+  glm_mat4_mulv(m2, v2, v2);
+
+  ASSERT(test_eq(v2[0],  13.0f))
+  ASSERT(test_eq(v2[1], -22.0f))
+  ASSERT(test_eq(v2[2], -105.0f))
+  ASSERT(test_eq(v2[3],  1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, scale_make) {
+  mat4 m1;
+  vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2;
+
+  GLM(scale_make)(m1, (vec3){13.0f, 11.0f, 7.0f});
+  glm_mat4_mulv(m1, v1, v2);
+
+  ASSERT(test_eq(v2[0], 13.0f))
+  ASSERT(test_eq(v2[1], 22.0f))
+  ASSERT(test_eq(v2[2], 21.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  GLM(scale_make)(m1, (vec3){1.0f, -1.0f, -5.0f});
+  glm_mat4_mulv(m1, v2, v2);
+
+  ASSERT(test_eq(v2[0],  13.0f))
+  ASSERT(test_eq(v2[1], -22.0f))
+  ASSERT(test_eq(v2[2], -105.0f))
+  ASSERT(test_eq(v2[3],  1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, scale) {
+  mat4 m1;
+  vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat4_identity(m1);
+  GLM(scale)(m1, (vec3){13.0f, 11.0f, 7.0f});
+  glm_mat4_mulv(m1, v1, v2);
+
+  ASSERT(test_eq(v2[0], 13.0f))
+  ASSERT(test_eq(v2[1], 22.0f))
+  ASSERT(test_eq(v2[2], 21.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  glm_mat4_identity(m1);
+  GLM(scale)(m1, (vec3){1.0f, -1.0f, -5.0f});
+  glm_mat4_mulv(m1, v2, v2);
+
+  ASSERT(test_eq(v2[0],  13.0f))
+  ASSERT(test_eq(v2[1], -22.0f))
+  ASSERT(test_eq(v2[2], -105.0f))
+  ASSERT(test_eq(v2[3],  1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, scale_uni) {
+  mat4 m1;
+  vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat4_identity(m1);
+  GLM(scale_uni)(m1, 13.0f);
+  glm_mat4_mulv(m1, v1, v2);
+
+  ASSERT(test_eq(v2[0], 13.0f))
+  ASSERT(test_eq(v2[1], 26.0f))
+  ASSERT(test_eq(v2[2], 39.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  glm_mat4_identity(m1);
+  GLM(scale_uni)(m1, -5.0f);
+  glm_mat4_mulv(m1, v2, v2);
+
+  ASSERT(test_eq(v2[0], -65.0f))
+  ASSERT(test_eq(v2[1], -130.0f))
+  ASSERT(test_eq(v2[2], -195.0f))
+  ASSERT(test_eq(v2[3],  1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, rotate_x) {
+  mat4   m1 = GLM_MAT4_IDENTITY_INIT;
+  vec4   v1 = {0.0f, 1.0f, 0.0f, 1.0f}, v2 = {0.0f, 1.0f, 0.0f, 1.0f};
+
+  GLM(rotate_x)(m1, GLM_PI_2f, m1);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0], 0.0f))
+  ASSERT(test_eq(v1[1], 0.0f))
+  ASSERT(test_eq(v1[2], 1.0f))
+
+  glm_vec3_copy(v2, v1);
+
+  GLM(rotate_x)(m1, GLM_PI_2f, m1);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1], -1.0f))
+  ASSERT(test_eq(v1[2],  0.0f))
+
+  glm_vec3_copy(v2, v1);
+
+  GLM(rotate_x)(m1, GLM_PI_2f, m1);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2], -1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, rotate_y) {
+  mat4   m1 = GLM_MAT4_IDENTITY_INIT;
+  vec4   v1 = {1.0f, 0.0f, 0.0f, 1.0f}, v2 = {1.0f, 0.0f, 0.0f, 1.0f};
+
+  GLM(rotate_y)(m1, GLM_PI_2f, m1);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2], -1.0f))
+
+  glm_vec3_copy(v2, v1);
+
+  GLM(rotate_y)(m1, GLM_PI_2f, m1);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0], -1.0f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2],  0.0f))
+
+  glm_vec3_copy(v2, v1);
+
+  GLM(rotate_y)(m1, GLM_PI_2f, m1);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0], 0.0f))
+  ASSERT(test_eq(v1[1], 0.0f))
+  ASSERT(test_eq(v1[2], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, rotate_z) {
+  mat4   m1 = GLM_MAT4_IDENTITY_INIT;
+  vec4   v1 = {0.0f, 1.0f, 0.0f, 1.0f}, v2 = {0.0f, 1.0f, 0.0f, 1.0f};
+
+  GLM(rotate_z)(m1, GLM_PI_2f, m1);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0], -1.0f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2],  0.0f))
+
+  glm_vec3_copy(v2, v1);
+
+  GLM(rotate_z)(m1, GLM_PI_2f, m1);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1], -1.0f))
+  ASSERT(test_eq(v1[2],  0.0f))
+
+  glm_vec3_copy(v2, v1);
+
+  GLM(rotate_z)(m1, GLM_PI_2f, m1);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0], 1.0f))
+  ASSERT(test_eq(v1[1], 0.0f))
+  ASSERT(test_eq(v1[2], 0.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, rotate_make) {
+  mat4   m1 = GLM_MAT4_IDENTITY_INIT;
+  vec4   v1 = {1.0f, 0.0f, 0.0f, 1.0f};
+
+  /* rotate X around Y = -Z */
+  GLM(rotate_make)(m1, GLM_PI_2f, GLM_YUP);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2], -1.0f))
+
+  /* rotate -Z around X = Y */
+  GLM(rotate_make)(m1, GLM_PI_2f, GLM_XUP);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1],  1.0f))
+  ASSERT(test_eq(v1[2],  0.0f))
+
+  /* rotate Y around X = +Z */
+  GLM(rotate_make)(m1, GLM_PI_2f, GLM_XUP);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2],  1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, rotate) {
+  mat4 m1 = GLM_MAT4_IDENTITY_INIT, m2 = GLM_MAT4_IDENTITY_INIT;
+  vec4 v1 = {1.0f, 0.0f, 0.0f, 1.0f};
+
+  /* 360 deg */
+  glm_rotate(m1, GLM_PI_2f, GLM_YUP);
+  glm_rotate(m1, GLM_PI_2f, GLM_YUP);
+  glm_rotate(m1, GLM_PI_2f, GLM_YUP);
+  glm_rotate(m1, GLM_PI_2f, GLM_YUP);
+  ASSERTIFY(test_assert_mat4_eq(m1, m2))
+
+  /* rotate X around Y = -Z */
+  GLM(rotate)(m1, GLM_PI_2f, GLM_YUP);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2], -1.0f))
+
+  glm_mat4_identity(m1);
+
+  /* rotate -Z around X = Y */
+  GLM(rotate)(m1, GLM_PI_2f, GLM_XUP);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1],  1.0f))
+  ASSERT(test_eq(v1[2],  0.0f))
+
+  glm_mat4_identity(m1);
+
+  /* rotate Y around X = +Z */
+  GLM(rotate)(m1, GLM_PI_2f, GLM_XUP);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2],  1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, rotate_at) {
+  mat4 m1 = GLM_MAT4_IDENTITY_INIT;
+  vec4 v1 = {1.0f, 0.0f, 0.0f, 1.0f};
+
+  GLM(rotate_at)(m1, (vec3){0.5f, 0.0f, 0.0f}, GLM_PI_2f, GLM_YUP);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.5f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2], -0.5f))
+
+  glm_mat4_identity(m1);
+
+  GLM(rotate_at)(m1, GLM_VEC3_ZERO, GLM_PI_2f, GLM_ZUP);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1],  0.5f))
+  ASSERT(test_eq(v1[2], -0.5f))
+
+  glm_mat4_identity(m1);
+
+  v1[0] = 1.0f;
+  v1[1] = 1.0f;
+  v1[2] = 1.0f;
+
+  GLM(rotate_at)(m1, GLM_VEC3_ZERO, GLM_PI_2f, GLM_XUP);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  1.0f))
+  ASSERT(test_eq(v1[1], -1.0f))
+  ASSERT(test_eq(v1[2],  1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, rotate_atm) {
+  mat4 m1 = GLM_MAT4_IDENTITY_INIT;
+  vec4 v1 = {1.0f, 0.0f, 0.0f, 1.0f};
+
+  GLM(rotate_atm)(m1, (vec3){0.5f, 0.0f, 0.0f}, GLM_PI_2f, GLM_YUP);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.5f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2], -0.5f))
+
+  GLM(rotate_atm)(m1, GLM_VEC3_ZERO, GLM_PI_2f, GLM_ZUP);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1],  0.5f))
+  ASSERT(test_eq(v1[2], -0.5f))
+
+  v1[0] = 1.0f;
+  v1[1] = 1.0f;
+  v1[2] = 1.0f;
+
+  GLM(rotate_atm)(m1, GLM_VEC3_ZERO, GLM_PI_2f, GLM_XUP);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  1.0f))
+  ASSERT(test_eq(v1[1], -1.0f))
+  ASSERT(test_eq(v1[2],  1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, decompose_scalev) {
+  mat4 m1;
+  vec3 s1;
+
+  GLM(scale_make)(m1, (vec3){7.0f, 8.0f, 9.0f});
+  GLM(decompose_scalev)(m1, s1);
+
+  ASSERT(test_eq(s1[0], 7.0f))
+  ASSERT(test_eq(s1[1], 8.0f))
+  ASSERT(test_eq(s1[2], 9.0f))
+
+  GLM(scale)(m1, (vec3){7.0f, 8.0f, 9.0f});
+  GLM(decompose_scalev)(m1, s1);
+
+  ASSERT(test_eq(s1[0], 49.0f))
+  ASSERT(test_eq(s1[1], 64.0f))
+  ASSERT(test_eq(s1[2], 81.0f))
+
+  glm_rotate(m1, GLM_PI_4f, (vec3){23.0f, 45.0f, 66.0f});
+  ASSERT(test_eq(s1[0], 49.0f))
+  ASSERT(test_eq(s1[1], 64.0f))
+  ASSERT(test_eq(s1[2], 81.0f))
+
+  glm_translate(m1, (vec3){4.0f, 5.0f, 6.0f});
+  ASSERT(test_eq(s1[0], 49.0f))
+  ASSERT(test_eq(s1[1], 64.0f))
+  ASSERT(test_eq(s1[2], 81.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, uniscaled) {
+  mat4 m1;
+
+  GLM(scale_make)(m1, (vec3){7.0f, 8.0f, 9.0f});
+  ASSERT(!GLM(uniscaled)(m1))
+
+  GLM(scale_make)(m1, (vec3){7.0f, 7.0f, 7.0f});
+  ASSERT(GLM(uniscaled)(m1))
+
+  glm_rotate(m1, GLM_PI_4f, (vec3){23.0f, 45.0f, 66.0f});
+  ASSERT(GLM(uniscaled)(m1))
+
+  glm_translate(m1, (vec3){4.0f, 5.0f, 6.0f});
+  ASSERT(GLM(uniscaled)(m1))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, decompose_rs) {
+  mat4 m1, m2, r;
+  vec3 s1;
+
+  GLM(scale_make)(m1, (vec3){7.0f, 8.0f, 9.0f});
+  GLM(decompose_rs)(m1, r, s1);
+
+  ASSERT(test_eq(s1[0], 7.0f))
+  ASSERT(test_eq(s1[1], 8.0f))
+  ASSERT(test_eq(s1[2], 9.0f))
+  ASSERTIFY(test_assert_mat4_eq_identity(r));
+
+  GLM(scale)(m1, (vec3){7.0f, 8.0f, 9.0f});
+  GLM(decompose_rs)(m1, r, s1);
+
+  ASSERT(test_eq(s1[0], 49.0f))
+  ASSERT(test_eq(s1[1], 64.0f))
+  ASSERT(test_eq(s1[2], 81.0f))
+  ASSERTIFY(test_assert_mat4_eq_identity(r));
+
+  glm_rotate(m1, GLM_PI_4f, (vec3){23.0f, 45.0f, 66.0f});
+  ASSERT(test_eq(s1[0], 49.0f))
+  ASSERT(test_eq(s1[1], 64.0f))
+  ASSERT(test_eq(s1[2], 81.0f))
+  GLM(decompose_rs)(m1, r, s1);
+
+  glm_mat4_identity(m2);
+  glm_mat4_mul(m2, r, m2);
+  glm_scale(m2, s1);
+
+  ASSERTIFY(test_assert_mat4_eq2(m1, m2, 0.00001f));
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, decompose) {
+  mat4 m1, m2, r;
+  vec4 t;
+  vec3 s;
+
+  GLM(scale_make)(m1, (vec3){7.0f, 8.0f, 9.0f});
+  GLM(decompose)(m1, t, r, s);
+
+  ASSERT(test_eq(s[0], 7.0f))
+  ASSERT(test_eq(s[1], 8.0f))
+  ASSERT(test_eq(s[2], 9.0f))
+  ASSERTIFY(test_assert_mat4_eq_identity(r));
+
+  GLM(scale)(m1, (vec3){7.0f, 8.0f, 9.0f});
+  GLM(decompose)(m1, t, r, s);
+
+  ASSERT(test_eq(s[0], 49.0f))
+  ASSERT(test_eq(s[1], 64.0f))
+  ASSERT(test_eq(s[2], 81.0f))
+  ASSERTIFY(test_assert_mat4_eq_identity(r));
+
+  glm_rotate(m1, GLM_PI_4f, (vec3){23.0f, 45.0f, 66.0f});
+  ASSERT(test_eq(s[0], 49.0f))
+  ASSERT(test_eq(s[1], 64.0f))
+  ASSERT(test_eq(s[2], 81.0f))
+  GLM(decompose)(m1, t, r, s);
+
+  glm_mat4_identity(m2);
+  glm_mat4_mul(m2, r, m2);
+  glm_scale(m2, s);
+
+  ASSERTIFY(test_assert_mat4_eq2(m1, m2, 0.00001f));
+
+  glm_mat4_identity(m1);
+  glm_translate(m1, (vec3){56.0f, 13.0f, 90.0f});
+  glm_rotate(m1, GLM_PI_4f, (vec3){23.0f, 45.0f, 66.0f});
+  glm_scale(m1, (vec3){12.0f, 34.0f, 23.0f});
+
+  GLM(decompose)(m1, t, r, s);
+
+  ASSERT(test_eq(t[0], 56.0f))
+  ASSERT(test_eq(t[1], 13.0f))
+  ASSERT(test_eq(t[2], 90.0f))
+
+  ASSERT(test_eq(s[0], 12.0f))
+  ASSERT(test_eq(s[1], 34.0f))
+  ASSERT(test_eq(s[2], 23.0f))
+
+  glm_mat4_identity(m2);
+  glm_translate(m2, t);
+  glm_mat4_mul(m2, r, m2);
+  glm_scale(m2, s);
+  ASSERTIFY(test_assert_mat4_eq2(m1, m2, 0.00001f));
+
+  TEST_SUCCESS
+}

test/src/test_affine_mat.h

@@ -0,0 +1,87 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "test_common.h"
+
+TEST_IMPL(GLM_PREFIX, mul) {
+  mat4 m1 = GLM_MAT4_IDENTITY_INIT;
+  mat4 m2 = GLM_MAT4_IDENTITY_INIT;
+  mat4 m3;
+  mat4 m4 = GLM_MAT4_ZERO_INIT;
+  int  i, j, k;
+
+  test_rand_mat4(m1);
+  test_rand_mat4(m2);
+
+  GLM(mul)(m1, m2, m3);
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 4; j++) {
+      for (k = 0; k < 4; k++)
+        /* column-major */
+        m4[i][j] += m1[k][j] * m2[i][k];
+    }
+  }
+
+  ASSERTIFY(test_assert_mat4_eq(m3, m4))
+
+  /* test pre compiled */
+  GLM(mul)(m1, m2, m3);
+  ASSERTIFY(test_assert_mat4_eq(m3, m4))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mul_rot) {
+  mat4 m1 = GLM_MAT4_IDENTITY_INIT;
+  mat4 m2 = GLM_MAT4_IDENTITY_INIT;
+  mat4 m3;
+  mat4 m4 = GLM_MAT4_ZERO_INIT;
+  int  i, j, k;
+
+  glm_rotate(m1, drand48(), (vec3){drand48(), drand48(), drand48()});
+  glm_rotate(m2, drand48(), (vec3){drand48(), drand48(), drand48()});
+
+  GLM(mul_rot)(m1, m2, m3);
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 4; j++) {
+      for (k = 0; k < 4; k++)
+        /* column-major */
+        m4[i][j] += m1[k][j] * m2[i][k];
+    }
+  }
+
+  ASSERTIFY(test_assert_mat4_eq(m3, m4))
+
+  /* test pre compiled */
+  GLM(mul_rot)(m1, m2, m3);
+  ASSERTIFY(test_assert_mat4_eq(m3, m4))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, inv_tr) {
+  mat4 m1, m2;
+  int  i;
+
+  for (i = 0; i < 10000; i++) {
+    test_rand_mat4(m1);
+
+    glm_mat4_copy(m1, m2);
+
+    /* test inverse precise */
+    GLM(inv_tr)(m1);
+    GLM(inv_tr)(m1);
+    ASSERTIFY(test_assert_mat4_eq(m1, m2))
+
+    /* test inverse precise */
+    GLM(mat4_inv)(m1, m2);
+    GLM(inv_tr)(m2);
+    ASSERTIFY(test_assert_mat4_eq(m1, m2))
+  }
+
+  TEST_SUCCESS
+}

test/src/test_bezier.c

@@ -35,8 +35,7 @@ test_hermite_plain(float s, float p0, float t0, float t1, float p1) {
        + t1 * (sss - ss);
 }
 
-void
-test_bezier(void **state) {
+TEST_IMPL(bezier) {
   float s, p0, p1, c0, c1, smc, Bs, Bs_plain;
 
   s        = test_rand();
@@ -50,16 +49,18 @@ test_bezier(void **state) {
   Bs       = glm_bezier(s, p0, c0, c1, p1);
   Bs_plain = test_bezier_plain(s, p0, c0, c1, p1);
 
-  assert_true(glm_eq(Bs,  Bs_plain));
-  test_assert_eqf(smc, Bs_plain);
-  test_assert_eqf(Bs,  smc);
+  ASSERT(test_eq(Bs,  Bs_plain));
+  ASSERTIFY(test_assert_eqf(smc, Bs_plain))
+  ASSERTIFY(test_assert_eqf(Bs,  smc))
 
   /* test cubic hermite */
   smc      = glm_smc(s, GLM_HERMITE_MAT, (vec4){p0, p1, c0, c1});
   Bs       = glm_hermite(s, p0, c0, c1, p1);
   Bs_plain = test_hermite_plain(s, p0, c0, c1, p1);
 
-  assert_true(glm_eq(Bs,  Bs_plain));
-  assert_true(glm_eq(smc, Bs_plain));
-  assert_true(glm_eq(Bs,  smc));
+  ASSERT(test_eq(Bs,  Bs_plain));
+  ASSERT(test_eq(smc, Bs_plain));
+  ASSERT(test_eq(Bs,  smc));
+  
+  TEST_SUCCESS
 }

test/src/test_cam.c

@@ -7,25 +7,24 @@
 
 #include "test_common.h"
 
-void
-test_camera_lookat(void **state) {
-  mat4  view1, view2;
+TEST_IMPL(camera_lookat) {
+  mat4 view1, view2;
   vec3 center,
-       eye    = {0.024f, 14.6f, 67.04f},
-       dir    = {0.0f, 0.0f, -1.0f},
-       up     = {0.0f, 1.0f, 0.0f}
-  ;
+       eye = {0.024f, 14.6f, 67.04f},
+       dir = {0.0f, 0.0f, -1.0f},
+       up  = {0.0f, 1.0f, 0.0f};
 
   glm_vec3_add(eye, dir, center);
   glm_lookat(eye, center, up, view1);
 
   glm_look(eye, dir, up, view2);
 
-  test_assert_mat4_eq(view1, view2);
+  ASSERTIFY(test_assert_mat4_eq(view1, view2))
+
+  TEST_SUCCESS
 }
 
-void
-test_camera_decomp(void **state) {
+TEST_IMPL(camera_decomp) {
   mat4  proj, proj2;
   vec4  sizes;
   float aspect, fovy, nearVal, farVal;
@@ -36,19 +35,21 @@ test_camera_decomp(void **state) {
   farVal  = 100.0f;
 
   glm_perspective(fovy, aspect, nearVal, farVal, proj);
-  assert_true(fabsf(aspect  - glm_persp_aspect(proj)) < FLT_EPSILON);
-  assert_true(fabsf(fovy    - glm_persp_fovy(proj))   < FLT_EPSILON);
-  assert_true(fabsf(49.984f - glm_deg(glm_persp_fovy(proj))) < FLT_EPSILON);
+  ASSERT(fabsf(aspect  - glm_persp_aspect(proj)) < GLM_FLT_EPSILON)
+  ASSERT(fabsf(fovy    - glm_persp_fovy(proj))   < GLM_FLT_EPSILON)
+  ASSERT(fabsf(49.984f - glm_deg(glm_persp_fovy(proj))) < GLM_FLT_EPSILON)
 
   glm_persp_sizes(proj, fovy, sizes);
 
-  glm_frustum(-sizes[0] * 0.5,
-               sizes[0] * 0.5,
-              -sizes[1] * 0.5,
-               sizes[1] * 0.5,
+  glm_frustum(-sizes[0] * 0.5f,
+               sizes[0] * 0.5f,
+              -sizes[1] * 0.5f,
+               sizes[1] * 0.5f,
                nearVal,
                farVal,
                proj2);
 
-  test_assert_mat4_eq(proj, proj2);
+  ASSERTIFY(test_assert_mat4_eq(proj, proj2))
+
+  TEST_SUCCESS
 }

test/src/test_camera.h

@@ -0,0 +1,68 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "test_common.h"
+
+TEST_IMPL(GLM_PREFIX, frustum) {
+  mat4  proj;
+  vec4  vp = {0.0f, 0.0f, 800.0f, 600.0f};
+  float left, right, top, bottom, znear, zfar;
+  
+  znear  =  0.1f;
+  zfar   =  100.0f;
+  left   = -100.0f;
+  right  =  100.0f;
+  bottom = -100.0f;
+  top    =  100.0f;
+  
+  GLM(frustum)(left, right, bottom, top, znear, zfar, proj);
+  
+  ASSERT(test_eq(proj[0][1], 0.0f))
+  ASSERT(test_eq(proj[0][2], 0.0f))
+  ASSERT(test_eq(proj[0][3], 0.0f))
+
+  ASSERT(test_eq(proj[1][0], 0.0f))
+  ASSERT(test_eq(proj[1][2], 0.0f))
+  ASSERT(test_eq(proj[1][3], 0.0f))
+
+  ASSERT(test_eq(proj[2][3], -1.0f))
+
+  ASSERT(test_eq(proj[3][0], 0.0f))
+  ASSERT(test_eq(proj[3][1], 0.0f))
+  ASSERT(test_eq(proj[3][3], 0.0f))
+
+  vec4  v1 = {1.0f, 20.0f, znear};
+  vec4  v2 = {1.0f, 20.0f, zfar};
+  vec4  v3, v4;
+
+  /* perspective test */
+  GLM(mat4_mulv)(proj, v1, v3);
+  GLM(project)(v3, proj, vp, v3);
+  
+  ASSERT(v3[0] > v1[0])
+  ASSERT(v3[1] > v1[1])
+  
+  GLM(mat4_mulv)(proj, v2, v4);
+  GLM(project)(v4, proj, vp, v4);
+  
+  ASSERT(v4[0] < v3[0])
+  ASSERT(v4[1] < v3[1])
+  
+  /* not infinity */
+  ASSERT(!GLM(vec4_isinf)(proj[0]))
+  ASSERT(!GLM(vec4_isinf)(proj[1]))
+  ASSERT(!GLM(vec4_isinf)(proj[2]))
+  ASSERT(!GLM(vec4_isinf)(proj[3]))
+  
+  /* not NaN */
+  ASSERT(!GLM(vec4_isnan)(proj[0]))
+  ASSERT(!GLM(vec4_isnan)(proj[1]))
+  ASSERT(!GLM(vec4_isnan)(proj[2]))
+  ASSERT(!GLM(vec4_isnan)(proj[3]))
+
+  TEST_SUCCESS
+}

test/src/test_clamp.c

@@ -7,24 +7,25 @@
 
 #include "test_common.h"
 
-void
-test_clamp(void **state) {
-  vec3 v3 = {15.07, 0.4, 17.3};
-  vec4 v4 = {5.07,  2.3, 1.3, 1.4};
+TEST_IMPL(clamp) {
+  vec3 v3 = {15.07f, 0.4f, 17.3f};
+  vec4 v4 = {5.07f,  2.3f, 1.3f, 1.4f};
 
-  assert_true(glm_clamp(1.6f, 0.0f, 1.0f)  == 1.0f);
-  assert_true(glm_clamp(-1.6f, 0.0f, 1.0f) == 0.0f);
-  assert_true(glm_clamp(0.6f, 0.0f, 1.0f)  == 0.6f);
+  ASSERT(glm_clamp(1.6f, 0.0f, 1.0f)  == 1.0f)
+  ASSERT(glm_clamp(-1.6f, 0.0f, 1.0f) == 0.0f)
+  ASSERT(glm_clamp(0.6f, 0.0f, 1.0f)  == 0.6f)
 
   glm_vec3_clamp(v3, 0.0, 1.0);
   glm_vec4_clamp(v4, 1.5, 3.0);
 
-  assert_true(v3[0] == 1.0f);
-  assert_true(v3[1] == 0.4f);
-  assert_true(v3[2] == 1.0f);
+  ASSERT(v3[0] == 1.0f)
+  ASSERT(v3[1] == 0.4f)
+  ASSERT(v3[2] == 1.0f)
 
-  assert_true(v4[0] == 3.0f);
-  assert_true(v4[1] == 2.3f);
-  assert_true(v4[2] == 1.5f);
-  assert_true(v4[3] == 1.5f);
+  ASSERT(v4[0] == 3.0f)
+  ASSERT(v4[1] == 2.3f)
+  ASSERT(v4[2] == 1.5f)
+  ASSERT(v4[3] == 1.5f)
+  
+  TEST_SUCCESS
 }

test/src/test_common.c

@@ -4,26 +4,20 @@
  */
 
 #include "test_common.h"
-#include <stdlib.h>
-#include <math.h>
-
-#define m 4
-#define n 4
+#include <time.h>
 
 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()}); */
 }
@@ -32,24 +26,28 @@ void
 test_rand_mat3(mat3 dest) {
   mat4 m4;
 
-  srand((unsigned int)time(NULL));
-
   /* random rotatation around random axis with random angle */
   glm_rotate_make(m4, drand48(), (vec3){drand48(), drand48(), drand48()});
   glm_mat4_pick3(m4, dest);
 }
 
 void
-test_rand_vec3(vec3 dest) {
-  srand((unsigned int)time(NULL));
+test_rand_mat2(mat2 dest) {
+  dest[0][0] = drand48();
+  dest[0][1] = drand48();
+  dest[1][0] = drand48();
+  dest[1][1] = drand48();
+}
 
+void
+test_rand_vec3(vec3 dest) {
   dest[0] = drand48();
   dest[1] = drand48();
   dest[2] = drand48();
 }
 
 vec3s
-test_rand_vec3s() {
+test_rand_vec3s(void) {
   vec3s r;
   test_rand_vec3(r.raw);
   return r;
@@ -57,8 +55,6 @@ test_rand_vec3s() {
 
 void
 test_rand_vec4(vec4 dest) {
-  srand((unsigned int)time(NULL));
-
   dest[0] = drand48();
   dest[1] = drand48();
   dest[2] = drand48();
@@ -66,7 +62,7 @@ test_rand_vec4(vec4 dest) {
 }
 
 vec4s
-test_rand_vec4s() {
+test_rand_vec4s(void) {
   vec4s r;
   test_rand_vec4(r.raw);
   return r;
@@ -74,97 +70,272 @@ test_rand_vec4s() {
 
 float
 test_rand(void) {
-  srand((unsigned int)time(NULL));
   return drand48();
 }
 
 void
 test_rand_quat(versor q) {
-  srand((unsigned int)time(NULL));
-
   glm_quat(q, drand48(), drand48(), drand48(), drand48());
   glm_quat_normalize(q);
 }
 
-void
+test_status_t
 test_assert_mat4_eq(mat4 m1, mat4 m2) {
-  int i, j, k;
+  int i, j;
 
-  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);
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 4; j++) {
+      ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009)
     }
   }
+
+  TEST_SUCCESS
 }
 
-void
+test_status_t
+test_assert_mat4_eqt(mat4 m1, mat4 m2) {
+  int i, j;
+
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 4; j++) {
+      ASSERT(fabsf(m1[j][i] - m2[i][j]) <= 0.0000009)
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
 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);
+  int i, j;
+
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 4; j++) {
+      ASSERT(fabsf(m1[i][j] - m2[i][j]) <= eps);
     }
   }
+
+  TEST_SUCCESS
 }
 
-void
+test_status_t
+test_assert_mat2_eqt(mat2 m1, mat2 m2) {
+  int i, j;
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 2; j++) {
+      ASSERT(fabsf(m1[j][i] - m2[i][j]) <= 0.0000009);
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat2_eq(mat2 m1, mat2 m2) {
+  int i, j;
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 2; j++) {
+      ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009);
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat2_eq_identity(mat2 m2) {
+  int i, j;
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 2; j++) {
+      if (i == j) {
+        ASSERT(test_eq(m2[i][j], 1.0f))
+      } else {
+        ASSERT(test_eq(m2[i][j], 0.0f))
+      }
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat2_eq_zero(mat2 m2) {
+  int i, j;
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 2; j++) {
+      ASSERT(test_eq(m2[i][j], 0.0f))
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
 test_assert_mat3_eq(mat3 m1, mat3 m2) {
-  int i, j, k;
+  int i, j;
 
   for (i = 0; i < 3; i++) {
     for (j = 0; j < 3; j++) {
-      for (k = 0; k < 3; k++)
-        assert_true(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009);
+      ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009);
     }
   }
+
+  TEST_SUCCESS
 }
 
-void
+test_status_t
+test_assert_mat3_eqt(mat3 m1, mat3 m2) {
+  int i, j;
+
+  for (i = 0; i < 3; i++) {
+    for (j = 0; j < 3; j++) {
+      ASSERT(fabsf(m1[j][i] - m2[i][j]) <= 0.0000009);
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat3_eq_identity(mat3 m3) {
+  int i, j;
+
+  for (i = 0; i < 3; i++) {
+    for (j = 0; j < 3; j++) {
+      if (i == j) {
+        ASSERT(test_eq(m3[i][j], 1.0f))
+      } else {
+        ASSERT(test_eq(m3[i][j], 0.0f))
+      }
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat3_eq_zero(mat3 m3) {
+  int i, j;
+
+  for (i = 0; i < 3; i++) {
+    for (j = 0; j < 3; j++) {
+      ASSERT(test_eq(m3[i][j], 0.0f))
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat4_eq_identity(mat4 m4) {
+  int i, j;
+
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 4; j++) {
+      if (i == j) {
+        ASSERT(test_eq(m4[i][j], 1.0f))
+      } else {
+        ASSERT(test_eq(m4[i][j], 0.0f))
+      }
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat4_eq_zero(mat4 m4) {
+  int i, j;
+
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 4; j++) {
+      ASSERT(test_eq(m4[i][j], 0.0f))
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
 test_assert_eqf(float a, float b) {
-  assert_true(fabsf(a - b) <= 0.000009); /* rounding errors */
+  ASSERT(fabsf(a - b) <= 0.000009); /* rounding errors */
+
+  TEST_SUCCESS
 }
 
-void
+test_status_t
+test_assert_vec2_eq(vec2 v1, vec2 v2) {
+  ASSERT(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */
+  ASSERT(fabsf(v1[1] - v2[1]) <= 0.000009);
+
+  TEST_SUCCESS
+}
+
+test_status_t
 test_assert_vec3_eq(vec3 v1, vec3 v2) {
-  assert_true(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */
-  assert_true(fabsf(v1[1] - v2[1]) <= 0.000009);
-  assert_true(fabsf(v1[2] - v2[2]) <= 0.000009);
+  ASSERT(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */
+  ASSERT(fabsf(v1[1] - v2[1]) <= 0.000009);
+  ASSERT(fabsf(v1[2] - v2[2]) <= 0.000009);
+
+  TEST_SUCCESS
 }
 
-void
+test_status_t
 test_assert_vec3s_eq(vec3s v1, vec3s v2) {
   test_assert_vec3_eq(v1.raw, v2.raw);
+
+  TEST_SUCCESS
 }
 
-void
+test_status_t
 test_assert_vec4_eq(vec4 v1, vec4 v2) {
-  assert_true(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */
-  assert_true(fabsf(v1[1] - v2[1]) <= 0.000009);
-  assert_true(fabsf(v1[2] - v2[2]) <= 0.000009);
-  assert_true(fabsf(v1[3] - v2[3]) <= 0.000009);
+  ASSERT(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */
+  ASSERT(fabsf(v1[1] - v2[1]) <= 0.000009);
+  ASSERT(fabsf(v1[2] - v2[2]) <= 0.000009);
+  ASSERT(fabsf(v1[3] - v2[3]) <= 0.000009);
+
+  TEST_SUCCESS
 }
 
-void
+test_status_t
 test_assert_vec4s_eq(vec4s v1, vec4s v2) {
   test_assert_vec4_eq(v1.raw, v2.raw);
+
+  TEST_SUCCESS
 }
 
-void
+test_status_t
 test_assert_quat_eq_abs(versor v1, versor v2) {
-  assert_true(fabsf(fabsf(v1[0]) - fabsf(v2[0])) <= 0.0009); /* rounding errors */
-  assert_true(fabsf(fabsf(v1[1]) - fabsf(v2[1])) <= 0.0009);
-  assert_true(fabsf(fabsf(v1[2]) - fabsf(v2[2])) <= 0.0009);
-  assert_true(fabsf(fabsf(v1[3]) - fabsf(v2[3])) <= 0.0009);
+  ASSERT(fabsf(fabsf(v1[0]) - fabsf(v2[0])) <= 0.0009); /* rounding errors */
+  ASSERT(fabsf(fabsf(v1[1]) - fabsf(v2[1])) <= 0.0009);
+  ASSERT(fabsf(fabsf(v1[2]) - fabsf(v2[2])) <= 0.0009);
+  ASSERT(fabsf(fabsf(v1[3]) - fabsf(v2[3])) <= 0.0009);
+
+  TEST_SUCCESS
 }
 
-void
+test_status_t
 test_assert_quat_eq(versor v1, versor v2) {
-  assert_true(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */
-  assert_true(fabsf(v1[1] - v2[1]) <= 0.000009);
-  assert_true(fabsf(v1[2] - v2[2]) <= 0.000009);
-  assert_true(fabsf(v1[3] - v2[3]) <= 0.000009);
+  ASSERT(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */
+  ASSERT(fabsf(v1[1] - v2[1]) <= 0.000009);
+  ASSERT(fabsf(v1[2] - v2[2]) <= 0.000009);
+  ASSERT(fabsf(v1[3] - v2[3]) <= 0.000009);
+
+  TEST_SUCCESS
 }
 
+test_status_t
+test_assert_quat_eq_identity(versor q) {
+  versor p = GLM_QUAT_IDENTITY_INIT;
+
+  ASSERT(fabsf(q[0] - p[0]) <= 0.000009); /* rounding errors */
+  ASSERT(fabsf(q[1] - p[1]) <= 0.000009);
+  ASSERT(fabsf(q[2] - p[2]) <= 0.000009);
+  ASSERT(fabsf(q[3] - p[3]) <= 0.000009);
+
+  TEST_SUCCESS
+}

test/src/test_common.h

@@ -8,20 +8,7 @@
 #ifndef test_common_h
 #define test_common_h
 
-#include <stdarg.h>
-#include <stdint.h>
-#include <stddef.h>
-#include <setjmp.h>
-#include <cmocka.h>
-#include <time.h>
-#include <stdlib.h>
-#include <math.h>
-#include <float.h>
-#include <stdbool.h>
-
-#include <cglm/cglm.h>
-#include <cglm/struct.h>
-#include <cglm/call.h>
+#include "../include/common.h"
 
 void
 test_rand_mat4(mat4 dest);
@@ -30,33 +17,72 @@ void
 test_rand_mat3(mat3 dest);
 
 void
+test_rand_mat2(mat2 dest);
+
+test_status_t
 test_assert_eqf(float a, float b);
 
-void
+test_status_t
 test_assert_mat4_eq(mat4 m1, mat4 m2);
 
-void
+test_status_t
+test_assert_mat4_eqt(mat4 m1, mat4 m2);
+
+test_status_t
 test_assert_mat4_eq2(mat4 m1, mat4 m2, float eps);
 
-void
+test_status_t
+test_assert_mat4_eq_identity(mat4 m4);
+
+test_status_t
+test_assert_mat4_eq_zero(mat4 m4);
+
+test_status_t
+test_assert_mat2_eqt(mat2 m1, mat2 m2);
+
+test_status_t
+test_assert_mat2_eq(mat2 m1, mat2 m2);
+
+test_status_t
+test_assert_mat2_eq_identity(mat2 m2);
+
+test_status_t
+test_assert_mat2_eq_zero(mat2 m2);
+
+test_status_t
 test_assert_mat3_eq(mat3 m1, mat3 m2);
 
-void
+test_status_t
+test_assert_vec2_eq(vec2 v1, vec2 v2);
+
+test_status_t
+test_assert_mat3_eqt(mat3 m1, mat3 m2);
+
+test_status_t
+test_assert_mat3_eq_identity(mat3 m3);
+
+test_status_t
+test_assert_mat3_eq_zero(mat3 m3);
+
+test_status_t
 test_assert_vec3_eq(vec3 v1, vec3 v2);
 
-void
+test_status_t
 test_assert_vec3s_eq(vec3s v1, vec3s v2);
 
-void
+test_status_t
 test_assert_vec4_eq(vec4 v1, vec4 v2);
 
-void
+test_status_t
 test_assert_vec4s_eq(vec4s v1, vec4s v2);
 
-void
+test_status_t
 test_assert_quat_eq(versor v1, versor v2);
 
-void
+test_status_t
+test_assert_quat_eq_identity(versor q) ;
+
+test_status_t
 test_assert_quat_eq_abs(versor v1, versor v2);
 
 void
@@ -77,4 +103,16 @@ test_rand(void);
 void
 test_rand_quat(versor q);
 
+CGLM_INLINE
+bool
+test_eq(float a, float b) {
+  return fabsf(a - b) <= GLM_FLT_EPSILON * 10;
+}
+
+CGLM_INLINE
+bool
+test_eq_th(float a, float b, float th) {
+  return fabsf(a - b) <= th;
+}
+
 #endif /* test_common_h */

test/src/test_euler.c

@@ -7,10 +7,9 @@
 
 #include "test_common.h"
 
-void
-test_euler(void **state) {
-  mat4  rot1, rot2;
-  vec3  inAngles, outAngles;
+TEST_IMPL(euler) {
+  mat4 rot1, rot2;
+  vec3 inAngles, outAngles;
 
   inAngles[0] = glm_rad(-45.0f);  /* X angle */
   inAngles[1] = glm_rad(88.0f);   /* Y angle */
@@ -22,11 +21,11 @@ test_euler(void **state) {
   glmc_euler_angles(rot1, outAngles);
 
   /* angles must be equal in that range */
-  test_assert_vec3_eq(inAngles, outAngles);
+  ASSERTIFY(test_assert_vec3_eq(inAngles, outAngles))
 
   /* matrices must be equal */
   glmc_euler_xyz(outAngles, rot2);
-  test_assert_mat4_eq(rot1, rot2);
+  ASSERTIFY(test_assert_mat4_eq(rot1, rot2))
 
   /* change range */
   inAngles[0] = glm_rad(-145.0f);  /* X angle */
@@ -40,5 +39,7 @@ test_euler(void **state) {
 
   /* matrices must be equal */
   glmc_euler_xyz(outAngles, rot2);
-  test_assert_mat4_eq(rot1, rot2);
+  ASSERTIFY(test_assert_mat4_eq(rot1, rot2))
+
+  TEST_SUCCESS
 }

test/src/test_main.c

@@ -1,48 +0,0 @@
-/*
- * 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),
-
-    /* mat3 */
-    cmocka_unit_test(test_mat3),
-
-    /* camera */
-    cmocka_unit_test(test_camera_lookat),
-    cmocka_unit_test(test_camera_decomp),
-
-    /* project */
-    cmocka_unit_test(test_project),
-
-    /* vector */
-    cmocka_unit_test(test_clamp),
-
-    /* euler */
-    cmocka_unit_test(test_euler),
-
-    /* quaternion */
-    cmocka_unit_test(test_quat),
-
-    /* vec4 */
-    cmocka_unit_test(test_vec4),
-
-    /* vec3 */
-    cmocka_unit_test(test_vec3),
-
-    /* affine */
-    cmocka_unit_test(test_affine),
-
-    /* bezier */
-    cmocka_unit_test(test_bezier)
-  };
-
-  return cmocka_run_group_tests(tests, NULL, NULL);
-}