win: enable anonymous structs for Visual Studio 2015 and later

build fix for ARM NEON

.github/FUNDING.yml

@@ -0,0 +1,8 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: # Replace with a single Patreon username
+open_collective: cglm
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+custom: # Replace with a single custom sponsorship URL

.gitignore

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

.gitmodules

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

.travis.yml

@@ -37,10 +37,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
@@ -55,8 +54,9 @@ after_success:
         --exclude lib
         --exclude test
         --gcov-options '\-lp'
-        --verbose;
+        --verbose &&
+      bash <(curl -s https://codecov.io/bash);
     fi
 
-after_failure:
+# after_failure:
-  - cat ./test-suite.log
+#   - cat ./test-suite.log

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),

Makefile.am

@@ -7,23 +7,21 @@
 #******************************************************************************
 
 ACLOCAL_AMFLAGS = -I m4
-
 AM_CFLAGS = -Wall \
-            -std=gnu99 \
+            -std=gnu11 \
             -O3 \
             -Wstrict-aliasing=2 \
             -fstrict-aliasing \
-            -pedantic
+            -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,14 +32,16 @@ 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/affine.h \
                include/cglm/vec3.h \
                include/cglm/vec3-ext.h \
@@ -59,7 +59,8 @@ cglm_HEADERS = include/cglm/version.h \
                include/cglm/sphere.h \
                include/cglm/ease.h \
                include/cglm/curve.h \
-               include/cglm/bezier.h
+               include/cglm/bezier.h \
+               include/cglm/applesimd.h
                
 cglm_calldir=$(includedir)/cglm/call
 cglm_call_HEADERS = include/cglm/call/mat4.h \
@@ -98,6 +99,26 @@ cglm_simd_avx_HEADERS = include/cglm/simd/avx/mat4.h \
 cglm_simd_neondir=$(includedir)/cglm/simd/neon
 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/vec3.h \
+                      include/cglm/struct/vec3-ext.h \
+                      include/cglm/struct/vec4.h \
+                      include/cglm/struct/vec4-ext.h \
+                      include/cglm/struct/affine.h \
+                      include/cglm/struct/io.h \
+                      include/cglm/struct/cam.h \
+                      include/cglm/struct/quat.h \
+                      include/cglm/struct/euler.h \
+                      include/cglm/struct/plane.h \
+                      include/cglm/struct/frustum.h \
+                      include/cglm/struct/box.h \
+                      include/cglm/struct/project.h \
+                      include/cglm/struct/sphere.h \
+                      include/cglm/struct/color.h \
+                      include/cglm/struct/curve.h
+
 libcglm_la_SOURCES=\
     src/euler.c \
     src/affine.c \
@@ -118,8 +139,8 @@ libcglm_la_SOURCES=\
     src/bezier.c
 
 test_tests_SOURCES=\
+    test/runner.c \
     test/src/test_common.c \
-    test/src/test_main.c \
     test/src/test_mat4.c \
     test/src/test_cam.c \
     test/src/test_project.c \
@@ -130,7 +151,16 @@ test_tests_SOURCES=\
     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
 
-all-local:
+pkgconfig_DATA=cglm.pc
-	sh ./post-build.sh
+
+# When running configure with --prefix, $VPATH references
+# 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
+
+# all-local:
+#	sh $${VPATH:-.}/post-build.sh

README.md

@@ -3,15 +3,14 @@
  [![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)
 
-The original glm library is for C++ only (templates, namespaces, classes...), this library targeted to C99 but currently you can use it for C89 safely by language extensions e.g `__restrict`
-
 #### Documentation
 
-Almost all functions (inline versions) and parameters are documented inside related headers. <br />
+Almost all functions (inline versions) and parameters are documented inside the corresponding headers. <br />
 Complete documentation: http://cglm.readthedocs.io
 
 #### Note for previous versions:
@@ -28,13 +27,13 @@ you have the latest version
 - **[major change]** by starting v0.5.1, built-in alignment is removed from **vec3** and **mat3** types
 
 #### Note for C++ developers:
-If you don't aware about original GLM library yet, you may also want to look at:
+If you are not aware of the original GLM library yet, you may also want to look at:
 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!
 
@@ -45,7 +44,8 @@ https://github.com/g-truc/glm
 `cglm` doesn't alloc any memory on heap. So it doesn't provide any allocator. You should alloc memory for **out** parameters too if you pass pointer of memory location. Don't forget that **vec4** (also quat/**versor**) and **mat4** must be aligned (16-bytes), because *cglm* uses SIMD instructions to optimize most operations if available.
 
 #### Returning vector or matrix... ?
-Since almost all types are arrays and **C** doesn't allow returning arrays, so **cglm** doesn't support this feature. In the future *cglm* may use **struct** for some types for this purpose.
+
+**cglm** supports both *ARRAY API* and *STRUCT API*, so you can return structs if you utilize struct api (`glms_`).
 
 #### Other APIs like Vulkan, Metal, Dx?
 Currently *cglm* uses default clip space configuration (-1, 1) for camera functions (perspective, extract corners...), in the future other clip space configurations will be supported
@@ -68,10 +68,11 @@ Currently *cglm* uses default clip space configuration (-1, 1) for camera functi
 </table>
 
 ## 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)
@@ -87,12 +88,13 @@ Currently *cglm* uses default clip space configuration (-1, 1) for camera functi
 - easing functions
 - curves
 - curve interpolation helpers (S*M*C, 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
+- and others...
 
 <hr />
 
 You have two option to call a function/operation: inline or library call (link)
-Almost all functions are marked inline (always_inline) so compiler probably will inline.
+Almost all functions are marked inline (always_inline) so compiler will probably inline.
 To call pre-compiled version, just use `glmc_` (c stands for 'call') instead of `glm_`.
 
 ```C
@@ -119,7 +121,7 @@ You can pass matrices and vectors as array to functions rather than get address.
   glm_translate(m, (vec3){1.0f, 0.0f, 0.0f});
 ```
 
-Library contains general purpose mat4 mul and inverse functions but also contains some special form (optimized) of these functions for affine transform matrices. If you want to multiply two affine transform matrices you can use glm_mul instead of glm_mat4_mul and glm_inv_tr (ROT + TR) instead glm_mat4_inv
+Library contains general purpose mat4 mul and inverse functions, and also contains some special forms (optimized) of these functions for affine transformations' matrices. If you want to multiply two affine transformation matrices you can use glm_mul instead of glm_mat4_mul and glm_inv_tr (ROT + TR) instead glm_mat4_inv
 ```C
 /* multiplication */
 mat4 modelMat;
@@ -129,26 +131,48 @@ 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
 
 ### 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`)
+$ make check # [Optional]
-$ [sudo] make install
+$ [sudo] make install # [Optional]
 ```
 
+This will also install pkg-config files so you can use
+`pkg-config --cflags cglm` and `pkg-config --libs cglm` to retrieve compiler
+and linker flags.
+
+The files will be installed into the given prefix (usually `/usr/local` by
+default on Linux), but your pkg-config may not be configured to actually check
+there. You can figure out where it's looking by running `pkg-config --variable
+pc_path pkg-config` and change the path the files are installed to via
+`./configure --with-pkgconfigdir=/your/path`. Alternatively, you can add the
+prefix path to your `PKG_CONFIG_PATH` environment variable.
+
 ### Windows (MSBuild)
-Windows related build files, project files are located in `win` folder,
+Windows related build file and project files are located in `win` folder,
 make sure you are inside `cglm/win` folder.
-Code Analysis are enabled, it may take awhile to build
+Code Analysis is enabled, so it may take awhile to build.
 
 ```Powershell
 $ cd win
@@ -159,6 +183,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:
@@ -169,11 +197,11 @@ $ sphinx-build source build
 it will compile docs into build folder, you can run index.html inside that function.
 
 ## How to use
-If you want to use inline versions of funcstions then; include main header
+If you want to use the inline versions of functions, then include the main header
 ```C
 #include <cglm/cglm.h>
 ```
-the header will include all headers. Then call func you want e.g. rotate vector by axis:
+the header will include all headers. Then call the func you want e.g. rotate vector by axis:
 ```C
 glm_vec3_rotate(v1, glm_rad(45), (vec3){1.0f, 0.0f, 0.0f});
 ```
@@ -204,7 +232,7 @@ glm_mat4_mul(m1, m2, m1);
 /* or */
 glm_mat4_mul(m1, m1, m1);
 ```
-the first two parameter are **[in]** and the last one is **[out]** parameter. After multiplied *m1* and *m2* the result is stored in *m1*. This is why we send *m1* twice. You may store result in different matrix, this just an example.
+the first two parameter are **[in]** and the last one is **[out]** parameter. After multiplying *m1* and *m2*, the result is stored in *m1*. This is why we send *m1* twice. You may store the result in a different matrix, this is just an example.
 
 ### Example: Computing MVP matrix
 
@@ -244,7 +272,7 @@ Option 2: Cast matrix to pointer type (also valid for multiple dimensional array
 glUniformMatrix4fv(location, 1, GL_FALSE, (float *)matrix);
 ```
 
-You can pass same way to another APIs e.g. Vulkan, DX...
+You can pass matrices the same way to other APIs e.g. Vulkan, DX...
 
 ## Notes
 

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.pc.in

@@ -0,0 +1,11 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: @PACKAGE_NAME@
+Description: OpenGL Mathematics (glm) for C
+URL: https://github.com/recp/cglm
+Version: @PACKAGE_VERSION@
+Cflags: -I${includedir}
+Libs: -L${libdir} -lcglm @LIBS@

cglm.podspec

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

configure.ac

@@ -7,13 +7,30 @@
 #*****************************************************************************
 
 AC_PREREQ([2.69])
-AC_INIT([cglm], [0.5.4], [info@recp.me])
+AC_INIT([cglm], [0.6.2], [info@recp.me])
-AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects])
+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/])
 AC_CONFIG_HEADERS([config.h])
 
+# Dependencies for pkg-config.
+PKG_PROG_PKG_CONFIG
+# Ancient versions of pkg-config (such as the one used in Travis CI)
+# don't have this macro, so we need to do it manually.
+m4_ifdef([PKG_INSTALLDIR], [
+    PKG_INSTALLDIR
+], [
+    AC_ARG_WITH([pkgconfigdir],
+        [AS_HELP_STRING([--with-pkgconfigdir],
+                        [pkg-config installation directory ['${libdir}/pkgconfig']])],,
+        [with_pkgconfigdir=]'${libdir}/pkgconfig')
+    AC_SUBST([pkgconfigdir], [$with_pkgconfigdir])
+])
+
 # Checks for programs.
 AC_PROG_CC
 AM_PROG_CC_C_O
@@ -53,6 +70,6 @@ AC_TYPE_UINT8_T
 # Checks for library functions.
 AC_FUNC_ERROR_AT_LINE
 
-AC_CONFIG_FILES([makefile])
+AC_CONFIG_FILES([Makefile cglm.pc])
 
 AC_OUTPUT

docs/source/build.rst

@@ -1,10 +1,7 @@
 Build cglm
 ================================
 
-| **cglm** does not have external dependencies except for unit testing. When you pulled **cglm** repo with submodules all dependencies will be pulled too. `build-deps.sh` will pull all dependencies/submodules and build for you.
+| **cglm** does not have any external dependencies.
-
-External dependencies:
-  * cmocka - for unit testing
 
 **NOTE:**
 If you only need to inline versions, you don't need to build **cglm**, you don't need to link it to your program.
@@ -16,8 +13,6 @@ Unix (Autotools):
 .. code-block:: bash
   :linenos:
 
-  $ sh ./build-deps.sh    # run this only once (dependencies)
-
   $ sh autogen.sh
   $ ./configure
   $ make
@@ -65,4 +60,3 @@ Example build:
 
   $ cd cglm/docs
   $ sphinx-build source build
-

docs/source/conf.py

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

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:
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

docs/source/vec3.rst

@@ -158,7 +158,8 @@ Functions documentation
 
 .. c:function:: float  glm_vec3_norm(vec3 vec)
 
-    norm (magnitude) of vec3
+    | euclidean norm (magnitude), also called L2 norm
+    | this will give magnitude of vector in euclidean space
 
     Parameters:
       | *[in]*  **vec**   vector

docs/source/vec4.rst

@@ -134,7 +134,8 @@ Functions documentation
 
 .. c:function:: float  glm_vec4_norm(vec4 vec)
 
-    norm (magnitude) of vec4
+    | euclidean norm (magnitude), also called L2 norm
+    | this will give magnitude of vector in euclidean space
 
     Parameters:
       | *[in]*  **vec**   vector

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_EPS   1e-9f
-#define CGLM_DECASTEL_MAX   1000
+#define CGLM_DECASTEL_MAX   1000.0f
-#define CGLM_DECASTEL_SMALL 1e-20
+#define CGLM_DECASTEL_SMALL 1e-20f
 
 /*!
  * @brief cubic bezier interpolation

include/cglm/call/euler.h

@@ -47,7 +47,7 @@ glmc_euler_yxz(vec3 angles, mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_euler_by_order(vec3 angles, glm_euler_sq axis, mat4 dest);
+glmc_euler_by_order(vec3 angles, glm_euler_seq axis, mat4 dest);
 
 #ifdef __cplusplus
 }

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

@@ -91,7 +91,7 @@ glmc_quat_angle(versor q);
 
 CGLM_EXPORT
 void
-glmc_quat_axis(versor q, versor dest);
+glmc_quat_axis(versor q, vec3 dest);
 
 CGLM_EXPORT
 void
@@ -117,6 +117,10 @@ CGLM_EXPORT
 void
 glmc_quat_lerp(versor from, versor to, float t, versor dest);
     
+CGLM_EXPORT
+void
+glmc_quat_lerpc(versor from, versor to, float t, versor dest);
+
 CGLM_EXPORT
 void
 glmc_quat_slerp(versor q, versor r, float t, versor dest);

include/cglm/call/vec3.h

@@ -56,6 +56,14 @@ CGLM_EXPORT
 float
 glmc_vec3_norm2(vec3 v);
     
+CGLM_EXPORT
+float
+glmc_vec3_norm_one(vec3 v);
+
+CGLM_EXPORT
+float
+glmc_vec3_norm_inf(vec3 v);
+
 CGLM_EXPORT
 void
 glmc_vec3_normalize_to(vec3 v, vec3 dest);
@@ -184,6 +192,46 @@ CGLM_EXPORT
 void
 glmc_vec3_lerp(vec3 from, vec3 to, float t, vec3 dest);
     
+CGLM_EXPORT
+void
+glmc_vec3_lerpc(vec3 from, vec3 to, float t, vec3 dest);
+    
+CGLM_INLINE
+void
+glmc_vec3_mix(vec3 from, vec3 to, float t, vec3 dest) {
+  glmc_vec3_lerp(from, to, t, dest);
+}
+
+CGLM_INLINE
+void
+glmc_vec3_mixc(vec3 from, vec3 to, float t, vec3 dest) {
+  glmc_vec3_lerpc(from, to, t, dest);
+}
+    
+CGLM_EXPORT
+void
+glmc_vec3_step_uni(float edge, vec3 x, vec3 dest);
+    
+CGLM_EXPORT
+void
+glmc_vec3_step(vec3 edge, vec3 x, vec3 dest);
+    
+CGLM_EXPORT
+void
+glmc_vec3_smoothstep_uni(float edge0, float edge1, vec3 x, vec3 dest);
+    
+CGLM_EXPORT
+void
+glmc_vec3_smoothstep(vec3 edge0, vec3 edge1, vec3 x, vec3 dest);
+    
+CGLM_EXPORT
+void
+glmc_vec3_smoothinterp(vec3 from, vec3 to, float t, vec3 dest);
+    
+CGLM_EXPORT
+void
+glmc_vec3_smoothinterpc(vec3 from, vec3 to, float t, vec3 dest);
+
 /* ext */
 
 CGLM_EXPORT
@@ -194,6 +242,10 @@ CGLM_EXPORT
 void
 glmc_vec3_broadcast(float val, vec3 d);
     
+CGLM_EXPORT
+void
+glmc_vec3_fill(vec3 v, float val);
+
 CGLM_EXPORT
 bool
 glmc_vec3_eq(vec3 v, float val);
@@ -238,6 +290,18 @@ CGLM_EXPORT
 void
 glmc_vec3_sign(vec3 v, vec3 dest);
     
+CGLM_EXPORT
+void
+glmc_vec3_abs(vec3 v, vec3 dest);
+    
+CGLM_EXPORT
+void
+glmc_vec3_fract(vec3 v, vec3 dest);
+    
+CGLM_EXPORT
+float
+glmc_vec3_hadd(vec3 v);
+
 CGLM_EXPORT
 void
 glmc_vec3_sqrt(vec3 v, vec3 dest);

include/cglm/call/vec4.h

@@ -57,6 +57,14 @@ CGLM_EXPORT
 float
 glmc_vec4_norm2(vec4 v);
     
+CGLM_EXPORT
+float
+glmc_vec4_norm_one(vec4 v);
+
+CGLM_EXPORT
+float
+glmc_vec4_norm_inf(vec4 v);
+
 CGLM_EXPORT
 void
 glmc_vec4_normalize_to(vec4 v, vec4 dest);
@@ -137,6 +145,10 @@ CGLM_EXPORT
 float
 glmc_vec4_distance(vec4 a, vec4 b);
     
+CGLM_EXPORT
+float
+glmc_vec4_distance2(vec4 a, vec4 b);
+
 CGLM_EXPORT
 void
 glmc_vec4_maxv(vec4 a, vec4 b, vec4 dest);
@@ -153,6 +165,46 @@ CGLM_EXPORT
 void
 glmc_vec4_lerp(vec4 from, vec4 to, float t, vec4 dest);
     
+CGLM_EXPORT
+void
+glmc_vec4_lerpc(vec4 from, vec4 to, float t, vec4 dest);
+    
+CGLM_INLINE
+void
+glmc_vec4_mix(vec4 from, vec4 to, float t, vec4 dest) {
+  glmc_vec4_lerp(from, to, t, dest);
+}
+
+CGLM_INLINE
+void
+glmc_vec4_mixc(vec4 from, vec4 to, float t, vec4 dest) {
+  glmc_vec4_lerpc(from, to, t, dest);
+}
+    
+CGLM_EXPORT
+void
+glmc_vec4_step_uni(float edge, vec4 x, vec4 dest);
+    
+CGLM_EXPORT
+void
+glmc_vec4_step(vec4 edge, vec4 x, vec4 dest);
+    
+CGLM_EXPORT
+void
+glmc_vec4_smoothstep_uni(float edge0, float edge1, vec4 x, vec4 dest);
+    
+CGLM_EXPORT
+void
+glmc_vec4_smoothstep(vec4 edge0, vec4 edge1, vec4 x, vec4 dest);
+    
+CGLM_EXPORT
+void
+glmc_vec4_smoothinterp(vec4 from, vec4 to, float t, vec4 dest);
+    
+CGLM_EXPORT
+void
+glmc_vec4_smoothinterpc(vec4 from, vec4 to, float t, vec4 dest);
+
 CGLM_EXPORT
 void
 glmc_vec4_cubic(float s, vec4 dest);
@@ -167,6 +219,10 @@ CGLM_EXPORT
 void
 glmc_vec4_broadcast(float val, vec4 d);
     
+CGLM_EXPORT
+void
+glmc_vec4_fill(vec4 v, float val);
+
 CGLM_EXPORT
 bool
 glmc_vec4_eq(vec4 v, float val);
@@ -211,6 +267,18 @@ CGLM_EXPORT
 void
 glmc_vec4_sign(vec4 v, vec4 dest);
     
+CGLM_EXPORT
+void
+glmc_vec4_abs(vec4 v, vec4 dest);
+    
+CGLM_EXPORT
+void
+glmc_vec4_fract(vec4 v, vec4 dest);
+    
+CGLM_EXPORT
+float
+glmc_vec4_hadd(vec4 v);
+
 CGLM_EXPORT
 void
 glmc_vec4_sqrt(vec4 v, vec4 dest);

include/cglm/cam.h

@@ -7,48 +7,37 @@
 
 /*
  Functions:
-   CGLM_INLINE void  glm_frustum(float left,
+   CGLM_INLINE void  glm_frustum(float left,    float right,
-                                 float right,
+                                 float bottom,  float top,
-                                 float bottom,
+                                 float nearVal, float farVal,
-                                 float top,
-                                 float nearVal,
-                                 float farVal,
                                  mat4  dest)
-   CGLM_INLINE void  glm_ortho(float left,
+   CGLM_INLINE void  glm_ortho(float left,    float right,
-                               float right,
+                               float bottom,  float top,
-                               float bottom,
+                               float nearVal, float farVal,
-                               float top,
-                               float nearVal,
-                               float farVal,
                                mat4  dest)
    CGLM_INLINE void  glm_ortho_aabb(vec3 box[2], mat4 dest)
-   CGLM_INLINE void  glm_ortho_aabb_p(vec3 box[2], float padding, mat4 dest)
+   CGLM_INLINE void  glm_ortho_aabb_p(vec3 box[2],  float padding, mat4 dest)
    CGLM_INLINE void  glm_ortho_aabb_pz(vec3 box[2], float padding, mat4 dest)
    CGLM_INLINE void  glm_ortho_default(float aspect, mat4  dest)
-   CGLM_INLINE void  glm_ortho_default_s(float aspect, float size, mat4  dest)
+   CGLM_INLINE void  glm_ortho_default_s(float aspect, float size, mat4 dest)
    CGLM_INLINE void  glm_perspective(float fovy,
                                      float aspect,
                                      float nearVal,
                                      float farVal,
                                      mat4  dest)
-   CGLM_INLINE void  glm_perspective_default(float aspect, mat4  dest)
+   CGLM_INLINE void  glm_perspective_default(float aspect, mat4 dest)
-   CGLM_INLINE void  glm_perspective_resize(float aspect, mat4  proj)
+   CGLM_INLINE void  glm_perspective_resize(float aspect, mat4 proj)
    CGLM_INLINE void  glm_lookat(vec3 eye, vec3 center, vec3 up, mat4 dest)
    CGLM_INLINE void  glm_look(vec3 eye, vec3 dir, vec3 up, mat4 dest)
    CGLM_INLINE void  glm_look_anyup(vec3 eye, vec3 dir, mat4 dest)
    CGLM_INLINE void  glm_persp_decomp(mat4   proj,
-                                      float *nearVal,
+                                      float *nearVal, float *farVal,
-                                      float *farVal,
+                                      float *top,     float *bottom,
-                                      float *top,
+                                      float *left,    float *right)
-                                      float *bottom,
-                                      float *left,
-                                      float *right)
    CGLM_INLINE void  glm_persp_decompv(mat4 proj, float dest[6])
    CGLM_INLINE void  glm_persp_decomp_x(mat4 proj, float *left, float *right)
    CGLM_INLINE void  glm_persp_decomp_y(mat4 proj, float *top,  float *bottom)
-   CGLM_INLINE void  glm_persp_decomp_z(mat4 proj,
+   CGLM_INLINE void  glm_persp_decomp_z(mat4 proj, float *nearv, float *farv)
-                                        float *nearVal,
-                                        float *farVal)
    CGLM_INLINE void  glm_persp_decomp_far(mat4 proj, float *farVal)
    CGLM_INLINE void  glm_persp_decomp_near(mat4 proj, float *nearVal)
    CGLM_INLINE float glm_persp_fovy(mat4 proj)
@@ -75,12 +64,9 @@
  */
 CGLM_INLINE
 void
-glm_frustum(float left,
+glm_frustum(float left,    float right,
-            float right,
+            float bottom,  float top,
-            float bottom,
+            float nearVal, float farVal,
-            float top,
-            float nearVal,
-            float farVal,
             mat4  dest) {
   float rl, tb, fn, nv;
 
@@ -113,12 +99,9 @@ glm_frustum(float left,
  */
 CGLM_INLINE
 void
-glm_ortho(float left,
+glm_ortho(float left,    float right,
-          float right,
+          float bottom,  float top,
-          float bottom,
+          float nearVal, float farVal,
-          float top,
-          float nearVal,
-          float farVal,
           mat4  dest) {
   float rl, tb, fn;
 
@@ -218,9 +201,7 @@ glm_ortho_default(float aspect, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_ortho_default_s(float aspect,
+glm_ortho_default_s(float aspect, float size, mat4 dest) {
-                    float size,
-                    mat4  dest) {
   if (aspect >= 1.0f) {
     glm_ortho(-size * aspect,
                size * aspect,
@@ -420,12 +401,9 @@ glm_look_anyup(vec3 eye, vec3 dir, mat4 dest) {
 CGLM_INLINE
 void
 glm_persp_decomp(mat4 proj,
-                 float * __restrict nearVal,
+                 float * __restrict nearVal, float * __restrict farVal,
-                 float * __restrict farVal,
+                 float * __restrict top,     float * __restrict bottom,
-                 float * __restrict top,
+                 float * __restrict left,    float * __restrict right) {
-                 float * __restrict bottom,
-                 float * __restrict left,
-                 float * __restrict right) {
   float m00, m11, m20, m21, m22, m32, n, f;
   float n_m11, n_m00;
 

include/cglm/common.h

@@ -28,6 +28,9 @@
 #  define CGLM_INLINE static inline __attribute((always_inline))
 #endif
 
+#define GLM_SHUFFLE4(z, y, x, w) (((z) << 6) | ((y) << 4) | ((x) << 2) | (w))
+#define GLM_SHUFFLE3(z, y, x)    (((z) << 4) | ((y) << 2) | (x))
+
 #include "types.h"
 #include "simd/intrin.h"
 

include/cglm/euler.h

@@ -15,10 +15,10 @@
 
 /*
  Types:
-   enum glm_euler_sq
+   enum glm_euler_seq
 
  Functions:
-   CGLM_INLINE glm_euler_sq glm_euler_order(int newOrder[3]);
+   CGLM_INLINE glm_euler_seq glm_euler_order(int newOrder[3]);
    CGLM_INLINE void glm_euler_angles(mat4 m, vec3 dest);
    CGLM_INLINE void glm_euler(vec3 angles, mat4 dest);
    CGLM_INLINE void glm_euler_xyz(vec3 angles, mat4 dest);
@@ -28,7 +28,7 @@
    CGLM_INLINE void glm_euler_yzx(vec3 angles, mat4 dest);
    CGLM_INLINE void glm_euler_yxz(vec3 angles, mat4 dest);
    CGLM_INLINE void glm_euler_by_order(vec3         angles,
-                                       glm_euler_sq ord,
+                                       glm_euler_seq ord,
                                        mat4         dest);
  */
 
@@ -41,24 +41,26 @@
  * if you have axis order like vec3 orderVec = [0, 1, 2] or [0, 2, 1]...
  * vector then you can convert it to this enum by doing this:
  * @code
- * glm_euler_sq order;
+ * glm_euler_seq order;
  * order = orderVec[0] | orderVec[1] << 2 | orderVec[2] << 4;
  * @endcode
  * you may need to explicit cast if required
  */
-typedef enum glm_euler_sq {
+typedef enum glm_euler_seq {
   GLM_EULER_XYZ = 0 << 0 | 1 << 2 | 2 << 4,
   GLM_EULER_XZY = 0 << 0 | 2 << 2 | 1 << 4,
   GLM_EULER_YZX = 1 << 0 | 2 << 2 | 0 << 4,
   GLM_EULER_YXZ = 1 << 0 | 0 << 2 | 2 << 4,
   GLM_EULER_ZXY = 2 << 0 | 0 << 2 | 1 << 4,
   GLM_EULER_ZYX = 2 << 0 | 1 << 2 | 0 << 4
-} glm_euler_sq;
+} glm_euler_seq;
+
+typedef glm_euler_seq glm_euler_sq;
 
 CGLM_INLINE
-glm_euler_sq
+glm_euler_seq
 glm_euler_order(int ord[3]) {
-  return (glm_euler_sq)(ord[0] << 0 | ord[1] << 2 | ord[2] << 4);
+  return (glm_euler_seq)(ord[0] << 0 | ord[1] << 2 | ord[2] << 4);
 }
 
 /*!
@@ -352,7 +354,7 @@ glm_euler_zyx(vec3 angles, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_euler_by_order(vec3 angles, glm_euler_sq ord, mat4 dest) {
+glm_euler_by_order(vec3 angles, glm_euler_seq ord, mat4 dest) {
   float cx, cy, cz,
         sx, sy, sz;
 

include/cglm/frustum.h

@@ -65,7 +65,7 @@
  * Exracted planes order: [left, right, bottom, top, near, far]
  *
  * @param[in]  m    matrix (see brief)
- * @param[out] dest exracted view frustum planes (see brief)
+ * @param[out] dest extracted view frustum planes (see brief)
  */
 CGLM_INLINE
 void

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

@@ -25,7 +25,7 @@
 /*!
  * @brief normalizes a plane
  *
- * @param[in, out] plane pnale to normalize
+ * @param[in, out] plane plane to normalize
  */
 CGLM_INLINE
 void

include/cglm/quat.h

@@ -29,13 +29,14 @@
    CGLM_INLINE void glm_quat_imagn(versor q, vec3 dest);
    CGLM_INLINE float glm_quat_imaglen(versor q);
    CGLM_INLINE float glm_quat_angle(versor q);
-   CGLM_INLINE void glm_quat_axis(versor q, versor dest);
+   CGLM_INLINE void glm_quat_axis(versor q, vec3 dest);
    CGLM_INLINE void glm_quat_mul(versor p, versor q, versor dest);
    CGLM_INLINE void glm_quat_mat4(versor q, mat4 dest);
    CGLM_INLINE void glm_quat_mat4t(versor q, mat4 dest);
    CGLM_INLINE void glm_quat_mat3(versor q, mat3 dest);
    CGLM_INLINE void glm_quat_mat3t(versor q, mat3 dest);
    CGLM_INLINE void glm_quat_lerp(versor from, versor to, float t, versor dest);
+   CGLM_INLINE void glm_quat_lerpc(versor from, versor to, float t, versor dest);
    CGLM_INLINE void glm_quat_slerp(versor q, versor r, float t, versor dest);
    CGLM_INLINE void glm_quat_look(vec3 eye, versor ori, mat4 dest);
    CGLM_INLINE void glm_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest);
@@ -388,7 +389,7 @@ glm_quat_angle(versor q) {
  */
 CGLM_INLINE
 void
-glm_quat_axis(versor q, versor dest) {
+glm_quat_axis(versor q, vec3 dest) {
   glm_quat_imagn(q, dest);
 }
 
@@ -601,7 +602,7 @@ glm_quat_mat3t(versor q, mat3 dest) {
  *
  * @param[in]   from  from
  * @param[in]   to    to
- * @param[in]   t     interpolant (amount) clamped between 0 and 1
+ * @param[in]   t     interpolant (amount)
  * @param[out]  dest  result quaternion
  */
 CGLM_INLINE
@@ -610,6 +611,21 @@ glm_quat_lerp(versor from, versor to, float t, versor dest) {
   glm_vec4_lerp(from, to, t, dest);
 }
 
+/*!
+ * @brief interpolates between two quaternions
+ *        using linear interpolation (LERP)
+ *
+ * @param[in]   from  from
+ * @param[in]   to    to
+ * @param[in]   t     interpolant (amount) clamped between 0 and 1
+ * @param[out]  dest  result quaternion
+ */
+CGLM_INLINE
+void
+glm_quat_lerpc(versor from, versor to, float t, versor dest) {
+  glm_vec4_lerpc(from, to, t, dest);
+}
+
 /*!
  * @brief interpolates between two quaternions
  *        using spherical linear interpolation (SLERP)

include/cglm/simd/arm.h

@@ -13,6 +13,12 @@
 #define glmm_load(p)      vld1q_f32(p)
 #define glmm_store(p, a)  vst1q_f32(p, a)
 
+static inline
+float32x4_t
+glmm_abs(float32x4_t v) {
+  return vabsq_f32(v);
+}
+
 static inline
 float
 glmm_hadd(float32x4_t v) {
@@ -25,6 +31,24 @@ glmm_hadd(float32x4_t v) {
 #endif
 }
 
+static inline
+float
+glmm_hmin(float32x4_t v) {
+  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) {
+  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
 float
 glmm_dot(float32x4_t a, float32x4_t b) {
@@ -37,5 +61,23 @@ glmm_norm(float32x4_t a) {
   return sqrtf(glmm_dot(a, a));
 }
 
+static inline
+float
+glmm_norm2(float32x4_t a) {
+  return glmm_dot(a, a);
+}
+
+static inline
+float
+glmm_norm_one(float32x4_t a) {
+  return glmm_hadd(glmm_abs(a));
+}
+
+static inline
+float
+glmm_norm_inf(float32x4_t a) {
+  return glmm_hmax(glmm_abs(a));
+}
+
 #endif
 #endif /* cglm_simd_arm_h */

include/cglm/simd/x86.h

@@ -42,6 +42,12 @@
 #  endif
 #endif
 
+static inline
+__m128
+glmm_abs(__m128 x) {
+  return _mm_andnot_ps(_mm_set1_ps(-0.0f), x);
+}
+
 static inline
 __m128
 glmm_vhadds(__m128 v) {
@@ -68,6 +74,38 @@ glmm_hadd(__m128 v) {
   return _mm_cvtss_f32(glmm_vhadds(v));
 }
 
+static inline
+__m128
+glmm_vhmin(__m128 v) {
+  __m128 x0, x1, x2;
+  x0 = _mm_movehl_ps(v, v);     /* [2, 3, 2, 3] */
+  x1 = _mm_min_ps(x0, v);       /* [0|2, 1|3, 2|2, 3|3] */
+  x2 = glmm_shuff1x(x1, 1);     /* [1|3, 1|3, 1|3, 1|3] */
+  return _mm_min_ss(x1, x2);
+}
+
+static inline
+float
+glmm_hmin(__m128 v) {
+  return _mm_cvtss_f32(glmm_vhmin(v));
+}
+
+static inline
+__m128
+glmm_vhmax(__m128 v) {
+  __m128 x0, x1, x2;
+  x0 = _mm_movehl_ps(v, v);     /* [2, 3, 2, 3] */
+  x1 = _mm_max_ps(x0, v);       /* [0|2, 1|3, 2|2, 3|3] */
+  x2 = glmm_shuff1x(x1, 1);     /* [1|3, 1|3, 1|3, 1|3] */
+  return _mm_max_ss(x1, x2);
+}
+
+static inline
+float
+glmm_hmax(__m128 v) {
+  return _mm_cvtss_f32(glmm_vhmax(v));
+}
+
 static inline
 __m128
 glmm_vdots(__m128 a, __m128 b) {
@@ -113,6 +151,24 @@ glmm_norm(__m128 a) {
   return _mm_cvtss_f32(_mm_sqrt_ss(glmm_vhadds(_mm_mul_ps(a, a))));
 }
 
+static inline
+float
+glmm_norm2(__m128 a) {
+  return _mm_cvtss_f32(glmm_vhadds(_mm_mul_ps(a, a)));
+}
+
+static inline
+float
+glmm_norm_one(__m128 a) {
+  return _mm_cvtss_f32(glmm_vhadds(glmm_abs(a)));
+}
+
+static inline
+float
+glmm_norm_inf(__m128 a) {
+  return _mm_cvtss_f32(glmm_vhmax(glmm_abs(a)));
+}
+
 static inline
 __m128
 glmm_load3(float v[3]) {
@@ -127,7 +183,7 @@ glmm_load3(float v[3]) {
 
 static inline
 void
-glmm_store3(__m128 vx, float v[3]) {
+glmm_store3(float v[3], __m128 vx) {
   _mm_storel_pi((__m64 *)&v[0], vx);
   _mm_store_ss(&v[2], glmm_shuff1(vx, 2, 2, 2, 2));
 }

include/cglm/struct.h

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglm_structs_h
+#define cglm_structs_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "cglm.h"
+#include "types-struct.h"
+#include "struct/vec3.h"
+#include "struct/vec4.h"
+#include "struct/mat3.h"
+#include "struct/mat4.h"
+#include "struct/affine.h"
+#include "struct/frustum.h"
+#include "struct/plane.h"
+#include "struct/box.h"
+#include "struct/color.h"
+#include "struct/io.h"
+#include "struct/cam.h"
+#include "struct/quat.h"
+#include "struct/euler.h"
+#include "struct/project.h"
+#include "struct/sphere.h"
+#include "struct/curve.h"
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglm_structs_h */

include/cglm/struct/affine.h

@@ -0,0 +1,337 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE mat4s glms_translate(mat4s m, vec3s v);
+   CGLM_INLINE mat4s glms_translate_x(mat4s m, float x);
+   CGLM_INLINE mat4s glms_translate_y(mat4s m, float y);
+   CGLM_INLINE mat4s glms_translate_z(mat4s m, float z);
+   CGLM_INLINE mat4s glms_translate_make(vec3s v);
+   CGLM_INLINE mat4s glms_scale_to(mat4s m, vec3s v);
+   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 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);
+   CGLM_INLINE mat4s glms_rotate(mat4s m, float angle, vec3s axis);
+   CGLM_INLINE mat4s glms_rotate_at(mat4s m, vec3s pivot, float angle, vec3s axis);
+   CGLM_INLINE mat4s glms_rotate_atm(mat4s m, vec3s pivot, float angle, vec3s axis);
+   CGLM_INLINE vec3s glms_decompose_scalev(mat4s m);
+   CGLM_INLINE bool  glms_uniscaled(mat4s m);
+   CGLM_INLINE void  glms_decompose_rs(mat4s m, mat4s * r, vec3s * s);
+   CGLM_INLINE void  glms_decompose(mat4s m, vec4s t, mat4s * r, vec3s * s);
+ */
+
+#ifndef cglms_affines_h
+#define cglms_affines_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../affine.h"
+#include "vec3.h"
+#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
+ *
+ * @param[in]       m   affine transfrom
+ * @param[in]       v   translate vector [x, y, z]
+ * @returns             affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_translate(mat4s m, vec3s v) {
+  glm_translate(m.raw, v.raw);
+  return m;
+}
+
+/*!
+ * @brief translate existing transform matrix by x factor
+ *
+ * @param[in]       m   affine transfrom
+ * @param[in]       x   x factor
+ * @returns             affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_translate_x(mat4s m, float x) {
+  glm_translate_x(m.raw, x);
+  return m;
+}
+
+/*!
+ * @brief translate existing transform matrix by y factor
+ *
+ * @param[in]       m   affine transfrom
+ * @param[in]       y   y factor
+ * @returns             affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_translate_y(mat4s m, float y) {
+  glm_translate_y(m.raw, y);
+  return m;
+}
+
+/*!
+ * @brief translate existing transform matrix by z factor
+ *
+ * @param[in]       m   affine transfrom
+ * @param[in]       z   z factor
+ * @returns             affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_translate_z(mat4s m, float z) {
+  glm_translate_z(m.raw, z);
+  return m;
+}
+
+/*!
+ * @brief creates NEW translate transform matrix by v vector
+ *
+ * @param[in]   v   translate vector [x, y, z]
+ * @returns         affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_translate_make(vec3s v) {
+  mat4s m;
+  glm_translate_make(m.raw, v.raw);
+  return m;
+}
+
+/*!
+ * @brief creates NEW scale matrix by v vector
+ *
+ * @param[in]   v  scale vector [x, y, z]
+ * @returns affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_scale_make(vec3s v) {
+  mat4s m;
+  glm_scale_make(m.raw, v.raw);
+  return m;
+}
+
+/*!
+ * @brief scales existing transform matrix by v vector
+ *        and stores result in same matrix
+ *
+ * @param[in]    m   affine transfrom
+ * @param[in]    v   scale vector [x, y, z]
+ * @returns          affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_scale(mat4s m, vec3s v) {
+  mat4s r;
+  glm_scale_to(m.raw, v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief applies uniform scale to existing transform matrix v = [s, s, s]
+ *        and stores result in same matrix
+ *
+ * @param[in]    m   affine transfrom
+ * @param[in]    s   scale factor
+ * @returns          affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_scale_uni(mat4s m, float s) {
+  glm_scale_uni(m.raw, s);
+  return m;
+}
+
+/*!
+ * @brief rotate existing transform matrix around X axis by angle
+ *        and store result in dest
+ *
+ * @param[in]   m       affine transfrom
+ * @param[in]   angle   angle (radians)
+ * @returns             rotated matrix
+ */
+CGLM_INLINE
+mat4s
+glms_rotate_x(mat4s m, float angle) {
+  mat4s r;
+  glm_rotate_x(m.raw, angle, r.raw);
+  return r;
+}
+
+/*!
+ * @brief rotate existing transform matrix around Y axis by angle
+ *        and store result in dest
+ *
+ * @param[in]   m       affine transfrom
+ * @param[in]   angle   angle (radians)
+ * @returns             rotated matrix
+ */
+CGLM_INLINE
+mat4s
+glms_rotate_y(mat4s m, float angle) {
+  mat4s r;
+  glm_rotate_y(m.raw, angle, r.raw);
+  return r;
+}
+
+/*!
+ * @brief rotate existing transform matrix around Z axis by angle
+ *        and store result in dest
+ *
+ * @param[in]   m       affine transfrom
+ * @param[in]   angle   angle (radians)
+ * @returns             rotated matrix
+ */
+CGLM_INLINE
+mat4s
+glms_rotate_z(mat4s m, float angle) {
+  mat4s r;
+  glm_rotate_z(m.raw, angle, r.raw);
+  return r;
+}
+
+/*!
+ * @brief creates NEW rotation matrix by angle and axis
+ *
+ * axis will be normalized so you don't need to normalize it
+ *
+ * @param[in]  angle  angle (radians)
+ * @param[in]  axis   axis
+ * @returns           affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_rotate_make(float angle, vec3s axis) {
+  mat4s m;
+  glm_rotate_make(m.raw, angle, axis.raw);
+  return m;
+}
+
+/*!
+ * @brief rotate existing transform matrix around given axis by angle
+ *
+ * @param[in]       m       affine transfrom
+ * @param[in]       angle   angle (radians)
+ * @param[in]       axis    axis
+ * @returns                 affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_rotate(mat4s m, float angle, vec3s axis) {
+  glm_rotate(m.raw, angle, axis.raw);
+  return m;
+}
+
+/*!
+ * @brief rotate existing transform
+ *        around given axis by angle at given pivot point (rotation center)
+ *
+ * @param[in]       m       affine transfrom
+ * @param[in]       pivot   rotation center
+ * @param[in]       angle   angle (radians)
+ * @param[in]       axis    axis
+ * @returns                 affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_rotate_at(mat4s m, vec3s pivot, float angle, vec3s axis) {
+  glm_rotate_at(m.raw, pivot.raw, angle, axis.raw);
+  return m;
+}
+
+/*!
+ * @brief creates NEW rotation matrix by angle and axis at given point
+ *
+ * this creates rotation matrix, it assumes you don't have a matrix
+ *
+ * this should work faster than glm_rotate_at because it reduces
+ * one glm_translate.
+ *
+ * @param[in]  m      affine transfrom
+ * @param[in]  pivot  rotation center
+ * @param[in]  angle  angle (radians)
+ * @param[in]  axis   axis
+ * @returns           affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_rotate_atm(mat4s m, vec3s pivot, float angle, vec3s axis) {
+  glm_rotate_atm(m.raw, pivot.raw, angle, axis.raw);
+  return m;
+}
+
+/*!
+ * @brief decompose scale vector
+ *
+ * @param[in]  m  affine transform
+ * @returns       scale vector (Sx, Sy, Sz)
+ */
+CGLM_INLINE
+vec3s
+glms_decompose_scalev(mat4s m) {
+  vec3s r;
+  glm_decompose_scalev(m.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief returns true if matrix is uniform scaled. This is helpful for
+ *        creating normal matrix.
+ *
+ * @param[in] m m
+ *
+ * @return boolean
+ */
+CGLM_INLINE
+bool
+glms_uniscaled(mat4s m) {
+  return glm_uniscaled(m.raw);
+}
+
+/*!
+ * @brief decompose rotation matrix (mat4) and scale vector [Sx, Sy, Sz]
+ *        DON'T pass projected matrix here
+ *
+ * @param[in]  m affine transform
+ * @param[out] r rotation matrix
+ * @param[out] s scale matrix
+ */
+CGLM_INLINE
+void
+glms_decompose_rs(mat4s m, mat4s * __restrict r, vec3s * __restrict s) {
+  glm_decompose_rs(m.raw, r->raw, s->raw);
+}
+
+/*!
+ * @brief decompose affine transform, TODO: extract shear factors.
+ *        DON'T pass projected matrix here
+ *
+ * @param[in]  m affine transfrom
+ * @param[out] t translation vector
+ * @param[out] r rotation matrix (mat4)
+ * @param[out] s scaling vector [X, Y, Z]
+ */
+CGLM_INLINE
+void
+glms_decompose(mat4s m, vec4s * __restrict t, mat4s * __restrict r, vec3s * __restrict s) {
+  glm_decompose(m.raw, t->raw, r->raw, s->raw);
+}
+
+#endif /* cglms_affines_h */

include/cglm/struct/box.h

@@ -0,0 +1,256 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglms_boxs_h
+#define cglms_boxs_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../box.h"
+#include "vec3.h"
+#include "vec4.h"
+#include "mat4.h"
+
+/*!
+ * @brief apply transform to Axis-Aligned Bounding Box
+ *
+ * @param[in]  box  bounding box
+ * @param[in]  m    transform matrix
+ * @param[out] dest transformed bounding box
+ */
+CGLM_INLINE
+void
+glms_aabb_transform(vec3s box[2], mat4s m, vec3s dest[2]) {
+  vec3 rawBox[2];
+  vec3 rawDest[2];
+
+  glms_vec3_unpack(rawBox, box, 2);
+  glm_aabb_transform(rawBox, m.raw, rawDest);
+  glms_vec3_pack(dest, rawDest, 2);
+}
+
+/*!
+ * @brief merges two AABB bounding box and creates new one
+ *
+ * two box must be in same space, if one of box is in different space then
+ * you should consider to convert it's space by glm_box_space
+ *
+ * @param[in]  box1 bounding box 1
+ * @param[in]  box2 bounding box 2
+ * @param[out] dest merged bounding box
+ */
+CGLM_INLINE
+void
+glms_aabb_merge(vec3s box1[2], vec3s box2[2], vec3s dest[2]) {
+  vec3 rawBox1[2];
+  vec3 rawBox2[2];
+  vec3 rawDest[2];
+
+  glms_vec3_unpack(rawBox1, box1, 2);
+  glms_vec3_unpack(rawBox2, box2, 2);
+  glm_aabb_merge(rawBox1, rawBox2, rawDest);
+  glms_vec3_pack(dest, rawDest, 2);
+}
+
+/*!
+ * @brief crops a bounding box with another one.
+ *
+ * this could be useful for gettng a bbox which fits with view frustum and
+ * object bounding boxes. In this case you crop view frustum box with objects
+ * box
+ *
+ * @param[in]  box     bounding box 1
+ * @param[in]  cropBox crop box
+ * @param[out] dest    cropped bounding box
+ */
+CGLM_INLINE
+void
+glms_aabb_crop(vec3s box[2], vec3s cropBox[2], vec3s dest[2]) {
+  vec3 rawBox[2];
+  vec3 rawCropBox[2];
+  vec3 rawDest[2];
+
+  glms_vec3_unpack(rawBox, box, 2);
+  glms_vec3_unpack(rawCropBox, cropBox, 2);
+  glm_aabb_crop(rawBox, rawCropBox, rawDest);
+  glms_vec3_pack(dest, rawDest, 2);
+}
+
+/*!
+ * @brief crops a bounding box with another one.
+ *
+ * this could be useful for gettng a bbox which fits with view frustum and
+ * object bounding boxes. In this case you crop view frustum box with objects
+ * box
+ *
+ * @param[in]  box      bounding box
+ * @param[in]  cropBox  crop box
+ * @param[in]  clampBox miniumum box
+ * @param[out] dest     cropped bounding box
+ */
+CGLM_INLINE
+void
+glms_aabb_crop_until(vec3s box[2],
+                     vec3s cropBox[2],
+                     vec3s clampBox[2],
+                     vec3s dest[2]) {
+  glms_aabb_crop(box, cropBox, dest);
+  glms_aabb_merge(clampBox, dest, dest);
+}
+
+/*!
+ * @brief check if AABB intersects with frustum planes
+ *
+ * this could be useful for frustum culling using AABB.
+ *
+ * OPTIMIZATION HINT:
+ *  if planes order is similar to LEFT, RIGHT, BOTTOM, TOP, NEAR, FAR
+ *  then this method should run even faster because it would only use two
+ *  planes if object is not inside the two planes
+ *  fortunately cglm extracts planes as this order! just pass what you got!
+ *
+ * @param[in]  box     bounding box
+ * @param[in]  planes  frustum planes
+ */
+CGLM_INLINE
+bool
+glms_aabb_frustum(vec3s box[2], vec4s planes[6]) {
+  vec3 rawBox[2];
+  vec4 rawPlanes[6];
+
+  glms_vec3_unpack(rawBox, box, 2);
+  glms_vec4_unpack(rawPlanes, planes, 6);
+  return glm_aabb_frustum(rawBox, rawPlanes);
+}
+
+/*!
+ * @brief invalidate AABB min and max values
+ *
+ * @param[in, out]  box bounding box
+ */
+CGLM_INLINE
+void
+glms_aabb_invalidate(vec3s box[2]) {
+  box[0] = glms_vec3_broadcast(FLT_MAX);
+  box[1] = glms_vec3_broadcast(-FLT_MAX);
+}
+
+/*!
+ * @brief check if AABB is valid or not
+ *
+ * @param[in]  box bounding box
+ */
+CGLM_INLINE
+bool
+glms_aabb_isvalid(vec3s box[2]) {
+  vec3 rawBox[2];
+  glms_vec3_unpack(rawBox, box, 2);
+  return glm_aabb_isvalid(rawBox);
+}
+
+/*!
+ * @brief distance between of min and max
+ *
+ * @param[in]  box bounding box
+ */
+CGLM_INLINE
+float
+glms_aabb_size(vec3s box[2]) {
+  return glm_vec3_distance(box[0].raw, box[1].raw);
+}
+
+/*!
+ * @brief radius of sphere which surrounds AABB
+ *
+ * @param[in]  box bounding box
+ */
+CGLM_INLINE
+float
+glms_aabb_radius(vec3s box[2]) {
+  return glms_aabb_size(box) * 0.5f;
+}
+
+/*!
+ * @brief computes center point of AABB
+ *
+ * @param[in]   box  bounding box
+ * @returns center of bounding box
+ */
+CGLM_INLINE
+vec3s
+glms_aabb_center(vec3s box[2]) {
+  return glms_vec3_center(box[0], box[1]);
+}
+
+/*!
+ * @brief check if two AABB intersects
+ *
+ * @param[in]   box    bounding box
+ * @param[in]   other  other bounding box
+ */
+CGLM_INLINE
+bool
+glms_aabb_aabb(vec3s box[2], vec3s other[2]) {
+  vec3 rawBox[2];
+  vec3 rawOther[2];
+
+  glms_vec3_unpack(rawBox, box, 2);
+  glms_vec3_unpack(rawOther, other, 2);
+  return glm_aabb_aabb(rawBox, rawOther);
+}
+
+/*!
+ * @brief check if AABB intersects with sphere
+ *
+ * https://github.com/erich666/GraphicsGems/blob/master/gems/BoxSphere.c
+ * Solid Box - Solid Sphere test.
+ *
+ * @param[in]   box    solid bounding box
+ * @param[in]   s      solid sphere
+ */
+CGLM_INLINE
+bool
+glms_aabb_sphere(vec3s box[2], vec4s s) {
+  vec3 rawBox[2];
+
+  glms_vec3_unpack(rawBox, box, 2);
+  return glm_aabb_sphere(rawBox, s.raw);
+}
+
+/*!
+ * @brief check if point is inside of AABB
+ *
+ * @param[in]   box    bounding box
+ * @param[in]   point  point
+ */
+CGLM_INLINE
+bool
+glms_aabb_point(vec3s box[2], vec3s point) {
+  vec3 rawBox[2];
+
+  glms_vec3_unpack(rawBox, box, 2);
+  return glm_aabb_point(rawBox, point.raw);
+}
+
+/*!
+ * @brief check if AABB contains other AABB
+ *
+ * @param[in]   box    bounding box
+ * @param[in]   other  other bounding box
+ */
+CGLM_INLINE
+bool
+glms_aabb_contains(vec3s box[2], vec3s other[2]) {
+  vec3 rawBox[2];
+  vec3 rawOther[2];
+
+  glms_vec3_unpack(rawBox, box, 2);
+  glms_vec3_unpack(rawOther, other, 2);
+  return glm_aabb_contains(rawBox, rawOther);
+}
+
+#endif /* cglms_boxs_h */

include/cglm/struct/cam.h

@@ -0,0 +1,451 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE mat4s glms_frustum(float left,    float right,
+                                  float bottom,  float top,
+                                  float nearVal, float farVal)
+   CGLM_INLINE mat4s glms_ortho(float left,    float right,
+                                float bottom,  float top,
+                                float nearVal, float farVal)
+   CGLM_INLINE mat4s glms_ortho_aabb(vec3s box[2]);
+   CGLM_INLINE mat4s glms_ortho_aabb_p(vec3s box[2],  float padding);
+   CGLM_INLINE mat4s glms_ortho_aabb_pz(vec3s box[2], float padding);
+   CGLM_INLINE mat4s glms_ortho_default(float aspect)
+   CGLM_INLINE mat4s glms_ortho_default_s(float aspect, float size)
+   CGLM_INLINE mat4s glms_perspective(float fovy,
+                                      float aspect,
+                                      float nearVal,
+                                      float farVal)
+   CGLM_INLINE void  glms_persp_move_far(mat4s proj, float deltaFar)
+   CGLM_INLINE mat4s glms_perspective_default(float aspect)
+   CGLM_INLINE void  glms_perspective_resize(mat4s proj, float aspect)
+   CGLM_INLINE mat4s glms_lookat(vec3s eye, vec3s center, vec3s up)
+   CGLM_INLINE mat4s glms_look(vec3s eye, vec3s dir, vec3s up)
+   CGLM_INLINE mat4s glms_look_anyup(vec3s eye, vec3s dir)
+   CGLM_INLINE void  glms_persp_decomp(mat4s  proj,
+                                       float *nearv, float *farv,
+                                       float *top,   float *bottom,
+                                       float *left,  float *right)
+   CGLM_INLINE void  glms_persp_decompv(mat4s proj, float dest[6])
+   CGLM_INLINE void  glms_persp_decomp_x(mat4s proj, float *left, float *right)
+   CGLM_INLINE void  glms_persp_decomp_y(mat4s proj, float *top, float *bottom)
+   CGLM_INLINE void  glms_persp_decomp_z(mat4s proj, float *nearv, float *farv)
+   CGLM_INLINE void  glms_persp_decomp_far(mat4s proj, float *farVal)
+   CGLM_INLINE void  glms_persp_decomp_near(mat4s proj, float *nearVal)
+   CGLM_INLINE float glms_persp_fovy(mat4s proj)
+   CGLM_INLINE float glms_persp_aspect(mat4s proj)
+   CGLM_INLINE vec4s glms_persp_sizes(mat4s proj, float fovy)
+ */
+
+#ifndef cglms_cam_h
+#define cglms_cam_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../plane.h"
+#include "../cam.h"
+
+/*!
+ * @brief set up perspective peprojection matrix
+ *
+ * @param[in]  left    viewport.left
+ * @param[in]  right   viewport.right
+ * @param[in]  bottom  viewport.bottom
+ * @param[in]  top     viewport.top
+ * @param[in]  nearVal near clipping plane
+ * @param[in]  farVal  far clipping plane
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_frustum(float left,    float right,
+             float bottom,  float top,
+             float nearVal, float farVal) {
+  mat4s dest;
+  glm_frustum(left, right, bottom, top, nearVal, farVal, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief set up orthographic projection matrix
+ *
+ * @param[in]  left    viewport.left
+ * @param[in]  right   viewport.right
+ * @param[in]  bottom  viewport.bottom
+ * @param[in]  top     viewport.top
+ * @param[in]  nearVal near clipping plane
+ * @param[in]  farVal  far clipping plane
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho(float left,    float right,
+           float bottom,  float top,
+           float nearVal, float farVal) {
+  mat4s dest;
+  glm_ortho(left, right, bottom, top, nearVal, farVal, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief set up orthographic projection matrix using bounding box
+ *
+ * bounding box (AABB) must be in view space
+ *
+ * @param[in]  box   AABB
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_aabb(vec3s box[2]) {
+  mat4s dest;
+  vec3  rawBox[2];
+
+  glms_vec3_unpack(rawBox, box, 2);
+  glm_ortho_aabb(rawBox, dest.raw);
+
+  return dest;
+}
+
+/*!
+ * @brief set up orthographic projection matrix using bounding box
+ *
+ * bounding box (AABB) must be in view space
+ *
+ * @param[in]  box     AABB
+ * @param[in]  padding padding
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_aabb_p(vec3s box[2], float padding) {
+  mat4s dest;
+  vec3  rawBox[2];
+
+  glms_vec3_unpack(rawBox, box, 2);
+  glm_ortho_aabb_p(rawBox, padding, dest.raw);
+
+  return dest;
+}
+
+/*!
+ * @brief set up orthographic projection matrix using bounding box
+ *
+ * bounding box (AABB) must be in view space
+ *
+ * @param[in]  box     AABB
+ * @param[in]  padding padding for near and far
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_aabb_pz(vec3s box[2], float padding) {
+  mat4s dest;
+  vec3  rawBox[2];
+
+  glms_vec3_unpack(rawBox, box, 2);
+  glm_ortho_aabb_pz(rawBox, padding, dest.raw);
+
+  return dest;
+}
+
+/*!
+ * @brief set up unit orthographic projection matrix
+ *
+ * @param[in]  aspect aspect ration ( width / height )
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_default(float aspect) {
+  mat4s dest;
+  glm_ortho_default(aspect, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief set up orthographic projection matrix with given CUBE size
+ *
+ * @param[in]  aspect aspect ratio ( width / height )
+ * @param[in]  size   cube size
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_default_s(float aspect, float size) {
+  mat4s dest;
+  glm_ortho_default_s(aspect, size, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief set up perspective projection matrix
+ *
+ * @param[in]  fovy    field of view angle
+ * @param[in]  aspect  aspect ratio ( width / height )
+ * @param[in]  nearVal near clipping plane
+ * @param[in]  farVal  far clipping planes
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_perspective(float fovy, float aspect, float nearVal, float farVal) {
+  mat4s dest;
+  glm_perspective(fovy, aspect, nearVal, farVal, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief extend perspective projection matrix's far distance
+ *
+ * this function does not guarantee far >= near, be aware of that!
+ *
+ * @param[in, out] proj      projection matrix to extend
+ * @param[in]      deltaFar  distance from existing far (negative to shink)
+ */
+CGLM_INLINE
+void
+glms_persp_move_far(mat4s proj, float deltaFar) {
+  glm_persp_move_far(proj.raw, deltaFar);
+}
+
+/*!
+ * @brief set up perspective projection matrix with default near/far
+ *        and angle values
+ *
+ * @param[in]  aspect aspect ratio ( width / height )
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_perspective_default(float aspect) {
+  mat4s dest;
+  glm_perspective_default(aspect, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief resize perspective matrix by aspect ratio ( width / height )
+ *        this makes very easy to resize proj matrix when window /viewport
+ *        reized
+ *
+ * @param[in, out] proj   perspective projection matrix
+ * @param[in]      aspect aspect ratio ( width / height )
+ */
+CGLM_INLINE
+void
+glms_perspective_resize(mat4s proj, float aspect) {
+  glm_perspective_resize(aspect, proj.raw);
+}
+
+/*!
+ * @brief set up view matrix
+ *
+ * NOTE: The UP vector must not be parallel to the line of sight from
+ *       the eye point to the reference point
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  center center vector
+ * @param[in]  up     up vector
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_lookat(vec3s eye, vec3s center, vec3s up) {
+  mat4s dest;
+  glm_lookat(eye.raw, center.raw, up.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief set up view matrix
+ *
+ * convenient wrapper for lookat: if you only have direction not target self
+ * then this might be useful. Because you need to get target from direction.
+ *
+ * NOTE: The UP vector must not be parallel to the line of sight from
+ *       the eye point to the reference point
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  dir    direction vector
+ * @param[in]  up     up vector
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_look(vec3s eye, vec3s dir, vec3s up) {
+  mat4s dest;
+  glm_look(eye.raw, dir.raw, up.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief set up view matrix
+ *
+ * convenient wrapper for look: if you only have direction and if you don't
+ * care what UP vector is then this might be useful to create view matrix
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  dir    direction vector
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_look_anyup(vec3s eye, vec3s dir) {
+  mat4s dest;
+  glm_look_anyup(eye.raw, dir.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief decomposes frustum values of perspective projection.
+ *
+ * @param[in]  proj    perspective projection matrix
+ * @param[out] nearVal near
+ * @param[out] farVal  far
+ * @param[out] top     top
+ * @param[out] bottom  bottom
+ * @param[out] left    left
+ * @param[out] right   right
+ */
+CGLM_INLINE
+void
+glms_persp_decomp(mat4s proj,
+                  float * __restrict nearVal, float * __restrict farVal,
+                  float * __restrict top,     float * __restrict bottom,
+                  float * __restrict left,    float * __restrict right) {
+  glm_persp_decomp(proj.raw, nearVal, farVal, top, bottom, left, right);
+}
+
+/*!
+ * @brief decomposes frustum values of perspective projection.
+ *        this makes easy to get all values at once
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] dest   array
+ */
+CGLM_INLINE
+void
+glms_persp_decompv(mat4s proj, float dest[6]) {
+  glm_persp_decompv(proj.raw, dest);
+}
+
+/*!
+ * @brief decomposes left and right values of perspective projection.
+ *        x stands for x axis (left / right axis)
+ *
+ * @param[in]  proj  perspective projection matrix
+ * @param[out] left  left
+ * @param[out] right right
+ */
+CGLM_INLINE
+void
+glms_persp_decomp_x(mat4s proj,
+                    float * __restrict left,
+                    float * __restrict right) {
+  glm_persp_decomp_x(proj.raw, left, right);
+}
+
+/*!
+ * @brief decomposes top and bottom values of perspective projection.
+ *        y stands for y axis (top / botom axis)
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] top    top
+ * @param[out] bottom bottom
+ */
+CGLM_INLINE
+void
+glms_persp_decomp_y(mat4s proj,
+                    float * __restrict top,
+                    float * __restrict bottom) {
+  glm_persp_decomp_y(proj.raw, top, bottom);
+}
+
+/*!
+ * @brief decomposes near and far values of perspective projection.
+ *        z stands for z axis (near / far axis)
+ *
+ * @param[in]  proj    perspective projection matrix
+ * @param[out] nearVal near
+ * @param[out] farVal  far
+ */
+CGLM_INLINE
+void
+glms_persp_decomp_z(mat4s proj,
+                    float * __restrict nearVal,
+                    float * __restrict farVal) {
+  glm_persp_decomp_z(proj.raw, nearVal, farVal);
+}
+
+/*!
+ * @brief decomposes far value of perspective projection.
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] farVal far
+ */
+CGLM_INLINE
+void
+glms_persp_decomp_far(mat4s proj, float * __restrict farVal) {
+  glm_persp_decomp_far(proj.raw, farVal);
+}
+
+/*!
+ * @brief decomposes near value of perspective projection.
+ *
+ * @param[in]  proj    perspective projection matrix
+ * @param[out] nearVal near
+ */
+CGLM_INLINE
+void
+glms_persp_decomp_near(mat4s proj, float * __restrict nearVal) {
+  glm_persp_decomp_near(proj.raw, nearVal);
+}
+
+/*!
+ * @brief returns field of view angle along the Y-axis (in radians)
+ *
+ * if you need to degrees, use glm_deg to convert it or use this:
+ * fovy_deg = glm_deg(glm_persp_fovy(projMatrix))
+ *
+ * @param[in] proj perspective projection matrix
+ */
+CGLM_INLINE
+float
+glms_persp_fovy(mat4s proj) {
+  return glm_persp_fovy(proj.raw);
+}
+
+/*!
+ * @brief returns aspect ratio of perspective projection
+ *
+ * @param[in] proj perspective projection matrix
+ */
+CGLM_INLINE
+float
+glms_persp_aspect(mat4s proj) {
+  return glm_persp_aspect(proj.raw);
+}
+
+/*!
+ * @brief returns sizes of near and far planes of perspective projection
+ *
+ * @param[in]  proj perspective projection matrix
+ * @param[in]  fovy fovy (see brief)
+ * @returns    sizes as vector, sizes order: [Wnear, Hnear, Wfar, Hfar]
+ */
+CGLM_INLINE
+vec4s
+glms_persp_sizes(mat4s proj, float fovy) {
+  vec4s dest;
+  glm_persp_sizes(proj.raw, fovy, dest.raw);
+  return dest;
+}
+
+#endif /* cglms_cam_h */

include/cglm/struct/color.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 cglms_colors_h
+#define cglms_colors_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../color.h"
+#include "vec3.h"
+
+/*!
+ * @brief averages the color channels into one value
+ *
+ * @param[in]  rgb RGB color
+ */
+CGLM_INLINE
+float
+glms_luminance(vec3s rgb) {
+  return glm_luminance(rgb.raw);
+}
+
+#endif /* cglms_colors_h */

include/cglm/struct/curve.h

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

include/cglm/struct/euler.h

@@ -0,0 +1,152 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ NOTE:
+  angles must be passed as [X-Angle, Y-Angle, Z-angle] order
+  For instance you don't pass angles as [Z-Angle, X-Angle, Y-angle] to
+  glm_euler_zxy funciton, All RELATED functions accept angles same order
+  which is [X, Y, Z].
+ */
+
+/*
+ Types:
+   enum glm_euler_seq
+
+ Functions:
+   CGLM_INLINE vec3s glms_euler_angles(mat4s m)
+   CGLM_INLINE mat4s glms_euler_xyz(vec3s angles)
+   CGLM_INLINE mat4s glms_euler_xzy(vec3s angles)
+   CGLM_INLINE mat4s glms_euler_yxz(vec3s angles)
+   CGLM_INLINE mat4s glms_euler_yzx(vec3s angles)
+   CGLM_INLINE mat4s glms_euler_zxy(vec3s angles)
+   CGLM_INLINE mat4s glms_euler_zyx(vec3s angles)
+   CGLM_INLINE mat4s glms_euler_by_order(vec3s angles, glm_euler_seq ord)
+ */
+
+#ifndef cglms_euler_h
+#define cglms_euler_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../euler.h"
+
+/*!
+ * @brief extract euler angles (in radians) using xyz order
+ *
+ * @param[in]  m    affine transform
+ * @returns angles vector [x, y, z]
+ */
+CGLM_INLINE
+vec3s
+glms_euler_angles(mat4s m) {
+  vec3s dest;
+  glm_euler_angles(m.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief build rotation matrix from euler angles
+ *
+ * @param[in]  angles angles as vector [Xangle, Yangle, Zangle]
+ * @returns rotation matrix
+ */
+CGLM_INLINE
+mat4s
+glms_euler_xyz(vec3s angles) {
+  mat4s dest;
+  glm_euler_xyz(angles.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief build rotation matrix from euler angles
+ *
+ * @param[in]  angles angles as vector [Xangle, Yangle, Zangle]
+ * @returns rotation matrix
+ */
+CGLM_INLINE
+mat4s
+glms_euler_xzy(vec3s angles) {
+  mat4s dest;
+  glm_euler_xzy(angles.raw, dest.raw);
+  return dest;
+}
+
+
+/*!
+ * @brief build rotation matrix from euler angles
+ *
+ * @param[in]  angles angles as vector [Xangle, Yangle, Zangle]
+ * @returns rotation matrix
+ */
+CGLM_INLINE
+mat4s
+glms_euler_yxz(vec3s angles) {
+  mat4s dest;
+  glm_euler_yxz(angles.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief build rotation matrix from euler angles
+ *
+ * @param[in]  angles angles as vector [Xangle, Yangle, Zangle]
+ * @returns rotation matrix
+ */
+CGLM_INLINE
+mat4s
+glms_euler_yzx(vec3s angles) {
+  mat4s dest;
+  glm_euler_yzx(angles.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief build rotation matrix from euler angles
+ *
+ * @param[in]  angles angles as vector [Xangle, Yangle, Zangle]
+ * @returns rotation matrix
+ */
+CGLM_INLINE
+mat4s
+glms_euler_zxy(vec3s angles) {
+  mat4s dest;
+  glm_euler_zxy(angles.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief build rotation matrix from euler angles
+ *
+ * @param[in]  angles angles as vector [Xangle, Yangle, Zangle]
+ * @returns rotation matrix
+ */
+CGLM_INLINE
+mat4s
+glms_euler_zyx(vec3s angles) {
+  mat4s dest;
+  glm_euler_zyx(angles.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief build rotation matrix from euler angles
+ *
+ * @param[in]  angles angles as vector [Xangle, Yangle, Zangle]
+ * @param[in]  ord    euler order
+ * @returns rotation matrix
+ */
+CGLM_INLINE
+mat4s
+glms_euler_by_order(vec3s angles, glm_euler_seq ord) {
+  mat4s dest;
+  glm_euler_by_order(angles.raw, ord, dest.raw);
+  return dest;
+}
+
+#endif /* cglms_euler_h */

include/cglm/struct/frustum.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 cglms_frustums_h
+#define cglms_frustums_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../frustum.h"
+#include "plane.h"
+#include "vec3.h"
+#include "vec4.h"
+#include "mat4.h"
+
+/* you can override clip space coords
+   but you have to provide all with same name
+   e.g.: define GLM_CSCOORD_LBN {0.0f, 0.0f, 1.0f, 1.0f} */
+#ifndef GLM_CUSTOM_CLIPSPACE
+
+/* near */
+#define GLMS_CSCOORD_LBN {-1.0f, -1.0f, -1.0f, 1.0f}
+#define GLMS_CSCOORD_LTN {-1.0f,  1.0f, -1.0f, 1.0f}
+#define GLMS_CSCOORD_RTN { 1.0f,  1.0f, -1.0f, 1.0f}
+#define GLMS_CSCOORD_RBN { 1.0f, -1.0f, -1.0f, 1.0f}
+
+/* far */
+#define GLMS_CSCOORD_LBF {-1.0f, -1.0f,  1.0f, 1.0f}
+#define GLMS_CSCOORD_LTF {-1.0f,  1.0f,  1.0f, 1.0f}
+#define GLMS_CSCOORD_RTF { 1.0f,  1.0f,  1.0f, 1.0f}
+#define GLMS_CSCOORD_RBF { 1.0f, -1.0f,  1.0f, 1.0f}
+
+#endif
+
+/*!
+ * @brief extracts view frustum planes
+ *
+ * planes' space:
+ *  1- if m = proj:     View Space
+ *  2- if m = viewProj: World Space
+ *  3- if m = MVP:      Object Space
+ *
+ * You probably want to extract planes in world space so use viewProj as m
+ * Computing viewProj:
+ *   glm_mat4_mul(proj, view, viewProj);
+ *
+ * Exracted planes order: [left, right, bottom, top, near, far]
+ *
+ * @param[in]  m    matrix (see brief)
+ * @param[out] dest extracted view frustum planes (see brief)
+ */
+CGLM_INLINE
+void
+glms_frustum_planes(mat4s m, vec4s dest[6]) {
+  vec4 rawDest[6];
+  glm_frustum_planes(m.raw, rawDest);
+  glms_vec4_pack(dest, rawDest, 6);
+}
+
+/*!
+ * @brief extracts view frustum corners using clip-space coordinates
+ *
+ * corners' space:
+ *  1- if m = invViewProj: World Space
+ *  2- if m = invMVP:      Object Space
+ *
+ * You probably want to extract corners in world space so use invViewProj
+ * Computing invViewProj:
+ *   glm_mat4_mul(proj, view, viewProj);
+ *   ...
+ *   glm_mat4_inv(viewProj, invViewProj);
+ *
+ * if you have a near coord at i index, you can get it's far coord by i + 4
+ *
+ * Find center coordinates:
+ *   for (j = 0; j < 4; j++) {
+ *     glm_vec3_center(corners[i], corners[i + 4], centerCorners[i]);
+ *   }
+ *
+ * @param[in]  invMat matrix (see brief)
+ * @param[out] dest   exracted view frustum corners (see brief)
+ */
+CGLM_INLINE
+void
+glms_frustum_corners(mat4s invMat, vec4s dest[8]) {
+  vec4 rawDest[8];
+  glm_frustum_corners(invMat.raw, rawDest);
+  glms_vec4_pack(dest, rawDest, 8);
+}
+
+/*!
+ * @brief finds center of view frustum
+ *
+ * @param[in]  corners view frustum corners
+ * @returns            view frustum center
+ */
+CGLM_INLINE
+vec4s
+glms_frustum_center(vec4s corners[8]) {
+  vec4 rawCorners[8];
+  vec4s r;
+
+  glms_vec4_unpack(rawCorners, corners, 8);
+  glm_frustum_center(rawCorners, r.raw);
+  return r;
+}
+
+/*!
+ * @brief finds bounding box of frustum relative to given matrix e.g. view mat
+ *
+ * @param[in]  corners view frustum corners
+ * @param[in]  m       matrix to convert existing conners
+ * @param[out] box     bounding box as array [min, max]
+ */
+CGLM_INLINE
+void
+glms_frustum_box(vec4s corners[8], mat4s m, vec3s box[2]) {
+  vec4 rawCorners[8];
+  vec3 rawBox[2];
+
+  glms_vec4_unpack(rawCorners, corners, 8);
+  glm_frustum_box(rawCorners, m.raw, rawBox);
+  glms_vec3_pack(box, rawBox, 2);
+}
+
+/*!
+ * @brief finds planes corners which is between near and far planes (parallel)
+ *
+ * this will be helpful if you want to split a frustum e.g. CSM/PSSM. This will
+ * find planes' corners but you will need to one more plane.
+ * Actually you have it, it is near, far or created previously with this func ;)
+ *
+ * @param[in]  corners view  frustum corners
+ * @param[in]  splitDist     split distance
+ * @param[in]  farDist       far distance (zFar)
+ * @param[out] planeCorners  plane corners [LB, LT, RT, RB]
+ */
+CGLM_INLINE
+void
+glms_frustum_corners_at(vec4s corners[8],
+                        float splitDist,
+                        float farDist,
+                        vec4s planeCorners[4]) {
+  vec4 rawCorners[8];
+  vec4 rawPlaneCorners[4];
+
+  glms_vec4_unpack(rawCorners, corners, 8);
+  glm_frustum_corners_at(rawCorners, splitDist, farDist, rawPlaneCorners);
+  glms_vec4_pack(planeCorners, rawPlaneCorners, 8);
+}
+
+#endif /* cglms_frustums_h */

include/cglm/struct/io.h

@@ -0,0 +1,82 @@
+/*
+ * 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_mat4_print(mat4 matrix, FILE *ostream);
+   CGLM_INLINE void glm_mat3_print(mat3 matrix, FILE *ostream);
+   CGLM_INLINE void glm_vec4_print(vec4 vec, FILE *ostream);
+   CGLM_INLINE void glm_vec3_print(vec3 vec, FILE *ostream);
+   CGLM_INLINE void glm_ivec3_print(ivec3 vec, FILE *ostream);
+   CGLM_INLINE void glm_versor_print(versor vec, FILE *ostream);
+ */
+
+#ifndef cglms_ios_h
+#define cglms_ios_h
+
+#include "../common.h"
+#include "../io.h"
+#include "mat4.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+CGLM_INLINE
+void
+glms_mat4_print(mat4s             matrix,
+                FILE * __restrict ostream) {
+
+  glm_mat4_print(matrix.raw, ostream);
+}
+
+CGLM_INLINE
+void
+glms_mat3_print(mat3s             matrix,
+                FILE * __restrict ostream) {
+  glm_mat3_print(matrix.raw, ostream);
+}
+
+CGLM_INLINE
+void
+glms_vec4_print(vec4s             vec,
+                FILE * __restrict ostream) {
+  glm_vec4_print(vec.raw, ostream);
+}
+
+CGLM_INLINE
+void
+glms_vec3_print(vec3s             vec,
+                FILE * __restrict ostream) {
+  glm_vec3_print(vec.raw, ostream);
+}
+
+CGLM_INLINE
+void
+glms_ivec3_print(ivec3s            vec,
+                 FILE * __restrict ostream) {
+  glm_ivec3_print(vec.raw, ostream);
+}
+
+CGLM_INLINE
+void
+glms_versor_print(versors           vec,
+                  FILE * __restrict ostream) {
+  glm_versor_print(vec.raw, ostream);
+}
+
+CGLM_INLINE
+void
+glms_aabb_print(vec3s                   bbox[2],
+                const char * __restrict tag,
+                FILE       * __restrict ostream) {
+  vec3 rawBbox[2];
+
+  glms_vec3_unpack(rawBbox, bbox, 2);
+  glm_aabb_print(rawBbox, tag, ostream);
+}
+
+#endif /* cglms_ios_h */

include/cglm/struct/mat3.h

@@ -0,0 +1,285 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   GLMS_MAT3_IDENTITY_INIT
+   GLMS_MAT3_ZERO_INIT
+   GLMS_MAT3_IDENTITY
+   GLMS_MAT3_ZERO
+
+ Functions:
+   CGLM_INLINE mat3s  glms_mat3_copy(mat3s mat);
+   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(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);
+   CGLM_INLINE float  glms_mat3_trace(mat3s m);
+   CGLM_INLINE versor glms_mat3_quat(mat3s m);
+   CGLM_INLINE mat3s  glms_mat3_scale(mat3s m, float s);
+   CGLM_INLINE float  glms_mat3_det(mat3s mat);
+   CGLM_INLINE mat3s  glms_mat3_inv(mat3s mat);
+   CGLM_INLINE mat3s  glms_mat3_swap_col(mat3s mat, int col1, int col2);
+   CGLM_INLINE mat3s  glms_mat3_swap_row(mat3s mat, int row1, int row2);
+   CGLM_INLINE float  glms_mat3_rmc(vec3s r, mat3s m, vec3s c);
+ */
+
+#ifndef cglms_mat3s_h
+#define cglms_mat3s_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../mat3.h"
+#include "vec3.h"
+
+#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)
+#define GLMS_MAT3_ZERO     ((mat3s)GLMS_MAT3_ZERO_INIT)
+
+/*!
+ * @brief copy all members of [mat] to [dest]
+ *
+ * @param[in]  mat  source
+ * @returns         destination
+ */
+CGLM_INLINE
+mat3s
+glms_mat3_copy(mat3s mat) {
+  mat3s r;
+  glm_mat3_copy(mat.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief make given matrix identity. It is identical with below,
+ *        but it is more easy to do that with this func especially for members
+ *        e.g. glm_mat3_identity(aStruct->aMatrix);
+ *
+ * @code
+ * glm_mat3_copy(GLM_MAT3_IDENTITY, mat); // C only
+ *
+ * // or
+ * mat3 mat = GLM_MAT3_IDENTITY_INIT;
+ * @endcode
+ *
+ * @returns  destination
+ */
+CGLM_INLINE
+mat3s
+glms_mat3_identity(void) {
+  mat3s r;
+  glm_mat3_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/32)
+ *                        if alignment is not disabled)
+ *
+ * @param[in]       count count of matrices
+ */
+CGLM_INLINE
+void
+glms_mat3_identity_array(mat3s * __restrict mat, size_t count) {
+  CGLM_ALIGN_MAT mat3s t = GLMS_MAT3_IDENTITY_INIT;
+  size_t i;
+
+  for (i = 0; i < count; i++) {
+    glm_mat3_copy(t.raw, mat[i].raw);
+  }
+}
+
+/*!
+ * @brief make given matrix zero.
+ *
+ * @returns  matrix
+ */
+CGLM_INLINE
+mat3s
+glms_mat3_zero(void) {
+  mat3s r;
+  glm_mat3_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
+ * mat3 m = GLM_MAT3_IDENTITY_INIT;
+ * glm_mat3_mul(m, m, m);
+ * @endcode
+ *
+ * @param[in]  m1   left matrix
+ * @param[in]  m2   right matrix
+ * @returns         destination matrix
+ */
+CGLM_INLINE
+mat3s
+glms_mat3_mul(mat3s m1, mat3s m2) {
+  mat3s r;
+  glm_mat3_mul(m1.raw, m2.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief tranpose mat3 and store result in same matrix
+ *
+ * @param[in, out] m source and dest
+ */
+CGLM_INLINE
+mat3s
+glms_mat3_transpose(mat3s m) {
+  glm_mat3_transpose(m.raw);
+  return m;
+}
+
+/*!
+ * @brief multiply mat3 with vec3 (column vector) and store in dest vector
+ *
+ * @param[in]  m    mat3 (left)
+ * @param[in]  v    vec3 (right, column vector)
+ * @returns         vec3 (result, column vector)
+ */
+CGLM_INLINE
+vec3s
+glms_mat3_mulv(mat3s m, vec3s v) {
+  vec3s r;
+  glm_mat3_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_mat3_trace(mat3s m) {
+  return glm_mat3_trace(m.raw);
+}
+
+/*!
+ * @brief convert mat3 to quaternion
+ *
+ * @param[in]  m    rotation matrix
+ * @returns         destination quaternion
+ */
+CGLM_INLINE
+versors
+glms_mat3_quat(mat3s m) {
+  versors r;
+  glm_mat3_quat(m.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief scale (multiply with scalar) matrix
+ *
+ * multiply matrix with scalar
+ *
+ * @param[in]      m matrix
+ * @param[in]      s scalar
+ * @returns          scaled matrix
+ */
+CGLM_INLINE
+mat3s
+glms_mat3_scale(mat3s m, float s) {
+  glm_mat3_scale(m.raw, s);
+  return m;
+}
+
+/*!
+ * @brief mat3 determinant
+ *
+ * @param[in] mat matrix
+ *
+ * @return determinant
+ */
+CGLM_INLINE
+float
+glms_mat3_det(mat3s mat) {
+  return glm_mat3_det(mat.raw);
+}
+
+/*!
+ * @brief inverse mat3 and store in dest
+ *
+ * @param[in]  mat  matrix
+ * @returns         inverse matrix
+ */
+CGLM_INLINE
+mat3s
+glms_mat3_inv(mat3s mat) {
+  mat3s r;
+  glm_mat3_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
+mat3s
+glms_mat3_swap_col(mat3s mat, int col1, int col2) {
+  glm_mat3_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
+mat3s
+glms_mat3_swap_row(mat3s mat, int row1, int row2) {
+  glm_mat3_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 = Matrix1x3 (row vector),
+ * then Matrix1x3 * Vec3 (column vector) = Matrix1x1 (Scalar)
+ *
+ * @param[in]  r   row vector or matrix1x3
+ * @param[in]  m   matrix3x3
+ * @param[in]  c   column vector or matrix3x1
+ *
+ * @return scalar value e.g. Matrix1x1
+ */
+CGLM_INLINE
+float
+glms_mat3_rmc(vec3s r, mat3s m, vec3s c) {
+  return glm_mat3_rmc(r.raw, m.raw, c.raw);
+}
+
+#endif /* cglms_mat3s_h */

include/cglm/struct/mat4.h

@@ -0,0 +1,459 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*!
+ * Most of functions in this header are optimized manually with SIMD
+ * if available. You dont need to call/incude SIMD headers manually
+ */
+
+/*
+ Macros:
+   GLMS_MAT4_IDENTITY_INIT
+   GLMS_MAT4_ZERO_INIT
+   GLMS_MAT4_IDENTITY
+   GLMS_MAT4_ZERO
+
+ Functions:
+   CGLM_INLINE mat4s   glms_mat4_ucopy(mat4s mat);
+   CGLM_INLINE mat4s   glms_mat4_copy(mat4s mat);
+   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(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);
+   CGLM_INLINE mat4s   glms_mat4_mul(mat4s m1, mat4s m2);
+   CGLM_INLINE mat4s   glms_mat4_mulN(mat4s * __restrict matrices[], uint32_t len);
+   CGLM_INLINE vec4s   glms_mat4_mulv(mat4s m, vec4s v);
+   CGLM_INLINE float   glms_mat4_trace(mat4s m);
+   CGLM_INLINE float   glms_mat4_trace3(mat4s m);
+   CGLM_INLINE versors glms_mat4_quat(mat4s m);
+   CGLM_INLINE vec3s   glms_mat4_mulv3(mat4s m, vec3s v, float last);
+   CGLM_INLINE mat4s   glms_mat4_transpose(mat4s m);
+   CGLM_INLINE mat4s   glms_mat4_scale_p(mat4s m, float s);
+   CGLM_INLINE mat4s   glms_mat4_scale(mat4s m, float s);
+   CGLM_INLINE float   glms_mat4_det(mat4s mat);
+   CGLM_INLINE mat4s   glms_mat4_inv(mat4s mat);
+   CGLM_INLINE mat4s   glms_mat4_inv_fast(mat4s mat);
+   CGLM_INLINE mat4s   glms_mat4_swap_col(mat4s mat, int col1, int col2);
+   CGLM_INLINE mat4s   glms_mat4_swap_row(mat4s mat, int row1, int row2);
+   CGLM_INLINE float   glms_mat4_rmc(vec4s r, mat4s m, vec4s c);
+ */
+
+#ifndef cglms_mat4s_h
+#define cglms_mat4s_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../mat4.h"
+#include "vec4.h"
+#include "vec3.h"
+
+#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)
+#define GLMS_MAT4_ZERO     ((mat4s)GLMS_MAT4_ZERO_INIT)
+
+/*!
+ * @brief copy all members of [mat] to [dest]
+ *
+ * matrix may not be aligned, u stands for unaligned, this may be useful when
+ * copying a matrix from external source e.g. asset importer...
+ *
+ * @param[in]  mat  source
+ * @returns         destination
+ */
+CGLM_INLINE
+mat4s
+glms_mat4_ucopy(mat4s mat) {
+  mat4s r;
+  glm_mat4_ucopy(mat.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief copy all members of [mat] to [dest]
+ *
+ * @param[in]  mat  source
+ * @returns         destination
+ */
+CGLM_INLINE
+mat4s
+glms_mat4_copy(mat4s mat) {
+  mat4s r;
+  glm_mat4_copy(mat.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief make given matrix identity. It is identical with below, 
+ *        but it is more easy to do that with this func especially for members
+ *        e.g. glm_mat4_identity(aStruct->aMatrix);
+ *
+ * @code
+ * glm_mat4_copy(GLM_MAT4_IDENTITY, mat); // C only
+ *
+ * // or
+ * mat4 mat = GLM_MAT4_IDENTITY_INIT;
+ * @endcode
+ *
+ * @retuns  destination
+ */
+CGLM_INLINE
+mat4s
+glms_mat4_identity(void) {
+  mat4s r;
+  glm_mat4_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/32)
+ *                        if alignment is not disabled)
+ *
+ * @param[in]       count count of matrices
+ */
+CGLM_INLINE
+void
+glms_mat4_identity_array(mat4s * __restrict mat, size_t count) {
+  CGLM_ALIGN_MAT mat4s t = GLMS_MAT4_IDENTITY_INIT;
+  size_t i;
+
+  for (i = 0; i < count; i++) {
+    glm_mat4_copy(t.raw, mat[i].raw);
+  }
+}
+
+/*!
+ * @brief make given matrix zero.
+ *
+ * @returns  matrix
+ */
+CGLM_INLINE
+mat4s
+glms_mat4_zero(void) {
+  mat4s r;
+  glm_mat4_zero(r.raw);
+  return r;
+}
+
+/*!
+ * @brief copy upper-left of mat4 to mat3
+ *
+ * @param[in]  mat  source
+ * @returns         destination
+ */
+CGLM_INLINE
+mat3s
+glms_mat4_pick3(mat4s mat) {
+  mat3s r;
+  glm_mat4_pick3(mat.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief copy upper-left of mat4 to mat3 (transposed)
+ *
+ * the postfix t stands for transpose
+ *
+ * @param[in]  mat  source
+ * @returns         destination
+ */
+CGLM_INLINE
+mat3s
+glms_mat4_pick3t(mat4s mat) {
+  mat3s r;
+  glm_mat4_pick3t(mat.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief copy mat3 to mat4's upper-left
+ *
+ * @param[in]  mat  source
+ * @returns         destination
+ */
+CGLM_INLINE
+mat4s
+glms_mat4_ins3(mat3s mat) {
+  mat4s r;
+  glm_mat4_ins3(mat.raw, 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
+ * mat4 m = GLM_MAT4_IDENTITY_INIT;
+ * glm_mat4_mul(m, m, m);
+ * @endcode
+ *
+ * @param[in]  m1   left matrix
+ * @param[in]  m2   right matrix
+ * @returns         destination matrix
+ */
+CGLM_INLINE
+mat4s
+glms_mat4_mul(mat4s m1, mat4s m2) {
+  mat4s r;
+  glm_mat4_mul(m1.raw, m2.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief mupliply N mat4 matrices and store result in dest
+ *
+ * this function lets you multiply multiple (more than two or more...) matrices
+ * <br><br>multiplication will be done in loop, this may reduce instructions
+ * size but if <b>len</b> is too small then compiler may unroll whole loop,
+ * usage:
+ * @code
+ * mat m1, m2, m3, m4, res;
+ *
+ * res = glm_mat4_mulN((mat4 *[]){&m1, &m2, &m3, &m4}, 4);
+ * @endcode
+ *
+ * @warning matrices parameter is pointer array not mat4 array!
+ *
+ * @param[in]  matrices mat4 * array
+ * @param[in]  len      matrices count
+ * @returns             result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_mat4_mulN(mat4s * __restrict matrices[], uint32_t len) {
+  CGLM_ALIGN_MAT mat4s r = GLMS_MAT4_IDENTITY_INIT;
+  size_t i;
+
+  for (i = 0; i < len; i++) {
+    r = glms_mat4_mul(r, *matrices[i]);
+  }
+  
+  return r;
+}
+
+/*!
+ * @brief multiply mat4 with vec4 (column vector) and store in dest vector
+ *
+ * @param[in]  m    mat4 (left)
+ * @param[in]  v    vec4 (right, column vector)
+ * @returns         vec4 (result, column vector)
+ */
+CGLM_INLINE
+vec4s
+glms_mat4_mulv(mat4s m, vec4s v) {
+  vec4s r;
+  glm_mat4_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_mat4_trace(mat4s m) {
+  return glm_mat4_trace(m.raw);
+}
+
+/*!
+ * @brief trace of matrix (rotation part)
+ *
+ * sum of the elements on the main diagonal from upper left to the lower right
+ *
+ * @param[in]  m matrix
+ */
+CGLM_INLINE
+float
+glms_mat4_trace3(mat4s m) {
+  return glm_mat4_trace3(m.raw);
+}
+
+/*!
+ * @brief convert mat4's rotation part to quaternion
+ *
+ * @param[in]  m    affine matrix
+ * @returns         destination quaternion
+ */
+CGLM_INLINE
+versors
+glms_mat4_quat(mat4s m) {
+  versors r;
+  glm_mat4_quat(m.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply vector with mat4
+ *
+ * @param[in]  m    mat4(affine transform)
+ * @param[in]  v    vec3
+ * @param[in]  last 4th item to make it vec4
+ * @returns         result vector (vec3)
+ */
+CGLM_INLINE
+vec3s
+glms_mat4_mulv3(mat4s m, vec3s v, float last) {
+  vec3s r;
+  glm_mat4_mulv3(m.raw, v.raw, last, r.raw);
+  return r;
+}
+
+/*!
+ * @brief tranpose mat4 and store result in same matrix
+ *
+ * @param[in] m source
+ * @returns     result
+ */
+CGLM_INLINE
+mat4s
+glms_mat4_transpose(mat4s m) {
+  glm_mat4_transpose(m.raw);
+  return m;
+}
+
+/*!
+ * @brief scale (multiply with scalar) matrix without simd optimization
+ *
+ * multiply matrix with scalar
+ *
+ * @param[in] m matrix
+ * @param[in] s scalar
+ * @returns     matrix    
+ */
+CGLM_INLINE
+mat4s
+glms_mat4_scale_p(mat4s m, float s) {
+  glm_mat4_scale_p(m.raw, s);
+  return m;
+}
+
+/*!
+ * @brief scale (multiply with scalar) matrix
+ *
+ * multiply matrix with scalar
+ *
+ * @param[in] m matrix
+ * @param[in] s scalar
+ * @returns     matrix
+ */
+CGLM_INLINE
+mat4s
+glms_mat4_scale(mat4s m, float s) {
+  glm_mat4_scale(m.raw, s);
+  return m;
+}
+
+/*!
+ * @brief mat4 determinant
+ *
+ * @param[in] mat matrix
+ *
+ * @return determinant
+ */
+CGLM_INLINE
+float
+glms_mat4_det(mat4s mat) {
+  return glm_mat4_det(mat.raw);
+}
+
+/*!
+ * @brief inverse mat4 and store in dest
+ *
+ * @param[in]  mat  matrix
+ * @returns         inverse matrix
+ */
+CGLM_INLINE
+mat4s
+glms_mat4_inv(mat4s mat) {
+  mat4s r;
+  glm_mat4_inv(mat.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief inverse mat4 and store in dest
+ *
+ * this func uses reciprocal approximation without extra corrections
+ * e.g Newton-Raphson. this should work faster than normal,
+ * to get more precise use glm_mat4_inv version.
+ *
+ * NOTE: You will lose precision, glm_mat4_inv is more accurate
+ *
+ * @param[in]  mat  matrix
+ * @returns         inverse matrix
+ */
+CGLM_INLINE
+mat4s
+glms_mat4_inv_fast(mat4s mat) {
+  mat4s r;
+  glm_mat4_inv_fast(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
+mat4s
+glms_mat4_swap_col(mat4s mat, int col1, int col2) {
+  glm_mat4_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
+mat4s
+glms_mat4_swap_row(mat4s mat, int row1, int row2) {
+  glm_mat4_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 = Matrix1x4 (row vector),
+ * then Matrix1x4 * Vec4 (column vector) = Matrix1x1 (Scalar)
+ *
+ * @param[in]  r   row vector or matrix1x4
+ * @param[in]  m   matrix4x4
+ * @param[in]  c   column vector or matrix4x1
+ *
+ * @return scalar value e.g. B(s)
+ */
+CGLM_INLINE
+float
+glms_mat4_rmc(vec4s r, mat4s m, vec4s c) {
+  return glm_mat4_rmc(r.raw, m.raw, c.raw);
+}
+
+#endif /* cglms_mat4s_h */

include/cglm/struct/plane.h

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglms_planes_h
+#define cglms_planes_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../plane.h"
+#include "vec4.h"
+
+/*
+ Plane equation:  Ax + By + Cz + D = 0;
+
+ It stored in vec4 as [A, B, C, D]. (A, B, C) is normal and D is distance
+*/
+
+/*
+ Functions:
+   CGLM_INLINE vec4s glms_plane_normalize(vec4s plane);
+ */
+
+/*!
+ * @brief normalizes a plane
+ *
+ * @param[in] plane plane to normalize
+ * @returns         normalized plane
+ */
+CGLM_INLINE
+vec4s
+glms_plane_normalize(vec4s plane) {
+  glm_plane_normalize(plane.raw);
+  return plane;
+}
+
+#endif /* cglms_planes_h */

include/cglm/struct/project.h

@@ -0,0 +1,104 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglms_projects_h
+#define cglms_projects_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../project.h"
+#include "vec3.h"
+#include "vec4.h"
+#include "mat4.h"
+
+/*!
+ * @brief maps the specified viewport coordinates into specified space [1]
+ *        the matrix should contain projection matrix.
+ *
+ * if you don't have ( and don't want to have ) an inverse matrix then use
+ * glm_unproject version. You may use existing inverse of matrix in somewhere
+ * else, this is why glm_unprojecti exists to save save inversion cost
+ *
+ * [1] space:
+ *  1- if m = invProj:     View Space
+ *  2- if m = invViewProj: World Space
+ *  3- if m = invMVP:      Object Space
+ *
+ * You probably want to map the coordinates into object space
+ * so use invMVP as m
+ *
+ * Computing viewProj:
+ *   glm_mat4_mul(proj, view, viewProj);
+ *   glm_mat4_mul(viewProj, model, MVP);
+ *   glm_mat4_inv(viewProj, invMVP);
+ *
+ * @param[in]  pos      point/position in viewport coordinates
+ * @param[in]  invMat   matrix (see brief)
+ * @param[in]  vp       viewport as [x, y, width, height]
+ * @returns             unprojected coordinates
+ */
+CGLM_INLINE
+vec3s
+glms_unprojecti(vec3s pos, mat4s invMat, vec4s vp) {
+  vec3s r;
+  glm_unprojecti(pos.raw, invMat.raw, vp.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief maps the specified viewport coordinates into specified space [1]
+ *        the matrix should contain projection matrix.
+ *
+ * this is same as glm_unprojecti except this function get inverse matrix for
+ * you.
+ *
+ * [1] space:
+ *  1- if m = proj:     View Space
+ *  2- if m = viewProj: World Space
+ *  3- if m = MVP:      Object Space
+ *
+ * You probably want to map the coordinates into object space
+ * so use MVP as m
+ *
+ * Computing viewProj and MVP:
+ *   glm_mat4_mul(proj, view, viewProj);
+ *   glm_mat4_mul(viewProj, model, MVP);
+ *
+ * @param[in]  pos      point/position in viewport coordinates
+ * @param[in]  m        matrix (see brief)
+ * @param[in]  vp       viewport as [x, y, width, height]
+ * @returns             unprojected coordinates
+ */
+CGLM_INLINE
+vec3s
+glms_unproject(vec3s pos, mat4s m, vec4s vp) {
+  vec3s r;
+  glm_unproject(pos.raw, m.raw, vp.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief map object coordinates to window coordinates
+ *
+ * Computing MVP:
+ *   glm_mat4_mul(proj, view, viewProj);
+ *   glm_mat4_mul(viewProj, model, MVP);
+ *
+ * @param[in]  pos      object coordinates
+ * @param[in]  m        MVP matrix
+ * @param[in]  vp       viewport as [x, y, width, height]
+ * @returns projected coordinates
+ */
+CGLM_INLINE
+vec3s
+glms_project(vec3s pos, mat4s m, vec4s vp) {
+  vec3s r;
+  glm_project(pos.raw, m.raw, vp.raw, r.raw);
+  return r;
+}
+
+#endif /* cglms_projects_h */

include/cglm/struct/quat.h

@@ -0,0 +1,532 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   GLMS_QUAT_IDENTITY_INIT
+   GLMS_QUAT_IDENTITY
+
+ Functions:
+   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)
+   CGLM_INLINE versors glms_quat(float angle, float x, float y, float z)
+   CGLM_INLINE float   glms_quat_norm(versors q)
+   CGLM_INLINE versors glms_quat_normalize(versors q)
+   CGLM_INLINE float   glms_quat_dot(versors p, versors q)
+   CGLM_INLINE versors glms_quat_conjugate(versors q)
+   CGLM_INLINE versors glms_quat_inv(versors q)
+   CGLM_INLINE versors glms_quat_add(versors p, versors q)
+   CGLM_INLINE versors glms_quat_sub(versors p, versors q)
+   CGLM_INLINE vec3s   glms_quat_imagn(versors q)
+   CGLM_INLINE float   glms_quat_imaglen(versors q)
+   CGLM_INLINE float   glms_quat_angle(versors q)
+   CGLM_INLINE vec3s   glms_quat_axis(versors q)
+   CGLM_INLINE versors glms_quat_mul(versors p, versors q)
+   CGLM_INLINE mat4s   glms_quat_mat4(versors q)
+   CGLM_INLINE mat4s   glms_quat_mat4t(versors q)
+   CGLM_INLINE mat3s   glms_quat_mat3(versors q)
+   CGLM_INLINE mat3s   glms_quat_mat3t(versors q)
+   CGLM_INLINE versors glms_quat_lerp(versors from, versors to, float t)
+   CGLM_INLINE versors glms_quat_lerpc(versors from, versors to, float t)
+   CGLM_INLINE versors glms_quat_slerp(versors from, versors to, float t)
+   CGLM_INLINE mat4s.  glms_quat_look(vec3s eye, versors ori)
+   CGLM_INLINE versors glms_quat_for(vec3s dir, vec3s fwd, vec3s up)
+   CGLM_INLINE versors glms_quat_forp(vec3s from, vec3s to, vec3s fwd, vec3s up)
+   CGLM_INLINE vec3s   glms_quat_rotatev(versors q, vec3s v)
+   CGLM_INLINE mat4s   glms_quat_rotate(mat4s m, versors q)
+   CGLM_INLINE mat4s   glms_quat_rotate_at(mat4s m, versors q, vec3s pivot)
+   CGLM_INLINE mat4s   glms_quat_rotate_atm(versors q, vec3s pivot)
+ */
+
+#ifndef cglms_quat_h
+#define cglms_quat_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../plane.h"
+#include "../quat.h"
+
+/*
+ * IMPORTANT:
+ * ----------------------------------------------------------------------------
+ * cglm stores quat as [x, y, z, w] since v0.3.6
+ *
+ * it was [w, x, y, z] before v0.3.6 it has been changed to [x, y, z, w]
+ * with v0.3.6 version.
+ * ----------------------------------------------------------------------------
+ */
+
+#define GLMS_QUAT_IDENTITY_INIT  {GLM_QUAT_IDENTITY_INIT}
+#define GLMS_QUAT_IDENTITY       ((versors)GLMS_QUAT_IDENTITY_INIT)
+
+/*!
+ * @brief makes given quat to identity
+ *
+ * @returns identity quaternion
+ */
+CGLM_INLINE
+versors
+glms_quat_identity(void) {
+  versors dest;
+  glm_quat_identity(dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief make given quaternion array's each element identity quaternion
+ *
+ * @param[in, out]  q     quat array (must be aligned (16)
+ *                        if alignment is not disabled)
+ *
+ * @param[in]       count count of quaternions
+ */
+CGLM_INLINE
+void
+glms_quat_identity_array(versors * __restrict q, size_t count) {
+  CGLM_ALIGN(16) versor v = GLM_QUAT_IDENTITY_INIT;
+  size_t i;
+
+  for (i = 0; i < count; i++) {
+    glm_vec4_copy(v, q[i].raw);
+  }
+}
+
+/*!
+ * @brief inits quaterion with raw values
+ *
+ * @param[in]   x     x
+ * @param[in]   y     y
+ * @param[in]   z     z
+ * @param[in]   w     w (real part)
+ * @returns quaternion
+ */
+CGLM_INLINE
+versors
+glms_quat_init(float x, float y, float z, float w) {
+  versors dest;
+  glm_quat_init(dest.raw, x, y, z, w);
+  return dest;
+}
+
+/*!
+ * @brief creates NEW quaternion with axis vector
+ *
+ * @param[in]   angle angle (radians)
+ * @param[in]   axis  axis
+ * @returns quaternion
+ */
+CGLM_INLINE
+versors
+glms_quatv(float angle, vec3s axis) {
+  versors dest;
+  glm_quatv(dest.raw, angle, axis.raw);
+  return dest;
+}
+
+/*!
+ * @brief creates NEW quaternion with individual axis components
+ *
+ * @param[in]   angle angle (radians)
+ * @param[in]   x     axis.x
+ * @param[in]   y     axis.y
+ * @param[in]   z     axis.z
+ * @returns quaternion
+ */
+CGLM_INLINE
+versors
+glms_quat(float angle, float x, float y, float z) {
+  versors dest;
+  glm_quat(dest.raw, angle, x, y, z);
+  return dest;
+}
+
+/*!
+ * @brief returns norm (magnitude) of quaternion
+ *
+ * @param[out]  q  quaternion
+ */
+CGLM_INLINE
+float
+glms_quat_norm(versors q) {
+  return glm_quat_norm(q.raw);
+}
+
+/*!
+ * @brief normalize quaternion
+ *
+ * @param[in]  q  quaternion
+ * @returns    quaternion
+ */
+CGLM_INLINE
+versors
+glms_quat_normalize(versors q) {
+  versors dest;
+  glm_quat_normalize_to(q.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief dot product of two quaternion
+ *
+ * @param[in]  p  quaternion 1
+ * @param[in]  q  quaternion 2
+ * @returns    dot product
+ */
+CGLM_INLINE
+float
+glms_quat_dot(versors p, versors q) {
+  return glm_quat_dot(p.raw, q.raw);
+}
+
+/*!
+ * @brief conjugate of quaternion
+ *
+ * @param[in]   q     quaternion
+ * @returns    conjugate
+ */
+CGLM_INLINE
+versors
+glms_quat_conjugate(versors q) {
+  versors dest;
+  glm_quat_conjugate(q.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief inverse of non-zero quaternion
+ *
+ * @param[in]  q    quaternion
+ * @returns    inverse quaternion
+ */
+CGLM_INLINE
+versors
+glms_quat_inv(versors q) {
+  versors dest;
+  glm_quat_inv(q.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief add (componentwise) two quaternions and store result in dest
+ *
+ * @param[in]   p    quaternion 1
+ * @param[in]   q    quaternion 2
+ * @returns result quaternion
+ */
+CGLM_INLINE
+versors
+glms_quat_add(versors p, versors q) {
+  versors dest;
+  glm_quat_add(p.raw, q.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief subtract (componentwise) two quaternions and store result in dest
+ *
+ * @param[in]   p    quaternion 1
+ * @param[in]   q    quaternion 2
+ * @returns result quaternion
+ */
+CGLM_INLINE
+versors
+glms_quat_sub(versors p, versors q) {
+  versors dest;
+  glm_quat_sub(p.raw, q.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief returns normalized imaginary part of quaternion
+ *
+ * @param[in]   q    quaternion
+ */
+CGLM_INLINE
+vec3s
+glms_quat_imagn(versors q) {
+  vec3s dest;
+  glm_normalize_to(q.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief returns length of imaginary part of quaternion
+ *
+ * @param[in]   q    quaternion
+ */
+CGLM_INLINE
+float
+glms_quat_imaglen(versors q) {
+  return glm_quat_imaglen(q.raw);
+}
+
+/*!
+ * @brief returns angle of quaternion
+ *
+ * @param[in]   q    quaternion
+ */
+CGLM_INLINE
+float
+glms_quat_angle(versors q) {
+  return glm_quat_angle(q.raw);
+}
+
+/*!
+ * @brief axis of quaternion
+ *
+ * @param[in]   q    quaternion
+ * @returns axis of quaternion
+ */
+CGLM_INLINE
+vec3s
+glms_quat_axis(versors q) {
+  vec3s dest;
+  glm_quat_axis(q.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief multiplies two quaternion and stores result in dest
+ *        this is also called Hamilton Product
+ *
+ * According to WikiPedia:
+ * The product of two rotation quaternions [clarification needed] will be
+ * equivalent to the rotation q followed by the rotation p
+ *
+ * @param[in]   p     quaternion 1
+ * @param[in]   q     quaternion 2
+ * @returns  result quaternion
+ */
+CGLM_INLINE
+versors
+glms_quat_mul(versors p, versors q) {
+  versors dest;
+  glm_quat_mul(p.raw, q.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief convert quaternion to mat4
+ *
+ * @param[in]   q     quaternion
+ * @returns  result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_quat_mat4(versors q) {
+  mat4s dest;
+  glm_quat_mat4(q.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief convert quaternion to mat4 (transposed)
+ *
+ * @param[in]   q     quaternion
+ * @returns  result matrix as transposed
+ */
+CGLM_INLINE
+mat4s
+glms_quat_mat4t(versors q) {
+  mat4s dest;
+  glm_quat_mat4t(q.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief convert quaternion to mat3
+ *
+ * @param[in]   q     quaternion
+ * @returns  result matrix
+ */
+CGLM_INLINE
+mat3s
+glms_quat_mat3(versors q) {
+  mat3s dest;
+  glm_quat_mat3(q.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief convert quaternion to mat3 (transposed)
+ *
+ * @param[in]   q     quaternion
+ * @returns  result matrix
+ */
+CGLM_INLINE
+mat3s
+glms_quat_mat3t(versors q) {
+  mat3s dest;
+  glm_quat_mat3t(q.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief interpolates between two quaternions
+ *        using linear interpolation (LERP)
+ *
+ * @param[in]   from  from
+ * @param[in]   to    to
+ * @param[in]   t     interpolant (amount)
+ * @returns  result quaternion
+ */
+CGLM_INLINE
+versors
+glms_quat_lerp(versors from, versors to, float t) {
+  versors dest;
+  glm_quat_lerp(from.raw, to.raw, t, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief interpolates between two quaternions
+ *        using linear interpolation (LERP)
+ *
+ * @param[in]   from  from
+ * @param[in]   to    to
+ * @param[in]   t     interpolant (amount) clamped between 0 and 1
+ * @returns  result quaternion
+ */
+CGLM_INLINE
+versors
+glms_quat_lerpc(versors from, versors to, float t) {
+  versors dest;
+  glm_quat_lerpc(from.raw, to.raw, t, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief interpolates between two quaternions
+ *        using spherical linear interpolation (SLERP)
+ *
+ * @param[in]   from  from
+ * @param[in]   to    to
+ * @param[in]   t     amout
+ * @returns result quaternion
+ */
+CGLM_INLINE
+versors
+glms_quat_slerp(versors from, versors to, float t) {
+  versors dest;
+  glm_quat_slerp(from.raw, to.raw, t, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief creates view matrix using quaternion as camera orientation
+ *
+ * @param[in]   eye   eye
+ * @param[in]   ori   orientation in world space as quaternion
+ * @returns  view matrix
+ */
+CGLM_INLINE
+mat4s
+glms_quat_look(vec3s eye, versors ori) {
+  mat4s dest;
+  glm_quat_look(eye.raw, ori.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @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) {
+  versors dest;
+  glm_quat_for(dir.raw, fwd.raw, up.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief creates look rotation quaternion using source and
+ *        destination positions p suffix stands for position
+ *
+ * @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) {
+  versors dest;
+  glm_quat_forp(from.raw, to.raw, fwd.raw, up.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief rotate vector using using quaternion
+ *
+ * @param[in]   q     quaternion
+ * @param[in]   v     vector to rotate
+ * @returns  rotated vector
+ */
+CGLM_INLINE
+vec3s
+glms_quat_rotatev(versors q, vec3s v) {
+  vec3s dest;
+  glm_quat_rotatev(q.raw, v.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief rotate existing transform matrix using quaternion
+ *
+ * @param[in]   m     existing transform matrix
+ * @param[in]   q     quaternion
+ * @returns  rotated matrix/transform
+ */
+CGLM_INLINE
+mat4s
+glms_quat_rotate(mat4s m, versors q) {
+  glm_quat_rotate(m.raw, q.raw, m.raw);
+  return m;
+}
+
+/*!
+ * @brief rotate existing transform matrix using quaternion at pivot point
+ *
+ * @param[in, out]   m     existing transform matrix
+ * @param[in]        q     quaternion
+ * @returns pivot
+ */
+CGLM_INLINE
+mat4s
+glms_quat_rotate_at(mat4s m, versors q, vec3s pivot) {
+  glm_quat_rotate_at(m.raw, q.raw, pivot.raw);
+  return m;
+}
+
+/*!
+ * @brief rotate NEW transform matrix using quaternion at pivot point
+ *
+ * this creates rotation matrix, it assumes you don't have a matrix
+ *
+ * this should work faster than glm_quat_rotate_at because it reduces
+ * one glm_translate.
+ *
+ * @param[in]   q     quaternion
+ * @returns pivot
+ */
+CGLM_INLINE
+mat4s
+glms_quat_rotate_atm(versors q, vec3s pivot) {
+  mat4s dest;
+  glm_quat_rotate_atm(dest.raw, q.raw, pivot.raw);
+  return dest;
+}
+
+#endif /* cglms_quat_h */

include/cglm/struct/sphere.h

@@ -0,0 +1,93 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglms_spheres_h
+#define cglms_spheres_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../sphere.h"
+#include "mat4.h"
+
+/*
+  Sphere Representation in cglm: [center.x, center.y, center.z, radii]
+
+  You could use this representation or you can convert it to vec4 before call
+  any function
+ */
+
+/*!
+ * @brief helper for getting sphere radius
+ *
+ * @param[in]   s  sphere
+ *
+ * @return returns radii
+ */
+CGLM_INLINE
+float
+glms_sphere_radii(vec4s s) {
+  return glm_sphere_radii(s.raw);
+}
+
+/*!
+ * @brief apply transform to sphere, it is just wrapper for glm_mat4_mulv3
+ *
+ * @param[in]  s    sphere
+ * @param[in]  m    transform matrix
+ * @returns         transformed sphere
+ */
+CGLM_INLINE
+vec4s
+glms_sphere_transform(vec4s s, mat4 m) {
+  vec4s r;
+  glm_sphere_transform(s.raw, m, r.raw);
+  return r;
+}
+
+/*!
+ * @brief merges two spheres and creates a new one
+ *
+ * two sphere must be in same space, for instance if one in world space then
+ * the other must be in world space too, not in local space.
+ *
+ * @param[in]  s1   sphere 1
+ * @param[in]  s2   sphere 2
+ * returns          merged/extended sphere
+ */
+CGLM_INLINE
+vec4s
+glms_sphere_merge(vec4s s1, vec4s s2) {
+  vec4s r;
+  glm_sphere_merge(s1.raw, s2.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief check if two sphere intersects
+ *
+ * @param[in]   s1  sphere
+ * @param[in]   s2  other sphere
+ */
+CGLM_INLINE
+bool
+glms_sphere_sphere(vec4s s1, vec4s s2) {
+  return glm_sphere_sphere(s1.raw, s2.raw);
+}
+
+/*!
+ * @brief check if sphere intersects with point
+ *
+ * @param[in]   s      sphere
+ * @param[in]   point  point
+ */
+CGLM_INLINE
+bool
+glms_sphere_point(vec4s s, vec3s point) {
+  return glm_sphere_point(s.raw, point.raw);
+}
+
+#endif /* cglms_spheres_h */

include/cglm/struct/vec3-ext.h

@@ -0,0 +1,257 @@
+/*
+ * 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 vec3s glms_vec3_broadcast(float val);
+   CGLM_INLINE vec3s glms_vec3_fill(float val);
+   CGLM_INLINE bool  glms_vec3_eq(vec3s v, float val);
+   CGLM_INLINE bool  glms_vec3_eq_eps(vec3s v, float val);
+   CGLM_INLINE bool  glms_vec3_eq_all(vec3s v);
+   CGLM_INLINE bool  glms_vec3_eqv(vec3s a, vec3s b);
+   CGLM_INLINE bool  glms_vec3_eqv_eps(vec3s a, vec3s b);
+   CGLM_INLINE float glms_vec3_max(vec3s v);
+   CGLM_INLINE float glms_vec3_min(vec3s v);
+   CGLM_INLINE bool  glms_vec3_isnan(vec3s v);
+   CGLM_INLINE bool  glms_vec3_isinf(vec3s v);
+   CGLM_INLINE bool  glms_vec3_isvalid(vec3s v);
+   CGLM_INLINE vec3s glms_vec3_sign(vec3s v);
+   CGLM_INLINE vec3s glms_vec3_abs(vec3s v);
+   CGLM_INLINE vec3s glms_vec3_fract(vec3s v);
+   CGLM_INLINE float glms_vec3_hadd(vec3s v);
+   CGLM_INLINE vec3s glms_vec3_sqrt(vec3s v);
+ */
+
+#ifndef cglms_vec3s_ext_h
+#define cglms_vec3s_ext_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../util.h"
+#include "../vec3-ext.h"
+
+/*!
+ * @brief fill a vector with specified value
+ *
+ * @param[in]  val  value
+ * @returns         dest
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_broadcast(float val) {
+  vec3s r;
+  glm_vec3_broadcast(val, r.raw);
+  return r;
+}
+
+/*!
+ * @brief fill a vector with specified value
+ *
+ * @param[in]  val  value
+ * @returns         dest
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_fill(float val) {
+  vec3s r;
+  glm_vec3_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_vec3_eq(vec3s v, float val) {
+  return glm_vec3_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_vec3_eq_eps(vec3s v, float val) {
+  return glm_vec3_eq_eps(v.raw, val);
+}
+
+/*!
+ * @brief check if vectors members are equal (without epsilon)
+ *
+ * @param[in] v   vector
+ */
+CGLM_INLINE
+bool
+glms_vec3_eq_all(vec3s v) {
+  return glm_vec3_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_vec3_eqv(vec3s a, vec3s b) {
+  return glm_vec3_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_vec3_eqv_eps(vec3s a, vec3s b) {
+  return glm_vec3_eqv_eps(a.raw, b.raw);
+}
+
+/*!
+ * @brief max value of vector
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+float
+glms_vec3_max(vec3s v) {
+  return glm_vec3_max(v.raw);
+}
+
+/*!
+ * @brief min value of vector
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+float
+glms_vec3_min(vec3s v) {
+  return glm_vec3_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_vec3_isnan(vec3s v) {
+  return glm_vec3_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_vec3_isinf(vec3s v) {
+  return glm_vec3_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_vec3_isvalid(vec3s v) {
+  return glm_vec3_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
+vec3s
+glms_vec3_sign(vec3s v) {
+  vec3s r;
+  glm_vec3_sign(v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief absolute value of each vector item
+ *
+ * @param[in]  v    vector
+ * @return          destination vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_abs(vec3s v) {
+  vec3s r;
+  glm_vec3_abs(v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief fractional part of each vector item
+ *
+ * @param[in]  v    vector
+ * @return          dest destination vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_fract(vec3s v) {
+  vec3s r;
+  glm_vec3_fract(v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief vector reduction by summation
+ * @warning could overflow
+ *
+ * @param[in]  v    vector
+ * @return     sum of all vector's elements
+ */
+CGLM_INLINE
+float
+glms_vec3_hadd(vec3s v) {
+  return glm_vec3_hadd(v.raw);
+}
+
+/*!
+ * @brief square root of each vector item
+ *
+ * @param[in]  v    vector
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_sqrt(vec3s v) {
+  vec3s r;
+  glm_vec3_sqrt(v.raw, r.raw);
+  return r;
+}
+
+#endif /* cglms_vec3s_ext_h */

include/cglm/struct/vec3.h

@@ -0,0 +1,970 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   GLMS_VEC3_ONE_INIT
+   GLMS_VEC3_ZERO_INIT
+   GLMS_VEC3_ONE
+   GLMS_VEC3_ZERO
+   GLMS_YUP
+   GLMS_ZUP
+   GLMS_XUP
+
+ Functions:
+   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(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);
+   CGLM_INLINE float glms_vec3_norm_one(vec3s v);
+   CGLM_INLINE float glms_vec3_norm_inf(vec3s v);
+   CGLM_INLINE vec3s glms_vec3_add(vec3s a, vec3s b);
+   CGLM_INLINE vec3s glms_vec3_adds(vec3s a, float s);
+   CGLM_INLINE vec3s glms_vec3_sub(vec3s a, vec3s b);
+   CGLM_INLINE vec3s glms_vec3_subs(vec3s a, float s);
+   CGLM_INLINE vec3s glms_vec3_mul(vec3s a, vec3s b);
+   CGLM_INLINE vec3s glms_vec3_scale(vec3s v, float s);
+   CGLM_INLINE vec3s glms_vec3_scale_as(vec3s v, float s);
+   CGLM_INLINE vec3s glms_vec3_div(vec3s a, vec3s b);
+   CGLM_INLINE vec3s glms_vec3_divs(vec3s a, float s);
+   CGLM_INLINE vec3s glms_vec3_addadd(vec3s a, vec3s b, vec3s dest);
+   CGLM_INLINE vec3s glms_vec3_subadd(vec3s a, vec3s b, vec3s dest);
+   CGLM_INLINE vec3s glms_vec3_muladd(vec3s a, vec3s b, vec3s dest);
+   CGLM_INLINE vec3s glms_vec3_muladds(vec3s a, float s, vec3s dest);
+   CGLM_INLINE vec3s glms_vec3_maxadd(vec3s a, vec3s b, vec3s dest);
+   CGLM_INLINE vec3s glms_vec3_minadd(vec3s a, vec3s b, vec3s dest);
+   CGLM_INLINE vec3s glms_vec3_flipsign(vec3s v);
+   CGLM_INLINE vec3s glms_vec3_negate(vec3s v);
+   CGLM_INLINE vec3s glms_vec3_inv(vec3s v);
+   CGLM_INLINE vec3s glms_vec3_normalize(vec3s v);
+   CGLM_INLINE vec3s glms_vec3_cross(vec3s a, vec3s b);
+   CGLM_INLINE vec3s glms_vec3_crossn(vec3s a, vec3s b);
+   CGLM_INLINE float glms_vec3_angle(vec3s a, vec3s b);
+   CGLM_INLINE vec3s glms_vec3_rotate(vec3s v, float angle, vec3s axis);
+   CGLM_INLINE vec3s glms_vec3_rotate_m4(mat4s m, vec3s v);
+   CGLM_INLINE vec3s glms_vec3_rotate_m3(mat3s m, vec3s v);
+   CGLM_INLINE vec3s glms_vec3_proj(vec3s a, vec3s b);
+   CGLM_INLINE vec3s glms_vec3_center(vec3s a, vec3s b);
+   CGLM_INLINE float glms_vec3_distance(vec3s a, vec3s b);
+   CGLM_INLINE float glms_vec3_distance2(vec3s a, vec3s b);
+   CGLM_INLINE vec3s glms_vec3_maxv(vec3s a, vec3s b);
+   CGLM_INLINE vec3s glms_vec3_minv(vec3s a, vec3s b);
+   CGLM_INLINE vec3s glms_vec3_ortho(vec3s v);
+   CGLM_INLINE vec3s glms_vec3_clamp(vec3s v, float minVal, float maxVal);
+   CGLM_INLINE vec3s glms_vec3_lerp(vec3s from, vec3s to, float t);
+   CGLM_INLINE vec3s glms_vec3_lerpc(vec3s from, vec3s to, float t);
+   CGLM_INLINE vec3s glms_vec3_mix(vec3s from, vec3s to, float t);
+   CGLM_INLINE vec3s glms_vec3_mixc(vec3s from, vec3s to, float t);
+   CGLM_INLINE vec3s glms_vec3_step_uni(float edge, vec3s x);
+   CGLM_INLINE vec3s glms_vec3_step(vec3s edge, vec3s x);
+   CGLM_INLINE vec3s glms_vec3_smoothstep_uni(float edge0, float edge1, vec3s x);
+   CGLM_INLINE vec3s glms_vec3_smoothstep(vec3s edge0, vec3s edge1, vec3s x);
+   CGLM_INLINE vec3s glms_vec3_smoothinterp(vec3s from, vec3s to, float t);
+   CGLM_INLINE vec3s glms_vec3_smoothinterpc(vec3s from, vec3s to, float t);
+   CGLM_INLINE vec3s glms_vec3_swizzle(vec3s v, int mask);
+
+ Convenient:
+   CGLM_INLINE vec3s glms_cross(vec3s a, vec3s b);
+   CGLM_INLINE float glms_dot(vec3s a, vec3s b);
+   CGLM_INLINE vec3s glms_normalize(vec3s v);
+ */
+
+#ifndef cglms_vec3s_h
+#define cglms_vec3s_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../util.h"
+#include "../vec3.h"
+#include "vec3-ext.h"
+
+#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}})
+
+/*!
+ * @brief init vec3 using vec4
+ *
+ * @param[in]  v4   vector4
+ * @returns         destination
+ */
+CGLM_INLINE
+vec3s
+glms_vec3(vec4s v4) {
+  vec3s r;
+  glm_vec3(v4.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief pack an array of vec3 into an array of vec3s
+ *
+ * @param[out] dst array of vec3
+ * @param[in]  src array of vec3s
+ * @param[in]  len number of elements
+ */
+CGLM_INLINE
+void
+glms_vec3_pack(vec3s dst[], vec3 src[], size_t len) {
+  size_t i;
+
+  for (i = 0; i < len; i++) {
+    glm_vec3_copy(src[i], dst[i].raw);
+  }
+}
+
+/*!
+ * @brief unpack an array of vec3s into an array of vec3
+ *
+ * @param[out] dst array of vec3s
+ * @param[in]  src array of vec3
+ * @param[in]  len number of elements
+ */
+CGLM_INLINE
+void
+glms_vec3_unpack(vec3 dst[], vec3s src[], size_t len) {
+  size_t i;
+
+  for (i = 0; i < len; i++) {
+    glm_vec3_copy(src[i].raw, dst[i]);
+  }
+}
+
+/*!
+ * @brief make vector zero
+ *
+ * @returns       zero vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_zero(void) {
+  vec3s r;
+  glm_vec3_zero(r.raw);
+  return r;
+}
+
+/*!
+ * @brief make vector one
+ *
+ * @returns       one vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_one(void) {
+  vec3s r;
+  glm_vec3_one(r.raw);
+  return r;
+}
+
+/*!
+ * @brief vec3 dot product
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ *
+ * @return dot product
+ */
+CGLM_INLINE
+float
+glms_vec3_dot(vec3s a, vec3s b) {
+  return glm_vec3_dot(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_vec3_norm2(vec3s v) {
+  return glm_vec3_norm2(v.raw);
+}
+
+/*!
+ * @brief norm (magnitude) of vec3
+ *
+ * @param[in] v vector
+ *
+ * @return norm
+ */
+CGLM_INLINE
+float
+glms_vec3_norm(vec3s v) {
+  return glm_vec3_norm(v.raw);
+}
+
+/*!
+ * @brief L1 norm of vec3
+ * Also known as Manhattan Distance or Taxicab norm.
+ * L1 Norm is the sum of the magnitudes of the vectors in a space.
+ * It is calculated as the sum of the absolute values of the vector components.
+ * In this norm, all the components of the vector are weighted equally.
+ *
+ * This computes:
+ * R = |v[0]| + |v[1]| + |v[2]|
+ *
+ * @param[in] v vector
+ *
+ * @return L1 norm
+ */
+CGLM_INLINE
+float
+glms_vec3_norm_one(vec3s v) {
+  return glm_vec3_norm_one(v.raw);
+}
+
+/*!
+ * @brief Infinity norm of vec3
+ * Also known as Maximum norm.
+ * Infinity Norm is the largest magnitude among each element of a vector.
+ * It is calculated as the maximum of the absolute values of the vector components.
+ *
+ * This computes:
+ * inf norm = max(|v[0]|, |v[1]|, |v[2]|)
+ *
+ * @param[in] v vector
+ *
+ * @return Infinity norm
+ */
+CGLM_INLINE
+float
+glms_vec3_norm_inf(vec3s v) {
+  return glm_vec3_norm_inf(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
+vec3s
+glms_vec3_add(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_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
+vec3s
+glms_vec3_adds(vec3s a, float s) {
+  vec3s r;
+  glm_vec3_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
+vec3s
+glms_vec3_sub(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_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
+vec3s
+glms_vec3_subs(vec3s a, float s) {
+  vec3s r;
+  glm_vec3_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
+vec3s
+glms_vec3_mul(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_mul(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply/scale vec3 vector with scalar: result = v * s
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_scale(vec3s v, float s) {
+  vec3s r;
+  glm_vec3_scale(v.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief make vec3 vector scale as specified: result = unit(v) * s
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_scale_as(vec3s v, float s) {
+  vec3s r;
+  glm_vec3_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
+vec3s
+glms_vec3_div(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_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
+vec3s
+glms_vec3_divs(vec3s a, float s) {
+  vec3s r;
+  glm_vec3_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
+vec3s
+glms_vec3_addadd(vec3s a, vec3s b, vec3s dest) {
+  glm_vec3_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
+vec3s
+glms_vec3_subadd(vec3s a, vec3s b, vec3s dest) {
+  glm_vec3_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
+vec3s
+glms_vec3_muladd(vec3s a, vec3s b, vec3s dest) {
+  glm_vec3_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
+vec3s
+glms_vec3_muladds(vec3s a, float s, vec3s dest) {
+  glm_vec3_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
+vec3s
+glms_vec3_maxadd(vec3s a, vec3s b, vec3s dest) {
+  glm_vec3_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
+vec3s
+glms_vec3_minadd(vec3s a, vec3s b, vec3s dest) {
+  glm_vec3_minadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief negate vector components and store result in dest
+ *
+ * @param[in]   v     vector
+ * @returns           result vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_flipsign(vec3s v) {
+  glm_vec3_flipsign(v.raw);
+  return v;
+}
+
+/*!
+ * @brief negate vector components
+ *
+ * @param[in]  v  vector
+ * @returns       negated vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_negate(vec3s v) {
+  glm_vec3_negate(v.raw);
+  return v;
+}
+
+/*!
+ * @brief normalize vec3 and store result in same vec
+ *
+ * @param[in] v vector
+ * @returns     normalized vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_normalize(vec3s v) {
+  glm_vec3_normalize(v.raw);
+  return v;
+}
+
+/*!
+ * @brief cross product of two vector (RH)
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         destination
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_cross(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_cross(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief cross product of two vector (RH) and normalize the result
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         destination
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_crossn(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_crossn(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief angle betwen two vector
+ *
+ * @param[in] a  vector1
+ * @param[in] b  vector2
+ *
+ * @return angle as radians
+ */
+CGLM_INLINE
+float
+glms_vec3_angle(vec3s a, vec3s b) {
+  return glm_vec3_angle(a.raw, b.raw);
+}
+
+/*!
+ * @brief rotate vec3 around axis by angle using Rodrigues' rotation formula
+ *
+ * @param[in]     v     vector
+ * @param[in]     axis  axis vector (must be unit vector)
+ * @param[in]     angle angle by radians
+ * @returns             rotated vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_rotate(vec3s v, float angle, vec3s axis) {
+  glm_vec3_rotate(v.raw, angle, axis.raw);
+  return v;
+}
+
+/*!
+ * @brief apply rotation matrix to vector
+ *
+ *  matrix format should be (no perspective):
+ *   a  b  c  x
+ *   e  f  g  y
+ *   i  j  k  z
+ *   0  0  0  w
+ *
+ * @param[in]  m    affine matrix or rot matrix
+ * @param[in]  v    vector
+ * @returns         rotated vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_rotate_m4(mat4s m, vec3s v) {
+  vec3s r;
+  glm_vec3_rotate_m4(m.raw, v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief apply rotation matrix to vector
+ *
+ * @param[in]  m    affine matrix or rot matrix
+ * @param[in]  v    vector
+ * @returns         rotated vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_rotate_m3(mat3s m, vec3s v) {
+  vec3s r;
+  glm_vec3_rotate_m3(m.raw, v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief project a vector onto b vector
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @returns         projected vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_proj(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_proj(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/**
+ * @brief find center point of two vector
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @returns         center point
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_center(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_center(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/**
+ * @brief distance between two vectors
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ * @return      distance
+ */
+CGLM_INLINE
+float
+glms_vec3_distance(vec3s a, vec3s b) {
+  return glm_vec3_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_vec3_distance2(vec3s a, vec3s b) {
+  return glm_vec3_distance2(a.raw, b.raw);
+}
+
+/*!
+ * @brief max values of vectors
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @returns         destination
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_maxv(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_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
+vec3s
+glms_vec3_minv(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_minv(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief possible orthogonal/perpendicular vector
+ *
+ * @param[in]  v    vector
+ * @returns         orthogonal/perpendicular vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_ortho(vec3s v) {
+  vec3s r;
+  glm_vec3_ortho(v.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
+vec3s
+glms_vec3_clamp(vec3s v, float minVal, float maxVal) {
+  glm_vec3_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
+vec3s
+glms_vec3_lerp(vec3s from, vec3s to, float t) {
+  vec3s r;
+  glm_vec3_lerp(from.raw, to.raw, t, r.raw);
+  return r;
+}
+
+/*!
+ * @brief linear interpolation between two vectors (clamped)
+ *
+ * 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
+ * @returns           destination
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_lerpc(vec3s from, vec3s to, float t) {
+  vec3s r;
+  glm_vec3_lerpc(from.raw, to.raw, t, r.raw);
+  return r;
+}
+
+/*!
+ * @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
+vec3s
+glms_vec3_mix(vec3s from, vec3s to, float t) {
+  vec3s r;
+  glm_vec3_mix(from.raw, to.raw, t, r.raw);
+  return r;
+}
+
+/*!
+ * @brief linear interpolation between two vectors (clamped)
+ *
+ * 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
+ * @returns           destination
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_mixc(vec3s from, vec3s to, float t) {
+  vec3s r;
+  glm_vec3_mixc(from.raw, to.raw, t, r.raw);
+  return r;
+}
+
+/*!
+ * @brief threshold function (unidimensional)
+ *
+ * @param[in]   edge    threshold
+ * @param[in]   x       value to test against threshold
+ * @returns             0.0 if x < edge, else 1.0
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_step_uni(float edge, vec3s x) {
+  vec3s r;
+  glm_vec3_step_uni(edge, x.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief threshold function
+ *
+ * @param[in]   edge    threshold
+ * @param[in]   x       value to test against threshold
+ * @returns             0.0 if x < edge, else 1.0
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_step(vec3s edge, vec3s x) {
+  vec3s r;
+  glm_vec3_step(edge.raw, x.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief threshold function with a smooth transition (unidimensional)
+ *
+ * @param[in]   edge0   low threshold
+ * @param[in]   edge1   high threshold
+ * @param[in]   x       value to test against threshold
+ * @returns             destination
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_smoothstep_uni(float edge0, float edge1, vec3s x) {
+  vec3s r;
+  glm_vec3_smoothstep_uni(edge0, edge1, x.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief threshold function with a smooth transition
+ *
+ * @param[in]   edge0   low threshold
+ * @param[in]   edge1   high threshold
+ * @param[in]   x       value to test against threshold
+ * @returns             destination
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_smoothstep(vec3s edge0, vec3s edge1, vec3s x) {
+  vec3s r;
+  glm_vec3_smoothstep(edge0.raw, edge1.raw, x.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief smooth Hermite 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
+vec3s
+glms_vec3_smoothinterp(vec3s from, vec3s to, float t) {
+  vec3s r;
+  glm_vec3_smoothinterp(from.raw, to.raw, t, r.raw);
+  return r;
+}
+
+/*!
+ * @brief smooth Hermite interpolation between two vectors (clamped)
+ *
+ * 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
+ * @returns             destination
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_smoothinterpc(vec3s from, vec3s to, float t) {
+  vec3s r;
+  glm_vec3_smoothinterpc(from.raw, to.raw, t, r.raw);
+  return r;
+}
+
+/*!
+ * @brief vec3 cross product
+ *
+ * this is just convenient wrapper
+ *
+ * @param[in]  a  source 1
+ * @param[in]  b  source 2
+ * @returns       destination
+ */
+CGLM_INLINE
+vec3s
+glms_cross(vec3s a, vec3s b) {
+  vec3s r;
+  glm_cross(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief vec3 dot product
+ *
+ * this is just convenient wrapper
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ * @return      dot product
+ */
+CGLM_INLINE
+float
+glms_dot(vec3s a, vec3s b) {
+  return glm_dot(a.raw, b.raw);
+}
+
+/*!
+ * @brief normalize vec3 and store result in same vec
+ *
+ * this is just convenient wrapper
+ *
+ * @param[in]   v   vector
+ * @returns         normalized vector
+ */
+CGLM_INLINE
+vec3s
+glms_normalize(vec3s v) {
+  glm_normalize(v.raw);
+  return v;
+}
+
+/*!
+ * @brief swizzle vector components
+ *
+ * you can use existin masks e.g. GLM_XXX, GLM_ZYX
+ *
+ * @param[in]  v    source
+ * @param[in]  mask mask
+ * @returns swizzled vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_swizzle(vec3s v, int mask) {
+  vec3s dest;
+  glm_vec3_swizzle(v.raw, mask, dest.raw);
+  return dest;
+}
+
+#endif /* cglms_vec3s_h */

include/cglm/struct/vec4-ext.h

@@ -0,0 +1,257 @@
+/*
+ * 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 vec4s glms_vec4_broadcast(float val);
+   CGLM_INLINE vec4s glms_vec4_fill(float val);
+   CGLM_INLINE bool  glms_vec4_eq(vec4s v, float val);
+   CGLM_INLINE bool  glms_vec4_eq_eps(vec4s v, float val);
+   CGLM_INLINE bool  glms_vec4_eq_all(vec4s v);
+   CGLM_INLINE bool  glms_vec4_eqv(vec4s a, vec4s b);
+   CGLM_INLINE bool  glms_vec4_eqv_eps(vec4s a, vec4s b);
+   CGLM_INLINE float glms_vec4_max(vec4s v);
+   CGLM_INLINE float glms_vec4_min(vec4s v);
+   CGLM_INLINE bool  glms_vec4_isnan(vec4s v);
+   CGLM_INLINE bool  glms_vec4_isinf(vec4s v);
+   CGLM_INLINE bool  glms_vec4_isvalid(vec4s v);
+   CGLM_INLINE vec4s glms_vec4_sign(vec4s v);
+   CGLM_INLINE vec4s glms_vec4_abs(vec4s v);
+   CGLM_INLINE vec4s glms_vec4_fract(vec4s v);
+   CGLM_INLINE float glms_vec4_hadd(vec4s v);
+   CGLM_INLINE vec4s glms_vec4_sqrt(vec4s v);
+ */
+
+#ifndef cglms_vec4s_ext_h
+#define cglms_vec4s_ext_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../util.h"
+#include "../vec4-ext.h"
+
+/*!
+ * @brief fill a vector with specified value
+ *
+ * @param val value
+ * @returns   dest
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_broadcast(float val) {
+  vec4s r;
+  glm_vec4_broadcast(val, r.raw);
+  return r;
+}
+
+/*!
+ * @brief fill a vector with specified value
+ *
+ * @param val value
+ * @returns   dest
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_fill(float val) {
+  vec4s r;
+  glm_vec4_fill(r.raw, val);
+  return r;
+}
+
+/*!
+ * @brief check if vector is equal to value (without epsilon)
+ *
+ * @param v   vector
+ * @param val value
+ */
+CGLM_INLINE
+bool
+glms_vec4_eq(vec4s v, float val) {
+  return glm_vec4_eq(v.raw, val);
+}
+
+/*!
+ * @brief check if vector is equal to value (with epsilon)
+ *
+ * @param v   vector
+ * @param val value
+ */
+CGLM_INLINE
+bool
+glms_vec4_eq_eps(vec4s v, float val) {
+  return glm_vec4_eq_eps(v.raw, val);
+}
+
+/*!
+ * @brief check if vectors members are equal (without epsilon)
+ *
+ * @param v   vector
+ */
+CGLM_INLINE
+bool
+glms_vec4_eq_all(vec4s v) {
+  return glm_vec4_eq_all(v.raw);
+}
+
+/*!
+ * @brief check if vector is equal to another (without epsilon)
+ *
+ * @param a vector
+ * @param b vector
+ */
+CGLM_INLINE
+bool
+glms_vec4_eqv(vec4s a, vec4s b) {
+  return glm_vec4_eqv(a.raw, b.raw);
+}
+
+/*!
+ * @brief check if vector is equal to another (with epsilon)
+ *
+ * @param a vector
+ * @param b vector
+ */
+CGLM_INLINE
+bool
+glms_vec4_eqv_eps(vec4s a, vec4s b) {
+  return glm_vec4_eqv_eps(a.raw, b.raw);
+}
+
+/*!
+ * @brief max value of vector
+ *
+ * @param v vector
+ */
+CGLM_INLINE
+float
+glms_vec4_max(vec4s v) {
+  return glm_vec4_max(v.raw);
+}
+
+/*!
+ * @brief min value of vector
+ *
+ * @param v vector
+ */
+CGLM_INLINE
+float
+glms_vec4_min(vec4s v) {
+  return glm_vec4_min(v.raw);
+}
+
+/*!
+ * @brief check if one of items is NaN (not a number)
+ *        you should only use this in DEBUG mode or very critical asserts
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+bool
+glms_vec4_isnan(vec4s v) {
+  return glm_vec4_isnan(v.raw);
+}
+
+/*!
+ * @brief check if one of items is INFINITY
+ *        you should only use this in DEBUG mode or very critical asserts
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+bool
+glms_vec4_isinf(vec4s v) {
+  return glm_vec4_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_vec4_isvalid(vec4s v) {
+  return glm_vec4_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
+vec4s
+glms_vec4_sign(vec4s v) {
+  vec4s r;
+  glm_vec4_sign(v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief absolute value of each vector item
+ *
+ * @param[in]  v    vector
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_abs(vec4s v) {
+  vec4s r;
+  glm_vec4_abs(v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief fractional part of each vector item
+ *
+ * @param[in]  v    vector
+ * @returns          dest destination vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_fract(vec4s v) {
+  vec4s r;
+  glm_vec4_fract(v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief vector reduction by summation
+ * @warning could overflow
+ *
+ * @param[in]  v    vector
+ * @return     sum of all vector's elements
+ */
+CGLM_INLINE
+float
+glms_vec4_hadd(vec4s v) {
+  return glm_vec4_hadd(v.raw);
+}
+
+/*!
+ * @brief square root of each vector item
+ *
+ * @param[in]  v    vector
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_sqrt(vec4s v) {
+  vec4s r;
+  glm_vec4_sqrt(v.raw, r.raw);
+  return r;
+}
+
+#endif /* cglms_vec4s_ext_h */

include/cglm/struct/vec4.h

@@ -0,0 +1,814 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   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);
+   CGLM_INLINE vec3s glms_vec4_copy3(vec4s v);
+   CGLM_INLINE vec4s glms_vec4_copy(vec4s v);
+   CGLM_INLINE vec4s glms_vec4_ucopy(vec4s v);
+   CGLM_INLINE void  glms_vec4_pack(vec4s dst[], vec4 src[], size_t len);
+   CGLM_INLINE void  glms_vec4_unpack(vec4 dst[], vec4s src[], size_t len);
+   CGLM_INLINE float glms_vec4_dot(vec4s a, vec4s b);
+   CGLM_INLINE float glms_vec4_norm2(vec4s v);
+   CGLM_INLINE float glms_vec4_norm(vec4s v);
+   CGLM_INLINE float glms_vec4_norm_one(vec4s v);
+   CGLM_INLINE float glms_vec4_norm_inf(vec4s v);
+   CGLM_INLINE vec4s glms_vec4_add(vec4s a, vec4s b);
+   CGLM_INLINE vec4s glms_vec4_adds(vec4s v, float s);
+   CGLM_INLINE vec4s glms_vec4_sub(vec4s a, vec4s b);
+   CGLM_INLINE vec4s glms_vec4_subs(vec4s v, float s);
+   CGLM_INLINE vec4s glms_vec4_mul(vec4s a, vec4s b);
+   CGLM_INLINE vec4s glms_vec4_scale(vec4s v, float s);
+   CGLM_INLINE vec4s glms_vec4_scale_as(vec4s v, float s);
+   CGLM_INLINE vec4s glms_vec4_div(vec4s a, vec4s b);
+   CGLM_INLINE vec4s glms_vec4_divs(vec4s v, float s);
+   CGLM_INLINE vec4s glms_vec4_addadd(vec4s a, vec4s b, vec4s dest);
+   CGLM_INLINE vec4s glms_vec4_subadd(vec4s a, vec4s b, vec4s dest);
+   CGLM_INLINE vec4s glms_vec4_muladd(vec4s a, vec4s b, vec4s dest);
+   CGLM_INLINE vec4s glms_vec4_muladds(vec4s a, float s, vec4s dest);
+   CGLM_INLINE vec4s glms_vec4_maxadd(vec4s a, vec4s b, vec4s dest);
+   CGLM_INLINE vec4s glms_vec4_minadd(vec4s a, vec4s b, vec4s dest);
+   CGLM_INLINE vec4s glms_vec4_negate(vec4s v);
+   CGLM_INLINE vec4s glms_vec4_inv(vec4s v);
+   CGLM_INLINE vec4s glms_vec4_normalize(vec4s v);
+   CGLM_INLINE float glms_vec4_distance(vec4s a, vec4s b);
+   CGLM_INLINE float glms_vec4_distance2(vec4s a, vec4s b);
+   CGLM_INLINE vec4s glms_vec4_maxv(vec4s a, vec4s b);
+   CGLM_INLINE vec4s glms_vec4_minv(vec4s a, vec4s b);
+   CGLM_INLINE vec4s glms_vec4_clamp(vec4s v, float minVal, float maxVal);
+   CGLM_INLINE vec4s glms_vec4_lerp(vec4s from, vec4s to, float t);
+   CGLM_INLINE vec4s glms_vec4_lerpc(vec4s from, vec4s to, float t);
+   CGLM_INLINE vec4s glms_vec4_mix(vec4s from, vec4s to, float t);
+   CGLM_INLINE vec4s glms_vec4_mixc(vec4s from, vec4s to, float t);
+   CGLM_INLINE vec4s glms_vec4_step_uni(float edge, vec4s x);
+   CGLM_INLINE vec4s glms_vec4_step(vec4s edge, vec4s x);
+   CGLM_INLINE vec4s glms_vec4_smoothstep_uni(float edge0, float edge1, vec4s x);
+   CGLM_INLINE vec4s glms_vec4_smoothstep(vec4s edge0, vec4s edge1, vec4s x);
+   CGLM_INLINE vec4s glms_vec4_smoothinterp(vec4s from, vec4s to, float t);
+   CGLM_INLINE vec4s glms_vec4_smoothinterpc(vec4s from, vec4s to, float t);
+   CGLM_INLINE vec4s glms_vec4_cubic(float s);
+   CGLM_INLINE vec4s glms_vec4_swizzle(vec4s v, int mask);
+ */
+
+#ifndef cglms_vec4s_h
+#define cglms_vec4s_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../util.h"
+#include "../vec4.h"
+#include "vec4-ext.h"
+
+#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)
+#define GLMS_VEC4_ZERO       ((vec4s)GLM_VEC4_ZERO_INIT)
+
+/*!
+ * @brief init vec4 using vec3
+ *
+ * @param[in]  v3   vector3
+ * @param[in]  last last item
+ * @returns         destination
+ */
+CGLM_INLINE
+vec4s
+glms_vec4(vec3s v3, float last) {
+  vec4s r;
+  glm_vec4(v3.raw, last, r.raw);
+  return r;
+}
+
+/*!
+ * @brief copy first 3 members of [a] to [dest]
+ *
+ * @param[in]  v    source
+ * @returns         vec3
+ */
+CGLM_INLINE
+vec3s
+glms_vec4_copy3(vec4s v) {
+  vec3s r;
+  glm_vec4_copy3(v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief copy all members of [a] to [dest]
+ *
+ * @param[in]  v    source
+ * @returns         destination
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_copy(vec4s v) {
+  vec4s r;
+  glm_vec4_copy(v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief copy all members of [a] to [dest]
+ *
+ * alignment is not required
+ *
+ * @param[in]  v    source
+ * @returns         destination
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_ucopy(vec4s v) {
+  vec4s r;
+  glm_vec4_ucopy(v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief pack an array of vec4 into an array of vec4s
+ *
+ * @param[out] dst array of vec4
+ * @param[in]  src array of vec4s
+ * @param[in]  len number of elements
+ */
+CGLM_INLINE
+void
+glms_vec4_pack(vec4s dst[], vec4 src[], size_t len) {
+  size_t i;
+
+  for (i = 0; i < len; i++) {
+    glm_vec4_copy(src[i], dst[i].raw);
+  }
+}
+
+/*!
+ * @brief unpack an array of vec4s into an array of vec4
+ *
+ * @param[out] dst array of vec4s
+ * @param[in]  src array of vec4
+ * @param[in]  len number of elements
+ */
+CGLM_INLINE
+void
+glms_vec4_unpack(vec4 dst[], vec4s src[], size_t len) {
+  size_t i;
+
+  for (i = 0; i < len; i++) {
+    glm_vec4_copy(src[i].raw, dst[i]);
+  }
+}
+
+/*!
+ * @brief make vector zero
+ *
+ * @returns      zero vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_zero(void) {
+  vec4s r;
+  glm_vec4_zero(r.raw);
+  return r;
+}
+
+/*!
+ * @brief make vector one
+ *
+ * @returns      one vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_one(void) {
+  vec4s r;
+  glm_vec4_one(r.raw);
+  return r;
+}
+
+/*!
+ * @brief vec4 dot product
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ *
+ * @return dot product
+ */
+CGLM_INLINE
+float
+glms_vec4_dot(vec4s a, vec4s b) {
+  return glm_vec4_dot(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 vec4
+ *
+ * @return norm * norm
+ */
+CGLM_INLINE
+float
+glms_vec4_norm2(vec4s v) {
+  return glm_vec4_norm2(v.raw);
+}
+
+/*!
+ * @brief norm (magnitude) of vec4
+ *
+ * @param[in] v vector
+ *
+ * @return norm
+ */
+CGLM_INLINE
+float
+glms_vec4_norm(vec4s v) {
+  return glm_vec4_norm(v.raw);
+}
+
+/*!
+ * @brief L1 norm of vec4
+ * Also known as Manhattan Distance or Taxicab norm.
+ * L1 Norm is the sum of the magnitudes of the vectors in a space.
+ * It is calculated as the sum of the absolute values of the vector components.
+ * In this norm, all the components of the vector are weighted equally.
+ *
+ * This computes:
+ * R = |v[0]| + |v[1]| + |v[2]| + |v[3]|
+ *
+ * @param[in] v vector
+ *
+ * @return L1 norm
+ */
+CGLM_INLINE
+float
+glms_vec4_norm_one(vec4s v) {
+  return glm_vec4_norm_one(v.raw);
+}
+
+/*!
+ * @brief Infinity norm of vec4
+ * Also known as Maximum norm.
+ * Infinity Norm is the largest magnitude among each element of a vector.
+ * It is calculated as the maximum of the absolute values of the vector components.
+ *
+ * This computes:
+ * inf norm = max(|v[0]|, |v[1]|, |v[2]|, |v[3]|)
+ *
+ * @param[in] v vector
+ *
+ * @return Infinity norm
+ */
+CGLM_INLINE
+float
+glms_vec4_norm_inf(vec4s v) {
+  return glm_vec4_norm_inf(v.raw);
+}
+
+/*!
+ * @brief add b vector to a vector store result in dest
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_add(vec4s a, vec4s b) {
+  vec4s r;
+  glm_vec4_add(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief add scalar to v vector store result in dest (d = v + vec(s))
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_adds(vec4s v, float s) {
+  vec4s r;
+  glm_vec4_adds(v.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief subtract b vector from a vector store result in dest (d = a - b)
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_sub(vec4s a, vec4s b) {
+  vec4s r;
+  glm_vec4_sub(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief subtract scalar from v vector store result in dest (d = v - vec(s))
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_subs(vec4s v, float s) {
+  vec4s r;
+  glm_vec4_subs(v.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply two vector (component-wise multiplication)
+ *
+ * @param a    vector1
+ * @param b    vector2
+ * @returns    dest = (a[0] * b[0], a[1] * b[1], a[2] * b[2], a[3] * b[3])
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_mul(vec4s a, vec4s b) {
+  vec4s r;
+  glm_vec4_mul(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply/scale vec4 vector with scalar: result = v * s
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_scale(vec4s v, float s) {
+  vec4s r;
+  glm_vec4_scale(v.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief make vec4 vector scale as specified: result = unit(v) * s
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_scale_as(vec4s v, float s) {
+  vec4s r;
+  glm_vec4_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], a[3]/b[3])
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_div(vec4s a, vec4s b) {
+  vec4s r;
+  glm_vec4_div(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief div vec4 vector with scalar: d = v / s
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_divs(vec4s v, float s) {
+  vec4s r;
+  glm_vec4_divs(v.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
+vec4s
+glms_vec4_addadd(vec4s a, vec4s b, vec4s dest) {
+  glm_vec4_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
+vec4s
+glms_vec4_subadd(vec4s a, vec4s b, vec4s dest) {
+  glm_vec4_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
+vec4s
+glms_vec4_muladd(vec4s a, vec4s b, vec4s dest) {
+  glm_vec4_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
+vec4s
+glms_vec4_muladds(vec4s a, float s, vec4s dest) {
+  glm_vec4_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
+vec4s
+glms_vec4_maxadd(vec4s a, vec4s b, vec4s dest) {
+  glm_vec4_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
+vec4s
+glms_vec4_minadd(vec4s a, vec4s b, vec4s dest) {
+  glm_vec4_minadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief negate vector components and store result in dest
+ *
+ * @param[in]  v     vector
+ * @returns          result vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_negate(vec4s v) {
+  glm_vec4_negate(v.raw);
+  return v;
+}
+
+/*!
+ * @brief normalize vec4 and store result in same vec
+ *
+ * @param[in] v   vector
+ * @returns       normalized vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_normalize(vec4s v) {
+  glm_vec4_normalize(v.raw);
+  return v;
+}
+
+/**
+ * @brief distance between two vectors
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ * @return returns distance
+ */
+CGLM_INLINE
+float
+glms_vec4_distance(vec4s a, vec4s b) {
+  return glm_vec4_distance(a.raw, b.raw);
+}
+
+/**
+ * @brief squared distance between two vectors
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ * @return returns squared distance
+ */
+CGLM_INLINE
+float
+glms_vec4_distance2(vec4s a, vec4s b) {
+  return glm_vec4_distance2(a.raw, b.raw);
+}
+
+/*!
+ * @brief max values of vectors
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @returns         destination
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_maxv(vec4s a, vec4s b) {
+  vec4s r;
+  glm_vec4_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
+vec4s
+glms_vec4_minv(vec4s a, vec4s b) {
+  vec4s r;
+  glm_vec4_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
+vec4s
+glms_vec4_clamp(vec4s v, float minVal, float maxVal) {
+  glm_vec4_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
+vec4s
+glms_vec4_lerp(vec4s from, vec4s to, float t) {
+  vec4s r;
+  glm_vec4_lerp(from.raw, to.raw, t, r.raw);
+  return r;
+}
+
+/*!
+ * @brief linear interpolation between two vectors (clamped)
+ *
+ * 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
+ * @returns           destination
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_lerpc(vec4s from, vec4s to, float t) {
+  vec4s r;
+  glm_vec4_lerpc(from.raw, to.raw, t, r.raw);
+  return r;
+}
+
+/*!
+ * @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
+vec4s
+glms_vec4_mix(vec4s from, vec4s to, float t) {
+  vec4s r;
+  glm_vec4_mix(from.raw, to.raw, t, r.raw);
+  return r;
+}
+
+/*!
+ * @brief linear interpolation between two vectors (clamped)
+ *
+ * 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
+ * @returns           destination
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_mixc(vec4s from, vec4s to, float t) {
+  vec4s r;
+  glm_vec4_mixc(from.raw, to.raw, t, r.raw);
+  return r;
+}
+
+/*!
+ * @brief threshold function (unidimensional)
+ *
+ * @param[in]   edge    threshold
+ * @param[in]   x       value to test against threshold
+ * @returns             0.0 if x < edge, else 1.0
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_step_uni(float edge, vec4s x) {
+  vec4s r;
+  glm_vec4_step_uni(edge, x.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief threshold function
+ *
+ * @param[in]   edge    threshold
+ * @param[in]   x       value to test against threshold
+ * @returns             0.0 if x < edge, else 1.0
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_step(vec4s edge, vec4s x) {
+  vec4s r;
+  glm_vec4_step(edge.raw, x.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief threshold function with a smooth transition (unidimensional)
+ *
+ * @param[in]   edge0   low threshold
+ * @param[in]   edge1   high threshold
+ * @param[in]   x       value to test against threshold
+ * @returns             destination
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_smoothstep_uni(float edge0, float edge1, vec4s x) {
+  vec4s r;
+  glm_vec4_smoothstep_uni(edge0, edge1, x.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief threshold function with a smooth transition
+ *
+ * @param[in]   edge0   low threshold
+ * @param[in]   edge1   high threshold
+ * @param[in]   x       value to test against threshold
+ * @returns             destination
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_smoothstep(vec4s edge0, vec4s edge1, vec4s x) {
+  vec4s r;
+  glm_vec4_smoothstep(edge0.raw, edge1.raw, x.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief smooth Hermite 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
+vec4s
+glms_vec4_smoothinterp(vec4s from, vec4s to, float t) {
+  vec4s r;
+  glm_vec4_smoothinterp(from.raw, to.raw, t, r.raw);
+  return r;
+}
+
+/*!
+ * @brief smooth Hermite interpolation between two vectors (clamped)
+ *
+ * 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
+ * @returns             destination
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_smoothinterpc(vec4s from, vec4s to, float t) {
+  vec4s r;
+  glm_vec4_smoothinterpc(from.raw, to.raw, t, r.raw);
+  return r;
+}
+
+/*!
+ * @brief helper to fill vec4 as [S^3, S^2, S, 1]
+ *
+ * @param[in]   s     parameter
+ * @returns           destination
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_cubic(float s) {
+  vec4s r;
+  glm_vec4_cubic(s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief swizzle vector components
+ *
+ * you can use existin masks e.g. GLM_XXXX, GLM_WZYX
+ *
+ * @param[in]  v    source
+ * @param[in]  mask mask
+ * @returns swizzled vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_swizzle(vec4s v, int mask) {
+  vec4s dest;
+  glm_vec4_swizzle(v.raw, mask, dest.raw);
+  return dest;
+}
+
+#endif /* cglms_vec4s_h */

include/cglm/types-struct.h

@@ -0,0 +1,129 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglm_types_struct_h
+#define cglm_types_struct_h
+
+#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 {
+  vec3 raw;
+#if CGLM_USE_ANONYMOUS_STRUCT
+  struct {
+    float x;
+    float y;
+    float z;
+  };
+#endif
+} vec3s;
+
+typedef union ivec3s {
+  ivec3 raw;
+#if CGLM_USE_ANONYMOUS_STRUCT
+  struct {
+    int x;
+    int y;
+    int z;
+  };
+#endif
+} ivec3s;
+
+typedef union CGLM_ALIGN_IF(16) vec4s {
+  vec4 raw;
+#if CGLM_USE_ANONYMOUS_STRUCT
+  struct {
+    float x;
+    float y;
+    float z;
+    float w;
+  };
+#endif
+} vec4s;
+
+typedef union CGLM_ALIGN_IF(16) versors {
+  vec4 raw;
+#if CGLM_USE_ANONYMOUS_STRUCT
+  struct {
+    float x;
+    float y;
+    float z;
+    float w;
+  };
+
+  struct {
+    vec3s imag;
+    float real;
+  };
+#endif
+} versors;
+
+typedef union mat3s {
+  mat3 raw;
+  vec3s col[3];
+#if CGLM_USE_ANONYMOUS_STRUCT
+  struct {
+    float m00, m01, m02;
+    float m10, m11, m12;
+    float m20, m21, m22;
+  };
+#endif
+} mat3s;
+
+typedef union CGLM_ALIGN_MAT mat4s {
+  mat4 raw;
+  vec4s col[4];
+#if CGLM_USE_ANONYMOUS_STRUCT
+  struct {
+    float m00, m01, m02, m03;
+    float m10, m11, m12, m13;
+    float m20, m21, m22, m23;
+    float m30, m31, m32, m33;
+  };
+#endif
+} mat4s;
+
+#endif /* cglm_types_struct_h */

include/cglm/types.h

@@ -38,12 +38,7 @@ typedef int                    ivec3[3];
 typedef CGLM_ALIGN_IF(16) float vec4[4];
 typedef vec4                    versor;
 typedef vec3                    mat3[3];
-
+typedef CGLM_ALIGN_MAT vec4     mat4[4];
-#ifdef __AVX__
-typedef CGLM_ALIGN_IF(32) vec4  mat4[4];
-#else
-typedef CGLM_ALIGN_IF(16) vec4  mat4[4];
-#endif
 
 #define GLM_E         2.71828182845904523536028747135266250   /* e           */
 #define GLM_LOG2E     1.44269504088896340735992468100189214   /* log2(e)     */

include/cglm/util.h

@@ -8,11 +8,26 @@
 /*
  Functions:
    CGLM_INLINE int   glm_sign(int val);
+   CGLM_INLINE float glm_signf(float val);
    CGLM_INLINE float glm_rad(float deg);
    CGLM_INLINE float glm_deg(float rad);
    CGLM_INLINE void  glm_make_rad(float *deg);
    CGLM_INLINE void  glm_make_deg(float *rad);
    CGLM_INLINE float glm_pow2(float x);
+   CGLM_INLINE float glm_min(float a, float b);
+   CGLM_INLINE float glm_max(float a, float b);
+   CGLM_INLINE float glm_clamp(float val, float minVal, float maxVal);
+   CGLM_INLINE float glm_clamp_zo(float val, float minVal, float maxVal);
+   CGLM_INLINE float glm_lerp(float from, float to, float t);
+   CGLM_INLINE float glm_lerpc(float from, float to, float t);
+   CGLM_INLINE float glm_step(float edge, float x);
+   CGLM_INLINE float glm_smooth(float t);
+   CGLM_INLINE float glm_smoothstep(float edge0, float edge1, float x);
+   CGLM_INLINE float glm_smoothinterp(float from, float to, float t);
+   CGLM_INLINE float glm_smoothinterpc(float from, float to, float t);
+   CGLM_INLINE bool  glm_eq(float a, float b);
+   CGLM_INLINE float glm_percent(float from, float to, float current);
+   CGLM_INLINE float glm_percentc(float from, float to, float current);
  */
 
 #ifndef cglm_util_h
@@ -157,9 +172,103 @@ glm_clamp_zo(float val) {
 }
 
 /*!
- * @brief linear interpolation between two number
+ * @brief linear interpolation between two numbers
  *
- * formula:  from + s * (to - from)
+ * formula:  from + t * (to - from)
+ *
+ * @param[in]   from from value
+ * @param[in]   to   to value
+ * @param[in]   t    interpolant (amount)
+ */
+CGLM_INLINE
+float
+glm_lerp(float from, float to, float t) {
+  return from + t * (to - from);
+}
+
+/*!
+ * @brief clamped linear interpolation between two numbers
+ *
+ * formula:  from + t * (to - from)
+ *
+ * @param[in]   from    from value
+ * @param[in]   to      to value
+ * @param[in]   t       interpolant (amount) clamped between 0 and 1
+ */
+CGLM_INLINE
+float
+glm_lerpc(float from, float to, float t) {
+  return glm_lerp(from, to, glm_clamp_zo(t));
+}
+
+/*!
+ * @brief threshold function
+ *
+ * @param[in]   edge    threshold
+ * @param[in]   x       value to test against threshold
+ * @return      returns 0.0 if x < edge, else 1.0
+ */
+CGLM_INLINE
+float
+glm_step(float edge, float x) {
+  /* branching - no type conversion */
+  return (x < edge) ? 0.0f : 1.0f;
+  /*
+   * An alternative implementation without branching
+   * but with type conversion could be:
+   * return !(x < edge);
+   */
+}
+
+/*!
+ * @brief smooth Hermite interpolation
+ *
+ * formula:  t^2 * (3-2t)
+ *
+ * @param[in]   t    interpolant (amount)
+ */
+CGLM_INLINE
+float
+glm_smooth(float t) {
+  return t * t * (3.0f - 2.0f * t);
+}
+
+/*!
+ * @brief threshold function with a smooth transition (according to OpenCL specs)
+ *
+ * formula:  t^2 * (3-2t)
+ *
+ * @param[in]   edge0 low threshold
+ * @param[in]   edge1 high threshold
+ * @param[in]   x     interpolant (amount)
+ */
+CGLM_INLINE
+float
+glm_smoothstep(float edge0, float edge1, float x) {
+  float t;
+  t = glm_clamp_zo((x - edge0) / (edge1 - edge0));
+  return glm_smooth(t);
+}
+
+/*!
+ * @brief smoothstep interpolation between two numbers
+ *
+ * formula:  from + smoothstep(t) * (to - from)
+ *
+ * @param[in]   from from value
+ * @param[in]   to   to value
+ * @param[in]   t    interpolant (amount)
+ */
+CGLM_INLINE
+float
+glm_smoothinterp(float from, float to, float t) {
+  return from + glm_smooth(t) * (to - from);
+}
+
+/*!
+ * @brief clamped smoothstep interpolation between two numbers
+ *
+ * formula:  from + smoothstep(t) * (to - from)
  *
  * @param[in]   from from value
  * @param[in]   to   to value
@@ -167,8 +276,8 @@ glm_clamp_zo(float val) {
  */
 CGLM_INLINE
 float
-glm_lerp(float from, float to, float t) {
+glm_smoothinterpc(float from, float to, float t) {
-  return from + glm_clamp_zo(t) * (to - from);
+  return glm_smoothinterp(from, to, glm_clamp_zo(t));
 }
 
 /*!

include/cglm/vec3-ext.h

@@ -12,6 +12,7 @@
 /*
  Functions:
    CGLM_INLINE void  glm_vec3_broadcast(float val, vec3 d);
+   CGLM_INLINE void  glm_vec3_fill(vec3 v, float val);
    CGLM_INLINE bool  glm_vec3_eq(vec3 v, float val);
    CGLM_INLINE bool  glm_vec3_eq_eps(vec3 v, float val);
    CGLM_INLINE bool  glm_vec3_eq_all(vec3 v);
@@ -23,6 +24,9 @@
    CGLM_INLINE bool  glm_vec3_isinf(vec3 v);
    CGLM_INLINE bool  glm_vec3_isvalid(vec3 v);
    CGLM_INLINE void  glm_vec3_sign(vec3 v, vec3 dest);
+   CGLM_INLINE void  glm_vec3_abs(vec3 v, vec3 dest);
+   CGLM_INLINE void  glm_vec3_fract(vec3 v, vec3 dest);
+   CGLM_INLINE float glm_vec3_hadd(vec3 v);
    CGLM_INLINE void  glm_vec3_sqrt(vec3 v, vec3 dest);
  */
 
@@ -44,6 +48,18 @@ glm_vec3_broadcast(float val, vec3 d) {
   d[0] = d[1] = d[2] = val;
 }
 
+/*!
+ * @brief fill a vector with specified value
+ *
+ * @param[out] v   dest
+ * @param[in]  val value
+ */
+CGLM_INLINE
+void
+glm_vec3_fill(vec3 v, float val) {
+  v[0] = v[1] = v[2] = val;
+}
+
 /*!
  * @brief check if vector is equal to value (without epsilon)
  *
@@ -198,6 +214,47 @@ glm_vec3_sign(vec3 v, vec3 dest) {
   dest[2] = glm_signf(v[2]);
 }
 
+/*!
+ * @brief absolute value of each vector item
+ *
+ * @param[in]  v    vector
+ * @param[out] dest destination vector
+ */
+CGLM_INLINE
+void
+glm_vec3_abs(vec3 v, vec3 dest) {
+  dest[0] = fabsf(v[0]);
+  dest[1] = fabsf(v[1]);
+  dest[2] = fabsf(v[2]);
+}
+
+/*!
+ * @brief fractional part of each vector item
+ *
+ * @param[in]  v    vector
+ * @param[out] dest destination vector
+ */
+CGLM_INLINE
+void
+glm_vec3_fract(vec3 v, vec3 dest) {
+  dest[0] = fminf(v[0] - floorf(v[0]), 0x1.fffffep-1f);
+  dest[1] = fminf(v[1] - floorf(v[1]), 0x1.fffffep-1f);
+  dest[2] = fminf(v[2] - floorf(v[2]), 0x1.fffffep-1f);
+}
+
+/*!
+ * @brief vector reduction by summation
+ * @warning could overflow
+ *
+ * @param[in]  v    vector
+ * @return     sum of all vector's elements
+ */
+CGLM_INLINE
+float
+glm_vec3_hadd(vec3 v) {
+  return v[0] + v[1] + v[2];
+}
+
 /*!
  * @brief square root of each vector item
  *

include/cglm/vec3.h

@@ -23,6 +23,8 @@
    CGLM_INLINE float glm_vec3_dot(vec3 a, vec3 b);
    CGLM_INLINE float glm_vec3_norm2(vec3 v);
    CGLM_INLINE float glm_vec3_norm(vec3 v);
+   CGLM_INLINE float glm_vec3_norm_one(vec3 v);
+   CGLM_INLINE float glm_vec3_norm_inf(vec3 v);
    CGLM_INLINE void  glm_vec3_add(vec3 a, vec3 b, vec3 dest);
    CGLM_INLINE void  glm_vec3_adds(vec3 a, float s, vec3 dest);
    CGLM_INLINE void  glm_vec3_sub(vec3 a, vec3 b, vec3 dest);
@@ -48,19 +50,29 @@
    CGLM_INLINE void  glm_vec3_normalize_to(vec3 v, vec3 dest);
    CGLM_INLINE void  glm_vec3_cross(vec3 a, vec3 b, vec3 d);
    CGLM_INLINE void  glm_vec3_crossn(vec3 a, vec3 b, vec3 dest);
-   CGLM_INLINE float glm_vec3_distance(vec3 a, vec3 b);
    CGLM_INLINE float glm_vec3_angle(vec3 a, vec3 b);
    CGLM_INLINE void  glm_vec3_rotate(vec3 v, float angle, vec3 axis);
    CGLM_INLINE void  glm_vec3_rotate_m4(mat4 m, vec3 v, vec3 dest);
    CGLM_INLINE void  glm_vec3_rotate_m3(mat3 m, vec3 v, vec3 dest);
    CGLM_INLINE void  glm_vec3_proj(vec3 a, vec3 b, vec3 dest);
    CGLM_INLINE void  glm_vec3_center(vec3 a, vec3 b, vec3 dest);
+   CGLM_INLINE float glm_vec3_distance(vec3 a, vec3 b);
    CGLM_INLINE float glm_vec3_distance2(vec3 a, vec3 b);
    CGLM_INLINE void  glm_vec3_maxv(vec3 a, vec3 b, vec3 dest);
    CGLM_INLINE void  glm_vec3_minv(vec3 a, vec3 b, vec3 dest);
    CGLM_INLINE void  glm_vec3_ortho(vec3 v, vec3 dest);
    CGLM_INLINE void  glm_vec3_clamp(vec3 v, float minVal, float maxVal);
    CGLM_INLINE void  glm_vec3_lerp(vec3 from, vec3 to, float t, vec3 dest);
+   CGLM_INLINE void  glm_vec3_lerpc(vec3 from, vec3 to, float t, vec3 dest);
+   CGLM_INLINE void  glm_vec3_mix(vec3 from, vec3 to, float t, vec3 dest);
+   CGLM_INLINE void  glm_vec3_mixc(vec3 from, vec3 to, float t, vec3 dest);
+   CGLM_INLINE void  glm_vec3_step_uni(float edge, vec3 x, vec3 dest);
+   CGLM_INLINE void  glm_vec3_step(vec3 edge, vec3 x, vec3 dest);
+   CGLM_INLINE void  glm_vec3_smoothstep_uni(float edge0, float edge1, vec3 x, vec3 dest);
+   CGLM_INLINE void  glm_vec3_smoothstep(vec3 edge0, vec3 edge1, vec3 x, vec3 dest);
+   CGLM_INLINE void  glm_vec3_smoothinterp(vec3 from, vec3 to, float t, vec3 dest);
+   CGLM_INLINE void  glm_vec3_smoothinterpc(vec3 from, vec3 to, float t, vec3 dest);
+   CGLM_INLINE void  glm_vec3_swizzle(vec3 v, int mask, vec3 dest);
 
  Convenient:
    CGLM_INLINE void  glm_cross(vec3 a, vec3 b, vec3 d);
@@ -103,6 +115,11 @@
 #define GLM_ZUP  ((vec3){0.0f, 0.0f, 1.0f})
 #define GLM_XUP  ((vec3){1.0f, 0.0f, 0.0f})
 
+#define GLM_XXX GLM_SHUFFLE3(0, 0, 0)
+#define GLM_YYY GLM_SHUFFLE3(1, 1, 1)
+#define GLM_ZZZ GLM_SHUFFLE3(2, 2, 2)
+#define GLM_ZYX GLM_SHUFFLE3(0, 1, 2)
+
 /*!
  * @brief init vec3 using vec4
  *
@@ -185,7 +202,8 @@ glm_vec3_norm2(vec3 v) {
 }
 
 /*!
- * @brief norm (magnitude) of vec3
+ * @brief euclidean norm (magnitude), also called L2 norm
+ *        this will give magnitude of vector in euclidean space
  *
  * @param[in] v vector
  *
@@ -197,6 +215,49 @@ glm_vec3_norm(vec3 v) {
   return sqrtf(glm_vec3_norm2(v));
 }
 
+/*!
+ * @brief L1 norm of vec3
+ * Also known as Manhattan Distance or Taxicab norm.
+ * L1 Norm is the sum of the magnitudes of the vectors in a space.
+ * It is calculated as the sum of the absolute values of the vector components.
+ * In this norm, all the components of the vector are weighted equally.
+ *
+ * This computes:
+ * R = |v[0]| + |v[1]| + |v[2]|
+ *
+ * @param[in] v vector
+ *
+ * @return L1 norm
+ */
+CGLM_INLINE
+float
+glm_vec3_norm_one(vec3 v) {
+  vec3 t;
+  glm_vec3_abs(v, t);
+  return glm_vec3_hadd(t);
+}
+
+/*!
+ * @brief infinity norm of vec3
+ * Also known as Maximum norm.
+ * Infinity Norm is the largest magnitude among each element of a vector.
+ * It is calculated as the maximum of the absolute values of the vector components.
+ *
+ * This computes:
+ * inf norm = max(|v[0]|, |v[1]|, |v[2]|)
+ *
+ * @param[in] v vector
+ *
+ * @return infinity norm
+ */
+CGLM_INLINE
+float
+glm_vec3_norm_inf(vec3 v) {
+  vec3 t;
+  glm_vec3_abs(v, t);
+  return glm_vec3_max(t);
+}
+
 /*!
  * @brief add a vector to b vector store result in dest
  *
@@ -688,9 +749,9 @@ glm_vec3_center(vec3 a, vec3 b, vec3 dest) {
 CGLM_INLINE
 float
 glm_vec3_distance2(vec3 a, vec3 b) {
-  return glm_pow2(b[0] - a[0])
+  return glm_pow2(a[0] - b[0])
-       + glm_pow2(b[1] - a[1])
+       + glm_pow2(a[1] - b[1])
-       + glm_pow2(b[2] - a[2]);
+       + glm_pow2(a[2] - b[2]);
 }
 
 /**
@@ -766,7 +827,29 @@ glm_vec3_clamp(vec3 v, float minVal, float maxVal) {
 }
 
 /*!
- * @brief linear interpolation between two vector
+ * @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)
+ * @param[out]  dest destination
+ */
+CGLM_INLINE
+void
+glm_vec3_lerp(vec3 from, vec3 to, float t, vec3 dest) {
+  vec3 s, v;
+
+  /* from + s * (to - from) */
+  glm_vec3_broadcast(t, s);
+  glm_vec3_sub(to, from, v);
+  glm_vec3_mul(s, v, v);
+  glm_vec3_add(from, v, dest);
+}
+
+/*!
+ * @brief linear interpolation between two vectors (clamped)
  *
  * formula:  from + s * (to - from)
  *
@@ -777,16 +860,163 @@ glm_vec3_clamp(vec3 v, float minVal, float maxVal) {
  */
 CGLM_INLINE
 void
-glm_vec3_lerp(vec3 from, vec3 to, float t, vec3 dest) {
+glm_vec3_lerpc(vec3 from, vec3 to, float t, vec3 dest) {
+  glm_vec3_lerp(from, to, glm_clamp_zo(t), dest);
+}
+
+/*!
+ * @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)
+ * @param[out]  dest destination
+ */
+CGLM_INLINE
+void
+glm_vec3_mix(vec3 from, vec3 to, float t, vec3 dest) {
+  glm_vec3_lerp(from, to, t, dest);
+}
+
+/*!
+ * @brief linear interpolation between two vectors (clamped)
+ *
+ * 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_vec3_mixc(vec3 from, vec3 to, float t, vec3 dest) {
+  glm_vec3_lerpc(from, to, t, dest);
+}
+
+/*!
+ * @brief threshold function (unidimensional)
+ *
+ * @param[in]   edge    threshold
+ * @param[in]   x       value to test against threshold
+ * @param[out]  dest    destination
+ */
+CGLM_INLINE
+void
+glm_vec3_step_uni(float edge, vec3 x, vec3 dest) {
+  dest[0] = glm_step(edge, x[0]);
+  dest[1] = glm_step(edge, x[1]);
+  dest[2] = glm_step(edge, x[2]);
+}
+
+/*!
+ * @brief threshold function
+ *
+ * @param[in]   edge    threshold
+ * @param[in]   x       value to test against threshold
+ * @param[out]  dest    destination
+ */
+CGLM_INLINE
+void
+glm_vec3_step(vec3 edge, vec3 x, vec3 dest) {
+  dest[0] = glm_step(edge[0], x[0]);
+  dest[1] = glm_step(edge[1], x[1]);
+  dest[2] = glm_step(edge[2], x[2]);
+}
+
+/*!
+ * @brief threshold function with a smooth transition (unidimensional)
+ *
+ * @param[in]   edge0   low threshold
+ * @param[in]   edge1   high threshold
+ * @param[in]   x       value to test against threshold
+ * @param[out]  dest    destination
+ */
+CGLM_INLINE
+void
+glm_vec3_smoothstep_uni(float edge0, float edge1, vec3 x, vec3 dest) {
+  dest[0] = glm_smoothstep(edge0, edge1, x[0]);
+  dest[1] = glm_smoothstep(edge0, edge1, x[1]);
+  dest[2] = glm_smoothstep(edge0, edge1, x[2]);
+}
+
+/*!
+ * @brief threshold function with a smooth transition
+ *
+ * @param[in]   edge0   low threshold
+ * @param[in]   edge1   high threshold
+ * @param[in]   x       value to test against threshold
+ * @param[out]  dest    destination
+ */
+CGLM_INLINE
+void
+glm_vec3_smoothstep(vec3 edge0, vec3 edge1, vec3 x, vec3 dest) {
+  dest[0] = glm_smoothstep(edge0[0], edge1[0], x[0]);
+  dest[1] = glm_smoothstep(edge0[1], edge1[1], x[1]);
+  dest[2] = glm_smoothstep(edge0[2], edge1[2], x[2]);
+}
+
+/*!
+ * @brief smooth Hermite interpolation between two vectors
+ *
+ * formula:  from + s * (to - from)
+ *
+ * @param[in]   from from value
+ * @param[in]   to   to value
+ * @param[in]   t    interpolant (amount)
+ * @param[out]  dest destination
+ */
+CGLM_INLINE
+void
+glm_vec3_smoothinterp(vec3 from, vec3 to, float t, vec3 dest) {
   vec3 s, v;
     
   /* from + s * (to - from) */
-  glm_vec3_broadcast(glm_clamp_zo(t), s);
+  glm_vec3_broadcast(glm_smooth(t), s);
   glm_vec3_sub(to, from, v);
   glm_vec3_mul(s, v, v);
   glm_vec3_add(from, v, dest);
 }
 
+/*!
+ * @brief smooth Hermite interpolation between two vectors (clamped)
+ *
+ * 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_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
  *

include/cglm/vec4-ext.h

@@ -12,6 +12,7 @@
 /*
  Functions:
    CGLM_INLINE void  glm_vec4_broadcast(float val, vec4 d);
+   CGLM_INLINE void  glm_vec4_fill(vec4 v, float val);
    CGLM_INLINE bool  glm_vec4_eq(vec4 v, float val);
    CGLM_INLINE bool  glm_vec4_eq_eps(vec4 v, float val);
    CGLM_INLINE bool  glm_vec4_eq_all(vec4 v);
@@ -23,6 +24,9 @@
    CGLM_INLINE bool  glm_vec4_isinf(vec4 v);
    CGLM_INLINE bool  glm_vec4_isvalid(vec4 v);
    CGLM_INLINE void  glm_vec4_sign(vec4 v, vec4 dest);
+   CGLM_INLINE void  glm_vec4_abs(vec4 v, vec4 dest);
+   CGLM_INLINE void  glm_vec4_fract(vec4 v, vec4 dest);
+   CGLM_INLINE float glm_vec4_hadd(vec4 v);
    CGLM_INLINE void  glm_vec4_sqrt(vec4 v, vec4 dest);
  */
 
@@ -48,6 +52,22 @@ glm_vec4_broadcast(float val, vec4 d) {
 #endif
 }
 
+/*!
+ * @brief fill a vector with specified value
+ *
+ * @param v   dest
+ * @param val value
+ */
+CGLM_INLINE
+void
+glm_vec4_fill(vec4 v, float val) {
+#if defined( __SSE__ ) || defined( __SSE2__ )
+  glmm_store(v, _mm_set1_ps(val));
+#else
+  v[0] = v[1] = v[2] = v[3] = val;
+#endif
+}
+
 /*!
  * @brief check if vector is equal to value (without epsilon)
  *
@@ -220,6 +240,59 @@ glm_vec4_sign(vec4 v, vec4 dest) {
 #endif
 }
 
+/*!
+ * @brief absolute value of each vector item
+ *
+ * @param[in]  v    vector
+ * @param[out] dest destination vector
+ */
+CGLM_INLINE
+void
+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(v)));
+#else
+  dest[0] = fabsf(v[0]);
+  dest[1] = fabsf(v[1]);
+  dest[2] = fabsf(v[2]);
+  dest[3] = fabsf(v[3]);
+#endif
+}
+
+/*!
+ * @brief fractional part of each vector item
+ *
+ * @param[in]  v    vector
+ * @param[out] dest destination vector
+ */
+CGLM_INLINE
+void
+glm_vec4_fract(vec4 v, vec4 dest) {
+  dest[0] = fminf(v[0] - floorf(v[0]), 0x1.fffffep-1f);
+  dest[1] = fminf(v[1] - floorf(v[1]), 0x1.fffffep-1f);
+  dest[2] = fminf(v[2] - floorf(v[2]), 0x1.fffffep-1f);
+  dest[3] = fminf(v[3] - floorf(v[3]), 0x1.fffffep-1f);
+}
+
+/*!
+ * @brief vector reduction by summation
+ * @warning could overflow
+ *
+ * @param[in]   v    vector
+ * @return      sum of all vector's elements
+ */
+CGLM_INLINE
+float
+glm_vec4_hadd(vec4 v) {
+#if defined( __SSE__ ) || defined( __SSE2__ )
+  return glmm_hadd(glmm_load(v));
+#else
+  return v[0] + v[1] + v[2] + v[3];
+#endif
+}
+
 /*!
  * @brief square root of each vector item
  *

include/cglm/vec4.h

@@ -22,6 +22,8 @@
    CGLM_INLINE float glm_vec4_dot(vec4 a, vec4 b);
    CGLM_INLINE float glm_vec4_norm2(vec4 v);
    CGLM_INLINE float glm_vec4_norm(vec4 v);
+   CGLM_INLINE float glm_vec4_norm_one(vec4 v);
+   CGLM_INLINE float glm_vec4_norm_inf(vec4 v);
    CGLM_INLINE void  glm_vec4_add(vec4 a, vec4 b, vec4 dest);
    CGLM_INLINE void  glm_vec4_adds(vec4 v, float s, vec4 dest);
    CGLM_INLINE void  glm_vec4_sub(vec4 a, vec4 b, vec4 dest);
@@ -43,10 +45,19 @@
    CGLM_INLINE void  glm_vec4_normalize(vec4 v);
    CGLM_INLINE void  glm_vec4_normalize_to(vec4 vec, vec4 dest);
    CGLM_INLINE float glm_vec4_distance(vec4 a, vec4 b);
+   CGLM_INLINE float glm_vec4_distance2(vec4 a, vec4 b);
    CGLM_INLINE void  glm_vec4_maxv(vec4 a, vec4 b, vec4 dest);
    CGLM_INLINE void  glm_vec4_minv(vec4 a, vec4 b, vec4 dest);
    CGLM_INLINE void  glm_vec4_clamp(vec4 v, float minVal, float maxVal);
-   CGLM_INLINE void  glm_vec4_lerp(vec4 from, vec4 to, float t, vec4 dest)
+   CGLM_INLINE void  glm_vec4_lerp(vec4 from, vec4 to, float t, vec4 dest);
+   CGLM_INLINE void  glm_vec4_lerpc(vec4 from, vec4 to, float t, vec4 dest);
+   CGLM_INLINE void  glm_vec4_step_uni(float edge, vec4 x, vec4 dest);
+   CGLM_INLINE void  glm_vec4_step(vec4 edge, vec4 x, vec4 dest);
+   CGLM_INLINE void  glm_vec4_smoothstep_uni(float edge0, float edge1, vec4 x, vec4 dest);
+   CGLM_INLINE void  glm_vec4_smoothstep(vec4 edge0, vec4 edge1, vec4 x, vec4 dest);
+   CGLM_INLINE void  glm_vec4_smoothinterp(vec4 from, vec4 to, float t, vec4 dest);
+   CGLM_INLINE void  glm_vec4_smoothinterpc(vec4 from, vec4 to, float t, vec4 dest);
+   CGLM_INLINE void  glm_vec4_swizzle(vec4 v, int mask, vec4 dest);
 
  DEPRECATED:
    glm_vec4_dup
@@ -81,6 +92,12 @@
 #define GLM_VEC4_BLACK      ((vec4)GLM_VEC4_BLACK_INIT)
 #define GLM_VEC4_ZERO       ((vec4)GLM_VEC4_ZERO_INIT)
 
+#define GLM_XXXX GLM_SHUFFLE4(0, 0, 0, 0)
+#define GLM_YYYY GLM_SHUFFLE4(1, 1, 1, 1)
+#define GLM_ZZZZ GLM_SHUFFLE4(2, 2, 2, 2)
+#define GLM_WWWW GLM_SHUFFLE4(3, 3, 3, 3)
+#define GLM_WZYX GLM_SHUFFLE4(0, 1, 2, 3)
+
 /*!
  * @brief init vec4 using vec3
  *
@@ -225,7 +242,8 @@ glm_vec4_norm2(vec4 v) {
 }
 
 /*!
- * @brief norm (magnitude) of vec4
+ * @brief euclidean norm (magnitude), also called L2 norm
+ *        this will give magnitude of vector in euclidean space
  *
  * @param[in] v vector
  *
@@ -241,6 +259,57 @@ glm_vec4_norm(vec4 v) {
 #endif
 }
 
+/*!
+ * @brief L1 norm of vec4
+ * Also known as Manhattan Distance or Taxicab norm.
+ * L1 Norm is the sum of the magnitudes of the vectors in a space.
+ * It is calculated as the sum of the absolute values of the vector components.
+ * In this norm, all the components of the vector are weighted equally.
+ *
+ * This computes:
+ * L1 norm = |v[0]| + |v[1]| + |v[2]| + |v[3]|
+ *
+ * @param[in] v vector
+ *
+ * @return L1 norm
+ */
+CGLM_INLINE
+float
+glm_vec4_norm_one(vec4 v) {
+#if defined(CGLM_SIMD)
+  return glmm_norm_one(glmm_load(v));
+#else
+  vec4 t;
+  glm_vec4_abs(v, t);
+  return glm_vec4_hadd(t);
+#endif
+}
+
+/*!
+ * @brief infinity norm of vec4
+ * Also known as Maximum norm.
+ * Infinity Norm is the largest magnitude among each element of a vector.
+ * It is calculated as the maximum of the absolute values of the vector components.
+ *
+ * This computes:
+ * inf norm = max(|v[0]|, |v[1]|, |v[2]|, |v[3]|)
+ *
+ * @param[in] v vector
+ *
+ * @return infinity norm
+ */
+CGLM_INLINE
+float
+glm_vec4_norm_inf(vec4 v) {
+#if defined(CGLM_SIMD)
+  return glmm_norm_inf(glmm_load(v));
+#else
+  vec4 t;
+  glm_vec4_abs(v, t);
+  return glm_vec4_max(t);
+#endif
+}
+
 /*!
  * @brief add b vector to a vector store result in dest
  *
@@ -690,14 +759,36 @@ CGLM_INLINE
 float
 glm_vec4_distance(vec4 a, vec4 b) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
-  return glmm_norm(_mm_sub_ps(glmm_load(b), glmm_load(a)));
+  return glmm_norm(_mm_sub_ps(glmm_load(a), glmm_load(b)));
 #elif defined(CGLM_NEON_FP)
   return glmm_norm(vsubq_f32(glmm_load(a), glmm_load(b)));
 #else
-  return sqrtf(glm_pow2(b[0] - a[0])
+  return sqrtf(glm_pow2(a[0] - b[0])
-             + glm_pow2(b[1] - a[1])
+             + glm_pow2(a[1] - b[1])
-             + glm_pow2(b[2] - a[2])
+             + glm_pow2(a[2] - b[2])
-             + glm_pow2(b[3] - a[3]));
+             + glm_pow2(a[3] - b[3]));
+#endif
+}
+
+/**
+ * @brief squared distance between two vectors
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ * @return returns squared distance
+ */
+CGLM_INLINE
+float
+glm_vec4_distance2(vec4 a, vec4 b) {
+#if defined( __SSE__ ) || defined( __SSE2__ )
+  return glmm_norm2(_mm_sub_ps(glmm_load(a), glmm_load(b)));
+#elif defined(CGLM_NEON_FP)
+  return glmm_norm2(vsubq_f32(glmm_load(a), glmm_load(b)));
+#else
+  return glm_pow2(a[0] - b[0])
+       + glm_pow2(a[1] - b[1])
+       + glm_pow2(a[2] - b[2])
+       + glm_pow2(a[3] - b[3]);
 #endif
 }
 
@@ -770,13 +861,13 @@ glm_vec4_clamp(vec4 v, float minVal, float maxVal) {
 }
 
 /*!
- * @brief linear interpolation between two vector
+ * @brief linear interpolation between two vectors
  *
- * formula:  from + s * (to - from)
+ * formula:  from + t * (to - from)
  *
  * @param[in]   from from value
  * @param[in]   to   to value
- * @param[in]   t    interpolant (amount) clamped between 0 and 1
+ * @param[in]   t    interpolant (amount)
  * @param[out]  dest destination
  */
 CGLM_INLINE
@@ -785,12 +876,164 @@ glm_vec4_lerp(vec4 from, vec4 to, float t, vec4 dest) {
   vec4 s, v;
 
   /* from + s * (to - from) */
-  glm_vec4_broadcast(glm_clamp_zo(t), s);
+  glm_vec4_broadcast(t, s);
   glm_vec4_sub(to, from, v);
   glm_vec4_mul(s, v, v);
   glm_vec4_add(from, v, dest);
 }
 
+/*!
+ * @brief linear interpolation between two vectors (clamped)
+ *
+ * formula:  from + t * (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_vec4_lerpc(vec4 from, vec4 to, float t, vec4 dest) {
+  glm_vec4_lerp(from, to, glm_clamp_zo(t), dest);
+}
+
+/*!
+ * @brief linear interpolation between two vectors
+ *
+ * formula:  from + t * (to - from)
+ *
+ * @param[in]   from from value
+ * @param[in]   to   to value
+ * @param[in]   t    interpolant (amount)
+ * @param[out]  dest destination
+ */
+CGLM_INLINE
+void
+glm_vec4_mix(vec4 from, vec4 to, float t, vec4 dest) {
+  glm_vec4_lerp(from, to, t, dest);
+}
+
+/*!
+ * @brief linear interpolation between two vectors (clamped)
+ *
+ * formula:  from + t * (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_vec4_mixc(vec4 from, vec4 to, float t, vec4 dest) {
+  glm_vec4_lerpc(from, to, t, dest);
+}
+
+/*!
+ * @brief threshold function (unidimensional)
+ *
+ * @param[in]   edge    threshold
+ * @param[in]   x       value to test against threshold
+ * @param[out]  dest    destination
+ */
+CGLM_INLINE
+void
+glm_vec4_step_uni(float edge, vec4 x, vec4 dest) {
+  dest[0] = glm_step(edge, x[0]);
+  dest[1] = glm_step(edge, x[1]);
+  dest[2] = glm_step(edge, x[2]);
+  dest[3] = glm_step(edge, x[3]);
+}
+
+/*!
+ * @brief threshold function
+ *
+ * @param[in]   edge    threshold
+ * @param[in]   x       value to test against threshold
+ * @param[out]  dest    destination
+ */
+CGLM_INLINE
+void
+glm_vec4_step(vec4 edge, vec4 x, vec4 dest) {
+  dest[0] = glm_step(edge[0], x[0]);
+  dest[1] = glm_step(edge[1], x[1]);
+  dest[2] = glm_step(edge[2], x[2]);
+  dest[3] = glm_step(edge[3], x[3]);
+}
+
+/*!
+ * @brief threshold function with a smooth transition (unidimensional)
+ *
+ * @param[in]   edge0   low threshold
+ * @param[in]   edge1   high threshold
+ * @param[in]   x       value to test against threshold
+ * @param[out]  dest    destination
+ */
+CGLM_INLINE
+void
+glm_vec4_smoothstep_uni(float edge0, float edge1, vec4 x, vec4 dest) {
+  dest[0] = glm_smoothstep(edge0, edge1, x[0]);
+  dest[1] = glm_smoothstep(edge0, edge1, x[1]);
+  dest[2] = glm_smoothstep(edge0, edge1, x[2]);
+  dest[3] = glm_smoothstep(edge0, edge1, x[3]);
+}
+
+/*!
+ * @brief threshold function with a smooth transition
+ *
+ * @param[in]   edge0   low threshold
+ * @param[in]   edge1   high threshold
+ * @param[in]   x       value to test against threshold
+ * @param[out]  dest    destination
+ */
+CGLM_INLINE
+void
+glm_vec4_smoothstep(vec4 edge0, vec4 edge1, vec4 x, vec4 dest) {
+  dest[0] = glm_smoothstep(edge0[0], edge1[0], x[0]);
+  dest[1] = glm_smoothstep(edge0[1], edge1[1], x[1]);
+  dest[2] = glm_smoothstep(edge0[2], edge1[2], x[2]);
+  dest[3] = glm_smoothstep(edge0[3], edge1[3], x[3]);
+}
+
+/*!
+ * @brief smooth Hermite interpolation between two vectors
+ *
+ * formula:  t^2 * (3 - 2*t)
+ *
+ * @param[in]   from    from value
+ * @param[in]   to      to value
+ * @param[in]   t       interpolant (amount)
+ * @param[out]  dest    destination
+ */
+CGLM_INLINE
+void
+glm_vec4_smoothinterp(vec4 from, vec4 to, float t, vec4 dest) {
+  vec4 s, v;
+    
+  /* from + smoothstep * (to - from) */
+  glm_vec4_broadcast(glm_smooth(t), s);
+  glm_vec4_sub(to, from, v);
+  glm_vec4_mul(s, v, v);
+  glm_vec4_add(from, v, dest);
+}
+
+/*!
+ * @brief smooth Hermite interpolation between two vectors (clamped)
+ *
+ * formula:  t^2 * (3 - 2*t)
+ *
+ * @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_vec4_smoothinterpc(vec4 from, vec4 to, float t, vec4 dest) {
+  glm_vec4_smoothinterp(from, to, glm_clamp_zo(t), dest);
+}
+
 /*!
  * @brief helper to fill vec4 as [S^3, S^2, S, 1]
  *
@@ -810,4 +1053,26 @@ glm_vec4_cubic(float s, vec4 dest) {
   dest[3] = 1.0f;
 }
 
+/*!
+ * @brief swizzle vector components
+ *
+ * you can use existin masks e.g. GLM_XXXX, GLM_WZYX
+ *
+ * @param[in]  v    source
+ * @param[in]  mask mask
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_vec4_swizzle(vec4 v, int mask, vec4 dest) {
+  vec4 t;
+
+  t[0] = v[(mask & (3 << 0))];
+  t[1] = v[(mask & (3 << 2)) >> 2];
+  t[2] = v[(mask & (3 << 4)) >> 4];
+  t[3] = v[(mask & (3 << 6)) >> 6];
+
+  glm_vec4_copy(t, dest);
+}
+
 #endif /* cglm_vec4_h */

include/cglm/version.h

@@ -9,7 +9,7 @@
 #define cglm_version_h
 
 #define CGLM_VERSION_MAJOR 0
-#define CGLM_VERSION_MINOR 5
+#define CGLM_VERSION_MINOR 6
-#define CGLM_VERSION_PATCH 4
+#define CGLM_VERSION_PATCH 2
 
 #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/dllmain.c

@@ -1,23 +0,0 @@
-/*
-* Copyright (c), Recep Aslantas.
-*
-* MIT License (MIT), http://opensource.org/licenses/MIT
-* Full license can be found in the LICENSE file
-*/
-
-#include "config.h"
-
-BOOL
-APIENTRY
-DllMain(HMODULE hModule,
-	    DWORD   ul_reason_for_call,
-	    LPVOID  lpReserved) {
-	switch (ul_reason_for_call) {
-	case DLL_PROCESS_ATTACH:
-	case DLL_THREAD_ATTACH:
-	case DLL_THREAD_DETACH:
-	case DLL_PROCESS_DETACH:
-		break;
-	}
-	return TRUE;
-}

src/euler.c

@@ -58,6 +58,6 @@ glmc_euler_yxz(vec3 angles, mat4 dest) {
 
 CGLM_EXPORT
 void
-glmc_euler_by_order(vec3 angles, glm_euler_sq axis, mat4 dest) {
+glmc_euler_by_order(vec3 angles, glm_euler_seq axis, mat4 dest) {
   glm_euler_by_order(angles, axis, dest);
 }

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
@@ -124,7 +124,7 @@ glmc_quat_angle(versor q) {
 
 CGLM_EXPORT
 void
-glmc_quat_axis(versor q, versor dest) {
+glmc_quat_axis(versor q, vec3 dest) {
   glm_quat_axis(q, dest);
 }
 
@@ -164,6 +164,12 @@ glmc_quat_lerp(versor from, versor to, float t, versor dest) {
   glm_quat_lerp(from, to, t, dest);
 }
 
+CGLM_EXPORT
+void
+glmc_quat_lerpc(versor from, versor to, float t, versor dest) {
+  glm_quat_lerpc(from, to, t, dest);
+}
+
 CGLM_EXPORT
 void
 glmc_quat_slerp(versor from, versor to, float t, versor dest) {

src/vec3.c

@@ -74,6 +74,18 @@ glmc_vec3_norm2(vec3 v) {
   return glm_vec3_norm2(v);
 }
 
+CGLM_EXPORT
+float
+glmc_vec3_norm_one(vec3 v) {
+  return glm_vec3_norm_one(v);
+}
+
+CGLM_EXPORT
+float
+glmc_vec3_norm_inf(vec3 v) {
+  return glm_vec3_norm_inf(v);
+}
+
 CGLM_EXPORT
 void
 glmc_vec3_add(vec3 a, vec3 b, vec3 dest) {
@@ -212,28 +224,28 @@ glmc_vec3_center(vec3 a, vec3 b, vec3 dest) {
   glm_vec3_center(a, b, dest);
 }
 
-CGLM_EXPORT
-float
-glmc_vec3_distance2(vec3 a, vec3 b) {
-  return glm_vec3_distance2(a, b);
-}
-
 CGLM_EXPORT
 float
 glmc_vec3_distance(vec3 a, vec3 b) {
   return glm_vec3_distance(a, b);
 }
 
+CGLM_EXPORT
+float
+glmc_vec3_distance2(vec3 a, vec3 b) {
+  return glm_vec3_distance2(a, 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
@@ -254,6 +266,48 @@ glmc_vec3_lerp(vec3 from, vec3 to, float t, vec3 dest) {
   glm_vec3_lerp(from, to, t, dest);
 }
 
+CGLM_EXPORT
+void
+glmc_vec3_lerpc(vec3 from, vec3 to, float t, vec3 dest) {
+  glm_vec3_lerpc(from, to, t, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec3_step_uni(float edge, vec3 x, vec3 dest) {
+  glm_vec3_step_uni(edge, x, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec3_step(vec3 edge, vec3 x, vec3 dest) {
+  glm_vec3_step(edge, x, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec3_smoothstep_uni(float edge0, float edge1, vec3 x, vec3 dest) {
+  glm_vec3_smoothstep_uni(edge0, edge1, x, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec3_smoothstep(vec3 edge0, vec3 edge1, vec3 x, vec3 dest) {
+  glm_vec3_smoothstep(edge0, edge1, x, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec3_smoothinterp(vec3 from, vec3 to, float t, vec3 dest) {
+  glm_vec3_smoothinterp(from, to, t, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec3_smoothinterpc(vec3 from, vec3 to, float t, vec3 dest) {
+  glm_vec3_smoothinterpc(from, to, t, dest);
+}
+
 /* ext */
 
 CGLM_EXPORT
@@ -268,6 +322,12 @@ glmc_vec3_broadcast(float val, vec3 d) {
   glm_vec3_broadcast(val, d);
 }
 
+CGLM_EXPORT
+void
+glmc_vec3_fill(vec3 v, float val) {
+  glm_vec3_fill(v, val);
+}
+
 CGLM_EXPORT
 bool
 glmc_vec3_eq(vec3 v, float val) {
@@ -334,6 +394,24 @@ glmc_vec3_sign(vec3 v, vec3 dest) {
   glm_vec3_sign(v, dest);
 }
 
+CGLM_EXPORT
+void
+glmc_vec3_abs(vec3 v, vec3 dest) {
+  glm_vec3_abs(v, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec3_fract(vec3 v, vec3 dest) {
+  glm_vec3_fract(v, dest);
+}
+
+CGLM_EXPORT
+float
+glmc_vec3_hadd(vec3 v) {
+  return glm_vec3_hadd(v);
+}
+
 CGLM_EXPORT
 void
 glmc_vec3_sqrt(vec3 v, vec3 dest) {

src/vec4.c

@@ -74,6 +74,18 @@ glmc_vec4_norm2(vec4 v) {
   return glm_vec4_norm2(v);
 }
 
+CGLM_EXPORT
+float
+glmc_vec4_norm_one(vec4 v) {
+  return glm_vec4_norm_one(v);
+}
+
+CGLM_EXPORT
+float
+glmc_vec4_norm_inf(vec4 v) {
+  return glm_vec4_norm_inf(v);
+}
+
 CGLM_EXPORT
 void
 glmc_vec4_add(vec4 a, vec4 b, vec4 dest) {
@@ -182,16 +194,22 @@ glmc_vec4_distance(vec4 a, vec4 b) {
   return glm_vec4_distance(a, b);
 }
 
+CGLM_EXPORT
+float
+glmc_vec4_distance2(vec4 a, vec4 b) {
+  return glm_vec4_distance2(a, 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
@@ -206,6 +224,48 @@ glmc_vec4_lerp(vec4 from, vec4 to, float t, vec4 dest) {
   glm_vec4_lerp(from, to, t, dest);
 }
 
+CGLM_EXPORT
+void
+glmc_vec4_lerpc(vec4 from, vec4 to, float t, vec4 dest) {
+  glm_vec4_lerpc(from, to, t, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec4_step_uni(float edge, vec4 x, vec4 dest) {
+  glm_vec4_step_uni(edge, x, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec4_step(vec4 edge, vec4 x, vec4 dest) {
+  glm_vec4_step(edge, x, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec4_smoothstep_uni(float edge0, float edge1, vec4 x, vec4 dest) {
+  glm_vec4_smoothstep_uni(edge0, edge1, x, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec4_smoothstep(vec4 edge0, vec4 edge1, vec4 x, vec4 dest) {
+  glm_vec4_smoothstep(edge0, edge1, x, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec4_smoothinterp(vec4 from, vec4 to, float t, vec4 dest) {
+  glm_vec4_smoothinterp(from, to, t, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec4_smoothinterpc(vec4 from, vec4 to, float t, vec4 dest) {
+  glm_vec4_smoothinterpc(from, to, t, dest);
+}
+
 CGLM_EXPORT
 void
 glmc_vec4_cubic(float s, vec4 dest) {
@@ -226,6 +286,12 @@ glmc_vec4_broadcast(float val, vec4 d) {
   glm_vec4_broadcast(val, d);
 }
 
+CGLM_EXPORT
+void
+glmc_vec4_fill(vec4 v, float val) {
+  glm_vec4_fill(v, val);
+}
+
 CGLM_EXPORT
 bool
 glmc_vec4_eq(vec4 v, float val) {
@@ -292,6 +358,24 @@ glmc_vec4_sign(vec4 v, vec4 dest) {
   glm_vec4_sign(v, dest);
 }
 
+CGLM_EXPORT
+void
+glmc_vec4_abs(vec4 v, vec4 dest) {
+  glm_vec4_abs(v, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec4_fract(vec4 v, vec4 dest) {
+  glm_vec4_fract(v, dest);
+}
+
+CGLM_EXPORT
+float
+glmc_vec4_hadd(vec4 v) {
+  return glm_vec4_hadd(v);
+}
+
 CGLM_EXPORT
 void
 glmc_vec4_sqrt(vec4 v, vec4 dest) {

test/include/common.h

@@ -0,0 +1,119 @@
+/*
+ * 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
+
+#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;
+
+#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 */
+
+#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

@@ -7,8 +7,7 @@
 
 #include "test_common.h"
 
-void
+TEST_IMPL(affine) {
-test_affine(void **state) {
   mat4 t1, t2, t3, t4, t5;
 
   /* test translate is postmultiplied */
@@ -18,7 +17,7 @@ test_affine(void **state) {
   glmc_mat4_mul(t1, t2, t3); /* R * T */
 
   glm_translate(t1, (vec3){34, 57, 36});
-  test_assert_mat4_eq(t1, t3);
+  ASSERTIFY(test_assert_mat4_eq(t1, t3))
 
   /* test rotate is postmultiplied */
   glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
@@ -27,7 +26,7 @@ test_affine(void **state) {
   glmc_mat4_mul(t2, t1, t3); /* T * R */
 
   glm_rotate(t2, GLM_PI_4f, GLM_YUP);
-  test_assert_mat4_eq(t2, t3);
+  ASSERTIFY(test_assert_mat4_eq(t2, t3))
 
   /* test scale is postmultiplied */
   glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
@@ -38,7 +37,7 @@ test_affine(void **state) {
   glmc_mat4_mul(t3, t4, t5); /* T * R * S */
 
   glm_scale(t3, (vec3){3, 5, 6});
-  test_assert_mat4_eq(t3, t5);
+  ASSERTIFY(test_assert_mat4_eq(t3, t5))
 
   /* test translate_x */
   glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
@@ -46,7 +45,7 @@ test_affine(void **state) {
 
   glmc_mat4_mul(t1, t2, t3); /* R * T */
   glm_translate_x(t1, 34);
-  test_assert_mat4_eq(t1, t3);
+  ASSERTIFY(test_assert_mat4_eq(t1, t3))
 
   /* test translate_y */
   glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
@@ -54,7 +53,7 @@ test_affine(void **state) {
 
   glmc_mat4_mul(t1, t2, t3); /* R * T */
   glm_translate_y(t1, 57);
-  test_assert_mat4_eq(t1, t3);
+  ASSERTIFY(test_assert_mat4_eq(t1, t3))
 
   /* test translate_z */
   glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
@@ -62,7 +61,7 @@ test_affine(void **state) {
 
   glmc_mat4_mul(t1, t2, t3); /* R * T */
   glm_translate_z(t1, 36);
-  test_assert_mat4_eq(t1, t3);
+  ASSERTIFY(test_assert_mat4_eq(t1, t3))
 
   /* test rotate_x */
   glmc_rotate_make(t1, GLM_PI_4f, (vec3){1, 0, 0});
@@ -71,7 +70,7 @@ test_affine(void **state) {
   glmc_mat4_mul(t2, t1, t3); /* T * R */
 
   glm_rotate_x(t2, GLM_PI_4f, t2);
-  test_assert_mat4_eq(t2, t3);
+  ASSERTIFY(test_assert_mat4_eq(t2, t3))
 
   /* test rotate_y */
   glmc_rotate_make(t1, GLM_PI_4f, (vec3){0, 1, 0});
@@ -80,7 +79,7 @@ test_affine(void **state) {
   glmc_mat4_mul(t2, t1, t3); /* T * R */
 
   glm_rotate_y(t2, GLM_PI_4f, t2);
-  test_assert_mat4_eq(t2, t3);
+  ASSERTIFY(test_assert_mat4_eq(t2, t3))
 
   /* test rotate_z */
   glmc_rotate_make(t1, GLM_PI_4f, (vec3){0, 0, 1});
@@ -89,7 +88,7 @@ test_affine(void **state) {
   glmc_mat4_mul(t2, t1, t3); /* T * R */
 
   glm_rotate_z(t2, GLM_PI_4f, t2);
-  test_assert_mat4_eq(t2, t3);
+  ASSERTIFY(test_assert_mat4_eq(t2, t3))
 
   /* test rotate */
   glmc_rotate_make(t1, GLM_PI_4f, (vec3){0, 0, 1});
@@ -98,7 +97,7 @@ test_affine(void **state) {
   glmc_mat4_mul(t2, t1, t3); /* T * R */
   glmc_rotate(t2, GLM_PI_4f, (vec3){0, 0, 1});
 
-  test_assert_mat4_eq(t3, t2);
+  ASSERTIFY(test_assert_mat4_eq(t3, t2))
 
   /* test scale_uni */
   glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
@@ -109,5 +108,7 @@ test_affine(void **state) {
   glmc_mat4_mul(t3, t4, t5); /* T * R * S */
 
   glm_scale_uni(t3, 3);
-  test_assert_mat4_eq(t3, t5);
+  ASSERTIFY(test_assert_mat4_eq(t3, t5))
+
+  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_IMPL(bezier) {
-test_bezier(void **state) {
   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));
+  ASSERT(test_eq(Bs,  Bs_plain));
-  test_assert_eqf(smc, Bs_plain);
+  ASSERTIFY(test_assert_eqf(smc, Bs_plain))
-  test_assert_eqf(Bs,  smc);
+  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(test_eq(Bs,  Bs_plain));
-  assert_true(glm_eq(smc, Bs_plain));
+  ASSERT(test_eq(smc, Bs_plain));
-  assert_true(glm_eq(Bs,  smc));
+  ASSERT(test_eq(Bs,  smc));
+  
+  TEST_SUCCESS
 }

test/src/test_cam.c

@@ -7,25 +7,24 @@
 
 #include "test_common.h"
 
-void
+TEST_IMPL(camera_lookat) {
-test_camera_lookat(void **state) {
+  mat4 view1, view2;
-  mat4  view1, view2;
   vec3 center,
-       eye    = {0.024f, 14.6f, 67.04f},
+       eye = {0.024f, 14.6f, 67.04f},
-       dir    = {0.0f, 0.0f, -1.0f},
+       dir = {0.0f, 0.0f, -1.0f},
-       up     = {0.0f, 1.0f, 0.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_IMPL(camera_decomp) {
-test_camera_decomp(void **state) {
   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(fabsf(aspect  - glm_persp_aspect(proj)) < FLT_EPSILON)
-  assert_true(fabsf(fovy    - glm_persp_fovy(proj))   < FLT_EPSILON);
+  ASSERT(fabsf(fovy    - glm_persp_fovy(proj))   < FLT_EPSILON)
-  assert_true(fabsf(49.984f - glm_deg(glm_persp_fovy(proj))) < FLT_EPSILON);
+  ASSERT(fabsf(49.984f - glm_deg(glm_persp_fovy(proj))) < FLT_EPSILON)
 
   glm_persp_sizes(proj, fovy, sizes);
 
-  glm_frustum(-sizes[0] * 0.5,
+  glm_frustum(-sizes[0] * 0.5f,
-               sizes[0] * 0.5,
+               sizes[0] * 0.5f,
-              -sizes[1] * 0.5,
+              -sizes[1] * 0.5f,
-               sizes[1] * 0.5,
+               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_clamp.c

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

test/src/test_common.c

@@ -4,18 +4,12 @@
  */
 
 #include "test_common.h"
-#include <stdlib.h>
+#include <time.h>
-#include <math.h>
-
-#define m 4
-#define n 4
 
 void
 test_rand_mat4(mat4 dest) {
   glm_mat4_copy(GLM_MAT4_IDENTITY, dest);
 
-  srand((unsigned int)time(NULL));
-
   /* random position */
   dest[3][0] = drand48();
   dest[3][1] = drand48();
@@ -32,8 +26,6 @@ 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);
@@ -41,106 +33,242 @@ test_rand_mat3(mat3 dest) {
 
 void
 test_rand_vec3(vec3 dest) {
-  srand((unsigned int)time(NULL));
-
   dest[0] = drand48();
   dest[1] = drand48();
   dest[2] = drand48();
 }
 
+vec3s
+test_rand_vec3s() {
+  vec3s r;
+  test_rand_vec3(r.raw);
+  return r;
+}
+
 void
 test_rand_vec4(vec4 dest) {
-  srand((unsigned int)time(NULL));
-
   dest[0] = drand48();
   dest[1] = drand48();
   dest[2] = drand48();
   dest[3] = drand48();
 }
 
+vec4s
+test_rand_vec4s() {
+  vec4s r;
+  test_rand_vec4(r.raw);
+  return r;
+}
+
 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;
 
-  for (i = 0; i < m; i++) {
+  for (i = 0; i < 4; i++) {
-    for (j = 0; j < n; j++) {
+    for (j = 0; j < 4; j++) {
-      for (k = 0; k < m; k++)
+      for (k = 0; k < 4; 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_mat4_eqt(mat4 m1, mat4 m2) {
+  int i, j, k;
+
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 4; j++) {
+      for (k = 0; k < 4; k++)
+        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 (i = 0; i < 4; i++) {
-    for (j = 0; j < n; j++) {
+    for (j = 0; j < 4; j++) {
-      for (k = 0; k < m; k++)
+      for (k = 0; k < 4; k++)
-        assert_true(fabsf(m1[i][j] - m2[i][j]) <= eps);
+        ASSERT(fabsf(m1[i][j] - m2[i][j]) <= eps);
     }
   }
+  
+  TEST_SUCCESS
 }
 
-void
+test_status_t
 test_assert_mat3_eq(mat3 m1, mat3 m2) {
   int i, j, k;
 
   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, k;
+
+  for (i = 0; i < 3; i++) {
+    for (j = 0; j < 3; j++) {
+      for (k = 0; k < 3; k++)
+        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_vec3_eq(vec3 v1, vec3 v2) {
-  assert_true(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */
+  ASSERT(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */
-  assert_true(fabsf(v1[1] - v2[1]) <= 0.000009);
+  ASSERT(fabsf(v1[1] - v2[1]) <= 0.000009);
-  assert_true(fabsf(v1[2] - v2[2]) <= 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
+}
+
+test_status_t
 test_assert_vec4_eq(vec4 v1, vec4 v2) {
-  assert_true(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */
+  ASSERT(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */
-  assert_true(fabsf(v1[1] - v2[1]) <= 0.000009);
+  ASSERT(fabsf(v1[1] - v2[1]) <= 0.000009);
-  assert_true(fabsf(v1[2] - v2[2]) <= 0.000009);
+  ASSERT(fabsf(v1[2] - v2[2]) <= 0.000009);
-  assert_true(fabsf(v1[3] - v2[3]) <= 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
+}
+
+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(fabsf(fabsf(v1[0]) - fabsf(v2[0])) <= 0.0009); /* rounding errors */
-  assert_true(fabsf(fabsf(v1[1]) - fabsf(v2[1])) <= 0.0009);
+  ASSERT(fabsf(fabsf(v1[1]) - fabsf(v2[1])) <= 0.0009);
-  assert_true(fabsf(fabsf(v1[2]) - fabsf(v2[2])) <= 0.0009);
+  ASSERT(fabsf(fabsf(v1[2]) - fabsf(v2[2])) <= 0.0009);
-  assert_true(fabsf(fabsf(v1[3]) - fabsf(v2[3])) <= 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(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */
-  assert_true(fabsf(v1[1] - v2[1]) <= 0.000009);
+  ASSERT(fabsf(v1[1] - v2[1]) <= 0.000009);
-  assert_true(fabsf(v1[2] - v2[2]) <= 0.000009);
+  ASSERT(fabsf(v1[2] - v2[2]) <= 0.000009);
-  assert_true(fabsf(v1[3] - v2[3]) <= 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,19 +8,7 @@
 #ifndef test_common_h
 #define test_common_h
 
-#include <stdarg.h>
+#include "../include/common.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/call.h>
 
 void
 test_rand_mat4(mat4 dest);
@@ -28,35 +16,68 @@ test_rand_mat4(mat4 dest);
 void
 test_rand_mat3(mat3 dest);
 
-void
+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_mat3_eq(mat3 m1, mat3 m2);
 
-void
+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);
+
+test_status_t
 test_assert_vec4_eq(vec4 v1, vec4 v2);
 
-void
+test_status_t
+test_assert_vec4s_eq(vec4s v1, vec4s v2);
+
+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
 test_rand_vec3(vec3 dest);
 
+vec3s
+test_rand_vec3s(void);
+
 void
-test_rand_vec4(vec4 dest) ;
+test_rand_vec4(vec4 dest);
+
+vec4s
+test_rand_vec4s(void);
 
 float
 test_rand(void);
@@ -64,4 +85,16 @@ test_rand(void);
 void
 test_rand_quat(versor q);
 
+CGLM_INLINE
+bool
+test_eq(float a, float b) {
+  return fabsf(a - b) <= 1e-6;
+}
+
+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_IMPL(euler) {
-test_euler(void **state) {
+  mat4 rot1, rot2;
-  mat4  rot1, rot2;
+  vec3 inAngles, outAngles;
-  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);
-}

test/src/test_mat3.c

@@ -5,54 +5,22 @@
  * Full license can be found in the LICENSE file
  */
 
-#include "test_common.h"
+/* test inline mat3 */
 
-#define m 3
+#define GLM_PREFIX glm_
-#define n 3
+#define GLM(X) (glm_ ## X)
 
-void
+#include "test_mat3.h"
-test_mat3(void **state) {
-  mat3  m1 = GLM_MAT3_IDENTITY_INIT;
-  mat3  m2 = GLM_MAT3_IDENTITY_INIT;
-  mat3  m3;
-  mat3  m4 = GLM_MAT3_ZERO_INIT;
-  mat3  m5;
-  int   i, j, k;
 
-  /* test identity matrix multiplication */
+#undef GLM
-  glmc_mat3_mul(m1, m2, m3);
+#undef GLM_PREFIX
-  for (i = 0; i < m; i++) {
-    for (j = 0; j < n; j++) {
-      if (i == j)
-        assert_true(glm_eq(m3[i][j], 1.0f));
-      else
-        assert_true(glm_eq(m3[i][j], 0.0f));
-    }
-  }
 
-  /* test random matrices */
+/* test pre-compiled mat3 */
-  /* random matrices */
-  test_rand_mat3(m1);
-  test_rand_mat3(m2);
 
-  glmc_mat3_mul(m1, m2, m3);
+#define GLM_PREFIX glmc_
-  for (i = 0; i < m; i++) {
+#define GLM(X) (glmc_ ## X)
-    for (j = 0; j < n; j++) {
-      for (k = 0; k < m; k++)
-        /* column-major */
-        m4[i][j] += m1[k][j] * m2[i][k];
-    }
-  }
 
-  test_assert_mat3_eq(m3, m4);
+#include "test_mat3.h"
 
-  for (i = 0; i < 100000; i++) {
+#undef GLM
-    test_rand_mat3(m3);
+#undef GLM_PREFIX
-    test_rand_mat3(m4);
-
-    /* test inverse precise */
-    glmc_mat3_inv(m3, m4);
-    glmc_mat3_inv(m4, m5);
-    test_assert_mat3_eq(m3, m5);
-  }
-}

test/src/test_mat3.h

@@ -0,0 +1,309 @@
+/*
+ * 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"
+
+#define A_MATRIX {{1,2,3},{5,6,7},{9,10,11}}
+
+TEST_IMPL(GLM_PREFIX, mat3_copy) {
+  mat3 m1 = A_MATRIX;
+  mat3 m2 = GLM_MAT3_IDENTITY_INIT;
+
+  GLM(mat3_copy)(m1, m2);
+
+  test_assert_mat3_eq(m1, m2);
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3_identity) {
+  mat3 m1 = GLM_MAT3_IDENTITY_INIT;
+  mat3 m2 = GLM_MAT3_IDENTITY_INIT;
+  mat3 m3;
+
+  GLM(mat3_identity)(m3);
+
+  ASSERTIFY(test_assert_mat3_eq_identity(m1))
+  ASSERTIFY(test_assert_mat3_eq_identity(m2))
+  ASSERTIFY(test_assert_mat3_eq_identity(m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3_identity_array) {
+  int i, count;
+  mat3 matrices[4] = {
+    A_MATRIX,
+    A_MATRIX,
+    A_MATRIX,
+    A_MATRIX
+  };
+
+  count = 4;
+
+  GLM(mat3_identity_array)(matrices, count);
+
+  for (i = 0; i < count; i++) {
+    ASSERTIFY(test_assert_mat3_eq_identity(matrices[i]))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3_zero) {
+  mat3 m1 = GLM_MAT3_ZERO_INIT;
+  mat3 m2 = GLM_MAT3_ZERO_INIT;
+  mat3 m3;
+
+  GLM(mat3_zero)(m3);
+
+  ASSERTIFY(test_assert_mat3_eq_zero(m1))
+  ASSERTIFY(test_assert_mat3_eq_zero(m2))
+  ASSERTIFY(test_assert_mat3_eq_zero(m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3_mul) {
+  mat3 m1 = GLM_MAT3_IDENTITY_INIT;
+  mat3 m2 = GLM_MAT3_IDENTITY_INIT;
+  mat3 m3;
+  mat3 m4 = GLM_MAT3_ZERO_INIT;
+  int  i, j, k;
+
+  /* test random matrices */
+  /* random matrices */
+  test_rand_mat3(m1);
+  test_rand_mat3(m2);
+
+  GLM(mat3_mul)(m1, m2, m3);
+  for (i = 0; i < 3; i++) {
+    for (j = 0; j < 3; j++) {
+      for (k = 0; k < 3; k++)
+        /* column-major */
+        m4[i][j] += m1[k][j] * m2[i][k];
+    }
+  }
+
+  ASSERTIFY(test_assert_mat3_eq(m3, m4))
+
+  /* test pre compiled */
+  GLM(mat3_mul)(m1, m2, m3);
+  ASSERTIFY(test_assert_mat3_eq(m3, m4))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3_mulv) {
+  vec4 res;
+  mat3 mat = A_MATRIX;
+  vec4 v = {1.0f, 2.0f, 3.0f, 4.0f};
+  int  i;
+
+  GLM(mat3_mulv)(mat, v, res);
+
+  for (i = 0; i < 3; i++) {
+    ASSERT(test_eq(res[i],
+                  v[0] * mat[0][i]
+                  + v[1] * mat[1][i]
+                  + v[2] * mat[2][i]))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3_trace) {
+  mat3  mat = A_MATRIX;
+  float trace;
+
+  trace = GLM(mat3_trace)(mat);
+
+  ASSERT(test_eq(trace, mat[0][0] + mat[1][1] + mat[2][2]))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3_quat) {
+  mat3   m1, m3;
+  mat4   m2;
+  versor q1, q2, q3;
+  vec3   axis1;
+  vec3   axis2 = {1.9f, 2.3f, 4.5f};
+
+  GLM(quat)(q1, GLM_PI_4f, 1.9f, 2.3f, 4.5f);
+  GLM(quat_mat3)(q1, m1);
+  GLM(mat3_quat)(m1, q2);
+
+  GLM(rotate_make)(m2, GLM_PI_4f, axis2);
+  GLM(mat3_quat)(m1, q3);
+
+  GLM(quat_axis)(q3, axis1);
+
+  GLM(vec3_normalize)(axis1);
+  GLM(vec3_normalize)(axis2);
+
+  GLM(mat4_pick3)(m2, m3);
+
+  ASSERT(test_eq(glm_quat_angle(q3), GLM_PI_4f))
+  ASSERTIFY(test_assert_vec3_eq(axis1, axis2))
+  ASSERTIFY(test_assert_vec4_eq(q1, q2))
+  ASSERTIFY(test_assert_mat3_eq(m1, m3))
+  ASSERTIFY(test_assert_vec4_eq(q1, q3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3_transpose_to) {
+  mat3 mat = A_MATRIX;
+  mat3 m1;
+
+  GLM(mat3_transpose_to)(mat, m1);
+
+  ASSERTIFY(test_assert_mat3_eqt(mat, m1))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3_transpose) {
+  mat3 mat = A_MATRIX;
+  mat3 m1;
+
+  GLM(mat3_copy)(mat, m1);
+  GLM(mat3_transpose)(m1);
+
+  ASSERTIFY(test_assert_mat3_eqt(mat, m1))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3_scale) {
+  mat3 m1 = A_MATRIX;
+  mat3 m2 = A_MATRIX;
+  int i, j, k, scale;
+
+  scale = rand() % 100;
+
+  GLM(mat3_scale)(m1, (float)scale);
+
+  for (i = 0; i < 3; i++) {
+    for (j = 0; j < 3; j++) {
+      for (k = 0; k < 3; k++)
+        ASSERT(test_eq(m1[i][j], m2[i][j] * scale))
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3_det) {
+  mat3 mat;
+  float a, b, c,
+        d, e, f,
+        g, h, i;
+  float det1, det2;
+
+  test_rand_mat3(mat);
+
+  a = mat[0][0]; b = mat[0][1]; c = mat[0][2];
+  d = mat[1][0]; e = mat[1][1]; f = mat[1][2];
+  g = mat[2][0]; h = mat[2][1]; i = mat[2][2];
+
+  det1 = a * (e * i - h * f) - d * (b * i - c * h) + g * (b * f - c * e);
+  det2 = GLM(mat3_det)(mat);
+
+  ASSERT(test_eq(det1, det2))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3_inv) {
+  mat3 m1 = GLM_MAT3_IDENTITY_INIT;
+  mat3 m2 = GLM_MAT3_IDENTITY_INIT;
+  mat3 m3;
+  int  i;
+
+  for (i = 0; i < 100000; i++) {
+    test_rand_mat3(m1);
+    test_rand_mat3(m2);
+
+    /* test inverse precise */
+    GLM(mat3_inv)(m1, m2);
+    GLM(mat3_inv)(m2, m3);
+    ASSERTIFY(test_assert_mat3_eq(m1, m3))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3_swap_col) {
+  mat3 m1 = A_MATRIX;
+  mat3 m2 = A_MATRIX;
+
+  GLM(mat3_swap_col)(m1, 0, 1);
+
+  ASSERTIFY(test_assert_vec3_eq(m1[0], m2[1]))
+  ASSERTIFY(test_assert_vec3_eq(m1[1], m2[0]))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3_swap_row) {
+  mat3 m1 = A_MATRIX;
+  mat3 m2 = A_MATRIX;
+
+  GLM(mat3_swap_row)(m1, 0, 1);
+
+  ASSERT(test_eq(m1[0][0], m2[0][1]))
+  ASSERT(test_eq(m1[0][1], m2[0][0]))
+  ASSERT(test_eq(m1[0][2], m2[0][2]))
+
+  ASSERT(test_eq(m1[1][0], m2[1][1]))
+  ASSERT(test_eq(m1[1][1], m2[1][0]))
+  ASSERT(test_eq(m1[1][2], m2[1][2]))
+
+  ASSERT(test_eq(m1[2][0], m2[2][1]))
+  ASSERT(test_eq(m1[2][1], m2[2][0]))
+  ASSERT(test_eq(m1[2][2], m2[2][2]))
+
+  GLM(mat3_swap_row)(m1, 1, 2);
+
+  ASSERT(test_eq(m1[0][0], m2[0][1]))
+  ASSERT(test_eq(m1[0][1], m2[0][2]))
+  ASSERT(test_eq(m1[0][2], m2[0][0]))
+
+  ASSERT(test_eq(m1[1][0], m2[1][1]))
+  ASSERT(test_eq(m1[1][1], m2[1][2]))
+  ASSERT(test_eq(m1[1][2], m2[1][0]))
+
+  ASSERT(test_eq(m1[2][0], m2[2][1]))
+  ASSERT(test_eq(m1[2][1], m2[2][2]))
+  ASSERT(test_eq(m1[2][2], m2[2][0]))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3_rmc) {
+  mat3  mat = A_MATRIX;
+  vec3  v   = {11.0f, 12.0f, 13.0f};
+  vec3  v1;
+  float r1, r2;
+  int   i;
+
+  r1 = GLM(mat3_rmc)(v, mat, v);
+
+  for (i = 0; i < 3; i++) {
+    v1[i] = v[0] * mat[i][0]
+          + v[1] * mat[i][1]
+          + v[2] * mat[i][2];
+  }
+
+  r2 = v[0] * v1[0] + v[1] * v1[1] + v[2] * v1[2];
+
+  ASSERT(test_eq(r1, r2))
+
+  TEST_SUCCESS
+}

test/src/test_mat4.c

@@ -5,90 +5,22 @@
  * Full license can be found in the LICENSE file
  */
 
-#include "test_common.h"
+/* test inline mat4 */
 
-#define m 4
+#define GLM_PREFIX glm_
-#define n 4
+#define GLM(X) (glm_ ## X)
 
-void
+#include "test_mat4.h"
-test_mat4(void **state) {
-  mat4  m1 = GLM_MAT4_IDENTITY_INIT;
-  mat4  m2 = GLM_MAT4_IDENTITY_INIT;
-  mat4  m3;
-  mat4  m4 = GLM_MAT4_ZERO_INIT;
-  mat4  m5;
-  int   i, j, k;
 
-  /* test identity matrix multiplication */
+#undef GLM
-  glm_mat4_mul(m1, m2, m3);
+#undef GLM_PREFIX
-  for (i = 0; i < m; i++) {
-    for (j = 0; j < n; j++) {
-      if (i == j)
-        assert_true(glm_eq(m3[i][j], 1.0f));
-      else
-        assert_true(glm_eq(m3[i][j], 0.0f));
-    }
-  }
 
-  /* test random matrices */
+/* test pre-compiled mat4 */
-  /* random matrices */
-  test_rand_mat4(m1);
-  test_rand_mat4(m2);
 
-  glm_mat4_mul(m1, m2, m3);
+#define GLM_PREFIX glmc_
-  for (i = 0; i < m; i++) {
+#define GLM(X) (glmc_ ## X)
-    for (j = 0; j < n; j++) {
-      for (k = 0; k < m; k++)
-        /* column-major */
-        m4[i][j] += m1[k][j] * m2[i][k];
-    }
-  }
 
-  test_assert_mat4_eq(m3, m4);
+#include "test_mat4.h"
 
-  /* test pre compiled */
+#undef GLM
-  glmc_mat4_mul(m1, m2, m3);
+#undef GLM_PREFIX
-  test_assert_mat4_eq(m3, m4);
-
-  for (i = 0; i < 100000; i++) {
-    test_rand_mat4(m3);
-    test_rand_mat4(m4);
-    
-    /* test inverse precise */
-    glm_mat4_inv_precise(m3, m4);
-    glm_mat4_inv_precise(m4, m5);
-    test_assert_mat4_eq(m3, m5);
-    
-    test_rand_mat4(m3);
-    test_rand_mat4(m4);
-
-    glmc_mat4_inv_precise(m3, m4);
-    glmc_mat4_inv_precise(m4, m5);
-    test_assert_mat4_eq(m3, m5);
-    
-    /* test inverse rcp */
-    test_rand_mat4(m3);
-    test_rand_mat4(m4);
-    
-    glm_mat4_inv_fast(m3, m4);
-    glm_mat4_inv_fast(m4, m5);
-    test_assert_mat4_eq2(m3, m5, 0.0009f);
-    
-    test_rand_mat4(m3);
-    test_rand_mat4(m4);
-    
-    glmc_mat4_inv(m3, m4);
-    glmc_mat4_inv(m4, m5);
-    test_assert_mat4_eq2(m3, m5, 0.0009f);
-  }
-
-  /* print */
-  glm_mat4_print(m3, stderr);
-  glm_mat4_print(m4, stderr);
-
-  /* test determinant */
-  assert_int_equal(glm_mat4_det(m1), glmc_mat4_det(m1));
-#if defined( __SSE2__ )
-  assert_int_equal(glmc_mat4_det(m1), glm_mat4_det_sse2(m1));
-#endif
-}

test/src/test_mat4.h

@@ -0,0 +1,485 @@
+/*
+ * 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"
+
+#define A_MATRIX  {{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}}
+#define A_MATRIX3 {{1,2,3},{5,6,7},{9,10,11}}
+
+TEST_IMPL(GLM_PREFIX, mat4_ucopy) {
+  mat4 m1 = A_MATRIX;
+  mat4 m2 = GLM_MAT4_IDENTITY_INIT;
+
+  GLM(mat4_ucopy)(m1, m2);
+
+  ASSERTIFY(test_assert_mat4_eq(m1, m2))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4_copy) {
+  mat4 m1 = A_MATRIX;
+  mat4 m2 = GLM_MAT4_IDENTITY_INIT;
+
+  GLM(mat4_copy)(m1, m2);
+
+  test_assert_mat4_eq(m1, m2);
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4_identity) {
+  mat4 m1 = GLM_MAT4_IDENTITY_INIT;
+  mat4 m2 = GLM_MAT4_IDENTITY_INIT;
+  mat4 m3;
+
+  GLM(mat4_identity)(m3);
+
+  ASSERTIFY(test_assert_mat4_eq_identity(m1))
+  ASSERTIFY(test_assert_mat4_eq_identity(m2))
+  ASSERTIFY(test_assert_mat4_eq_identity(m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4_identity_array) {
+  int i, count;
+  mat4 matrices[4] = {
+    A_MATRIX,
+    A_MATRIX,
+    A_MATRIX,
+    A_MATRIX
+  };
+
+  count = 4;
+
+  GLM(mat4_identity_array)(matrices, count);
+
+  for (i = 0; i < count; i++) {
+    ASSERTIFY(test_assert_mat4_eq_identity(matrices[i]))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4_zero) {
+  mat4 m1 = GLM_MAT4_ZERO_INIT;
+  mat4 m2 = GLM_MAT4_ZERO_INIT;
+  mat4 m3;
+
+  GLM(mat4_zero)(m3);
+
+  ASSERTIFY(test_assert_mat4_eq_zero(m1))
+  ASSERTIFY(test_assert_mat4_eq_zero(m2))
+  ASSERTIFY(test_assert_mat4_eq_zero(m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4_pick3) {
+  mat4 m1 = A_MATRIX;
+  mat3 m2 = GLM_MAT3_ZERO_INIT;
+  mat3 m3 = A_MATRIX3;
+
+  GLM(mat4_pick3)(m1, m2);
+
+  ASSERTIFY(test_assert_mat3_eq(m2, m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4_pick3t) {
+  mat4 m1 = A_MATRIX;
+  mat3 m2 = GLM_MAT3_ZERO_INIT;
+  mat3 m3 = A_MATRIX3;
+
+  GLM(mat4_pick3t)(m1, m2);
+
+  ASSERTIFY(test_assert_mat3_eqt(m2, m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4_ins3) {
+  mat4 m1 = GLM_MAT4_IDENTITY_INIT;
+  mat3 m2 = A_MATRIX3;
+  int i, j;
+
+  GLM(mat4_ins3)(m2, m1);
+
+  for (i = 0; i < 3; i++) {
+    for (j = 0; j < 3; j++) {
+      ASSERT(m1[i][j] == m2[i][j])
+    }
+  }
+
+  ASSERT(test_eq(m1[3][0], 0.0f))
+  ASSERT(test_eq(m1[3][1], 0.0f))
+  ASSERT(test_eq(m1[3][2], 0.0f))
+  ASSERT(test_eq(m1[3][3], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4_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 random matrices */
+  /* random matrices */
+  test_rand_mat4(m1);
+  test_rand_mat4(m2);
+
+  GLM(mat4_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(mat4_mul)(m1, m2, m3);
+  ASSERTIFY(test_assert_mat4_eq(m3, m4))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4_mulN) {
+  mat4 res1, res2;
+  mat4 m1 = A_MATRIX;
+  mat4 m2 = A_MATRIX;
+  mat4 m3 = A_MATRIX;
+
+  mat4 *matrices[] = {
+    &m1, &m2, &m3
+  };
+
+  GLM(mat4_mulN)(matrices, sizeof(matrices) / sizeof(matrices[0]), res1);
+
+  GLM(mat4_mul)(*matrices[0], *matrices[1], res2);
+  GLM(mat4_mul)(res2, *matrices[2], res2);
+
+  ASSERTIFY(test_assert_mat4_eq(res1, res1))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4_mulv) {
+  vec4 res;
+  mat4 mat = A_MATRIX;
+  vec4 v = {1.0f, 2.0f, 3.0f, 4.0f};
+  int  i;
+
+  GLM(mat4_mulv)(mat, v, res);
+
+  for (i = 0; i < 4; i++) {
+    ASSERT(test_eq(res[i],
+                  v[0] * mat[0][i]
+                + v[1] * mat[1][i]
+                + v[2] * mat[2][i]
+                + v[3] * mat[3][i]))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4_mulv3) {
+  vec4  res;
+  mat4  mat = A_MATRIX;
+  vec3  v = {1.0f, 2.0f, 3.0f};
+  float last;
+  int   i;
+
+  last = 1.0f;
+
+  GLM(mat4_mulv3)(mat, v, last, res);
+
+  for (i = 0; i < 3; i++) {
+    ASSERT(test_eq(res[i],
+                  v[0] * mat[0][i]
+                  + v[1] * mat[1][i]
+                  + v[2] * mat[2][i]
+                  + last * mat[3][i]))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4_trace) {
+  mat4  mat = A_MATRIX;
+  float trace;
+
+  trace = GLM(mat4_trace)(mat);
+
+  ASSERT(test_eq(trace, mat[0][0] + mat[1][1] + mat[2][2] + mat[3][3]))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4_trace3) {
+  mat4  mat = A_MATRIX;
+  float trace;
+
+  trace = GLM(mat4_trace3)(mat);
+
+  ASSERT(test_eq(trace, mat[0][0] + mat[1][1] + mat[2][2]))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4_quat) {
+  mat4   m1, m2;
+  versor q1, q2, q3;
+  vec3   axis1;
+  vec3   axis2 = {1.9f, 2.3f, 4.5f};
+  
+  GLM(quat)(q1, GLM_PI_4f, 1.9f, 2.3f, 4.5f);
+  GLM(quat_mat4)(q1, m1);
+  GLM(mat4_quat)(m1, q2);
+  
+  GLM(rotate_make)(m2, GLM_PI_4f, axis2);
+  GLM(mat4_quat)(m1, q3);
+  
+  GLM(quat_axis)(q3, axis1);
+  
+  GLM(vec3_normalize)(axis1);
+  GLM(vec3_normalize)(axis2);
+  
+  ASSERT(test_eq(glm_quat_angle(q3), GLM_PI_4f))
+  ASSERTIFY(test_assert_vec3_eq(axis1, axis2))
+  ASSERTIFY(test_assert_vec4_eq(q1, q2))
+  ASSERTIFY(test_assert_mat4_eq(m1, m2))
+  ASSERTIFY(test_assert_vec4_eq(q1, q3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4_transpose_to) {
+  mat4  mat = A_MATRIX;
+  mat4  m1;
+
+  GLM(mat4_transpose_to)(mat, m1);
+  
+  ASSERTIFY(test_assert_mat4_eqt(mat, m1))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4_transpose) {
+  mat4 mat = A_MATRIX;
+  mat4 m1;
+
+  GLM(mat4_copy)(mat, m1);
+  GLM(mat4_transpose)(m1);
+  
+  ASSERTIFY(test_assert_mat4_eqt(mat, m1))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4_scale_p) {
+  mat4 m1 = A_MATRIX;
+  mat4 m2 = A_MATRIX;
+  int i, j, k, scale;
+
+  scale = rand() % 100;
+  
+  GLM(mat4_scale_p)(m1, (float)scale);
+
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 4; j++) {
+      for (k = 0; k < 4; k++)
+        ASSERT(test_eq(m1[i][j], m2[i][j] * scale))
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4_scale) {
+  mat4 m1 = A_MATRIX;
+  mat4 m2 = A_MATRIX;
+  int i, j, k, scale;
+
+  scale = rand() % 100;
+  
+  GLM(mat4_scale)(m1, (float)scale);
+
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 4; j++) {
+      for (k = 0; k < 4; k++)
+        ASSERT(test_eq(m1[i][j], m2[i][j] * scale))
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4_det) {
+  mat4 mat = GLM_MAT4_IDENTITY_INIT;
+  float t[6];
+  float a, b, c, d,
+        e, f, g, h,
+        i, j, k, l,
+        m, n, o, p;
+  float det1, det2;
+
+  test_rand_mat4(mat);
+
+  a = mat[0][0]; b = mat[0][1]; c = mat[0][2]; d = mat[0][3];
+  e = mat[1][0]; f = mat[1][1]; g = mat[1][2]; h = mat[1][3];
+  i = mat[2][0]; j = mat[2][1]; k = mat[2][2]; l = mat[2][3];
+  m = mat[3][0]; n = mat[3][1]; o = mat[3][2]; p = mat[3][3];
+
+  t[0] = k * p - o * l;
+  t[1] = j * p - n * l;
+  t[2] = j * o - n * k;
+  t[3] = i * p - m * l;
+  t[4] = i * o - m * k;
+  t[5] = i * n - m * j;
+
+  det1 = a * (f * t[0] - g * t[1] + h * t[2])
+       - b * (e * t[0] - g * t[3] + h * t[4])
+       + c * (e * t[1] - f * t[3] + h * t[5])
+       - d * (e * t[2] - f * t[4] + g * t[5]);
+
+  det2 = GLM(mat4_det(mat));
+
+  ASSERT(test_eq(det1, det2))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4_inv) {
+  mat4 m1, m2, m3;
+  int  i;
+
+  for (i = 0; i < 100000; i++) {
+    test_rand_mat4(m1);
+    test_rand_mat4(m2);
+
+    /* test inverse precise */
+    GLM(mat4_inv)(m1, m2);
+    GLM(mat4_inv)(m2, m3);
+    ASSERTIFY(test_assert_mat4_eq(m1, m3))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4_inv_precise) {
+  mat4 m1, m2, m3;
+  mat4 m4, m5, m6;
+  int  i;
+
+  for (i = 0; i < 100000; i++) {
+    test_rand_mat4(m1);
+    test_rand_mat4(m2);
+    
+    glm_mat4_inv_precise(m1, m2);
+    glm_mat4_inv_precise(m2, m3);
+    ASSERTIFY(test_assert_mat4_eq(m1, m3))
+    
+    test_rand_mat4(m4);
+    test_rand_mat4(m5);
+    
+    glmc_mat4_inv_precise(m4, m5);
+    glmc_mat4_inv_precise(m5, m6);
+    ASSERTIFY(test_assert_mat4_eq(m4, m6))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4_inv_fast) {
+  mat4 m1, m2, m3;
+  int  i;
+  
+  for (i = 0; i < 100000; i++) {
+    test_rand_mat4(m1);
+    test_rand_mat4(m2);
+    
+    /* test inverse precise */
+    GLM(mat4_inv_fast)(m1, m2);
+    GLM(mat4_inv_fast)(m2, m3);
+    ASSERTIFY(test_assert_mat4_eq2(m1, m3, 0.0009f))
+  }
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4_swap_col) {
+  mat4 m1 = A_MATRIX;
+  mat4 m2 = A_MATRIX;
+  
+  GLM(mat4_swap_col)(m1, 0, 1);
+  GLM(mat4_swap_col)(m1, 2, 3);
+
+  ASSERTIFY(test_assert_vec4_eq(m1[0], m2[1]))
+  ASSERTIFY(test_assert_vec4_eq(m1[1], m2[0]))
+  ASSERTIFY(test_assert_vec4_eq(m1[2], m2[3]))
+  ASSERTIFY(test_assert_vec4_eq(m1[3], m2[2]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4_swap_row) {
+  mat4 m1 = A_MATRIX;
+  mat4 m2 = A_MATRIX;
+  
+  GLM(mat4_swap_row)(m1, 0, 1);
+  GLM(mat4_swap_row)(m1, 2, 3);
+  
+  ASSERT(test_eq(m1[0][0], m2[0][1]))
+  ASSERT(test_eq(m1[0][1], m2[0][0]))
+  ASSERT(test_eq(m1[0][2], m2[0][3]))
+  ASSERT(test_eq(m1[0][3], m2[0][2]))
+  ASSERT(test_eq(m1[1][0], m2[1][1]))
+  ASSERT(test_eq(m1[1][1], m2[1][0]))
+  ASSERT(test_eq(m1[1][2], m2[1][3]))
+  ASSERT(test_eq(m1[1][3], m2[1][2]))
+  ASSERT(test_eq(m1[2][0], m2[2][1]))
+  ASSERT(test_eq(m1[2][1], m2[2][0]))
+  ASSERT(test_eq(m1[2][2], m2[2][3]))
+  ASSERT(test_eq(m1[2][3], m2[2][2]))
+  ASSERT(test_eq(m1[3][0], m2[3][1]))
+  ASSERT(test_eq(m1[3][1], m2[3][0]))
+  ASSERT(test_eq(m1[3][2], m2[3][3]))
+  ASSERT(test_eq(m1[3][3], m2[3][2]))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4_rmc) {
+  mat4  mat = A_MATRIX;
+  vec4  v = {1.0f, 2.0f, 3.0f, 4.0f};
+  vec4  v1;
+  float r1, r2;
+  int   i;
+
+  r1 = GLM(mat4_rmc)(v, mat, v);
+
+  for (i = 0; i < 4; i++) {
+    v1[i] = v[0] * mat[i][0]
+          + v[1] * mat[i][1]
+          + v[2] * mat[i][2]
+          + v[3] * mat[i][3];
+  }
+  
+  r2 = v[0] * v1[0] + v[1] * v1[1] + v[2] * v1[2] + v[3] * v1[3];
+
+  ASSERT(test_eq(r1, r2))
+
+  TEST_SUCCESS
+}

test/src/test_project.c

@@ -5,27 +5,22 @@
  * Full license can be found in the LICENSE file
  */
 
-#include "test_common.h"
+/* test inline project */
 
-void
+#define GLM_PREFIX glm_
-test_project(void **state) {
+#define GLM(X) (glm_ ## X)
-  mat4 model, view, proj, mvp;
-  vec4 viewport = {0.0f, 0.0f, 800.0f, 600.0f};
-  vec3 pos      = {13.0f, 45.0f, 0.74f};
-  vec3 projected, unprojected;
 
-  glm_translate_make(model, (vec3){0.0f, 0.0f, -10.0f});
+#include "test_project.h"
-  glm_lookat((vec3){0.0f, 0.0f, 0.0f}, pos, GLM_YUP, view);
 
-  glm_perspective_default(0.5f, proj);
+#undef GLM
-  glm_mat4_mulN((mat4 *[]){&proj, &view, &model}, 3, mvp);
+#undef GLM_PREFIX
 
-  glmc_project(pos, mvp, viewport, projected);
+/* test pre-compiled project */
-  glmc_unproject(projected, mvp, viewport, unprojected);
 
-  /* unprojected of projected vector must be same as original one */
+#define GLM_PREFIX glmc_
-  /* we used 0.01 because of projection floating point errors */
+#define GLM(X) (glmc_ ## X)
-  assert_true(fabsf(pos[0] - unprojected[0]) < 0.01);
+
-  assert_true(fabsf(pos[1] - unprojected[1]) < 0.01);
+#include "test_project.h"
-  assert_true(fabsf(pos[2] - unprojected[2]) < 0.01);
+
-}
+#undef GLM
+#undef GLM_PREFIX

test/src/test_project.h

@@ -0,0 +1,92 @@
+/*
+ * 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, unprojecti) {
+  mat4 model, view, proj, mvp;
+  vec4 viewport = {0.0f, 0.0f, 800.0f, 600.0f};
+  vec3 pos      = {13.0f, 45.0f, 0.74f};
+  vec3 projected, unprojected;
+
+  glm_translate_make(model, (vec3){0.0f, 0.0f, -10.0f});
+  glm_lookat((vec3){0.0f, 0.0f, 0.0f}, pos, GLM_YUP, view);
+
+  glm_perspective_default(0.5f, proj);
+  glm_mat4_mulN((mat4 *[]){&proj, &view, &model}, 3, mvp);
+
+  GLM(project)(pos, mvp, viewport, projected);
+
+  glm_mat4_inv(mvp, mvp);
+  GLM(unprojecti)(projected, mvp, viewport, unprojected);
+
+  /* unprojected of projected vector must be same as original one */
+  /* we used 0.01 because of projection floating point errors */
+  ASSERT(fabsf(pos[0] - unprojected[0]) < 0.01)
+  ASSERT(fabsf(pos[1] - unprojected[1]) < 0.01)
+  ASSERT(fabsf(pos[2] - unprojected[2]) < 0.01)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, unproject) {
+  mat4 model, view, proj, mvp;
+  vec4 viewport = {0.0f, 0.0f, 800.0f, 600.0f};
+  vec3 pos      = {13.0f, 45.0f, 0.74f};
+  vec3 projected, unprojected;
+
+  glm_translate_make(model, (vec3){0.0f, 0.0f, -10.0f});
+  glm_lookat((vec3){0.0f, 0.0f, 0.0f}, pos, GLM_YUP, view);
+
+  glm_perspective_default(0.5f, proj);
+  glm_mat4_mulN((mat4 *[]){&proj, &view, &model}, 3, mvp);
+
+  GLM(project)(pos, mvp, viewport, projected);
+  GLM(unproject)(projected, mvp, viewport, unprojected);
+
+  /* unprojected of projected vector must be same as original one */
+  /* we used 0.01 because of projection floating point errors */
+  ASSERT(fabsf(pos[0] - unprojected[0]) < 0.01)
+  ASSERT(fabsf(pos[1] - unprojected[1]) < 0.01)
+  ASSERT(fabsf(pos[2] - unprojected[2]) < 0.01)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, project) {
+  mat4 model, view, proj, mvp;
+  vec4 viewport = {0.0f, 0.0f, 800.0f, 600.0f};
+  vec3 pos      = {13.0f, 45.0f, 0.74f};
+  vec3 projected, unprojected;
+
+  glm_translate_make(model, (vec3){0.0f, 0.0f, -10.0f});
+  glm_lookat((vec3){0.0f, 0.0f, 0.0f}, pos, GLM_YUP, view);
+
+  glm_perspective_default(0.5f, proj);
+  glm_mat4_mulN((mat4 *[]){&proj, &view, &model}, 3, mvp);
+
+  GLM(project)(pos, mvp, viewport, projected);
+  GLM(unproject)(projected, mvp, viewport, unprojected);
+
+  /* unprojected of projected vector must be same as original one */
+  /* we used 0.01 because of projection floating point errors */
+  ASSERT(fabsf(pos[0] - unprojected[0]) < 0.01)
+  ASSERT(fabsf(pos[1] - unprojected[1]) < 0.01)
+  ASSERT(fabsf(pos[2] - unprojected[2]) < 0.01)
+
+  /* test with no projection */
+  glm_mat4_identity(mvp);
+
+  GLM(project)(pos, mvp, viewport, projected);
+  GLM(unproject)(projected, mvp, viewport, unprojected);
+
+  ASSERT(test_eq(pos[0], unprojected[0]))
+  ASSERT(test_eq(pos[1], unprojected[1]))
+  ASSERT(test_eq(pos[2], unprojected[2]))
+
+  TEST_SUCCESS
+}

test/src/test_quat.c

@@ -7,6 +7,26 @@
 
 #include "test_common.h"
 
+/* test inline quat */
+
+#define GLM_PREFIX glm_
+#define GLM(X) (glm_ ## X)
+
+#include "test_quat.h"
+
+#undef GLM
+#undef GLM_PREFIX
+
+/* test pre-compiled quat */
+
+#define GLM_PREFIX glmc_
+#define GLM(X) (glmc_ ## X)
+
+#include "test_quat.h"
+
+#undef GLM
+#undef GLM_PREFIX
+
 CGLM_INLINE
 void
 test_quat_mul_raw(versor p, versor q, versor dest) {
@@ -16,8 +36,7 @@ test_quat_mul_raw(versor p, versor q, versor dest) {
   dest[3] = p[3] * q[3] - p[0] * q[0] - p[1] * q[1] - p[2] * q[2];
 }
 
-void
+TEST_IMPL(quat) {
-test_quat(void **state) {
   mat4   inRot, outRot, view1, view2, rot1, rot2;
   versor inQuat, outQuat, q3, q4, q5;
   vec3   eye, axis, imag, v1, v2;
@@ -25,9 +44,10 @@ test_quat(void **state) {
 
   /* 0. test identiy quat */
   glm_quat_identity(q4);
-  assert_true(glm_eq(glm_quat_real(q4), cosf(glm_rad(0.0f) * 0.5f)));
+  ASSERT(test_eq(glm_quat_real(q4), cosf(glm_rad(0.0f) * 0.5f)))
+
   glm_quat_mat4(q4, rot1);
-  test_assert_mat4_eq2(rot1, GLM_MAT4_IDENTITY, 0.000009);
+  ASSERTIFY(test_assert_mat4_eq2(rot1, GLM_MAT4_IDENTITY, 0.000009f))
 
   /* 1. test quat to mat and mat to quat */
   for (i = 0; i < 1000; i++) {
@@ -38,15 +58,18 @@ test_quat(void **state) {
     glmc_quat_mat4(outQuat, outRot);
 
     /* 2. test first quat and generated one equality */
-    test_assert_quat_eq_abs(inQuat, outQuat);
+    ASSERTIFY(test_assert_quat_eq_abs(inQuat, outQuat));
 
     /* 3. test first rot and second rotation */
-    test_assert_mat4_eq2(inRot, outRot, 0.000009); /* almost equal */
+    /* almost equal */
+    ASSERTIFY(test_assert_mat4_eq2(inRot, outRot, 0.000009f));
 
     /* 4. test SSE mul and raw mul */
+#if defined( __SSE__ ) || defined( __SSE2__ )
     test_quat_mul_raw(inQuat, outQuat, q3);
     glm_quat_mul_sse2(inQuat, outQuat, q4);
-    test_assert_quat_eq(q3, q4);
+    ASSERTIFY(test_assert_quat_eq(q3, q4));
+#endif
   }
 
   /* 5. test lookat */
@@ -59,7 +82,7 @@ test_quat(void **state) {
   /* create view matrix with quaternion */
   glm_quat_look(eye, q3, view2);
 
-  test_assert_mat4_eq2(view1, view2, 0.000009);
+  ASSERTIFY(test_assert_mat4_eq2(view1, view2, 0.000009f));
 
   /* 6. test quaternion rotation matrix result */
   test_rand_quat(q3);
@@ -69,7 +92,7 @@ test_quat(void **state) {
   glm_quat_axis(q3, axis);
   glm_rotate_make(rot2, glm_quat_angle(q3), axis);
 
-  test_assert_mat4_eq2(rot1, rot2, 0.000009);
+  ASSERTIFY(test_assert_mat4_eq2(rot1, rot2, 0.000009f));
 
   /* 7. test quaternion multiplication (hamilton product),
         final rotation = first rotation + second = quat1 * quat2
@@ -89,7 +112,7 @@ test_quat(void **state) {
   glm_quat_mat4(q5, rot2);
 
   /* result must be same (almost) */
-  test_assert_mat4_eq2(rot1, rot2, 0.000009);
+  ASSERTIFY(test_assert_mat4_eq2(rot1, rot2, 0.000009f))
 
   /* 8. test quaternion for look rotation */
 
@@ -99,26 +122,26 @@ test_quat(void **state) {
 
   /* result must be identity */
   glm_quat_identity(q4);
-  test_assert_quat_eq(q3, q4);
+  ASSERTIFY(test_assert_quat_eq(q3, q4))
 
   /* look at from 0, 0, 1 to zero, direction = 0, 0, -1 */
   glm_quat_forp(GLM_ZUP, GLM_VEC3_ZERO, (vec3){0, 0, -1}, GLM_YUP, q3);
 
   /* result must be identity */
   glm_quat_identity(q4);
-  test_assert_quat_eq(q3, q4);
+  ASSERTIFY(test_assert_quat_eq(q3, q4))
 
   /* 8.2 perpendicular */
   glm_quat_for(GLM_XUP, (vec3){0, 0, -1}, GLM_YUP, q3);
 
   /* result must be -90 */
   glm_quatv(q4, glm_rad(-90.0f), GLM_YUP);
-  test_assert_quat_eq(q3, q4);
+  ASSERTIFY(test_assert_quat_eq(q3, q4))
 
   /* 9. test imag, real */
 
   /* 9.1 real */
-  assert_true(glm_eq(glm_quat_real(q4), cosf(glm_rad(-90.0f) * 0.5f)));
+  ASSERT(test_eq(glm_quat_real(q4), cosf(glm_rad(-90.0f) * 0.5f)))
 
   /* 9.1 imag */
   glm_quat_imag(q4, imag);
@@ -128,7 +151,7 @@ test_quat(void **state) {
   axis[1] = sinf(glm_rad(-90.0f) * 0.5f) * 1.0f;
   axis[2] = 0.0f;
 
-  assert_true(glm_vec3_eqv_eps(imag, axis));
+  ASSERT(glm_vec3_eqv_eps(imag, axis));
 
   /* 9.2 axis */
   glm_quat_axis(q4, axis);
@@ -136,7 +159,7 @@ test_quat(void **state) {
   imag[1] = -1.0f;
   imag[2] =  0.0f;
 
-  test_assert_vec3_eq(imag, axis);
+  ASSERTIFY(test_assert_vec3_eq(imag, axis));
 
   /* 10. test rotate vector using quat */
   /* (0,0,-1) around (1,0,0) must give (0,1,0) */
@@ -150,11 +173,11 @@ test_quat(void **state) {
   glm_quat_rotatev(q3, v2, v2);
 
   /* result must be : (0,1,0) */
-  assert_true(fabsf(v1[0]) <= 0.00009f
+  ASSERT(fabsf(v1[0]) <= 0.00009f
-              && fabsf(v1[1] - 1.0f) <= 0.00009f
+          && fabsf(v1[1] - 1.0f) <= 0.00009f
-              && fabsf(v1[2]) <= 0.00009f);
+          && fabsf(v1[2]) <= 0.00009f)
 
-  test_assert_vec3_eq(v1, v2);
+  ASSERTIFY(test_assert_vec3_eq(v1, v2))
 
   /* 11. test rotate transform */
   glm_translate_make(rot1, (vec3){-10.0, 45.0f, 8.0f});
@@ -165,7 +188,7 @@ test_quat(void **state) {
   glm_quat_rotate(rot2, q3, rot2);
 
   /* result must be same (almost) */
-  test_assert_mat4_eq2(rot1, rot2, 0.000009);
+  ASSERTIFY(test_assert_mat4_eq2(rot1, rot2, 0.000009f))
 
   glm_rotate_make(rot1, glm_rad(-90), GLM_ZUP);
   glm_translate(rot1, (vec3){-10.0, 45.0f, 8.0f});
@@ -176,7 +199,7 @@ test_quat(void **state) {
   glm_translate(rot2, (vec3){-10.0, 45.0f, 8.0f});
 
   /* result must be same (almost) */
-  test_assert_mat4_eq2(rot1, rot2, 0.000009);
+  ASSERTIFY(test_assert_mat4_eq2(rot1, rot2, 0.000009f))
 
   /* reverse */
   glm_rotate_make(rot1, glm_rad(-90), GLM_ZUP);
@@ -184,7 +207,7 @@ test_quat(void **state) {
   glm_quat_rotate(rot1, q3, rot1);
 
   /* result must be identity */
-  test_assert_mat4_eq2(rot1, GLM_MAT4_IDENTITY, 0.000009);
+  ASSERTIFY(test_assert_mat4_eq2(rot1, GLM_MAT4_IDENTITY, 0.000009f))
 
   test_rand_quat(q3);
 
@@ -193,7 +216,9 @@ test_quat(void **state) {
   glm_quat_mul(q3, q4, q5);
 
   glm_quat_identity(q3);
-  test_assert_quat_eq(q3, q5);
+  ASSERTIFY(test_assert_quat_eq(q3, q5))
 
   /* TODO: add tests for slerp, lerp */
+
+  TEST_SUCCESS
 }

test/src/test_quat.h

@@ -0,0 +1,762 @@
+/*
+ * 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"
+
+#ifndef CGLM_TEST_QUAT_ONCE
+#define CGLM_TEST_QUAT_ONCE
+
+/* Macros */
+
+TEST_IMPL(MACRO_GLM_QUAT_IDENTITY_INIT) {
+  versor v = GLM_QUAT_IDENTITY_INIT;
+
+  ASSERT(test_eq(v[0], 0.0f))
+  ASSERT(test_eq(v[1], 0.0f))
+  ASSERT(test_eq(v[2], 0.0f))
+  ASSERT(test_eq(v[3], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_QUAT_IDENTITY) {
+  ASSERT(test_eq(GLM_QUAT_IDENTITY[0], 0.0f))
+  ASSERT(test_eq(GLM_QUAT_IDENTITY[1], 0.0f))
+  ASSERT(test_eq(GLM_QUAT_IDENTITY[2], 0.0f))
+  ASSERT(test_eq(GLM_QUAT_IDENTITY[3], 1.0f))
+
+  TEST_SUCCESS
+}
+
+#endif /* CGLM_TEST_QUAT_ONCE */
+
+TEST_IMPL(GLM_PREFIX, quat_identity) {
+  versor a = GLM_QUAT_IDENTITY_INIT;
+  versor b = GLM_QUAT_IDENTITY_INIT;
+  versor c;
+  mat4   r;
+
+  GLM(quat_identity)(c);
+
+  ASSERTIFY(test_assert_quat_eq_identity(a))
+  ASSERTIFY(test_assert_quat_eq_identity(b))
+  ASSERTIFY(test_assert_quat_eq_identity(c))
+
+  glm_quat_identity(c);
+  ASSERT(test_eq(glm_quat_real(c), cosf(glm_rad(0.0f) * 0.5f)))
+
+  glm_quat_mat4(c, r);
+  ASSERTIFY(test_assert_mat4_eq2(r, GLM_MAT4_IDENTITY, 0.000009f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_identity_array) {
+  int i, count;
+  versor quats[4] = {
+    {1.0f, 2.0f, 3.0f, 4.0f},
+    {1.0f, 2.0f, 3.0f, 4.0f},
+    {1.0f, 2.0f, 3.0f, 4.0f},
+    {1.0f, 2.0f, 3.0f, 4.0f},
+  };
+
+  count = 4;
+
+  GLM(quat_identity_array)(quats, count);
+
+  for (i = 0; i < count; i++) {
+    ASSERTIFY(test_assert_quat_eq_identity(quats[i]))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_init) {
+  versor q1 = {1.0f, 2.0f, 3.0f, 4.0f};
+  versor q2 = {1.0f, 2.0f, 3.0f, 4.0f};
+  versor q3 = {1.0f, 2.0f, 3.0f, 4.0f};
+
+  GLM(quat_init)(q1, 10.0f, 11.0f, 12.0f, 13.0f);
+  GLM(quat_init)(q2, 100.0f, 110.0f, 120.0f, 130.0f);
+  GLM(quat_init)(q3, 1000.0f, 1100.0f, 1200.0f, 1300.0f);
+
+  ASSERT(q1[0] == 10.0f)
+  ASSERT(q1[1] == 11.0f)
+  ASSERT(q1[2] == 12.0f)
+  ASSERT(q1[3] == 13.0f)
+
+  ASSERT(q2[0] == 100.0f)
+  ASSERT(q2[1] == 110.0f)
+  ASSERT(q2[2] == 120.0f)
+  ASSERT(q2[3] == 130.0f)
+
+  ASSERT(q3[0] == 1000.0f)
+  ASSERT(q3[1] == 1100.0f)
+  ASSERT(q3[2] == 1200.0f)
+  ASSERT(q3[3] == 1300.0f)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quatv) {
+  versor q1 = {1.0f, 2.0f, 3.0f, 4.0f};
+  vec3   v1, v2;
+  float  a1;
+
+  test_rand_vec3(v1);
+  GLM(quatv)(q1, glm_rad(60.0f), v1);
+
+  glm_quat_axis(q1, v2);
+  a1 = glm_quat_angle(q1);
+
+  ASSERT(test_eq(a1, glm_rad(60.0f)))
+
+  glm_vec3_normalize(v1);
+  ASSERTIFY(test_assert_vec3_eq(v1, v2))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat) {
+  versor q1 = {1.0f, 2.0f, 3.0f, 4.0f};
+  vec3   v1, v2;
+  float  a1;
+
+  test_rand_vec3(v1);
+  GLM(quat)(q1, glm_rad(60.0f), v1[0], v1[1], v1[2]);
+
+  glm_quat_axis(q1, v2);
+  a1 = glm_quat_angle(q1);
+
+  ASSERT(test_eq(a1, glm_rad(60.0f)))
+
+  glm_vec3_normalize(v1);
+  ASSERTIFY(test_assert_vec3_eq(v1, v2))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_copy) {
+  versor v1 = {10.0f, 9.0f, 8.0f, 78.0f};
+  versor v2 = {1.0f, 2.0f, 3.0f, 4.0f};
+
+  GLM(quat_copy)(v1, v2);
+
+  ASSERTIFY(test_assert_vec4_eq(v1, v2))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_norm) {
+  versor a = {10.0f, 9.0f, 8.0f, 78.0f};
+  float  n1, n2;
+
+  n1 = GLM(quat_norm)(a);
+  n2 = sqrtf(a[0] * a[0] + a[1] * a[1] + a[2] * a[2] + a[3] * a[3]);
+
+  ASSERT(test_eq(n1, n2))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_normalize_to) {
+  versor v1 = {2.0f, -3.0f, 4.0f, 5.0f}, v2;
+  float  s  = 1.0f;
+  float  norm;
+
+  GLM(quat_normalize_to)(v1, v2);
+
+  norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2] + v1[3] * v1[3]);
+  if (norm <= 0.0f) {
+    ASSERTIFY(test_assert_quat_eq_identity(v1))
+
+    TEST_SUCCESS
+  }
+
+  norm = s / norm;
+
+  ASSERT(test_eq(v1[0] * norm, v2[0]))
+  ASSERT(test_eq(v1[1] * norm, v2[1]))
+  ASSERT(test_eq(v1[2] * norm, v2[2]))
+  ASSERT(test_eq(v1[3] * norm, v2[3]))
+
+  glm_vec4_zero(v1);
+  GLM(quat_normalize_to)(v1, v2);
+  ASSERTIFY(test_assert_quat_eq_identity(v2))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_normalize) {
+  versor v1 = {2.0f, -3.0f, 4.0f, 5.0f}, v2 = {2.0f, -3.0f, 4.0f, 5.0f};
+  float  s  = 1.0f;
+  float  norm;
+
+  GLM(quat_normalize)(v2);
+
+  norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2] + v1[3] * v1[3]);
+  if (norm <= 0.0f) {
+    ASSERTIFY(test_assert_quat_eq_identity(v1))
+
+    TEST_SUCCESS
+  }
+
+  norm = s / norm;
+
+  ASSERT(test_eq(v1[0] * norm, v2[0]))
+  ASSERT(test_eq(v1[1] * norm, v2[1]))
+  ASSERT(test_eq(v1[2] * norm, v2[2]))
+  ASSERT(test_eq(v1[3] * norm, v2[3]))
+
+  glm_vec4_zero(v1);
+  GLM(quat_normalize)(v1);
+  ASSERTIFY(test_assert_quat_eq_identity(v1))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_dot) {
+  versor a = {10.0f, 9.0f, 8.0f, 78.0f};
+  versor b = {1.0f, 2.0f, 3.0f, 4.0f};
+  float  dot1, dot2;
+
+  dot1 = GLM(quat_dot)(a, b);
+  dot2 = a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
+
+  ASSERT(test_eq(dot1, dot2))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_conjugate) {
+  versor a = {10.0f, 9.0f, 8.0f, 78.0f};
+  versor b = {1.0f, 2.0f, 3.0f, 4.0f};
+  versor d, e;
+
+  GLM(quat_conjugate)(a, d);
+  GLM(quat_conjugate)(b, e);
+
+  ASSERT(test_eq(d[0], -a[0]))
+  ASSERT(test_eq(d[1], -a[1]))
+  ASSERT(test_eq(d[2], -a[2]))
+  ASSERT(test_eq(d[3],  a[3]))
+
+  ASSERT(test_eq(e[0], -b[0]))
+  ASSERT(test_eq(e[1], -b[1]))
+  ASSERT(test_eq(e[2], -b[2]))
+  ASSERT(test_eq(e[3],  b[3]))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_inv) {
+  versor a = {10.0f, 9.0f, 8.0f, 78.0f};
+  versor b = {1.0f, 2.0f, 3.0f, 4.0f};
+  versor d, e;
+  float n1, n2;
+
+  n1 = 1.0f / glm_vec4_norm2(a);
+  n2 = 1.0f / glm_vec4_norm2(b);
+
+  GLM(quat_inv)(a, d);
+  GLM(quat_inv)(b, e);
+
+  ASSERT(test_eq(d[0], -a[0] * n1))
+  ASSERT(test_eq(d[1], -a[1] * n1))
+  ASSERT(test_eq(d[2], -a[2] * n1))
+  ASSERT(test_eq(d[3],  a[3] * n1))
+
+  ASSERT(test_eq(e[0], -b[0] * n2))
+  ASSERT(test_eq(e[1], -b[1] * n2))
+  ASSERT(test_eq(e[2], -b[2] * n2))
+  ASSERT(test_eq(e[3],  b[3] * n2))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_add) {
+  versor a = {-10.0f, 9.0f, -8.0f, 56.0f};
+  versor b = {12.0f, 19.0f, -18.0f, 1.0f};
+  versor c, d;
+
+  c[0] = a[0] + b[0];
+  c[1] = a[1] + b[1];
+  c[2] = a[2] + b[2];
+  c[3] = a[3] + b[3];
+
+  GLM(quat_add)(a, b, d);
+
+  ASSERTIFY(test_assert_quat_eq(c, d))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_sub) {
+  vec4 a = {-10.0f, 9.0f, -8.0f, 56.0f};
+  vec4 b = {12.0f, 19.0f, -18.0f, 1.0f};
+  vec4 c, d;
+
+  c[0] = a[0] - b[0];
+  c[1] = a[1] - b[1];
+  c[2] = a[2] - b[2];
+  c[3] = a[3] - b[3];
+
+  GLM(quat_sub)(a, b, d);
+
+  ASSERTIFY(test_assert_quat_eq(c, d))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_real) {
+  versor a = {10.0f, 9.0f, 8.0f, 78.0f};
+  versor b = {1.0f, 2.0f, 3.0f, 4.0f};
+
+  ASSERT(test_eq(GLM(quat_real)(a), 78.0f))
+  ASSERT(test_eq(GLM(quat_real)(b), 4.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_imag) {
+  versor a = {10.0f, 9.0f, 8.0f, 78.0f};
+  versor b = {1.0f, 2.0f, 3.0f, 4.0f};
+  vec3   d, e;
+
+  GLM(quat_imag)(a, d);
+  GLM(quat_imag)(b, e);
+
+  ASSERT(test_eq(d[0], a[0]))
+  ASSERT(test_eq(d[1], a[1]))
+  ASSERT(test_eq(d[2], a[2]))
+
+  ASSERT(test_eq(e[0], b[0]))
+  ASSERT(test_eq(e[1], b[1]))
+  ASSERT(test_eq(e[2], b[2]))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_imagn) {
+  versor a = {10.0f, 9.0f, 8.0f, 78.0f};
+  versor b = {1.0f, 2.0f, 3.0f, 4.0f};
+  vec3   d, e;
+
+  GLM(quat_imagn)(a, d);
+  GLM(quat_imagn)(b, e);
+
+  glm_vec3_normalize(a);
+  glm_vec3_normalize(b);
+  glm_vec3_normalize(d);
+  glm_vec3_normalize(e);
+
+  ASSERT(test_eq(d[0], a[0]))
+  ASSERT(test_eq(d[1], a[1]))
+  ASSERT(test_eq(d[2], a[2]))
+
+  ASSERT(test_eq(e[0], b[0]))
+  ASSERT(test_eq(e[1], b[1]))
+  ASSERT(test_eq(e[2], b[2]))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_imaglen) {
+  versor a = {10.0f, 9.0f, 8.0f, 78.0f};
+  versor b = {1.0f, 2.0f, 3.0f, 4.0f};
+
+  ASSERT(test_eq(GLM(quat_imaglen)(a), glm_vec3_norm(a)));
+  ASSERT(test_eq(GLM(quat_imaglen)(b), glm_vec3_norm(b)));
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_angle) {
+  versor q1 = {1.0f, 2.0f, 3.0f, 4.0f}, q2, q3;
+  vec3   v1;
+  float  a1, a2, a3;
+
+  test_rand_vec3(v1);
+  GLM(quatv)(q1, glm_rad(60.140f), v1);
+  GLM(quatv)(q2, glm_rad(160.04f), v1);
+  GLM(quatv)(q3, glm_rad(20.350f), v1);
+
+  a1 = GLM(quat_angle)(q1);
+  a2 = GLM(quat_angle)(q2);
+  a3 = GLM(quat_angle)(q3);
+
+  ASSERT(test_eq(a1, glm_rad(60.140f)))
+  ASSERT(test_eq(a2, glm_rad(160.04f)))
+  ASSERT(test_eq(a3, glm_rad(20.350f)))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_axis) {
+  versor q1 = {1.0f, 2.0f, 3.0f, 4.0f}, q2, q3;
+  vec3   v1, v2;
+
+  test_rand_vec3(v1);
+  GLM(quatv)(q1, glm_rad(60.0f), v1);
+
+  glm_quat_axis(q1, v2);
+  glm_vec3_normalize(v1);
+  ASSERTIFY(test_assert_vec3_eq(v1, v2))
+
+  test_rand_vec3(v1);
+  GLM(quatv)(q2, glm_rad(60.0f), v1);
+
+  glm_quat_axis(q2, v2);
+  glm_vec3_normalize(v1);
+  ASSERTIFY(test_assert_vec3_eq(v1, v2))
+
+  test_rand_vec3(v1);
+  GLM(quatv)(q3, glm_rad(60.0f), v1);
+
+  glm_quat_axis(q3, v2);
+  glm_vec3_normalize(v1);
+  ASSERTIFY(test_assert_vec3_eq(v1, v2))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_mul) {
+  versor q1 = {2.0f, 3.0f, 4.0f, 5.0f};
+  versor q2 = {6.0f, 7.0f, 8.0f, 9.0f};
+  versor q3;
+  versor q4;
+  vec3   v1 = {1.5f, 2.5f, 3.5f};
+
+  GLM(quat_mul)(q1, q2, q3);
+
+  ASSERT(test_eq(q3[0], q1[3] * q2[0] + q1[0] * q2[3] + q1[1] * q2[2] - q1[2] * q2[1]))
+  ASSERT(test_eq(q3[1], q1[3] * q2[1] - q1[0] * q2[2] + q1[1] * q2[3] + q1[2] * q2[0]))
+  ASSERT(test_eq(q3[2], q1[3] * q2[2] + q1[0] * q2[1] - q1[1] * q2[0] + q1[2] * q2[3]))
+  ASSERT(test_eq(q3[3], q1[3] * q2[3] - q1[0] * q2[0] - q1[1] * q2[1] - q1[2] * q2[2]))
+
+  glm_quatv(q1, glm_rad(30.0f), v1);
+  glm_quatv(q2, glm_rad(20.0f), v1);
+  glm_quatv(q3, glm_rad(50.0f), v1);
+
+  GLM(quat_mul)(q1, q2, q4);
+
+  ASSERTIFY(test_assert_quat_eq(q3, q4))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_mat4) {
+  mat4   m1, m2;
+  versor q1, q2, q3;
+  vec3   axis1;
+  vec3   axis2 = {1.9f, 2.3f, 4.5f};
+  int    i;
+
+  GLM(quat)(q1, GLM_PI_4f, 1.9f, 2.3f, 4.5f);
+  GLM(quat_mat4)(q1, m1);
+  GLM(mat4_quat)(m1, q2);
+
+  GLM(rotate_make)(m2, GLM_PI_4f, axis2);
+  GLM(mat4_quat)(m1, q3);
+
+  GLM(quat_axis)(q3, axis1);
+
+  GLM(vec3_normalize)(axis1);
+  GLM(vec3_normalize)(axis2);
+
+  ASSERT(test_eq(glm_quat_angle(q3), GLM_PI_4f))
+  ASSERTIFY(test_assert_vec3_eq(axis1, axis2))
+  ASSERTIFY(test_assert_vec4_eq(q1, q2))
+  ASSERTIFY(test_assert_mat4_eq(m1, m2))
+  ASSERTIFY(test_assert_vec4_eq(q1, q3))
+
+  /* 1. test quat to mat and mat to quat */
+  for (i = 0; i < 1000; i++) {
+    test_rand_quat(q1);
+
+    GLM(quat_mat4)(q1, m1);
+    GLM(mat4_quat)(m1, q2);
+    GLM(quat_mat4)(q2, m2);
+
+    /* 2. test first quat and generated one equality */
+    ASSERTIFY(test_assert_quat_eq_abs(q1, q2));
+
+    /* 3. test first rot and second rotation */
+    /* almost equal */
+    ASSERTIFY(test_assert_mat4_eq2(m1, m2, 0.000009f));
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_mat4t) {
+  mat4   m1, m2;
+  versor q1, q2, q3;
+  vec3   axis1;
+  vec3   axis2 = {1.9f, 2.3f, 4.5f};
+  int    i;
+
+  GLM(quat)(q1, GLM_PI_4f, 1.9f, 2.3f, 4.5f);
+
+  GLM(quat_mat4t)(q1, m1);
+  glm_mat4_transpose(m1);
+
+  GLM(mat4_quat)(m1, q2);
+
+  GLM(rotate_make)(m2, GLM_PI_4f, axis2);
+  GLM(mat4_quat)(m1, q3);
+
+  GLM(quat_axis)(q3, axis1);
+
+  GLM(vec3_normalize)(axis1);
+  GLM(vec3_normalize)(axis2);
+
+  ASSERT(test_eq(glm_quat_angle(q3), GLM_PI_4f))
+  ASSERTIFY(test_assert_vec3_eq(axis1, axis2))
+  ASSERTIFY(test_assert_vec4_eq(q1, q2))
+  ASSERTIFY(test_assert_mat4_eq(m1, m2))
+  ASSERTIFY(test_assert_vec4_eq(q1, q3))
+
+  /* 1. test quat to mat and mat to quat */
+  for (i = 0; i < 1000; i++) {
+    test_rand_quat(q1);
+
+    GLM(quat_mat4t)(q1, m1);
+    glm_mat4_transpose(m1);
+
+    GLM(mat4_quat)(m1, q2);
+
+    GLM(quat_mat4t)(q2, m2);
+    glm_mat4_transpose(m2);
+
+    /* 2. test first quat and generated one equality */
+    ASSERTIFY(test_assert_quat_eq_abs(q1, q2));
+
+    /* 3. test first rot and second rotation */
+    /* almost equal */
+    ASSERTIFY(test_assert_mat4_eq2(m1, m2, 0.000009f));
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_mat3) {
+  mat4   m1, m2;
+  mat3   m3;
+  versor q1, q2, q3;
+  vec3   axis1;
+  vec3   axis2 = {1.9f, 2.3f, 4.5f};
+  int    i;
+
+  GLM(quat)(q1, GLM_PI_4f, 1.9f, 2.3f, 4.5f);
+  GLM(quat_mat3)(q1, m3);
+  glm_mat4_identity(m1);
+  glm_mat4_ins3(m3, m1);
+
+  GLM(mat4_quat)(m1, q2);
+
+  GLM(rotate_make)(m2, GLM_PI_4f, axis2);
+  GLM(mat4_quat)(m1, q3);
+
+  GLM(quat_axis)(q3, axis1);
+
+  GLM(vec3_normalize)(axis1);
+  GLM(vec3_normalize)(axis2);
+
+  ASSERT(test_eq(glm_quat_angle(q3), GLM_PI_4f))
+  ASSERTIFY(test_assert_vec3_eq(axis1, axis2))
+  ASSERTIFY(test_assert_vec4_eq(q1, q2))
+  ASSERTIFY(test_assert_mat4_eq(m1, m2))
+  ASSERTIFY(test_assert_vec4_eq(q1, q3))
+
+  /* 1. test quat to mat and mat to quat */
+  for (i = 0; i < 1000; i++) {
+    test_rand_quat(q1);
+
+    GLM(quat_mat3)(q1, m3);
+    glm_mat4_identity(m1);
+    glm_mat4_ins3(m3, m1);
+
+    GLM(mat4_quat)(m1, q2);
+
+    GLM(quat_mat3)(q2, m3);
+    glm_mat4_identity(m2);
+    glm_mat4_ins3(m3, m2);
+
+    /* 2. test first quat and generated one equality */
+    ASSERTIFY(test_assert_quat_eq_abs(q1, q2));
+
+    /* 3. test first rot and second rotation */
+    /* almost equal */
+    ASSERTIFY(test_assert_mat4_eq2(m1, m2, 0.000009f));
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_mat3t) {
+  mat4   m1, m2;
+  mat3   m3;
+  versor q1, q2, q3;
+  vec3   axis1;
+  vec3   axis2 = {1.9f, 2.3f, 4.5f};
+  int    i;
+
+  GLM(quat)(q1, GLM_PI_4f, 1.9f, 2.3f, 4.5f);
+
+  GLM(quat_mat3t)(q1, m3);
+  glm_mat3_transpose(m3);
+  glm_mat4_identity(m1);
+  glm_mat4_ins3(m3, m1);
+
+  GLM(mat4_quat)(m1, q2);
+
+  GLM(rotate_make)(m2, GLM_PI_4f, axis2);
+  GLM(mat4_quat)(m1, q3);
+
+  GLM(quat_axis)(q3, axis1);
+
+  GLM(vec3_normalize)(axis1);
+  GLM(vec3_normalize)(axis2);
+
+  ASSERT(test_eq(glm_quat_angle(q3), GLM_PI_4f))
+  ASSERTIFY(test_assert_vec3_eq(axis1, axis2))
+  ASSERTIFY(test_assert_vec4_eq(q1, q2))
+  ASSERTIFY(test_assert_mat4_eq(m1, m2))
+  ASSERTIFY(test_assert_vec4_eq(q1, q3))
+
+  /* 1. test quat to mat and mat to quat */
+  for (i = 0; i < 1000; i++) {
+    test_rand_quat(q1);
+
+    GLM(quat_mat3t)(q1, m3);
+    glm_mat3_transpose(m3);
+    glm_mat4_identity(m1);
+    glm_mat4_ins3(m3, m1);
+
+    GLM(mat4_quat)(m1, q2);
+
+    GLM(quat_mat3t)(q2, m3);
+    glm_mat3_transpose(m3);
+    glm_mat4_identity(m2);
+    glm_mat4_ins3(m3, m2);
+
+    /* 2. test first quat and generated one equality */
+    ASSERTIFY(test_assert_quat_eq_abs(q1, q2));
+
+    /* 3. test first rot and second rotation */
+    /* almost equal */
+    ASSERTIFY(test_assert_mat4_eq2(m1, m2, 0.000009f));
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_lerp) {
+  versor v1 = {-100.0f, -200.0f, -10.0f, -10.0f};
+  versor v2 = {100.0f, 200.0f, 10.0f, 10.0f};
+  versor v3;
+
+  GLM(quat_lerp)(v1, v2, 0.5f, v3);
+  ASSERT(test_eq(v3[0], 0.0f))
+  ASSERT(test_eq(v3[1], 0.0f))
+  ASSERT(test_eq(v3[2], 0.0f))
+  ASSERT(test_eq(v3[3], 0.0f))
+
+  GLM(quat_lerp)(v1, v2, 0.75f, v3);
+  ASSERT(test_eq(v3[0], 50.0f))
+  ASSERT(test_eq(v3[1], 100.0f))
+  ASSERT(test_eq(v3[2], 5.0f))
+  ASSERT(test_eq(v3[3], 5.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_lerpc) {
+  versor v1 = {-100.0f, -200.0f, -10.0f, -10.0f};
+  versor v2 = {100.0f, 200.0f, 10.0f, 10.0f};
+  versor v3;
+
+  GLM(quat_lerpc)(v1, v2, 0.5f, v3);
+  ASSERT(test_eq(v3[0], 0.0f))
+  ASSERT(test_eq(v3[1], 0.0f))
+  ASSERT(test_eq(v3[2], 0.0f))
+  ASSERT(test_eq(v3[3], 0.0f))
+
+  GLM(quat_lerpc)(v1, v2, 0.75f, v3);
+  ASSERT(test_eq(v3[0], 50.0f))
+  ASSERT(test_eq(v3[1], 100.0f))
+  ASSERT(test_eq(v3[2], 5.0f))
+  ASSERT(test_eq(v3[3], 5.0f))
+
+  GLM(quat_lerpc)(v1, v2, -1.75f, v3);
+  ASSERT(test_eq(v3[0], -100.0f))
+  ASSERT(test_eq(v3[1], -200.0f))
+  ASSERT(test_eq(v3[2], -10.0f))
+  ASSERT(test_eq(v3[3], -10.0f))
+
+  GLM(quat_lerpc)(v1, v2, 1.75f, v3);
+  ASSERT(test_eq(v3[0], 100.0f))
+  ASSERT(test_eq(v3[1], 200.0f))
+  ASSERT(test_eq(v3[2], 10.0f))
+  ASSERT(test_eq(v3[3], 10.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_slerp) {
+  versor q1, q2, q3, q4;
+  vec3 v1 = {10.0f, 0.0f, 0.0f}, v2;
+
+  glm_quatv(q1, glm_rad(30.0f), v1);
+  glm_quatv(q2, glm_rad(90.0f), v1);
+
+  q1[0] = 10.0f;
+  GLM(quat_slerp)(q1, q2, 1.0f, q3);
+  ASSERTIFY(test_assert_quat_eq(q1, q3));
+
+  glm_quatv(q1, glm_rad(30.001f), v1);
+  glm_quatv(q2, glm_rad(30.002f), v1);
+  GLM(quat_slerp)(q1, q2, 0.7f, q3);
+  glm_quat_lerp(q1, q2, 0.7f, q4);
+  ASSERTIFY(test_assert_quat_eq(q3, q4));
+
+  glm_quatv(q1, glm_rad(30.0f), v1);
+  glm_quatv(q2, glm_rad(90.0f), v1);
+  GLM(quat_slerp)(q1, q2, 0.5f, q3);
+
+  glm_quat_axis(q3, v2);
+  glm_vec3_normalize(v1);
+  glm_vec3_normalize(v2);
+
+  ASSERT(glm_quat_angle(q3) > glm_rad(30.0f));
+  ASSERT(glm_quat_angle(q3) < glm_rad(90.0f));
+  ASSERTIFY(test_assert_vec3_eq(v1, v2))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_look) {
+  versor q1;
+  vec3   v1 = {0.0f, 1.0f, 0.0f};
+  mat4   m1, m2;
+  
+  glm_quat(q1, glm_rad(90.0f), 0.0f, 1.0f, 0.0f);
+  GLM(quat_look)(v1, q1, m1);
+
+  glm_look(v1, (vec3){-1.0f, 0.0f, 0.0f}, GLM_YUP, m2);
+  ASSERTIFY(test_assert_mat4_eq(m1, m2));
+  
+  glm_quat(q1, glm_rad(180.0f), 1.0f, 0.0f, 0.0f);
+  GLM(quat_look)(v1, q1, m1);
+  
+  glm_look(v1, (vec3){0.0f, 0.0f, 1.0f}, (vec3){0.0f, -1.0f, 0.0f}, m2);
+
+  ASSERTIFY(test_assert_mat4_eq(m1, m2));
+
+  TEST_SUCCESS
+}

test/src/test_struct.c

@@ -0,0 +1,78 @@
+/*
+* 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(mat3s_identity_init) {
+  mat3s mat3_identity   = GLMS_MAT3_IDENTITY_INIT;
+  mat3  mat3_identity_a =  GLM_MAT3_IDENTITY_INIT;
+  test_assert_mat3_eq(mat3_identity.raw, mat3_identity_a);
+  TEST_SUCCESS
+}
+
+TEST_IMPL(mat3s_zero_init) {
+  mat3s mat3_zero   = GLMS_MAT3_ZERO_INIT;
+  mat3  mat3_zero_a =  GLM_MAT3_ZERO_INIT;
+  test_assert_mat3_eq(mat3_zero.raw, mat3_zero_a);
+  TEST_SUCCESS
+}
+
+TEST_IMPL(mat4s_identity_init) {
+  mat4s mat4_identity   = GLMS_MAT4_IDENTITY_INIT;
+  mat4  mat4_identity_a =  GLM_MAT4_IDENTITY_INIT;
+  test_assert_mat4_eq(mat4_identity.raw, mat4_identity_a);
+  TEST_SUCCESS
+}
+
+TEST_IMPL(mat4s_zero_init) {
+  mat4s mat4_zero   = GLMS_MAT4_ZERO_INIT;
+  mat4  mat4_zero_a =  GLM_MAT4_ZERO_INIT;
+  test_assert_mat4_eq(mat4_zero.raw, mat4_zero_a);
+  TEST_SUCCESS
+}
+
+TEST_IMPL(quats_zero_init) {
+  versors quat_zero   = GLMS_QUAT_IDENTITY_INIT;
+  versor  quat_zero_a =  GLM_QUAT_IDENTITY_INIT;
+  test_assert_quat_eq(quat_zero.raw, quat_zero_a);
+  TEST_SUCCESS
+}
+
+TEST_IMPL(vec3s_one_init) {
+  vec3s vec3_one   = GLMS_VEC3_ONE_INIT;
+  vec3  vec3_one_a =  GLM_VEC3_ONE_INIT;
+  test_assert_vec3_eq(vec3_one.raw, vec3_one_a);
+  TEST_SUCCESS
+}
+
+TEST_IMPL(vec3s_zero_init) {
+  vec3s vec3_zero   = GLMS_VEC3_ZERO_INIT;
+  vec3  vec3_zero_a =  GLM_VEC3_ZERO_INIT;
+  test_assert_vec3_eq(vec3_zero.raw, vec3_zero_a);
+  TEST_SUCCESS
+}
+
+TEST_IMPL(vec4s_black_init) {
+  vec4s vec4_black   = GLMS_VEC4_BLACK_INIT;
+  vec4  vec4_black_a =  GLM_VEC4_BLACK_INIT;
+  test_assert_vec4_eq(vec4_black.raw, vec4_black_a);
+  TEST_SUCCESS
+}
+
+TEST_IMPL(vec4s_one_init) {
+  vec4s vec4_one   = GLMS_VEC4_ONE_INIT;
+  vec4  vec4_one_a =  GLM_VEC4_ONE_INIT;
+  test_assert_vec4_eq(vec4_one.raw, vec4_one_a);
+  TEST_SUCCESS
+}
+
+TEST_IMPL(vec4s_zero_init) {
+  vec4s vec4_zero   = GLMS_VEC4_ZERO_INIT;
+  vec4  vec4_zero_a =  GLM_VEC4_ZERO_INIT;
+  test_assert_vec4_eq(vec4_zero.raw, vec4_zero_a);
+  TEST_SUCCESS
+}

test/src/test_tests.h

@@ -1,46 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- * MIT License (MIT), http://opensource.org/licenses/MIT
- */
-
-#ifndef test_tests_h
-#define test_tests_h
-
-/* mat4 */
-void test_mat4(void **state);
-
-/* mat3 */
-void test_mat3(void **state);
-
-/* camera */
-void
-test_camera_lookat(void **state);
-
-void
-test_camera_decomp(void **state);
-
-void
-test_project(void **state);
-
-void
-test_clamp(void **state);
-
-void
-test_euler(void **state);
-
-void
-test_quat(void **state);
-
-void
-test_vec4(void **state);
-
-void
-test_vec3(void **state);
-
-void
-test_affine(void **state);
-
-void
-test_bezier(void **state);
-
-#endif /* test_tests_h */

test/src/test_vec3.c

@@ -5,74 +5,22 @@
  * Full license can be found in the LICENSE file
  */
 
-#include "test_common.h"
+/* test inline mat3 */
 
-void
+#define GLM_PREFIX glm_
-test_vec3(void **state) {
+#define GLM(X) (glm_ ## X)
-  mat3 rot1m3;
-  mat4 rot1;
-  vec3 v, v1, v2;
 
-  /* test zero */
+#include "test_vec3.h"
-  glm_vec3_zero(v);
-  test_assert_vec3_eq(GLM_VEC3_ZERO, v);
 
-  /* test one */
+#undef GLM
-  glm_vec3_one(v);
+#undef GLM_PREFIX
-  test_assert_vec3_eq(GLM_VEC3_ONE, v);
 
-  /* adds, subs, div, divs, mul */
+/* test pre-compiled mat3 */
-  glm_vec3_add(v, GLM_VEC3_ONE, v);
-  assert_true(glmc_vec3_eq_eps(v, 2));
 
-  glm_vec3_adds(v, 10, v);
+#define GLM_PREFIX glmc_
-  assert_true(glmc_vec3_eq_eps(v, 12));
+#define GLM(X) (glmc_ ## X)
 
-  glm_vec3_sub(v, GLM_VEC3_ONE, v);
+#include "test_vec3.h"
-  assert_true(glmc_vec3_eq_eps(v, 11));
 
-  glm_vec3_subs(v, 1, v);
+#undef GLM
-  assert_true(glmc_vec3_eq_eps(v, 10));
+#undef GLM_PREFIX
-
-  glm_vec3_broadcast(2, v1);
-  glm_vec3_div(v, v1, v);
-  assert_true(glmc_vec3_eq_eps(v, 5));
-
-  glm_vec3_divs(v, 0.5, v);
-  assert_true(glmc_vec3_eq_eps(v, 10));
-
-  glm_vec3_mul(v, v1, v);
-  assert_true(glmc_vec3_eq_eps(v, 20));
-
-  glm_vec3_scale(v, 0.5, v);
-  assert_true(glmc_vec3_eq_eps(v, 10));
-
-  glm_vec3_normalize_to(v, v1);
-  glm_vec3_scale(v1, 0.8, v1);
-  glm_vec3_scale_as(v, 0.8, v);
-  test_assert_vec3_eq(v1, v);
-
-  /* addadd, subadd, muladd */
-  glm_vec3_one(v);
-
-  glm_vec3_addadd(GLM_VEC3_ONE, GLM_VEC3_ONE, v);
-  assert_true(glmc_vec3_eq_eps(v, 3));
-
-  glm_vec3_subadd(GLM_VEC3_ONE, GLM_VEC3_ZERO, v);
-  assert_true(glmc_vec3_eq_eps(v, 4));
-
-  glm_vec3_broadcast(2, v1);
-  glm_vec3_broadcast(3, v2);
-  glm_vec3_muladd(v1, v2, v);
-  assert_true(glmc_vec3_eq_eps(v, 10));
-
-  /* rotate */
-  glm_vec3_copy(GLM_YUP, v);
-  glm_rotate_make(rot1, glm_rad(90), GLM_XUP);
-  glm_vec3_rotate_m4(rot1, v, v1);
-  glm_mat4_pick3(rot1, rot1m3);
-  glm_vec3_rotate_m3(rot1m3, v, v2);
-
-  test_assert_vec3_eq(v1, v2);
-  test_assert_vec3_eq(v1, GLM_ZUP);
-}

test/src/test_vec4.c

@@ -5,181 +5,22 @@
  * Full license can be found in the LICENSE file
  */
 
-#include "test_common.h"
+/* test inline mat3 */
 
-CGLM_INLINE
+#define GLM_PREFIX glm_
-float
+#define GLM(X) (glm_ ## X)
-test_vec4_dot(vec4 a, vec4 b) {
-  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
-}
 
-CGLM_INLINE
+#include "test_vec4.h"
-void
-test_vec4_normalize_to(vec4 vec, vec4 dest) {
-  float norm;
 
-  norm = glm_vec4_norm(vec);
+#undef GLM
+#undef GLM_PREFIX
 
-  if (norm == 0.0f) {
+/* test pre-compiled mat3 */
-    dest[0] = dest[1] = dest[2] = dest[3] = 0.0f;
-    return;
-  }
 
-  glm_vec4_scale(vec, 1.0f / norm, dest);
+#define GLM_PREFIX glmc_
-}
+#define GLM(X) (glmc_ ## X)
 
-float
+#include "test_vec4.h"
-test_vec4_norm2(vec4 vec) {
-  return test_vec4_dot(vec, vec);
-}
 
-float
+#undef GLM
-test_vec4_norm(vec4 vec) {
+#undef GLM_PREFIX
-  return sqrtf(test_vec4_dot(vec, vec));
-}
-
-void
-test_vec4_maxv(vec4 v1, vec4 v2, vec4 dest) {
-  dest[0] = glm_max(v1[0], v2[0]);
-  dest[1] = glm_max(v1[1], v2[1]);
-  dest[2] = glm_max(v1[2], v2[2]);
-  dest[3] = glm_max(v1[3], v2[3]);
-}
-
-void
-test_vec4_minv(vec4 v1, vec4 v2, vec4 dest) {
-  dest[0] = glm_min(v1[0], v2[0]);
-  dest[1] = glm_min(v1[1], v2[1]);
-  dest[2] = glm_min(v1[2], v2[2]);
-  dest[3] = glm_min(v1[3], v2[3]);
-}
-
-void
-test_vec4_clamp(vec4 v, float minVal, float maxVal) {
-  v[0] = glm_clamp(v[0], minVal, maxVal);
-  v[1] = glm_clamp(v[1], minVal, maxVal);
-  v[2] = glm_clamp(v[2], minVal, maxVal);
-  v[3] = glm_clamp(v[3], minVal, maxVal);
-}
-
-void
-test_vec4(void **state) {
-  vec4  v, v1, v2, v3, v4;
-  int   i;
-  float d1, d2;
-
-
-  for (i = 0; i < 1000; i++) {
-    /* 1. test SSE/SIMD dot product */
-    test_rand_vec4(v);
-    d1 = glm_vec4_dot(v, v);
-    d2 = test_vec4_dot(v, v);
-
-    assert_true(fabsf(d1 - d2) <= 0.000009);
-
-    /* 2. test SIMD normalize */
-    test_vec4_normalize_to(v, v1);
-    glm_vec4_normalize_to(v, v2);
-    glm_vec4_normalize(v);
-
-    /* all must be same */
-    test_assert_vec4_eq(v1, v2);
-    test_assert_vec4_eq(v, v2);
-
-    /* 3. test SIMD norm */
-    test_rand_vec4(v);
-    test_assert_eqf(test_vec4_norm(v), glm_vec4_norm(v));
-
-    /* 3. test SIMD norm2 */
-    test_rand_vec4(v);
-    test_assert_eqf(test_vec4_norm2(v), glm_vec4_norm2(v));
-
-    /* 4. test SSE/SIMD distance */
-    test_rand_vec4(v1);
-    test_rand_vec4(v2);
-    d1 = glm_vec4_distance(v1, v2);
-    d2 = sqrtf(powf(v1[0]-v2[0], 2.0f) + pow(v1[1]-v2[1], 2.0f) + pow(v1[2]-v2[2], 2.0f) + pow(v1[3]-v2[3], 2.0f));
-    assert_true(fabsf(d1 - d2) <= 0.000009);
-  }
-
-  /* test zero */
-  glm_vec4_zero(v);
-  test_assert_vec4_eq(GLM_VEC4_ZERO, v);
-
-  /* test one */
-  glm_vec4_one(v);
-  test_assert_vec4_eq(GLM_VEC4_ONE, v);
-
-  /* adds, subs, div, divs, mul */
-  glm_vec4_add(v, GLM_VEC4_ONE, v);
-  assert_true(glmc_vec4_eq_eps(v, 2));
-
-  glm_vec4_adds(v, 10, v);
-  assert_true(glmc_vec4_eq_eps(v, 12));
-
-  glm_vec4_sub(v, GLM_VEC4_ONE, v);
-  assert_true(glmc_vec4_eq_eps(v, 11));
-
-  glm_vec4_subs(v, 1, v);
-  assert_true(glmc_vec4_eq_eps(v, 10));
-
-  glm_vec4_broadcast(2, v1);
-  glm_vec4_div(v, v1, v);
-  assert_true(glmc_vec4_eq_eps(v, 5));
-
-  glm_vec4_divs(v, 0.5, v);
-  assert_true(glmc_vec4_eq_eps(v, 10));
-
-  glm_vec4_mul(v, v1, v);
-  assert_true(glmc_vec4_eq_eps(v, 20));
-
-  glm_vec4_scale(v, 0.5, v);
-  assert_true(glmc_vec4_eq_eps(v, 10));
-
-  glm_vec4_normalize_to(v, v1);
-  glm_vec4_scale(v1, 0.8, v1);
-  glm_vec4_scale_as(v, 0.8, v);
-  test_assert_vec4_eq(v1, v);
-
-  /* addadd, subadd, muladd */
-  glm_vec4_one(v);
-
-  glm_vec4_addadd(GLM_VEC4_ONE, GLM_VEC4_ONE, v);
-  assert_true(glmc_vec4_eq_eps(v, 3));
-
-  glm_vec4_subadd(GLM_VEC4_ONE, GLM_VEC4_ZERO, v);
-  assert_true(glmc_vec4_eq_eps(v, 4));
-
-  glm_vec4_broadcast(2, v1);
-  glm_vec4_broadcast(3, v2);
-  glm_vec4_muladd(v1, v2, v);
-  assert_true(glmc_vec4_eq_eps(v, 10));
-
-  /* min, max */
-  test_rand_vec4(v1);
-  test_rand_vec4(v2);
-
-  glm_vec4_maxv(v1, v2, v3);
-  test_vec4_maxv(v1, v2, v4);
-  test_assert_vec4_eq(v3, v4);
-
-  glm_vec4_minv(v1, v2, v3);
-  test_vec4_minv(v1, v2, v4);
-  test_assert_vec4_eq(v3, v4);
-
-  glm_vec4_print(v3, stderr);
-  glm_vec4_print(v4, stderr);
-
-  /* clamp */
-  glm_vec4_clamp(v3, 0.1, 0.8);
-  test_vec4_clamp(v4, 0.1, 0.8);
-  test_assert_vec4_eq(v3, v4);
-
-  glm_vec4_print(v3, stderr);
-  glm_vec4_print(v4, stderr);
-
-  assert_true(v3[0] >= 0.0999 && v3[0] <= 0.80001); /* rounding erros */
-  assert_true(v3[1] >= 0.0999 && v3[1] <= 0.80001);
-  assert_true(v3[2] >= 0.0999 && v3[2] <= 0.80001);
-  assert_true(v3[3] >= 0.0999 && v3[3] <= 0.80001);
-}

win/.gitignore

@@ -1,4 +1,9 @@
 !cglm.sln
+
 !cglm.vcxproj
 !cglm.vcxproj.filters
+
+!cglm-test.vcxproj
+!cglm-test.vcxproj.filters
+
 !packages.config

win/cglm-test.vcxproj

@@ -0,0 +1,196 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\test\runner.c" />
+    <ClCompile Include="..\test\src\test_affine.c" />
+    <ClCompile Include="..\test\src\test_bezier.c" />
+    <ClCompile Include="..\test\src\test_cam.c" />
+    <ClCompile Include="..\test\src\test_clamp.c" />
+    <ClCompile Include="..\test\src\test_common.c" />
+    <ClCompile Include="..\test\src\test_euler.c" />
+    <ClCompile Include="..\test\src\test_mat3.c" />
+    <ClCompile Include="..\test\src\test_mat4.c" />
+    <ClCompile Include="..\test\src\test_project.c" />
+    <ClCompile Include="..\test\src\test_quat.c" />
+    <ClCompile Include="..\test\src\test_struct.c" />
+    <ClCompile Include="..\test\src\test_vec3.c" />
+    <ClCompile Include="..\test\src\test_vec4.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\test\include\common.h" />
+    <ClInclude Include="..\test\src\test_common.h" />
+    <ClInclude Include="..\test\src\test_mat3.h" />
+    <ClInclude Include="..\test\src\test_mat4.h" />
+    <ClInclude Include="..\test\src\test_project.h" />
+    <ClInclude Include="..\test\src\test_quat.h" />
+    <ClInclude Include="..\test\src\test_vec3.h" />
+    <ClInclude Include="..\test\src\test_vec4.h" />
+    <ClInclude Include="..\test\tests.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="cglm.vcxproj">
+      <Project>{ca8bcaf9-cd25-4133-8f62-3d1449b5d2fc}</Project>
+    </ProjectReference>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>16.0</VCProjectVersion>
+    <ProjectGuid>{200E0DF1-7532-44E6-8273-84FB92C5557E}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>cglmtest</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <AdditionalIncludeDirectories>../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <AdditionalIncludeDirectories>../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <AdditionalIncludeDirectories>../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <AdditionalIncludeDirectories>../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

win/cglm-test.vcxproj.filters

@@ -0,0 +1,86 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="src">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="include">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;ipp;xsd</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\test\runner.c">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\test\src\test_affine.c">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\test\src\test_bezier.c">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\test\src\test_cam.c">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\test\src\test_clamp.c">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\test\src\test_common.c">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\test\src\test_euler.c">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\test\src\test_mat3.c">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\test\src\test_mat4.c">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\test\src\test_project.c">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\test\src\test_quat.c">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\test\src\test_vec3.c">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\test\src\test_vec4.c">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\test\src\test_struct.c">
+      <Filter>src</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\test\tests.h">
+      <Filter>include</Filter>
+    </ClInclude>
+    <ClInclude Include="..\test\src\test_common.h">
+      <Filter>include</Filter>
+    </ClInclude>
+    <ClInclude Include="..\test\include\common.h">
+      <Filter>include</Filter>
+    </ClInclude>
+    <ClInclude Include="..\test\src\test_mat3.h">
+      <Filter>src</Filter>
+    </ClInclude>
+    <ClInclude Include="..\test\src\test_mat4.h">
+      <Filter>src</Filter>
+    </ClInclude>
+    <ClInclude Include="..\test\src\test_project.h">
+      <Filter>src</Filter>
+    </ClInclude>
+    <ClInclude Include="..\test\src\test_quat.h">
+      <Filter>src</Filter>
+    </ClInclude>
+    <ClInclude Include="..\test\src\test_vec3.h">
+      <Filter>src</Filter>
+    </ClInclude>
+    <ClInclude Include="..\test\src\test_vec4.h">
+      <Filter>src</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

win/cglm.sln

@@ -1,10 +1,12 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 15
+# Visual Studio Version 16
-VisualStudioVersion = 15.0.26403.7
+VisualStudioVersion = 16.0.29123.88
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cglm", "cglm.vcxproj", "{CA8BCAF9-CD25-4133-8F62-3D1449B5D2FC}"
 EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cglm-test", "cglm-test.vcxproj", "{200E0DF1-7532-44E6-8273-84FB92C5557E}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|x64 = Debug|x64
@@ -21,8 +23,19 @@ Global
 		{CA8BCAF9-CD25-4133-8F62-3D1449B5D2FC}.Release|x64.Build.0 = Release|x64
 		{CA8BCAF9-CD25-4133-8F62-3D1449B5D2FC}.Release|x86.ActiveCfg = Release|Win32
 		{CA8BCAF9-CD25-4133-8F62-3D1449B5D2FC}.Release|x86.Build.0 = Release|Win32
+		{200E0DF1-7532-44E6-8273-84FB92C5557E}.Debug|x64.ActiveCfg = Debug|x64
+		{200E0DF1-7532-44E6-8273-84FB92C5557E}.Debug|x64.Build.0 = Debug|x64
+		{200E0DF1-7532-44E6-8273-84FB92C5557E}.Debug|x86.ActiveCfg = Debug|Win32
+		{200E0DF1-7532-44E6-8273-84FB92C5557E}.Debug|x86.Build.0 = Debug|Win32
+		{200E0DF1-7532-44E6-8273-84FB92C5557E}.Release|x64.ActiveCfg = Release|x64
+		{200E0DF1-7532-44E6-8273-84FB92C5557E}.Release|x64.Build.0 = Release|x64
+		{200E0DF1-7532-44E6-8273-84FB92C5557E}.Release|x86.ActiveCfg = Release|Win32
+		{200E0DF1-7532-44E6-8273-84FB92C5557E}.Release|x86.Build.0 = Release|Win32
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {2AEF23C9-433B-428B-BEBC-068BF3AC9A65}
+	EndGlobalSection
 EndGlobal

win/cglm.vcxproj

@@ -24,7 +24,6 @@
     <ClCompile Include="..\src\box.c" />
     <ClCompile Include="..\src\cam.c" />
     <ClCompile Include="..\src\curve.c" />
-    <ClCompile Include="..\src\dllmain.c" />
     <ClCompile Include="..\src\ease.c" />
     <ClCompile Include="..\src\euler.c" />
     <ClCompile Include="..\src\frustum.c" />
@@ -86,6 +85,26 @@
     <ClInclude Include="..\include\cglm\simd\sse2\quat.h" />
     <ClInclude Include="..\include\cglm\simd\x86.h" />
     <ClInclude Include="..\include\cglm\sphere.h" />
+    <ClInclude Include="..\include\cglm\struct.h" />
+    <ClInclude Include="..\include\cglm\struct\affine.h" />
+    <ClInclude Include="..\include\cglm\struct\box.h" />
+    <ClInclude Include="..\include\cglm\struct\cam.h" />
+    <ClInclude Include="..\include\cglm\struct\color.h" />
+    <ClInclude Include="..\include\cglm\struct\curve.h" />
+    <ClInclude Include="..\include\cglm\struct\euler.h" />
+    <ClInclude Include="..\include\cglm\struct\frustum.h" />
+    <ClInclude Include="..\include\cglm\struct\io.h" />
+    <ClInclude Include="..\include\cglm\struct\mat3.h" />
+    <ClInclude Include="..\include\cglm\struct\mat4.h" />
+    <ClInclude Include="..\include\cglm\struct\plane.h" />
+    <ClInclude Include="..\include\cglm\struct\project.h" />
+    <ClInclude Include="..\include\cglm\struct\quat.h" />
+    <ClInclude Include="..\include\cglm\struct\sphere.h" />
+    <ClInclude Include="..\include\cglm\struct\vec3-ext.h" />
+    <ClInclude Include="..\include\cglm\struct\vec3.h" />
+    <ClInclude Include="..\include\cglm\struct\vec4-ext.h" />
+    <ClInclude Include="..\include\cglm\struct\vec4.h" />
+    <ClInclude Include="..\include\cglm\types-struct.h" />
     <ClInclude Include="..\include\cglm\types.h" />
     <ClInclude Include="..\include\cglm\util.h" />
     <ClInclude Include="..\include\cglm\vec3-ext.h" />
@@ -100,7 +119,7 @@
     <ProjectGuid>{CA8BCAF9-CD25-4133-8F62-3D1449B5D2FC}</ProjectGuid>
     <Keyword>Win32Proj</Keyword>
     <RootNamespace>cglm</RootNamespace>
-    <WindowsTargetPlatformVersion>10.0.16299.0</WindowsTargetPlatformVersion>
+    <WindowsTargetPlatformVersion>10.0.17763.0</WindowsTargetPlatformVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">

win/cglm.vcxproj.filters

@@ -5,10 +5,6 @@
       <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
       <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
     </Filter>
-    <Filter Include="Resource Files">
-      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
-      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
-    </Filter>
     <Filter Include="src">
       <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
       <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
@@ -34,6 +30,9 @@
     <Filter Include="include\cglm\simd\neon">
       <UniqueIdentifier>{fb97f276-fe14-47ba-8a9f-01032f065a19}</UniqueIdentifier>
     </Filter>
+    <Filter Include="include\cglm\struct">
+      <UniqueIdentifier>{0b5febe7-a88d-4330-94ae-305897a5e957}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="..\src\affine.c">
@@ -42,9 +41,6 @@
     <ClCompile Include="..\src\cam.c">
       <Filter>src</Filter>
     </ClCompile>
-    <ClCompile Include="..\src\dllmain.c">
-      <Filter>src</Filter>
-    </ClCompile>
     <ClCompile Include="..\src\euler.c">
       <Filter>src</Filter>
     </ClCompile>
@@ -257,5 +253,65 @@
     <ClInclude Include="..\include\cglm\call\bezier.h">
       <Filter>include\cglm\call</Filter>
     </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\affine.h">
+      <Filter>include\cglm\struct</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\box.h">
+      <Filter>include\cglm\struct</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\cam.h">
+      <Filter>include\cglm\struct</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\color.h">
+      <Filter>include\cglm\struct</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\curve.h">
+      <Filter>include\cglm\struct</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\euler.h">
+      <Filter>include\cglm\struct</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\frustum.h">
+      <Filter>include\cglm\struct</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\io.h">
+      <Filter>include\cglm\struct</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\mat3.h">
+      <Filter>include\cglm\struct</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\mat4.h">
+      <Filter>include\cglm\struct</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\plane.h">
+      <Filter>include\cglm\struct</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\project.h">
+      <Filter>include\cglm\struct</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\quat.h">
+      <Filter>include\cglm\struct</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\sphere.h">
+      <Filter>include\cglm\struct</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\vec3.h">
+      <Filter>include\cglm\struct</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\vec3-ext.h">
+      <Filter>include\cglm\struct</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\vec4.h">
+      <Filter>include\cglm\struct</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\vec4-ext.h">
+      <Filter>include\cglm\struct</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\types-struct.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>