euler: use enum and static values for EULER ORDER, remove some macros

this must be more robust and flexible api

.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/*
@@ -69,3 +68,7 @@ win/cglm_test_*
 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,5 +54,9 @@ after_success:
         --exclude lib
         --exclude test
         --gcov-options '\-lp'
-        --verbose;
+        --verbose &&
+      bash <(curl -s https://codecov.io/bash);
     fi
+
+# after_failure:
+#   - 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),

CREDITS

@@ -52,3 +52,32 @@ https://gamedev.stackexchange.com/questions/28395/rotating-vector3-by-a-quaterni
 
 9. Sphere AABB intersect
 https://github.com/erich666/GraphicsGems/blob/master/gems/BoxSphere.c
+
+10. Horizontal add
+https://stackoverflow.com/questions/6996764/fastest-way-to-do-horizontal-float-vector-sum-on-x86
+
+11. de casteljau implementation and comments
+https://forums.khronos.org/showthread.php/10264-Animations-in-1-4-1-release-notes-revision-A/page2?highlight=bezier
+https://forums.khronos.org/showthread.php/10644-Animation-Bezier-interpolation
+https://forums.khronos.org/showthread.php/10387-2D-Tangents-in-Bezier-Splines?p=34164&viewfull=1#post34164
+https://forums.khronos.org/showthread.php/10651-Animation-TCB-Spline-Interpolation-in-COLLADA?highlight=bezier
+
+12. vec2 cross product
+http://allenchou.net/2013/07/cross-product-of-2d-vectors/
+
+13. Ken Shoemake's algorithm Implementation and Euler
+Ken Shoemake's algorithm impl. is taken from this repo by permission:
+  https://github.com/erich666/GraphicsGems/blob/master/gemsiv/euler_angle
+
+* -------------------------- GraphicsGems EULA ----------------------------- *
+|   http://www.realtimerendering.com/resources/GraphicsGems/                 |
+|                                                                            |
+| EULA: The Graphics Gems code is copyright-protected. In other words, you   |
+| cannot claim the text of the code as your own and resell it. Using the     |
+| code is permitted in any program, product, or library, non-commercial or   |
+| commercial. Giving credit is not required, though is a nice gesture.       |
+| The code comes as-is, and if there are any flaws or problems with any Gems |
+| code, nobody involved with Gems - authors, editors, publishers, or         |
+| webmasters - are to be held responsible. Basically, don't be a jerk, and   |
+| remember that anything free comes with no guarantee.                       |
+* -------------------------------- END --------------------------------------*/

Makefile.am

@@ -0,0 +1,169 @@
+#******************************************************************************
+# Copyright (c), Recep Aslantas.                                              *
+#                                                                             *
+# MIT License (MIT), http://opensource.org/licenses/MIT                       *
+# Full license can be found in the LICENSE file                               *
+#                                                                             *
+#******************************************************************************
+
+ACLOCAL_AMFLAGS = -I m4
+AM_CFLAGS = -Wall \
+            -std=gnu11 \
+            -O3 \
+            -Wstrict-aliasing=2 \
+            -fstrict-aliasing \
+            -pedantic \
+            -Werror=strict-prototypes
+
+lib_LTLIBRARIES = libcglm.la
+libcglm_la_LDFLAGS = -no-undefined -version-info 0:1:0
+
+checkLDFLAGS = -L./.libs \
+               -lm \
+               -lcglm
+checkCFLAGS = $(AM_CFLAGS) \
+              -I./include
+
+check_PROGRAMS = test/tests
+TESTS = $(check_PROGRAMS)
+
+test_tests_LDFLAGS = $(checkLDFLAGS)
+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/mat2.h \
+               include/cglm/affine.h \
+               include/cglm/vec2.h \
+               include/cglm/vec2-ext.h \
+               include/cglm/vec3.h \
+               include/cglm/vec3-ext.h \
+               include/cglm/vec4.h \
+               include/cglm/vec4-ext.h \
+               include/cglm/euler.h \
+               include/cglm/util.h \
+               include/cglm/quat.h \
+               include/cglm/affine-mat.h \
+               include/cglm/plane.h \
+               include/cglm/frustum.h \
+               include/cglm/box.h \
+               include/cglm/color.h \
+               include/cglm/project.h \
+               include/cglm/sphere.h \
+               include/cglm/ease.h \
+               include/cglm/curve.h \
+               include/cglm/bezier.h \
+               include/cglm/applesimd.h
+               
+cglm_calldir=$(includedir)/cglm/call
+cglm_call_HEADERS = include/cglm/call/mat4.h \
+                    include/cglm/call/mat3.h \
+                    include/cglm/call/mat2.h \
+                    include/cglm/call/vec2.h \
+                    include/cglm/call/vec3.h \
+                    include/cglm/call/vec4.h \
+                    include/cglm/call/affine.h \
+                    include/cglm/call/io.h \
+                    include/cglm/call/cam.h \
+                    include/cglm/call/quat.h \
+                    include/cglm/call/euler.h \
+                    include/cglm/call/plane.h \
+                    include/cglm/call/frustum.h \
+                    include/cglm/call/box.h \
+                    include/cglm/call/project.h \
+                    include/cglm/call/sphere.h \
+                    include/cglm/call/ease.h \
+                    include/cglm/call/curve.h \
+                    include/cglm/call/bezier.h
+
+cglm_simddir=$(includedir)/cglm/simd
+cglm_simd_HEADERS = include/cglm/simd/intrin.h \
+                    include/cglm/simd/x86.h \
+                    include/cglm/simd/arm.h
+
+cglm_simd_sse2dir=$(includedir)/cglm/simd/sse2
+cglm_simd_sse2_HEADERS = include/cglm/simd/sse2/affine.h \
+                         include/cglm/simd/sse2/mat4.h \
+                         include/cglm/simd/sse2/mat3.h \
+                         include/cglm/simd/sse2/quat.h
+
+cglm_simd_avxdir=$(includedir)/cglm/simd/avx
+cglm_simd_avx_HEADERS = include/cglm/simd/avx/mat4.h \
+                        include/cglm/simd/avx/affine.h
+
+cglm_simd_neondir=$(includedir)/cglm/simd/neon
+cglm_simd_neon_HEADERS = include/cglm/simd/neon/mat4.h
+
+cglm_structdir=$(includedir)/cglm/struct
+cglm_struct_HEADERS = include/cglm/struct/mat4.h \
+                      include/cglm/struct/mat3.h \
+                      include/cglm/struct/vec2.h \
+                      include/cglm/struct/vec2-ext.h \
+                      include/cglm/struct/vec3.h \
+                      include/cglm/struct/vec3-ext.h \
+                      include/cglm/struct/vec4.h \
+                      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 \
+    src/io.c \
+    src/quat.c \
+    src/cam.c \
+    src/vec2.c \
+    src/vec3.c \
+    src/vec4.c \
+    src/mat2.c \
+    src/mat3.c \
+    src/mat4.c \
+    src/plane.c \
+    src/frustum.c \
+    src/box.c \
+    src/project.c \
+    src/sphere.c \
+    src/ease.c \
+    src/curve.c \
+    src/bezier.c
+
+test_tests_SOURCES=\
+    test/runner.c \
+    test/src/test_common.c \
+    test/src/tests.c \
+    test/src/test_cam.c \
+    test/src/test_clamp.c \
+    test/src/test_euler.c \
+    test/src/test_bezier.c \
+    test/src/test_struct.c
+
+pkgconfig_DATA=cglm.pc
+
+# 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:
@@ -24,15 +23,17 @@ you have the latest version
 - **[major change]** by starting v0.4.0, quaternions are stored as [x, y, z, w], it was [w, x, y, z] in v0.3.5 and earlier versions
 - **[api rename]** by starting v0.4.5, **glm_simd** functions are renamed to **glmm_**  
 - **[new option]** by starting v0.4.5, you can disable alignment requirement, check options in docs.  
+- **[major change]** by starting v0.5.0, vec3 functions use **glm_vec3_** namespace, it was **glm_vec_** until v0.5.0
+- **[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!
 
@@ -43,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
@@ -66,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)
@@ -80,12 +83,18 @@ Currently *cglm* uses default clip space configuration (-1, 1) for camera functi
 - inline or pre-compiled function call
 - frustum (extract view frustum planes, corners...)
 - bounding box  (AABB in Frustum (culling), crop, merge...)
+- bounding sphere
 - project, unproject
+- easing functions
+- curves
+- curve interpolation helpers (S*M*C, deCasteljau...)
+- helpers to convert cglm types to Apple's simd library to pass cglm types to Metal GL without packing them on both sides
+- 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
@@ -112,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;
@@ -122,59 +131,48 @@ glm_mul(T, R, modelMat);
 glm_inv_tr(modelMat);
 ```
 
-## Contributors
+### Struct API
 
-This project exists thanks to all the people who contribute. [[Contribute](CONTRIBUTING.md)].
-<a href="graphs/contributors"><img src="https://opencollective.com/cglm/contributors.svg?width=890&button=false" /></a>
+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>
 
-## Backers
+mat4s mat = GLMS_MAT4_IDENTITY_INIT;
+mat4s inv = glms_mat4_inv(mat);
+```
 
-Thank you to all our backers! 🙏 [[Become a backer](https://opencollective.com/cglm#backer)]
+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.
 
-<a href="https://opencollective.com/cglm#backers" target="_blank"><img src="https://opencollective.com/cglm/backers.svg?width=890"></a>
-
-
-## Sponsors
-
-Support this project by becoming a sponsor. Your logo will show up here with a link to your website. [[Become a sponsor](https://opencollective.com/cglm#sponsor)]
-
-<a href="https://opencollective.com/cglm/sponsor/0/website" target="_blank"><img src="https://opencollective.com/cglm/sponsor/0/avatar.svg"></a>
-<a href="https://opencollective.com/cglm/sponsor/1/website" target="_blank"><img src="https://opencollective.com/cglm/sponsor/1/avatar.svg"></a>
-<a href="https://opencollective.com/cglm/sponsor/2/website" target="_blank"><img src="https://opencollective.com/cglm/sponsor/2/avatar.svg"></a>
-<a href="https://opencollective.com/cglm/sponsor/3/website" target="_blank"><img src="https://opencollective.com/cglm/sponsor/3/avatar.svg"></a>
-<a href="https://opencollective.com/cglm/sponsor/4/website" target="_blank"><img src="https://opencollective.com/cglm/sponsor/4/avatar.svg"></a>
-<a href="https://opencollective.com/cglm/sponsor/5/website" target="_blank"><img src="https://opencollective.com/cglm/sponsor/5/avatar.svg"></a>
-<a href="https://opencollective.com/cglm/sponsor/6/website" target="_blank"><img src="https://opencollective.com/cglm/sponsor/6/avatar.svg"></a>
-<a href="https://opencollective.com/cglm/sponsor/7/website" target="_blank"><img src="https://opencollective.com/cglm/sponsor/7/avatar.svg"></a>
-<a href="https://opencollective.com/cglm/sponsor/8/website" target="_blank"><img src="https://opencollective.com/cglm/sponsor/8/avatar.svg"></a>
-<a href="https://opencollective.com/cglm/sponsor/9/website" target="_blank"><img src="https://opencollective.com/cglm/sponsor/9/avatar.svg"></a>
-
-
-
-## License
-MIT. check the LICENSE file
+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`)
-$ [sudo] make install
+$ make check # [Optional]
+$ [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
@@ -185,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:
@@ -195,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});
 ```
@@ -230,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
 
@@ -270,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
 
@@ -284,3 +286,35 @@ You can pass same way to another APIs e.g. Vulkan, DX...
 - [ ] Unaligned operations (e.g. `glm_umat4_mul`)
 - [x] Extra documentation
 - [ ] ARM Neon Arch (In Progress)
+
+
+## Contributors
+
+This project exists thanks to all the people who contribute. [[Contribute](CONTRIBUTING.md)].
+<a href="graphs/contributors"><img src="https://opencollective.com/cglm/contributors.svg?width=890&button=false" /></a>
+
+
+## Backers
+
+Thank you to all our backers! 🙏 [[Become a backer](https://opencollective.com/cglm#backer)]
+
+<a href="https://opencollective.com/cglm#backers" target="_blank"><img src="https://opencollective.com/cglm/backers.svg?width=890"></a>
+
+
+## Sponsors
+
+Support this project by becoming a sponsor. Your logo will show up here with a link to your website. [[Become a sponsor](https://opencollective.com/cglm#sponsor)]
+
+<a href="https://opencollective.com/cglm/sponsor/0/website" target="_blank"><img src="https://opencollective.com/cglm/sponsor/0/avatar.svg"></a>
+<a href="https://opencollective.com/cglm/sponsor/1/website" target="_blank"><img src="https://opencollective.com/cglm/sponsor/1/avatar.svg"></a>
+<a href="https://opencollective.com/cglm/sponsor/2/website" target="_blank"><img src="https://opencollective.com/cglm/sponsor/2/avatar.svg"></a>
+<a href="https://opencollective.com/cglm/sponsor/3/website" target="_blank"><img src="https://opencollective.com/cglm/sponsor/3/avatar.svg"></a>
+<a href="https://opencollective.com/cglm/sponsor/4/website" target="_blank"><img src="https://opencollective.com/cglm/sponsor/4/avatar.svg"></a>
+<a href="https://opencollective.com/cglm/sponsor/5/website" target="_blank"><img src="https://opencollective.com/cglm/sponsor/5/avatar.svg"></a>
+<a href="https://opencollective.com/cglm/sponsor/6/website" target="_blank"><img src="https://opencollective.com/cglm/sponsor/6/avatar.svg"></a>
+<a href="https://opencollective.com/cglm/sponsor/7/website" target="_blank"><img src="https://opencollective.com/cglm/sponsor/7/avatar.svg"></a>
+<a href="https://opencollective.com/cglm/sponsor/8/website" target="_blank"><img src="https://opencollective.com/cglm/sponsor/8/avatar.svg"></a>
+<a href="https://opencollective.com/cglm/sponsor/9/website" target="_blank"><img src="https://opencollective.com/cglm/sponsor/9/avatar.svg"></a>
+
+## License
+MIT. check the LICENSE file

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.4.6"
+  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.0], [info@recp.me])
-AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects])
+AC_INIT([cglm], [0.7.1], [info@recp.me])
+AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects serial-tests])
+
+# Don't use the default cflags (-O2 -g), we set ours manually in Makefile.am.
+: ${CFLAGS=""}
 
 AC_CONFIG_MACRO_DIR([m4])
 AC_CONFIG_SRCDIR([src/])
 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
@@ -29,6 +46,7 @@ LT_INIT
 # Checks for libraries.
 AC_CHECK_LIB([m], [floor])
 
+m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
 AC_SYS_LARGEFILE
 
 # Checks for header files.
@@ -52,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/api.rst

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

docs/source/bezier.rst

@@ -0,0 +1,89 @@
+.. default-domain:: C
+
+Bezier
+================================================================================
+
+Header: cglm/bezier.h
+
+Common helpers for cubic bezier and similar curves.
+
+Table of contents (click to go):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Functions:
+
+1. :c:func:`glm_bezier`
+2. :c:func:`glm_hermite`
+3. :c:func:`glm_decasteljau`
+
+Functions documentation
+~~~~~~~~~~~~~~~~~~~~~~~
+
+.. c:function:: float glm_bezier(float s, float p0, float c0, float c1, float p1)
+
+    | cubic bezier interpolation
+    | formula:
+
+    .. code-block:: text
+
+      B(s) = P0*(1-s)^3 + 3*C0*s*(1-s)^2 + 3*C1*s^2*(1-s) + P1*s^3
+
+    | similar result using matrix:
+
+    .. code-block:: text
+
+      B(s) = glm_smc(t, GLM_BEZIER_MAT, (vec4){p0, c0, c1, p1})
+
+    | glm_eq(glm_smc(...), glm_bezier(...)) should return TRUE
+
+    Parameters:
+      | *[in]*  **s**   parameter between 0 and 1
+      | *[in]*  **p0**  begin point
+      | *[in]*  **c0**  control point 1
+      | *[in]*  **c1**  control point 2
+      | *[in]*  **p1**  end point
+
+    Returns:
+        B(s)
+
+.. c:function:: float glm_hermite(float s, float p0, float t0, float t1, float p1)
+
+    | cubic hermite interpolation
+    | formula:
+
+    .. code-block:: text
+
+      H(s) = P0*(2*s^3 - 3*s^2 + 1) + T0*(s^3 - 2*s^2 + s) + P1*(-2*s^3 + 3*s^2) + T1*(s^3 - s^2)
+
+    | similar result using matrix:
+
+    .. code-block:: text
+
+      H(s) = glm_smc(t, GLM_HERMITE_MAT, (vec4){p0, p1, c0, c1})
+
+    | glm_eq(glm_smc(...), glm_hermite(...)) should return TRUE
+
+
+    Parameters:
+      | *[in]*  **s**   parameter between 0 and 1
+      | *[in]*  **p0**  begin point
+      | *[in]*  **t0**  tangent 1
+      | *[in]*  **t1**  tangent 2
+      | *[in]*  **p1**  end point
+
+    Returns:
+        B(s)
+
+.. c:function:: float glm_decasteljau(float prm, float p0, float c0, float c1, float p1)
+
+    | iterative way to solve cubic equation
+
+    Parameters:
+      | *[in]*  **prm** parameter between 0 and 1
+      | *[in]*  **p0**  begin point
+      | *[in]*  **c0**  control point 1
+      | *[in]*  **c1**  control point 2
+      | *[in]*  **p1**  end point
+
+    Returns:
+        parameter to use in cubic equation

docs/source/build.rst

@@ -1,24 +1,18 @@
-Building cglm
+Build cglm
 ================================
 
-| **cglm** does not have external dependencies except for unit testing.
-| When you pulled cglm repo with submodules all dependencies will be pulled too.
-| `build-deps.sh` will pull all dependencies/submodules and build for you.
-
-External dependencies:
-  * cmocka - for unit testing
+| **cglm** does not have any external dependencies.
 
 **NOTE:**
 If you only need to inline versions, you don't need to build **cglm**, you don't need to link it to your program.
 Just import cglm to your project as dependency / external lib by copy-paste then use it as usual
 
-**Unix (Autotools):**
+Unix (Autotools):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 .. code-block:: bash
   :linenos:
 
-  $ sh ./build-deps.sh    # run this only once (dependencies)
-
   $ sh autogen.sh
   $ ./configure
   $ make
@@ -26,11 +20,12 @@ Just import cglm to your project as dependency / external lib by copy-paste then
   $ [sudo] make install   # install to system (optional)
 
 **make** will build cglm to **.libs** sub folder in project folder.
-If you don't want to install cglm to your system's folder you can get static and dynamic libs in this folder.
+If you don't want to install **cglm** to your system's folder you can get static and dynamic libs in this folder.
 
-**Build dependencies (windows):**
+Windows (MSBuild):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Windows related build files, project files are located in win folder,
+Windows related build files, project files are located in `win` folder,
 make sure you are inside in cglm/win folder.
 
 Code Analysis are enabled, it may take awhile to build.
@@ -50,3 +45,18 @@ then try to build with *devenv*:
   $ devenv cglm.sln /Build Release
 
 Currently tests are not available on Windows.
+
+Documentation (Sphinx):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+**cglm** uses sphinx framework for documentation, it allows lot of formats for documentation. To see all options see sphinx build page:
+
+https://www.sphinx-doc.org/en/master/man/sphinx-build.html
+
+Example build:
+
+.. code-block:: bash
+  :linenos:
+
+  $ cd cglm/docs
+  $ sphinx-build source build

docs/source/cam.rst

@@ -36,6 +36,7 @@ Functions:
 #. :c:func:`glm_ortho_default`
 #. :c:func:`glm_ortho_default_s`
 #. :c:func:`glm_perspective`
+#. :c:func:`glm_persp_move_far`
 #. :c:func:`glm_perspective_default`
 #. :c:func:`glm_perspective_resize`
 #. :c:func:`glm_lookat`
@@ -145,6 +146,16 @@ Functions documentation
       | *[in]*  **farVal**  far clipping planes
       | *[out]* **dest**    result matrix
 
+.. c:function:: void  glm_persp_move_far(mat4 proj, float deltaFar)
+
+    | extend perspective projection matrix's far distance
+
+    | this function does not guarantee far >= near, be aware of that!
+
+    Parameters:
+      | *[in, out]*  **proj**      projection matrix to extend
+      | *[in]*       **deltaFar**  distance from existing far (negative to shink)
+
 .. c:function:: void glm_perspective_default(float aspect, mat4 dest)
 
      | set up perspective projection matrix with default near/far

docs/source/conf.py

@@ -62,9 +62,9 @@ author = u'Recep Aslantas'
 # built documents.
 #
 # The short X.Y version.
-version = u'0.5.0'
+version = u'0.7.1'
 # The full version, including alpha/beta/rc tags.
-release = u'0.5.0'
+release = u'0.7.1'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
@@ -90,7 +90,7 @@ todo_include_todos = False
 # The theme to use for HTML and HTML Help pages.  See the documentation for
 # a list of builtin themes.
 #
-html_theme = 'alabaster'
+html_theme = 'sphinx_rtd_theme'
 
 # Theme options are theme-specific and customize the look and feel of a theme
 # further.  For a list of options available for each theme, see the
@@ -99,13 +99,13 @@ html_theme = 'alabaster'
 # html_theme_options = {}
 
 html_theme_options = {
-    'github_banner': 'true',
-    'github_button': 'true',
-    'github_user': 'recp',
-    'github_repo': 'cglm',
-    'travis_button': 'true',
-    'show_related': 'true',
-    'fixed_sidebar': 'true'
+    # 'github_banner': 'true',
+    # 'github_button': 'true',
+    # 'github_user': 'recp',
+    # 'github_repo': 'cglm',
+    # 'travis_button': 'true',
+    # 'show_related': 'true',
+    # 'fixed_sidebar': 'true'
 }
 
 # Add any paths that contain custom static files (such as style sheets) here,

docs/source/curve.rst

@@ -0,0 +1,41 @@
+.. default-domain:: C
+
+Curve
+================================================================================
+
+Header: cglm/curve.h
+
+Common helpers for common curves. For specific curve see its header/doc
+e.g bezier
+
+Table of contents (click to go):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Functions:
+
+1. :c:func:`glm_smc`
+
+Functions documentation
+~~~~~~~~~~~~~~~~~~~~~~~
+
+.. c:function:: float  glm_smc(float s, mat4 m, vec4 c)
+
+    | 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:
+
+    .. code-block:: c
+
+       Bs = glm_smc(s, GLM_BEZIER_MAT, (vec4){p0, c0, c1, p1})
+
+    Parameters:
+      | *[in]*  **s**  parameter between 0 and 1 (this will be [s3, s2, s, 1])
+      | *[in]*  **m**  basis matrix
+      | *[out]* **c**  position/control vector
+
+    Returns:
+        scalar value e.g. Bs

docs/source/features.rst

@@ -0,0 +1,23 @@
+Features
+================================================================================
+
+* general purpose matrix operations (mat4, mat3)
+* chain matrix multiplication (square only)
+* general purpose vector operations (cross, dot, rotate, proj, angle...)
+* affine transforms
+* matrix decomposition (extract rotation, scaling factor)
+* optimized affine transform matrices (mul, rigid-body inverse)
+* camera (lookat)
+* projections (ortho, perspective)
+* quaternions
+* euler angles / yaw-pitch-roll to matrix
+* extract euler angles
+* inline or pre-compiled function call
+* frustum (extract view frustum planes, corners...)
+* bounding box (AABB in Frustum (culling), crop, merge...)
+* bounding sphere
+* project, unproject
+* easing functions
+* curves
+* curve interpolation helpers (SMC, deCasteljau...)
+* and other...

docs/source/getting_started.rst

@@ -9,23 +9,26 @@ Types:
 .. code-block:: c
   :linenos:
 
-   typedef float vec3[3];
-   typedef int  ivec3[3];
-   typedef CGLM_ALIGN(16) float vec4[4];
+  typedef float                   vec2[2];
+  typedef float                   vec3[3];
+  typedef int                    ivec3[3];
+  typedef CGLM_ALIGN_IF(16) float vec4[4];
+  typedef vec4                    versor;
+  typedef vec3                    mat3[3];
 
-   typedef vec3 mat3[3];
-   typedef vec4 mat4[4];
-
-   typedef vec4 versor;
+  #ifdef __AVX__
+  typedef CGLM_ALIGN_IF(32) vec4  mat4[4];
+  #else
+  typedef CGLM_ALIGN_IF(16) vec4  mat4[4];
+  #endif
 
 As you can see types don't store extra informations in favor of space.
 You can send these values e.g. matrix to OpenGL directly without casting or calling a function like *value_ptr*
 
-Alignment is Required:
+Alignment Is Required:
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-**vec4** and **mat4** requires 16 byte alignment because vec4 and mat4 operations are
-vectorized by SIMD instructions (SSE/AVX).
+**vec4** and **mat4** requires 16 (32 for **mat4** if AVX is enabled) byte alignment because **vec4** and **mat4** operations are vectorized by SIMD instructions (SSE/AVX/NEON).
 
 **UPDATE:**
   By starting v0.4.5 cglm provides an option to disable alignment requirement, it is enabled as default
@@ -37,10 +40,9 @@ vectorized by SIMD instructions (SSE/AVX).
 Allocations:
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *cglm* doesn't alloc any memory on heap. So it doesn't provide any allocator.
-You must allocate memory yourself. You should alloc memory for out parameters too if you pass pointer of memory location.
-When allocating memory don't forget that **vec4** and **mat4** requires alignment.
+You must allocate memory yourself. You should alloc memory for out parameters too if you pass pointer of memory location. When allocating memory, don't forget that **vec4** and **mat4** require alignment.
 
-**NOTE:** Unaligned vec4 and unaligned mat4 operations will be supported in the future. Check todo list.
+**NOTE:** Unaligned **vec4** and unaligned **mat4** operations will be supported in the future. Check todo list.
 Because you may want to multiply a CGLM matrix with external matrix.
 There is no guarantee that non-CGLM matrix is aligned. Unaligned types will have *u* prefix e.g. **umat4**
 

docs/source/index.rst

@@ -3,7 +3,7 @@
    You can adapt this file completely to your liking, but it should at least
    contain the root `toctree` directive.
 
-Welcome to cglm's documentation!
+cglm Documentation
 ================================
 
 **cglm** is optimized 3D math library written in C99 (compatible with C89).
@@ -14,33 +14,36 @@ is considered to be supported as optional.
 
 Also currently only **float** type is supported for most operations.
 
-**Features**
-
-* general purpose matrix operations (mat4, mat3)
-* chain matrix multiplication (square only)
-* general purpose vector operations (cross, dot, rotate, proj, angle...)
-* affine transforms
-* matrix decomposition (extract rotation, scaling factor)
-* optimized affine transform matrices (mul, rigid-body inverse)
-* camera (lookat)
-* projections (ortho, perspective)
-* quaternions
-* euler angles / yaw-pitch-roll to matrix
-* extract euler angles
-* inline or pre-compiled function call
-* frustum (extract view frustum planes, corners...)
-* bounding box (AABB in Frustum (culling), crop, merge...)
-
-
 .. toctree::
-   :maxdepth: 1
-   :caption: Table Of Contents:
+   :maxdepth: 2
+   :caption: Getting Started:
 
+   features
    build
    getting_started
+
+.. toctree::
+   :maxdepth: 2
+   :caption: How To:
+
    opengl
+
+.. toctree::
+   :maxdepth: 2
+   :caption: API:
+
    api
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Options:
+
    opt
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Troubleshooting:
+
    troubleshooting
 
 Indices and tables

docs/source/mat2.rst

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

docs/source/mat3.rst

@@ -21,6 +21,7 @@ Functions:
 1. :c:func:`glm_mat3_copy`
 #. :c:func:`glm_mat3_identity`
 #. :c:func:`glm_mat3_identity_array`
+#. :c:func:`glm_mat3_zero`
 #. :c:func:`glm_mat3_mul`
 #. :c:func:`glm_mat3_transpose_to`
 #. :c:func:`glm_mat3_transpose`
@@ -29,8 +30,10 @@ Functions:
 #. :c:func:`glm_mat3_scale`
 #. :c:func:`glm_mat3_det`
 #. :c:func:`glm_mat3_inv`
+#. :c:func:`glm_mat3_trace`
 #. :c:func:`glm_mat3_swap_col`
 #. :c:func:`glm_mat3_swap_row`
+#. :c:func:`glm_mat3_rmc`
 
 Functions documentation
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -58,6 +61,13 @@ Functions documentation
       | *[in,out]* **mat**  matrix array (must be aligned (16/32) if alignment is not disabled)
       | *[in]* **count**  count of matrices
 
+.. c:function:: void  glm_mat3_zero(mat3 mat)
+
+    make given matrix zero
+
+    Parameters:
+      | *[in,out]* **mat**  matrix to
+
 .. c:function:: void  glm_mat3_mul(mat3 m1, mat3 m2, mat3 dest)
 
     multiply m1 and m2 to dest
@@ -133,6 +143,16 @@ Functions documentation
       | *[in]*  **mat**  matrix
       | *[out]* **dest** destination (inverse matrix)
 
+.. c:function:: void glm_mat3_trace(mat3 m)
+
+    | sum of the elements on the main diagonal from upper left to the lower right
+
+    Parameters:
+      | *[in]*  **m**  matrix
+
+    Returns:
+        trace of matrix
+
 .. c:function:: void  glm_mat3_swap_col(mat3 mat, int col1, int col2)
 
     swap two matrix columns
@@ -150,3 +170,20 @@ Functions documentation
       | *[in, out]*  **mat**   matrix
       | *[in]*       **row1**  row1
       | *[in]*       **row2**  row2
+
+.. c:function:: float  glm_mat3_rmc(vec3 r, mat3 m, vec3 c)
+
+    | **rmc** stands for **Row** * **Matrix** * **Column**
+
+    | helper for  R (row vector) * M (matrix) * C (column vector)
+
+    | the result is scalar because R * M = Matrix1x3 (row vector),
+    | then Matrix1x3 * Vec3 (column vector) = Matrix1x1 (Scalar)
+
+    Parameters:
+      | *[in]*  **r**  row vector or matrix1x3
+      | *[in]*  **m**  matrix3x3
+      | *[in]*  **c**  column vector or matrix3x1
+
+    Returns:
+        scalar value e.g. Matrix1x1

docs/source/mat4.rst

@@ -26,6 +26,7 @@ Functions:
 #. :c:func:`glm_mat4_copy`
 #. :c:func:`glm_mat4_identity`
 #. :c:func:`glm_mat4_identity_array`
+#. :c:func:`glm_mat4_zero`
 #. :c:func:`glm_mat4_pick3`
 #. :c:func:`glm_mat4_pick3t`
 #. :c:func:`glm_mat4_ins3`
@@ -33,6 +34,8 @@ Functions:
 #. :c:func:`glm_mat4_mulN`
 #. :c:func:`glm_mat4_mulv`
 #. :c:func:`glm_mat4_mulv3`
+#. :c:func:`glm_mat3_trace`
+#. :c:func:`glm_mat3_trace3`
 #. :c:func:`glm_mat4_quat`
 #. :c:func:`glm_mat4_transpose_to`
 #. :c:func:`glm_mat4_transpose`
@@ -43,6 +46,7 @@ Functions:
 #. :c:func:`glm_mat4_inv_fast`
 #. :c:func:`glm_mat4_swap_col`
 #. :c:func:`glm_mat4_swap_row`
+#. :c:func:`glm_mat4_rmc`
 
 Functions documentation
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -78,6 +82,13 @@ Functions documentation
       | *[in,out]* **mat**  matrix array (must be aligned (16/32) if alignment is not disabled)
       | *[in]* **count**  count of matrices
 
+.. c:function:: void  glm_mat4_zero(mat4 mat)
+
+    make given matrix zero
+
+    Parameters:
+      | *[in,out]* **mat**  matrix to
+
 .. c:function:: void  glm_mat4_pick3(mat4 mat, mat3 dest)
 
     copy upper-left of mat4 to mat3
@@ -156,6 +167,27 @@ Functions documentation
     | *[in]*  **v**     vec3 (right, column vector)
     | *[out]* **dest**  vec3 (result, column vector)
 
+.. c:function:: void  glm_mat4_trace(mat4 m)
+
+    | sum of the elements on the main diagonal from upper left to the lower right
+
+    Parameters:
+      | *[in]*  **m**  matrix
+
+    Returns:
+        trace of matrix
+
+.. c:function:: void  glm_mat4_trace3(mat4 m)
+
+    | trace of matrix (rotation part)
+    | sum of the elements on the main diagonal from upper left to the lower right
+
+    Parameters:
+      | *[in]*  **m**  matrix
+
+    Returns:
+        trace of matrix
+
 .. c:function:: void  glm_mat4_quat(mat4 m, versor dest)
 
     convert mat4's rotation part to quaternion
@@ -247,3 +279,20 @@ Functions documentation
       | *[in, out]*  **mat**   matrix
       | *[in]*       **row1**  row1
       | *[in]*       **row2**  row2
+
+.. c:function:: float  glm_mat4_rmc(vec4 r, mat4 m, vec4 c)
+
+    | **rmc** stands for **Row** * **Matrix** * **Column**
+
+    | helper for  R (row vector) * M (matrix) * C (column vector)
+
+    | the result is scalar because R * M = Matrix1x4 (row vector),
+    | then Matrix1x4 * Vec4 (column vector) = Matrix1x1 (Scalar)
+
+    Parameters:
+      | *[in]*  **r**  row vector or matrix1x4
+      | *[in]*  **m**  matrix4x4
+      | *[in]*  **c**  column vector or matrix4x1
+
+    Returns:
+        scalar value e.g. Matrix1x1

docs/source/opengl.rst

@@ -45,7 +45,7 @@ array of matrices:
 
 in this way, passing aray of matrices is same
 
-Passing / Uniforming Vectors to OpenGL:¶
+Passing / Uniforming Vectors to OpenGL:
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 You don't need to do extra thing when passing cglm vectors to OpengL or other APIs.

docs/source/opt.rst

@@ -40,3 +40,13 @@ SSE and SSE2 Shuffle Option
 **_mm_shuffle_ps** generates **shufps** instruction even if registers are same.
 You can force it to generate **pshufd** instruction by defining
 **CGLM_USE_INT_DOMAIN** macro. As default it is not defined.
+
+SSE3 and SSE4 Dot Product Options
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+You have to extra options for dot product: **CGLM_SSE4_DOT** and **CGLM_SSE3_DOT**.
+
+- If **SSE4** is enabled then you can define **CGLM_SSE4_DOT** to force cglm to use **_mm_dp_ps** instruction.
+- If **SSE3** is enabled then you can define **CGLM_SSE3_DOT** to force cglm to use **_mm_hadd_ps** instructions.
+
+otherwise cglm will use custom cglm's hadd functions which are optimized too.

docs/source/quat.rst

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

docs/source/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/vec2-ext.rst

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

docs/source/vec2.rst

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

docs/source/vec3.rst

@@ -39,7 +39,6 @@ Functions:
 #. :c:func:`glm_vec3_zero`
 #. :c:func:`glm_vec3_one`
 #. :c:func:`glm_vec3_dot`
-#. :c:func:`glm_vec3_cross`
 #. :c:func:`glm_vec3_norm2`
 #. :c:func:`glm_vec3_norm`
 #. :c:func:`glm_vec3_add`
@@ -65,6 +64,8 @@ Functions:
 #. :c:func:`glm_vec3_negate_to`
 #. :c:func:`glm_vec3_normalize`
 #. :c:func:`glm_vec3_normalize_to`
+#. :c:func:`glm_vec3_cross`
+#. :c:func:`glm_vec3_crossn`
 #. :c:func:`glm_vec3_distance2`
 #. :c:func:`glm_vec3_distance`
 #. :c:func:`glm_vec3_angle`
@@ -125,12 +126,21 @@ Functions documentation
 
 .. c:function:: void  glm_vec3_cross(vec3 a, vec3 b, vec3 d)
 
-    cross product
+    cross product of two vector (RH)
 
     Parameters:
-      | *[in]*  **a**  source 1
-      | *[in]*  **b**  source 2
-      | *[out]* **d**  destination
+      | *[in]*  **a**     vector 1
+      | *[in]*  **b**     vector 2
+      | *[out]* **dest**  destination
+
+.. c:function:: void  glm_vec3_crossn(vec3 a, vec3 b, vec3 dest)
+
+    cross product of two vector (RH) and normalize the result
+
+    Parameters:
+      | *[in]*  **a**     vector 1
+      | *[in]*  **b**     vector 2
+      | *[out]* **dest**  destination
 
 .. c:function:: float  glm_vec3_norm2(vec3 v)
 
@@ -148,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

@@ -58,11 +58,7 @@ Functions:
 #. :c:func:`glm_vec4_minv`
 #. :c:func:`glm_vec4_clamp`
 #. :c:func:`glm_vec4_lerp`
-#. :c:func:`glm_vec4_isnan`
-#. :c:func:`glm_vec4_isinf`
-#. :c:func:`glm_vec4_isvalid`
-#. :c:func:`glm_vec4_sign`
-#. :c:func:`glm_vec4_sqrt`
+#. :c:func:`glm_vec4_cubic`
 
 Functions documentation
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -138,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
@@ -401,3 +398,11 @@ Functions documentation
       | *[in]*  **to**     to value
       | *[in]*  **t**      interpolant (amount) clamped between 0 and 1
       | *[out]* **dest**   destination
+
+.. c:function:: void  glm_vec4_cubic(float s, vec4 dest)
+
+    helper to fill vec4 as [S^3, S^2, S, 1]
+
+    Parameters:
+      | *[in]*  **s**      parameter
+      | *[out]* **dest**   destination

include/cglm/affine-mat.h

@@ -152,7 +152,7 @@ glm_inv_tr(mat4 mat) {
   glm_inv_tr_sse2(mat);
 #else
   CGLM_ALIGN_MAT mat3 r;
-  CGLM_ALIGN(16) vec3 t;
+  CGLM_ALIGN(8)  vec3 t;
 
   /* rotate */
   glm_mat4_pick3t(mat, r);

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

@@ -0,0 +1,154 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglm_bezier_h
+#define cglm_bezier_h
+
+#include "common.h"
+
+#define GLM_BEZIER_MAT_INIT  {{-1.0f,  3.0f, -3.0f,  1.0f},                   \
+                              { 3.0f, -6.0f,  3.0f,  0.0f},                   \
+                              {-3.0f,  3.0f,  0.0f,  0.0f},                   \
+                              { 1.0f,  0.0f,  0.0f,  0.0f}}
+#define GLM_HERMITE_MAT_INIT {{ 2.0f, -3.0f,  0.0f,  1.0f},                   \
+                              {-2.0f,  3.0f,  0.0f,  0.0f},                   \
+                              { 1.0f, -2.0f,  1.0f,  0.0f},                   \
+                              { 1.0f, -1.0f,  0.0f,  0.0f}}
+/* for C only */
+#define GLM_BEZIER_MAT  ((mat4)GLM_BEZIER_MAT_INIT)
+#define GLM_HERMITE_MAT ((mat4)GLM_HERMITE_MAT_INIT)
+
+#define CGLM_DECASTEL_EPS   1e-9f
+#define CGLM_DECASTEL_MAX   1000.0f
+#define CGLM_DECASTEL_SMALL 1e-20f
+
+/*!
+ * @brief cubic bezier interpolation
+ *
+ * Formula:
+ *  B(s) = P0*(1-s)^3 + 3*C0*s*(1-s)^2 + 3*C1*s^2*(1-s) + P1*s^3
+ *
+ * similar result using matrix:
+ *  B(s) = glm_smc(t, GLM_BEZIER_MAT, (vec4){p0, c0, c1, p1})
+ *
+ * glm_eq(glm_smc(...), glm_bezier(...)) should return TRUE
+ *
+ * @param[in]  s    parameter between 0 and 1
+ * @param[in]  p0   begin point
+ * @param[in]  c0   control point 1
+ * @param[in]  c1   control point 2
+ * @param[in]  p1   end point
+ *
+ * @return B(s)
+ */
+CGLM_INLINE
+float
+glm_bezier(float s, float p0, float c0, float c1, float p1) {
+  float x, xx, ss, xs3, a;
+
+  x   = 1.0f - s;
+  xx  = x * x;
+  ss  = s * s;
+  xs3 = (s - ss) * 3.0f;
+  a   = p0 * xx + c0 * xs3;
+
+  return a + s * (c1 * xs3 + p1 * ss - a);
+}
+
+/*!
+ * @brief cubic hermite interpolation
+ *
+ * Formula:
+ *  H(s) = P0*(2*s^3 - 3*s^2 + 1) + T0*(s^3 - 2*s^2 + s)
+ *            + P1*(-2*s^3 + 3*s^2) + T1*(s^3 - s^2)
+ *
+ * similar result using matrix:
+ *  H(s) = glm_smc(t, GLM_HERMITE_MAT, (vec4){p0, p1, c0, c1})
+ *
+ * glm_eq(glm_smc(...), glm_hermite(...)) should return TRUE
+ *
+ * @param[in]  s    parameter between 0 and 1
+ * @param[in]  p0   begin point
+ * @param[in]  t0   tangent 1
+ * @param[in]  t1   tangent 2
+ * @param[in]  p1   end point
+ *
+ * @return H(s)
+ */
+CGLM_INLINE
+float
+glm_hermite(float s, float p0, float t0, float t1, float p1) {
+  float ss, d, a, b, c, e, f;
+
+  ss = s  * s;
+  a  = ss + ss;
+  c  = a  + ss;
+  b  = a  * s;
+  d  = s  * ss;
+  f  = d  - ss;
+  e  = b  - c;
+
+  return p0 * (e + 1.0f) + t0 * (f - ss + s) + t1 * f - p1 * e;
+}
+
+/*!
+ * @brief iterative way to solve cubic equation
+ *
+ * @param[in]  prm  parameter between 0 and 1
+ * @param[in]  p0   begin point
+ * @param[in]  c0   control point 1
+ * @param[in]  c1   control point 2
+ * @param[in]  p1   end point
+ *
+ * @return parameter to use in cubic equation
+ */
+CGLM_INLINE
+float
+glm_decasteljau(float prm, float p0, float c0, float c1, float p1) {
+  float u, v, a, b, c, d, e, f;
+  int   i;
+
+  if (prm - p0 < CGLM_DECASTEL_SMALL)
+    return 0.0f;
+
+  if (p1 - prm < CGLM_DECASTEL_SMALL)
+    return 1.0f;
+
+  u  = 0.0f;
+  v  = 1.0f;
+
+  for (i = 0; i < CGLM_DECASTEL_MAX; i++) {
+    /* de Casteljau Subdivision */
+    a  = (p0 + c0) * 0.5f;
+    b  = (c0 + c1) * 0.5f;
+    c  = (c1 + p1) * 0.5f;
+    d  = (a  + b)  * 0.5f;
+    e  = (b  + c)  * 0.5f;
+    f  = (d  + e)  * 0.5f; /* this one is on the curve! */
+
+    /* The curve point is close enough to our wanted t */
+    if (fabsf(f - prm) < CGLM_DECASTEL_EPS)
+      return glm_clamp_zo((u  + v) * 0.5f);
+
+    /* dichotomy */
+    if (f < prm) {
+      p0 = f;
+      c0 = e;
+      c1 = c;
+      u  = (u  + v) * 0.5f;
+    } else {
+      c0 = a;
+      c1 = d;
+      p1 = f;
+      v  = (u  + v) * 0.5f;
+    }
+  }
+
+  return glm_clamp_zo((u  + v) * 0.5f);
+}
+
+#endif /* cglm_bezier_h */

include/cglm/call.h

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

include/cglm/call/bezier.h

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_bezier_h
+#define cglmc_bezier_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+float
+glmc_bezier(float s, float p0, float c0, float c1, float p1);
+
+CGLM_EXPORT
+float
+glmc_hermite(float s, float p0, float t0, float t1, float p1);
+
+CGLM_EXPORT
+float
+glmc_decasteljau(float prm, float p0, float c0, float c1, float p1);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_bezier_h */

include/cglm/call/cam.h

@@ -61,6 +61,10 @@ glmc_perspective(float fovy,
                  float farVal,
                  mat4 dest);
 
+CGLM_EXPORT
+void
+glmc_persp_move_far(mat4 proj, float deltaFar);
+
 CGLM_EXPORT
 void
 glmc_perspective_default(float aspect, mat4 dest);

include/cglm/call/curve.h

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_curve_h
+#define cglmc_curve_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+float
+glmc_smc(float s, mat4 m, vec4 c);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_curve_h */

include/cglm/call/ease.h

@@ -137,4 +137,7 @@ CGLM_EXPORT
 float
 glmc_ease_bounce_inout(float t);
 
+#ifdef __cplusplus
+}
+#endif
 #endif /* cglmc_ease_h */

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/mat2.h

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

include/cglm/call/mat3.h

@@ -24,6 +24,10 @@ CGLM_EXPORT
 void
 glmc_mat3_identity(mat3 mat);
 
+CGLM_EXPORT
+void
+glmc_mat3_zero(mat3 mat);
+
 CGLM_EXPORT
 void
 glmc_mat3_identity_array(mat3 * __restrict mat, size_t count);
@@ -44,6 +48,10 @@ CGLM_EXPORT
 void
 glmc_mat3_mulv(mat3 m, vec3 v, vec3 dest);
 
+CGLM_EXPORT
+float
+glmc_mat3_trace(mat3 m);
+
 CGLM_EXPORT
 void
 glmc_mat3_quat(mat3 m, versor dest);
@@ -68,6 +76,10 @@ CGLM_EXPORT
 void
 glmc_mat3_swap_row(mat3 mat, int row1, int row2);
 
+CGLM_EXPORT
+float
+glmc_mat3_rmc(vec3 r, mat3 m, vec3 c);
+
 #ifdef __cplusplus
 }
 #endif

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);
@@ -61,6 +65,14 @@ CGLM_EXPORT
 void
 glmc_mat4_mulv3(mat4 m, vec3 v, float last, vec3 dest);
 
+CGLM_EXPORT
+float
+glmc_mat4_trace(mat4 m);
+
+CGLM_EXPORT
+float
+glmc_mat4_trace3(mat4 m);
+
 CGLM_EXPORT
 void
 glmc_mat4_quat(mat4 m, versor dest);
@@ -105,6 +117,10 @@ CGLM_EXPORT
 void
 glmc_mat4_swap_row(mat4 mat, int row1, int row2);
 
+CGLM_EXPORT
+float
+glmc_mat4_rmc(vec4 r, mat4 m, vec4 c);
+
 #ifdef __cplusplus
 }
 #endif

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);
@@ -127,11 +131,11 @@ glmc_quat_look(vec3 eye, versor ori, mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest);
+glmc_quat_for(vec3 dir, vec3 up, versor dest);
 
 CGLM_EXPORT
 void
-glmc_quat_forp(vec3 from, vec3 to, vec3 fwd, vec3 up, versor dest);
+glmc_quat_forp(vec3 from, vec3 to, vec3 up, versor dest);
 
 CGLM_EXPORT
 void

include/cglm/call/sphere.h

@@ -33,4 +33,7 @@ CGLM_EXPORT
 bool
 glmc_sphere_point(vec4 s, vec3 point);
 
+#ifdef __cplusplus
+}
+#endif
 #endif /* cglmc_sphere_h */

include/cglm/call/vec2.h

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

include/cglm/call/vec3.h

@@ -42,7 +42,11 @@ glmc_vec3_dot(vec3 a, vec3 b);
 
 CGLM_EXPORT
 void
-glmc_vec3_cross(vec3 a, vec3 b, vec3 d);
+glmc_vec3_cross(vec3 a, vec3 b, vec3 dest);
+
+CGLM_EXPORT
+void
+glmc_vec3_crossn(vec3 a, vec3 b, vec3 dest);
 
 CGLM_EXPORT
 float
@@ -52,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);
@@ -180,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
@@ -190,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);
@@ -234,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,50 @@ 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);
+
 /* ext */
 
 CGLM_EXPORT
@@ -163,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);
@@ -207,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,
-                                 float right,
-                                 float bottom,
-                                 float top,
-                                 float nearVal,
-                                 float farVal,
+   CGLM_INLINE void  glm_frustum(float left,    float right,
+                                 float bottom,  float top,
+                                 float nearVal, float farVal,
                                  mat4  dest)
-   CGLM_INLINE void  glm_ortho(float left,
-                               float right,
-                               float bottom,
-                               float top,
-                               float nearVal,
-                               float farVal,
+   CGLM_INLINE void  glm_ortho(float left,    float right,
+                               float bottom,  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_resize(float aspect, mat4  proj)
+   CGLM_INLINE void  glm_perspective_default(float aspect, mat4 dest)
+   CGLM_INLINE void  glm_perspective_resize(float aspect, mat4 proj)
    CGLM_INLINE void  glm_lookat(vec3 eye, vec3 center, vec3 up, mat4 dest)
    CGLM_INLINE void  glm_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 *farVal,
-                                      float *top,
-                                      float *bottom,
-                                      float *left,
-                                      float *right)
+                                      float *nearVal, float *farVal,
+                                      float *top,     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,
-                                        float *nearVal,
-                                        float *farVal)
+   CGLM_INLINE void  glm_persp_decomp_z(mat4 proj, float *nearv, float *farv)
    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,16 +64,13 @@
  */
 CGLM_INLINE
 void
-glm_frustum(float left,
-            float right,
-            float bottom,
-            float top,
-            float nearVal,
-            float farVal,
+glm_frustum(float left,    float right,
+            float bottom,  float top,
+            float nearVal, float farVal,
             mat4  dest) {
   float rl, tb, fn, nv;
 
-  glm__memzero(float, dest, sizeof(mat4));
+  glm_mat4_zero(dest);
 
   rl = 1.0f / (right  - left);
   tb = 1.0f / (top    - bottom);
@@ -113,16 +99,13 @@ glm_frustum(float left,
  */
 CGLM_INLINE
 void
-glm_ortho(float left,
-          float right,
-          float bottom,
-          float top,
-          float nearVal,
-          float farVal,
+glm_ortho(float left,    float right,
+          float bottom,  float top,
+          float nearVal, float farVal,
           mat4  dest) {
   float rl, tb, fn;
 
-  glm__memzero(float, dest, sizeof(mat4));
+  glm_mat4_zero(dest);
 
   rl = 1.0f / (right  - left);
   tb = 1.0f / (top    - bottom);
@@ -218,9 +201,7 @@ glm_ortho_default(float aspect, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_ortho_default_s(float aspect,
-                    float size,
-                    mat4  dest) {
+glm_ortho_default_s(float aspect, float size, mat4 dest) {
   if (aspect >= 1.0f) {
     glm_ortho(-size * aspect,
                size * aspect,
@@ -259,7 +240,7 @@ glm_perspective(float fovy,
                 mat4  dest) {
   float f, fn;
 
-  glm__memzero(float, dest, sizeof(mat4));
+  glm_mat4_zero(dest);
 
   f  = 1.0f / tanf(fovy * 0.5f);
   fn = 1.0f / (nearVal - farVal);
@@ -271,6 +252,30 @@ glm_perspective(float fovy,
   dest[3][2] = 2.0f * nearVal * farVal * fn;
 }
 
+/*!
+ * @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
+glm_persp_move_far(mat4 proj, float deltaFar) {
+  float fn, farVal, nearVal, p22, p32;
+
+  p22        = proj[2][2];
+  p32        = proj[3][2];
+
+  nearVal    = p32 / (p22 - 1.0f);
+  farVal     = p32 / (p22 + 1.0f) + deltaFar;
+  fn         = 1.0f / (nearVal - farVal);
+
+  proj[2][2] = (nearVal + farVal) * fn;
+  proj[3][2] = 2.0f * nearVal * farVal * fn;
+}
+
 /*!
  * @brief set up perspective projection matrix with default near/far
  *        and angle values
@@ -314,18 +319,13 @@ glm_perspective_resize(float aspect, mat4 proj) {
  */
 CGLM_INLINE
 void
-glm_lookat(vec3 eye,
-           vec3 center,
-           vec3 up,
-           mat4 dest) {
+glm_lookat(vec3 eye, vec3 center, vec3 up, mat4 dest) {
   CGLM_ALIGN(8) vec3 f, u, s;
 
   glm_vec3_sub(center, eye, f);
   glm_vec3_normalize(f);
 
-  glm_vec3_cross(f, up, s);
-  glm_vec3_normalize(s);
-
+  glm_vec3_crossn(f, up, s);
   glm_vec3_cross(s, f, u);
 
   dest[0][0] = s[0];
@@ -398,12 +398,9 @@ glm_look_anyup(vec3 eye, vec3 dir, mat4 dest) {
 CGLM_INLINE
 void
 glm_persp_decomp(mat4 proj,
-                 float * __restrict nearVal,
-                 float * __restrict farVal,
-                 float * __restrict top,
-                 float * __restrict bottom,
-                 float * __restrict left,
-                 float * __restrict right) {
+                 float * __restrict nearVal, float * __restrict farVal,
+                 float * __restrict top,     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/cglm.h

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

include/cglm/common.h

@@ -11,8 +11,10 @@
 #define _USE_MATH_DEFINES /* for windows */
 
 #include <stdint.h>
+#include <stddef.h>
 #include <math.h>
 #include <float.h>
+#include <stdbool.h>
 
 #if defined(_MSC_VER)
 #  ifdef CGLM_DLL
@@ -26,33 +28,8 @@
 #  define CGLM_INLINE static inline __attribute((always_inline))
 #endif
 
-#define glm__memcpy(type, dest, src, size)                                    \
-  do {                                                                        \
-    type *srci;                                                               \
-    type *srci_end;                                                           \
-    type *desti;                                                              \
-                                                                              \
-    srci     = (type *)src;                                                   \
-    srci_end = (type *)((char *)srci + size);                                 \
-    desti    = (type *)dest;                                                  \
-                                                                              \
-    while (srci != srci_end)                                                  \
-      *desti++ = *srci++;                                                     \
-  } while (0)
-
-#define glm__memset(type, dest, size, val)                                    \
-  do {                                                                        \
-    type *desti;                                                              \
-    type *desti_end;                                                          \
-                                                                              \
-    desti     = (type *)dest;                                                 \
-    desti_end = (type *)((char *)desti + size);                               \
-                                                                              \
-    while (desti != desti_end)                                                \
-      *desti++ = val;                                                         \
-  } while (0)
-
-#define glm__memzero(type, dest, size) glm__memset(type, dest, size, 0)
+#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/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 cglm_curve_h
+#define cglm_curve_h
+
+#include "common.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
+glm_smc(float s, mat4 m, vec4 c) {
+  vec4 vs;
+  glm_vec4_cubic(s, vs);
+  return glm_mat4_rmc(vs, m, c);
+}
+
+#endif /* cglm_curve_h */

include/cglm/euler.h

@@ -15,50 +15,188 @@
 
 /*
  Types:
-   enum glm_euler_sq
+   enum glm_euler_seq
 
  Functions:
-   CGLM_INLINE glm_euler_sq glm_euler_order(int newOrder[3]);
-   CGLM_INLINE void glm_euler_angles(mat4 m, vec3 dest);
-   CGLM_INLINE void glm_euler(vec3 angles, mat4 dest);
-   CGLM_INLINE void glm_euler_xyz(vec3 angles, mat4 dest);
-   CGLM_INLINE void glm_euler_zyx(vec3 angles, mat4 dest);
-   CGLM_INLINE void glm_euler_zxy(vec3 angles, mat4 dest);
-   CGLM_INLINE void glm_euler_xzy(vec3 angles, mat4 dest);
-   CGLM_INLINE void glm_euler_yzx(vec3 angles, mat4 dest);
-   CGLM_INLINE void glm_euler_yxz(vec3 angles, mat4 dest);
-   CGLM_INLINE void glm_euler_by_order(vec3         angles,
-                                       glm_euler_sq ord,
-                                       mat4         dest);
+   CGLM_INLINE glm_eul_mat4(vec3 ea, int order, mat4 dest)
  */
 
 #ifndef cglm_euler_h
 #define cglm_euler_h
 
 #include "common.h"
+#include "util.h"
+
+/* ---------- Notice for Ken Shoemake's algorithm Implementation -------------*
+ | Ken Shoemake's algorithm impl. is taken from this repo by permission:      |
+ |   https://github.com/erich666/GraphicsGems/blob/master/gemsiv/euler_angle  |
+ |                                                                            |
+ | cglm doesn't claim the ownership of GraphicsGems source codes              |
+ | and the algorithm itself. But cglm may change variable names or some piece |
+ | of codes in order to apply optimizations or to make it usable in cglm.     |
+ |                                                                            |
+ | Related issue: https://github.com/recp/cglm/issues/30                      |
+ |                                                                            |
+ * -------------------------- GraphicsGems EULA ----------------------------- *
+ | Related EULA for GraphicsGems can be found at below, plus in CREDITS:      |
+ |   http://www.realtimerendering.com/resources/GraphicsGems/                 |
+ |                                                                            |
+ | EULA: The Graphics Gems code is copyright-protected. In other words, you   |
+ | cannot claim the text of the code as your own and resell it. Using the     |
+ | code is permitted in any program, product, or library, non-commercial or   |
+ | commercial. Giving credit is not required, though is a nice gesture.       |
+ | The code comes as-is, and if there are any flaws or problems with any Gems |
+ | code, nobody involved with Gems - authors, editors, publishers, or         |
+ | webmasters - are to be held responsible. Basically, don't be a jerk, and   |
+ | remember that anything free comes with no guarantee.                       |
+ * -------------------------------- END --------------------------------------*/
+
+/* Order type constants, constructors, extractors
+ * There are 24 possible conventions, designated by:
+ *	  o EulAxI = axis used initially
+ *	  o EulPar = parity of axis permutation
+ *	  o EulRep = repetition of initial axis as last
+ *	  o EulFrm = frame from which axes are taken
+ * Axes I,J,K will be a permutation of X,Y,Z.
+ * Axis H will be either I or K, depending on EulRep.
+ * Frame S takes axes from initial static frame.
+ * If ord = (AxI=X, Par=Even, Rep=No, Frm=S), then
+ * {a,b,c,ord} means Rz(c)Ry(b)Rx(a), where Rz(c)v
+ * rotates v around Z by c radians.			    
+*/
+
+#define EulRep(ord)  (((unsigned)(ord)>>1)&1)
+#define EulFrm(ord)  ((unsigned)(ord)&1)
+#define EulPar(ord)  (((unsigned)(ord)>>2)&1)
+
+/*! this code is merely a quick (and legal!) way to set arrays,
+    EulSafe being 0,1,2,0 */
+#define EulSafe	     "\000\001\002\000"
+#define EulNext	     "\001\002\000\001"
+#define EulAxI(ord)  ((int)(EulSafe[(((unsigned)(ord)>>3)&3)]))
+#define EulAxJ(ord)  ((int)(EulNext[EulAxI(ord)+(EulPar(ord)==EulParOdd)]))
+#define EulAxK(ord)  ((int)(EulNext[EulAxI(ord)+(EulPar(ord)!=EulParOdd)]))
+#define EulAxH(ord)  ((EulRep(ord)==EulRepNo)?EulAxK(ord):EulAxI(ord))
+
+/*! EulGetOrd unpacks all useful information about order simultaneously. */
+#define EulGetOrd(ord,i,j,k,h,n,s,f)                                          \
+  {unsigned o=(unsigned)ord;f=o&1;o>>=1;s=o&1;o>>=1;\
+    n=o&1;o>>=1;i=EulSafe[o&3];j=EulNext[i+n];k=EulNext[i+1-n];h=s?k:i;}
+
+typedef enum glm_eul_order {
+  /*! Static axes */
+  GLM_EUL_XYZs  = 0,
+  GLM_EUL_XYXs  = 2,
+  GLM_EUL_XZYs  = 4,
+  GLM_EUL_XZXs  = 6,
+  GLM_EUL_YZXs  = 8,
+  GLM_EUL_YZYs  = 10,
+  GLM_EUL_YXZs  = 12,
+  GLM_EUL_YXYs  = 14,
+  GLM_EUL_ZXYs  = 16,
+  GLM_EUL_ZXZs  = 18,
+  GLM_EUL_ZYXs  = 20,
+  GLM_EUL_ZYZs  = 22,
+  
+  /*! Rotating axes */
+  GLM_EUL_ZYXr  = 1,
+  GLM_EUL_XYXr  = 3,
+  GLM_EUL_YZXr  = 5,
+  GLM_EUL_XZXr  = 7,
+  GLM_EUL_XZYr  = 9,
+  GLM_EUL_YZYr  = 11,
+  GLM_EUL_ZXYr  = 13,
+  GLM_EUL_YXYr  = 15,
+  GLM_EUL_YXZr  = 17,
+  GLM_EUL_ZXZr  = 19,
+  GLM_EUL_XYZr  = 21,
+  GLM_EUL_ZYZr  = 23
+} glm_eul_order;
+
+/*!
+ * @brief build matrix from euler angles
+ *
+ * @param[in]  ea     [Xangle, Yangle, Zangle]
+ * @param[out] dest   rotation matrix
+ */
+CGLM_INLINE
+void
+glm_eul_mat4(vec3 ea, glm_eul_order order, mat4 dest) {
+  float ti, tj, th, ci, cj, ch, si, sj, sh, cc, cs, sc, ss;
+  int   i, j, k, h, parOdd, repYes, frmR;
+
+  EulGetOrd(order, i, j, k, h, parOdd, repYes, frmR);
+  
+  if (frmR == 1)
+    glm_swapf(&ea[0], &ea[2]);
+  
+  if (parOdd == 1)
+    glm_vec3_negate(ea);
+  
+  ti = ea[0]; tj = ea[1]; th = ea[2];
+  
+  ci = cosf(ti);  cj = cosf(tj);
+  ch = cosf(th);  si = sinf(ti);
+  sj = sinf(tj);  sh = sinf(th);
+  
+  cc = ci * ch;  cs = ci * sh;
+  sc = si * ch;  ss = si * sh;
+  
+  if (repYes == 1) {
+    dest[i][i] =  cj;
+    dest[i][j] =  sj * si;
+    dest[i][k] =  sj * ci;
+    dest[j][i] =  sj * sh;
+    dest[j][j] = -cj * ss + cc;
+    dest[j][k] = -cj * cs - sc;
+    dest[k][i] = -sj * ch;
+    dest[k][j] =  cj * sc + cs;
+    dest[k][k] =  cj * cc - ss;
+  } else {
+    dest[i][i] =  cj * ch;
+    dest[i][j] =  sj * sc - cs;
+    dest[i][k] =  sj * cc + ss;
+    dest[j][i] =  cj * sh;
+    dest[j][j] =  sj * ss + cc;
+    dest[j][k] =  sj * cs - sc;
+    dest[k][i] = -sj;
+    dest[k][j] =  cj * si;
+    dest[k][k] =  cj * ci;
+  }
+  
+  dest[3][0] = 0.f;
+  dest[3][1] = 0.f;
+  dest[3][2] = 0.f;
+  dest[0][3] = 0.f;
+  dest[1][3] = 0.f;
+  dest[2][3] = 0.f;
+  dest[3][3] = 1.f;
+}
 
 /*!
  * 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 +490,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/io.h

@@ -83,6 +83,36 @@ glm_mat3_print(mat3              matrix,
 #undef n
 }
 
+CGLM_INLINE
+void
+glm_mat2_print(mat2              matrix,
+               FILE * __restrict ostream) {
+  int i;
+  int j;
+
+#define m 2
+#define n 2
+
+  fprintf(ostream, "Matrix (float%dx%d):\n", m, n);
+
+  for (i = 0; i < m; i++) {
+    fprintf(ostream, "\t|");
+    for (j = 0; j < n; j++) {
+      fprintf(ostream, "%0.4f", matrix[j][i]);;
+
+      if (j != n - 1)
+        fprintf(ostream, "\t");
+    }
+
+    fprintf(ostream, "|\n");
+  }
+
+  fprintf(ostream, "\n");
+
+#undef m
+#undef n
+}
+
 CGLM_INLINE
 void
 glm_vec4_print(vec4              vec,
@@ -149,6 +179,28 @@ glm_ivec3_print(ivec3             vec,
 #undef m
 }
 
+CGLM_INLINE
+void
+glm_vec2_print(vec2              vec,
+               FILE * __restrict ostream) {
+  int i;
+
+#define m 2
+
+  fprintf(ostream, "Vector (float%d):\n\t|", m);
+
+  for (i = 0; i < m; i++) {
+    fprintf(ostream, "%0.4f", vec[i]);
+
+    if (i != m - 1)
+      fprintf(ostream, "\t");
+  }
+
+  fprintf(ostream, "|\n\n");
+
+#undef m
+}
+
 CGLM_INLINE
 void
 glm_versor_print(versor            vec,

include/cglm/mat2.h

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

include/cglm/mat3.h

@@ -17,15 +17,19 @@
    CGLM_INLINE void  glm_mat3_copy(mat3 mat, mat3 dest);
    CGLM_INLINE void  glm_mat3_identity(mat3 mat);
    CGLM_INLINE void  glm_mat3_identity_array(mat3 * restrict mat, size_t count);
+   CGLM_INLINE void  glm_mat3_zero(mat3 mat);
    CGLM_INLINE void  glm_mat3_mul(mat3 m1, mat3 m2, mat3 dest);
    CGLM_INLINE void  glm_mat3_transpose_to(mat3 m, mat3 dest);
    CGLM_INLINE void  glm_mat3_transpose(mat3 m);
    CGLM_INLINE void  glm_mat3_mulv(mat3 m, vec3 v, vec3 dest);
+   CGLM_INLINE float glm_mat3_trace(mat3 m);
+   CGLM_INLINE void  glm_mat3_quat(mat3 m, versor dest);
    CGLM_INLINE void  glm_mat3_scale(mat3 m, float s);
    CGLM_INLINE float glm_mat3_det(mat3 mat);
    CGLM_INLINE void  glm_mat3_inv(mat3 mat, mat3 dest);
    CGLM_INLINE void  glm_mat3_swap_col(mat3 mat, int col1, int col2);
    CGLM_INLINE void  glm_mat3_swap_row(mat3 mat, int row1, int row2);
+   CGLM_INLINE float glm_mat3_rmc(vec3 r, mat3 m, vec3 c);
  */
 
 #ifndef cglm_mat3_h
@@ -62,7 +66,17 @@
 CGLM_INLINE
 void
 glm_mat3_copy(mat3 mat, mat3 dest) {
-  glm__memcpy(float, dest, mat, sizeof(mat3));
+  dest[0][0] = mat[0][0];
+  dest[0][1] = mat[0][1];
+  dest[0][2] = mat[0][2];
+
+  dest[1][0] = mat[1][0];
+  dest[1][1] = mat[1][1];
+  dest[1][2] = mat[1][2];
+
+  dest[2][0] = mat[2][0];
+  dest[2][1] = mat[2][1];
+  dest[2][2] = mat[2][2];
 }
 
 /*!
@@ -105,6 +119,18 @@ glm_mat3_identity_array(mat3 * __restrict mat, size_t count) {
   }
 }
 
+/*!
+ * @brief make given matrix zero.
+ *
+ * @param[in, out]  mat  matrix
+ */
+CGLM_INLINE
+void
+glm_mat3_zero(mat3 mat) {
+  CGLM_ALIGN_MAT mat3 t = GLM_MAT3_ZERO_INIT;
+  glm_mat3_copy(t, mat);
+}
+
 /*!
  * @brief multiply m1 and m2 to dest
  *
@@ -207,6 +233,18 @@ glm_mat3_mulv(mat3 m, vec3 v, vec3 dest) {
   dest[2] = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2];
 }
 
+/*!
+ * @brief trace of matrix
+ *
+ * sum of the elements on the main diagonal from upper left to the lower right
+ *
+ * @param[in]  m matrix
+ */
+CGLM_INLINE
+float
+glm_mat3_trace(mat3 m) {
+  return m[0][0] + m[1][1] + m[2][2];
+}
 
 /*!
  * @brief convert mat3 to quaternion
@@ -359,4 +397,26 @@ glm_mat3_swap_row(mat3 mat, int row1, int row2) {
   mat[2][row2] = tmp[2];
 }
 
+/*!
+ * @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
+glm_mat3_rmc(vec3 r, mat3 m, vec3 c) {
+  vec3 tmp;
+  glm_mat3_mulv(m, c, tmp);
+  return glm_vec3_dot(r, tmp);
+}
+
 #endif /* cglm_mat3_h */

include/cglm/mat4.h

@@ -22,6 +22,7 @@
    CGLM_INLINE void  glm_mat4_copy(mat4 mat, mat4 dest);
    CGLM_INLINE void  glm_mat4_identity(mat4 mat);
    CGLM_INLINE void  glm_mat4_identity_array(mat4 * restrict mat, size_t count);
+   CGLM_INLINE void  glm_mat4_zero(mat4 mat);
    CGLM_INLINE void  glm_mat4_pick3(mat4 mat, mat3 dest);
    CGLM_INLINE void  glm_mat4_pick3t(mat4 mat, mat3 dest);
    CGLM_INLINE void  glm_mat4_ins3(mat3 mat, mat4 dest);
@@ -29,6 +30,9 @@
    CGLM_INLINE void  glm_mat4_mulN(mat4 *matrices[], int len, mat4 dest);
    CGLM_INLINE void  glm_mat4_mulv(mat4 m, vec4 v, vec4 dest);
    CGLM_INLINE void  glm_mat4_mulv3(mat4 m, vec3 v, vec3 dest);
+   CGLM_INLINE float glm_mat4_trace(mat4 m);
+   CGLM_INLINE float glm_mat4_trace3(mat4 m);
+   CGLM_INLINE void  glm_mat4_quat(mat4 m, versor dest) ;
    CGLM_INLINE void  glm_mat4_transpose_to(mat4 m, mat4 dest);
    CGLM_INLINE void  glm_mat4_transpose(mat4 m);
    CGLM_INLINE void  glm_mat4_scale_p(mat4 m, float s);
@@ -38,6 +42,7 @@
    CGLM_INLINE void  glm_mat4_inv_fast(mat4 mat, mat4 dest);
    CGLM_INLINE void  glm_mat4_swap_col(mat4 mat, int col1, int col2);
    CGLM_INLINE void  glm_mat4_swap_row(mat4 mat, int row1, int row2);
+   CGLM_INLINE float glm_mat4_rmc(vec4 r, mat4 m, vec4 c);
  */
 
 #ifndef cglm_mat_h
@@ -96,7 +101,15 @@
 CGLM_INLINE
 void
 glm_mat4_ucopy(mat4 mat, mat4 dest) {
-  glm__memcpy(float, dest, mat, sizeof(mat4));
+  dest[0][0] = mat[0][0];  dest[1][0] = mat[1][0];
+  dest[0][1] = mat[0][1];  dest[1][1] = mat[1][1];
+  dest[0][2] = mat[0][2];  dest[1][2] = mat[1][2];
+  dest[0][3] = mat[0][3];  dest[1][3] = mat[1][3];
+
+  dest[2][0] = mat[2][0];  dest[3][0] = mat[3][0];
+  dest[2][1] = mat[2][1];  dest[3][1] = mat[3][1];
+  dest[2][2] = mat[2][2];  dest[3][2] = mat[3][2];
+  dest[2][3] = mat[2][3];  dest[3][3] = mat[3][3];
 }
 
 /*!
@@ -116,6 +129,11 @@ glm_mat4_copy(mat4 mat, mat4 dest) {
   glmm_store(dest[1], glmm_load(mat[1]));
   glmm_store(dest[2], glmm_load(mat[2]));
   glmm_store(dest[3], glmm_load(mat[3]));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest[0], vld1q_f32(mat[0]));
+  vst1q_f32(dest[1], vld1q_f32(mat[1]));
+  vst1q_f32(dest[2], vld1q_f32(mat[2]));
+  vst1q_f32(dest[3], vld1q_f32(mat[3]));
 #else
   glm_mat4_ucopy(mat, dest);
 #endif
@@ -161,6 +179,18 @@ glm_mat4_identity_array(mat4 * __restrict mat, size_t count) {
   }
 }
 
+/*!
+ * @brief make given matrix zero.
+ *
+ * @param[in, out]  mat  matrix
+ */
+CGLM_INLINE
+void
+glm_mat4_zero(mat4 mat) {
+  CGLM_ALIGN_MAT mat4 t = GLM_MAT4_ZERO_INIT;
+  glm_mat4_copy(t, mat);
+}
+
 /*!
  * @brief copy upper-left of mat4 to mat3
  *
@@ -250,7 +280,7 @@ glm_mat4_mul(mat4 m1, mat4 m2, mat4 dest) {
   glm_mat4_mul_avx(m1, m2, dest);
 #elif defined( __SSE__ ) || defined( __SSE2__ )
   glm_mat4_mul_sse2(m1, m2, dest);
-#elif defined( __ARM_NEON_FP )
+#elif defined(CGLM_NEON_FP)
   glm_mat4_mul_neon(m1, m2, dest);
 #else
   float a00 = m1[0][0], a01 = m1[0][1], a02 = m1[0][2], a03 = m1[0][3],
@@ -338,6 +368,32 @@ glm_mat4_mulv(mat4 m, vec4 v, vec4 dest) {
 #endif
 }
 
+/*!
+ * @brief trace of matrix
+ *
+ * sum of the elements on the main diagonal from upper left to the lower right
+ *
+ * @param[in]  m matrix
+ */
+CGLM_INLINE
+float
+glm_mat4_trace(mat4 m) {
+  return m[0][0] + m[1][1] + m[2][2] + m[3][3];
+}
+
+/*!
+ * @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
+glm_mat4_trace3(mat4 m) {
+  return m[0][0] + m[1][1] + m[2][2];
+}
+
 /*!
  * @brief convert mat4's rotation part to quaternion
  *
@@ -390,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
@@ -441,10 +500,8 @@ glm_mat4_transpose(mat4 m) {
   glm_mat4_transp_sse2(m, m);
 #else
   mat4 d;
-
   glm_mat4_transpose_to(m, d);
-
-  glm__memcpy(float, m, d, sizeof(mat4));
+  glm_mat4_ucopy(d, m);
 #endif
 }
 
@@ -478,6 +535,13 @@ void
 glm_mat4_scale(mat4 m, float s) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glm_mat4_scale_sse2(m, s);
+#elif defined(CGLM_NEON_FP)
+  float32x4_t v0;
+  v0 = vdupq_n_f32(s);
+  vst1q_f32(m[0], vmulq_f32(vld1q_f32(m[0]), v0));
+  vst1q_f32(m[1], vmulq_f32(vld1q_f32(m[1]), v0));
+  vst1q_f32(m[2], vmulq_f32(vld1q_f32(m[2]), v0));
+  vst1q_f32(m[3], vmulq_f32(vld1q_f32(m[3]), v0));
 #else
   glm_mat4_scale_p(m, s);
 #endif
@@ -637,4 +701,26 @@ glm_mat4_swap_row(mat4 mat, int row1, int row2) {
   mat[3][row2] = tmp[3];
 }
 
+/*!
+ * @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
+glm_mat4_rmc(vec4 r, mat4 m, vec4 c) {
+  vec4 tmp;
+  glm_mat4_mulv(m, c, tmp);
+  return glm_vec4_dot(r, tmp);
+}
+
 #endif /* cglm_mat_h */

include/cglm/plane.h

@@ -25,12 +25,19 @@
 /*!
  * @brief normalizes a plane
  *
- * @param[in, out] plane pnale to normalize
+ * @param[in, out] plane plane to normalize
  */
 CGLM_INLINE
 void
 glm_plane_normalize(vec4 plane) {
-  glm_vec4_scale(plane, 1.0f / glm_vec3_norm(plane), plane);
+  float norm;
+  
+  if ((norm = glm_vec3_norm(plane)) == 0.0f) {
+    glm_vec4_zero(plane);
+    return;
+  }
+  
+  glm_vec4_scale(plane, 1.0f / norm, plane);
 }
 
 #endif /* cglm_plane_h */

include/cglm/project.h

@@ -8,6 +8,7 @@
 #ifndef cglm_project_h
 #define cglm_project_h
 
+#include "common.h"
 #include "vec3.h"
 #include "vec4.h"
 #include "mat4.h"

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);
@@ -218,7 +219,7 @@ glm_quat_normalize_to(versor q, versor dest) {
   float  dot;
 
   x0   = glmm_load(q);
-  xdot = glmm_dot(x0, x0);
+  xdot = glmm_vdot(x0, x0);
   dot  = _mm_cvtss_f32(xdot);
 
   if (dot <= 0.0f) {
@@ -233,7 +234,7 @@ glm_quat_normalize_to(versor q, versor dest) {
   dot = glm_vec4_norm2(q);
 
   if (dot <= 0.0f) {
-    glm_quat_identity(q);
+    glm_quat_identity(dest);
     return;
   }
 
@@ -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)
@@ -677,32 +693,23 @@ glm_quat_look(vec3 eye, versor ori, mat4 dest) {
  * @brief creates look rotation quaternion
  *
  * @param[in]   dir   direction to look
- * @param[in]   fwd   forward vector
  * @param[in]   up    up vector
  * @param[out]  dest  destination quaternion
  */
 CGLM_INLINE
 void
-glm_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest) {
-  CGLM_ALIGN(8) vec3 axis;
-  float dot, angle;
+glm_quat_for(vec3 dir, vec3 up, versor dest) {
+  CGLM_ALIGN_MAT mat3 m;
 
-  dot = glm_vec3_dot(dir, fwd);
-  if (fabsf(dot + 1.0f)  < 0.000001f) {
-    glm_quat_init(dest, up[0], up[1], up[2], GLM_PIf);
-    return;
-  }
+  glm_vec3_normalize_to(dir, m[2]); 
 
-  if (fabsf(dot - 1.0f) < 0.000001f) {
-    glm_quat_identity(dest);
-    return;
-  }
+  /* No need to negate in LH, but we use RH here */
+  glm_vec3_negate(m[2]);
   
-  angle = acosf(dot);
-  glm_cross(fwd, dir, axis);
-  glm_normalize(axis);
+  glm_vec3_crossn(up, m[2], m[0]);
+  glm_vec3_cross(m[2], m[0], m[1]);
 
-  glm_quatv(dest, angle, axis);
+  glm_mat3_quat(m, dest);
 }
 
 /*!
@@ -711,16 +718,15 @@ glm_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest) {
  *
  * @param[in]   from  source point
  * @param[in]   to    destination point
- * @param[in]   fwd   forward vector
  * @param[in]   up    up vector
  * @param[out]  dest  destination quaternion
  */
 CGLM_INLINE
 void
-glm_quat_forp(vec3 from, vec3 to, vec3 fwd, vec3 up, versor dest) {
+glm_quat_forp(vec3 from, vec3 to, vec3 up, versor dest) {
   CGLM_ALIGN(8) vec3 dir;
   glm_vec3_sub(to, from, dir);
-  glm_quat_for(dir, fwd, up, dest);
+  glm_quat_for(dir, up, dest);
 }
 
 /*!

include/cglm/simd/arm.h

@@ -0,0 +1,83 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglm_simd_arm_h
+#define cglm_simd_arm_h
+#include "intrin.h"
+#ifdef CGLM_SIMD_ARM
+
+#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) {
+#if defined(__aarch64__)
+  return vaddvq_f32(v);
+#else
+  v = vaddq_f32(v, vrev64q_f32(v));
+  v = vaddq_f32(v, vcombine_f32(vget_high_f32(v), vget_low_f32(v)));
+  return vgetq_lane_f32(v, 0);
+#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) {
+  return glmm_hadd(vmulq_f32(a, b));
+}
+
+static inline
+float
+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/intrin.h

@@ -27,90 +27,64 @@
 #if defined( __SSE__ ) || defined( __SSE2__ )
 #  include <xmmintrin.h>
 #  include <emmintrin.h>
-
-/* OPTIONAL: You may save some instructions but latency (not sure) */
-#ifdef CGLM_USE_INT_DOMAIN
-#  define glmm_shuff1(xmm, z, y, x, w)                                        \
-     _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(xmm),                \
-                                        _MM_SHUFFLE(z, y, x, w)))
-#else
-#  define glmm_shuff1(xmm, z, y, x, w)                                        \
-     _mm_shuffle_ps(xmm, xmm, _MM_SHUFFLE(z, y, x, w))
-#endif
-
-#define glmm_shuff1x(xmm, x) glmm_shuff1(xmm, x, x, x, x)
-#define glmm_shuff2(a, b, z0, y0, x0, w0, z1, y1, x1, w1)                     \
-     glmm_shuff1(_mm_shuffle_ps(a, b, _MM_SHUFFLE(z0, y0, x0, w0)),           \
-                 z1, y1, x1, w1)
-
-static inline
-__m128
-glmm_dot(__m128 a, __m128 b) {
-  __m128 x0;
-  x0 = _mm_mul_ps(a, b);
-  x0 = _mm_add_ps(x0, glmm_shuff1(x0, 1, 0, 3, 2));
-  return _mm_add_ps(x0, glmm_shuff1(x0, 0, 1, 0, 1));
-}
-
-static inline
-__m128
-glmm_norm(__m128 a) {
-  return _mm_sqrt_ps(glmm_dot(a, a));
-}
-
-static inline
-__m128
-glmm_load3(float v[3]) {
-  __m128i xy;
-  __m128  z;
-
-  xy = _mm_loadl_epi64((const __m128i *)v);
-  z  = _mm_load_ss(&v[2]);
-
-  return _mm_movelh_ps(_mm_castsi128_ps(xy), z);
-}
-
-static inline
-void
-glmm_store3(__m128 vx, float v[3]) {
-  _mm_storel_pi((__m64 *)&v[0], vx);
-  _mm_store_ss(&v[2], glmm_shuff1(vx, 2, 2, 2, 2));
-}
-
-#ifdef CGLM_ALL_UNALIGNED
-#  define glmm_load(p)      _mm_loadu_ps(p)
-#  define glmm_store(p, a)  _mm_storeu_ps(p, a)
-#else
-#  define glmm_load(p)      _mm_load_ps(p)
-#  define glmm_store(p, a)  _mm_store_ps(p, a)
-#endif
-
-#endif
-
-/* x86, x64 */
-#if defined( __SSE__ ) || defined( __SSE2__ )
 #  define CGLM_SSE_FP 1
+#  ifndef CGLM_SIMD_x86
+#    define CGLM_SIMD_x86
+#  endif
+#endif
+
+#if defined(__SSE3__)
+#  include <x86intrin.h>
+#  ifndef CGLM_SIMD_x86
+#    define CGLM_SIMD_x86
+#  endif
+#endif
+
+#if defined(__SSE4_1__)
+#  include <smmintrin.h>
+#  ifndef CGLM_SIMD_x86
+#    define CGLM_SIMD_x86
+#  endif
+#endif
+
+#if defined(__SSE4_2__)
+#  include <nmmintrin.h>
+#  ifndef CGLM_SIMD_x86
+#    define CGLM_SIMD_x86
+#  endif
 #endif
 
 #ifdef __AVX__
+#  include <immintrin.h>
 #  define CGLM_AVX_FP 1
-
-#ifdef CGLM_ALL_UNALIGNED
-#  define glmm_load256(p)      _mm256_loadu_ps(p)
-#  define glmm_store256(p, a)  _mm256_storeu_ps(p, a)
-#else
-#  define glmm_load256(p)      _mm256_load_ps(p)
-#  define glmm_store256(p, a)  _mm256_store_ps(p, a)
-#endif
-
+#  ifndef CGLM_SIMD_x86
+#    define CGLM_SIMD_x86
+#  endif
 #endif
 
 /* ARM Neon */
-#if defined(__ARM_NEON) && defined(__ARM_NEON_FP)
+#if defined(__ARM_NEON)
 #  include <arm_neon.h>
-#  define CGLM_NEON_FP 1
-#else
-#  undef  CGLM_NEON_FP
+#  if defined(__ARM_NEON_FP)
+#    define CGLM_NEON_FP 1
+#    ifndef CGLM_SIMD_ARM
+#      define CGLM_SIMD_ARM
+#    endif
+#  endif
+#endif
+
+#if defined(CGLM_SIMD_x86) || defined(CGLM_NEON_FP)
+#  ifndef CGLM_SIMD
+#    define CGLM_SIMD
+#  endif
+#endif
+
+#if defined(CGLM_SIMD_x86)
+#  include "x86.h"
+#endif
+
+#if defined(CGLM_SIMD_ARM)
+#  include "arm.h"
 #endif
 
 #endif /* cglm_intrin_h */

include/cglm/simd/sse2/mat2.h

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

include/cglm/simd/x86.h

@@ -0,0 +1,192 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglm_simd_x86_h
+#define cglm_simd_x86_h
+#include "intrin.h"
+#ifdef CGLM_SIMD_x86
+
+#ifdef CGLM_ALL_UNALIGNED
+#  define glmm_load(p)      _mm_loadu_ps(p)
+#  define glmm_store(p, a)  _mm_storeu_ps(p, a)
+#else
+#  define glmm_load(p)      _mm_load_ps(p)
+#  define glmm_store(p, a)  _mm_store_ps(p, a)
+#endif
+
+#ifdef CGLM_USE_INT_DOMAIN
+#  define glmm_shuff1(xmm, z, y, x, w)                                        \
+     _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(xmm),                \
+                                        _MM_SHUFFLE(z, y, x, w)))
+#else
+#  define glmm_shuff1(xmm, z, y, x, w)                                        \
+       _mm_shuffle_ps(xmm, xmm, _MM_SHUFFLE(z, y, x, w))
+#endif
+
+#define glmm_shuff1x(xmm, x) glmm_shuff1(xmm, x, x, x, x)
+#define glmm_shuff2(a, b, z0, y0, x0, w0, z1, y1, x1, w1)                     \
+     glmm_shuff1(_mm_shuffle_ps(a, b, _MM_SHUFFLE(z0, y0, x0, w0)),           \
+                 z1, y1, x1, w1)
+
+#ifdef __AVX__
+#  ifdef CGLM_ALL_UNALIGNED
+#    define glmm_load256(p)      _mm256_loadu_ps(p)
+#    define glmm_store256(p, a)  _mm256_storeu_ps(p, a)
+#  else
+#    define glmm_load256(p)      _mm256_load_ps(p)
+#    define glmm_store256(p, a)  _mm256_store_ps(p, a)
+#  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) {
+#if defined(__SSE3__)
+  __m128 shuf, sums;
+  shuf = _mm_movehdup_ps(v);
+  sums = _mm_add_ps(v, shuf);
+  shuf = _mm_movehl_ps(shuf, sums);
+  sums = _mm_add_ss(sums, shuf);
+  return sums;
+#else
+  __m128 shuf, sums;
+  shuf = glmm_shuff1(v, 2, 3, 0, 1);
+  sums = _mm_add_ps(v, shuf);
+  shuf = _mm_movehl_ps(shuf, sums);
+  sums = _mm_add_ss(sums, shuf);
+  return sums;
+#endif
+}
+
+static inline
+float
+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) {
+#if (defined(__SSE4_1__) || defined(__SSE4_2__)) && defined(CGLM_SSE4_DOT)
+  return _mm_dp_ps(a, b, 0xFF);
+#elif defined(__SSE3__) && defined(CGLM_SSE3_DOT)
+  __m128 x0, x1;
+  x0 = _mm_mul_ps(a, b);
+  x1 = _mm_hadd_ps(x0, x0);
+  return _mm_hadd_ps(x1, x1);
+#else
+  return glmm_vhadds(_mm_mul_ps(a, b));
+#endif
+}
+
+static inline
+__m128
+glmm_vdot(__m128 a, __m128 b) {
+#if (defined(__SSE4_1__) || defined(__SSE4_2__)) && defined(CGLM_SSE4_DOT)
+  return _mm_dp_ps(a, b, 0xFF);
+#elif defined(__SSE3__) && defined(CGLM_SSE3_DOT)
+  __m128 x0, x1;
+  x0 = _mm_mul_ps(a, b);
+  x1 = _mm_hadd_ps(x0, x0);
+  return _mm_hadd_ps(x1, x1);
+#else
+  __m128 x0;
+  x0 = _mm_mul_ps(a, b);
+  x0 = _mm_add_ps(x0, glmm_shuff1(x0, 1, 0, 3, 2));
+  return _mm_add_ps(x0, glmm_shuff1(x0, 0, 1, 0, 1));
+#endif
+}
+
+static inline
+float
+glmm_dot(__m128 a, __m128 b) {
+  return _mm_cvtss_f32(glmm_vdots(a, b));
+}
+
+static inline
+float
+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]) {
+  __m128i xy;
+  __m128  z;
+
+  xy = _mm_loadl_epi64((const __m128i *)v);
+  z  = _mm_load_ss(&v[2]);
+
+  return _mm_movelh_ps(_mm_castsi128_ps(xy), z);
+}
+
+static inline
+void
+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));
+}
+
+#endif
+#endif /* cglm_simd_x86_h */

include/cglm/struct.h

@@ -0,0 +1,38 @@
+/*
+ * 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/vec2.h"
+#include "struct/vec3.h"
+#include "struct/vec4.h"
+#include "struct/mat2.h"
+#include "struct/mat3.h"
+#include "struct/mat4.h"
+#include "struct/affine.h"
+#include "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/mat2.h

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

include/cglm/struct/mat3.h

@@ -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,530 @@
+/*
+ * 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]   up    up vector
+ * @returns  destination quaternion
+ */
+CGLM_INLINE
+versors
+glms_quat_for(vec3s dir, vec3s up) {
+  versors dest;
+  glm_quat_for(dir.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]   up    up vector
+ * @returns  destination quaternion
+ */
+CGLM_INLINE
+versors
+glms_quat_forp(vec3s from, vec3s to, vec3s up) {
+  versors dest;
+  glm_quat_forp(from.raw, to.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/vec2-ext.h

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

include/cglm/struct/vec2.h

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

include/cglm/struct/vec3-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,140 @@
+/*
+ * 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 mat2s {
+  mat2  raw;
+  vec2s col[2];
+#if CGLM_USE_ANONYMOUS_STRUCT
+  struct {
+    float m00, m01;
+    float m10, m11;
+  };
+#endif
+} mat2s;
+
+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

@@ -10,12 +10,12 @@
 
 #if defined(_MSC_VER)
 /* do not use alignment for older visual studio versions */
-#if _MSC_VER < 1913 /*  Visual Studio 2017 version 15.6  */
-#  define CGLM_ALL_UNALIGNED
-#  define CGLM_ALIGN(X) /* no alignment */
-#else
-#  define CGLM_ALIGN(X) __declspec(align(X))
-#endif
+#  if _MSC_VER < 1913 /*  Visual Studio 2017 version 15.6  */
+#    define CGLM_ALL_UNALIGNED
+#    define CGLM_ALIGN(X) /* no alignment */
+#  else
+#    define CGLM_ALIGN(X) __declspec(align(X))
+#  endif
 #else
 #  define CGLM_ALIGN(X) __attribute((aligned(X)))
 #endif
@@ -33,19 +33,18 @@
 #endif
 
 typedef float                   vec2[2];
-typedef CGLM_ALIGN_IF(8)  float vec3[3];
+typedef float                   vec3[3];
 typedef int                    ivec3[3];
 typedef CGLM_ALIGN_IF(16) float vec4[4];
+typedef vec4                    versor;     /* |x, y, z, w| -> w is the last */
+typedef vec3                    mat3[3];
+typedef CGLM_ALIGN_IF(16) vec2  mat2[2];
+typedef CGLM_ALIGN_MAT    vec4  mat4[4];
 
-#ifdef __AVX__
-typedef CGLM_ALIGN_IF(32) vec3  mat3[3];
-typedef CGLM_ALIGN_IF(32) vec4  mat4[4];
-#else
-typedef                   vec3  mat3[3];
-typedef CGLM_ALIGN_IF(16) vec4  mat4[4];
-#endif
-
-typedef vec4                    versor;
+/*
+  Important: cglm stores quaternion as [x, y, z, w] in memory since v0.4.0 
+  it was [w, x, y, z] before v0.4.0 ( v0.3.5 and earlier ). w is real part.
+*/
 
 #define GLM_E         2.71828182845904523536028747135266250   /* e           */
 #define GLM_LOG2E     1.44269504088896340735992468100189214   /* log2(e)     */

include/cglm/util.h

@@ -8,18 +8,32 @@
 /*
  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
 #define cglm_util_h
 
 #include "common.h"
-#include <stdbool.h>
 
 #define GLM_MIN(X, Y) (((X) < (Y)) ? (X) : (Y))
 #define GLM_MAX(X, Y) (((X) > (Y)) ? (X) : (Y))
@@ -158,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
@@ -168,8 +276,8 @@ glm_clamp_zo(float val) {
  */
 CGLM_INLINE
 float
-glm_lerp(float from, float to, float t) {
-  return from + glm_clamp_zo(t) * (to - from);
+glm_smoothinterpc(float from, float to, float t) {
+  return glm_smoothinterp(from, to, glm_clamp_zo(t));
 }
 
 /*!
@@ -217,4 +325,19 @@ glm_percentc(float from, float to, float current) {
   return glm_clamp(glm_percent(from, to, current), 0.0f, 1.0f);
 }
 
+/*!
+* @brief swap two float values
+*
+* @param[in]   a float value 1 (pointer)
+* @param[in]   b float value 2 (pointer)
+*/
+CGLM_INLINE
+void
+glm_swapf(float * __restrict a, float * __restrict b) {
+  float t;
+  t  = *a;
+  *a = *b;
+  *b = t;
+}
+
 #endif /* cglm_util_h */

include/cglm/vec2-ext.h

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

include/cglm/vec2.h

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

include/cglm/vec3-ext.h

@@ -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);
  */
 
@@ -31,9 +35,6 @@
 
 #include "common.h"
 #include "util.h"
-#include <stdbool.h>
-#include <math.h>
-#include <float.h>
 
 /*!
  * @brief fill a vector with specified value
@@ -47,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)
  *
@@ -201,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

@@ -21,9 +21,10 @@
    CGLM_INLINE void  glm_vec3_zero(vec3 v);
    CGLM_INLINE void  glm_vec3_one(vec3 v);
    CGLM_INLINE float glm_vec3_dot(vec3 a, vec3 b);
-   CGLM_INLINE void  glm_vec3_cross(vec3 a, vec3 b, vec3 d);
    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);
@@ -47,19 +48,31 @@
    CGLM_INLINE void  glm_vec3_inv_to(vec3 v, vec3 dest);
    CGLM_INLINE void  glm_vec3_normalize(vec3 v);
    CGLM_INLINE void  glm_vec3_normalize_to(vec3 v, vec3 dest);
-   CGLM_INLINE float glm_vec3_distance(vec3 a, vec3 b);
+   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_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);
@@ -98,9 +111,15 @@
 #define GLM_VEC3_ONE  ((vec3)GLM_VEC3_ONE_INIT)
 #define GLM_VEC3_ZERO ((vec3)GLM_VEC3_ZERO_INIT)
 
-#define GLM_YUP  ((vec3){0.0f, 1.0f, 0.0f})
-#define GLM_ZUP  ((vec3){0.0f, 0.0f, 1.0f})
-#define GLM_XUP  ((vec3){1.0f, 0.0f, 0.0f})
+#define GLM_YUP       ((vec3){0.0f,  1.0f,  0.0f})
+#define GLM_ZUP       ((vec3){0.0f,  0.0f,  1.0f})
+#define GLM_XUP       ((vec3){1.0f,  0.0f,  0.0f})
+#define GLM_FORWARD   ((vec3){0.0f,  0.0f, -1.0f})
+
+#define GLM_XXX GLM_SHUFFLE3(0, 0, 0)
+#define GLM_YYY GLM_SHUFFLE3(1, 1, 1)
+#define GLM_ZZZ GLM_SHUFFLE3(2, 2, 2)
+#define GLM_ZYX GLM_SHUFFLE3(0, 1, 2)
 
 /*!
  * @brief init vec3 using vec4
@@ -166,22 +185,6 @@ glm_vec3_dot(vec3 a, vec3 b) {
   return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
 }
 
-/*!
- * @brief vec3 cross product
- *
- * @param[in]  a source 1
- * @param[in]  b source 2
- * @param[out] d destination
- */
-CGLM_INLINE
-void
-glm_vec3_cross(vec3 a, vec3 b, vec3 d) {
-  /* (u2.v3 - u3.v2, u3.v1 - u1.v3, u1.v2 - u2.v1) */
-  d[0] = a[1] * b[2] - a[2] * b[1];
-  d[1] = a[2] * b[0] - a[0] * b[2];
-  d[2] = a[0] * b[1] - a[1] * b[0];
-}
-
 /*!
  * @brief norm * norm (magnitude) of vec
  *
@@ -200,7 +203,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
  *
@@ -212,6 +216,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
  *
@@ -443,8 +490,8 @@ glm_vec3_maxadd(vec3 a, vec3 b, vec3 dest) {
  *
  * it applies += operator so dest must be initialized
  *
- * @param[in]  a    vector
- * @param[in]  s    scalar
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
  * @param[out] dest dest += min(a, b)
  */
 CGLM_INLINE
@@ -521,6 +568,36 @@ glm_vec3_normalize_to(vec3 v, vec3 dest) {
   glm_vec3_scale(v, 1.0f / norm, dest);
 }
 
+/*!
+ * @brief cross product of two vector (RH)
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_vec3_cross(vec3 a, vec3 b, vec3 dest) {
+  /* (u2.v3 - u3.v2, u3.v1 - u1.v3, u1.v2 - u2.v1) */
+  dest[0] = a[1] * b[2] - a[2] * b[1];
+  dest[1] = a[2] * b[0] - a[0] * b[2];
+  dest[2] = a[0] * b[1] - a[1] * b[0];
+}
+
+/*!
+ * @brief cross product of two vector (RH) and normalize the result
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_vec3_crossn(vec3 a, vec3 b, vec3 dest) {
+  glm_vec3_cross(a, b, dest);
+  glm_vec3_normalize(dest);
+}
+
 /*!
  * @brief angle betwen two vector
  *
@@ -673,9 +750,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])
-       + glm_pow2(b[1] - a[1])
-       + glm_pow2(b[2] - a[2]);
+  return glm_pow2(a[0] - b[0])
+       + glm_pow2(a[1] - b[1])
+       + glm_pow2(a[2] - b[2]);
 }
 
 /**
@@ -751,7 +828,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)
  *
@@ -762,16 +861,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);
  */
 
@@ -31,9 +35,6 @@
 
 #include "common.h"
 #include "vec3-ext.h"
-#include <stdbool.h>
-#include <math.h>
-#include <float.h>
 
 /*!
  * @brief fill a vector with specified value
@@ -51,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)
  *
@@ -223,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
  *
@@ -122,6 +139,8 @@ void
 glm_vec4_copy(vec4 v, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, glmm_load(v));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, vld1q_f32(v));
 #else
   dest[0] = v[0];
   dest[1] = v[1];
@@ -157,6 +176,8 @@ void
 glm_vec4_zero(vec4 v) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(v, _mm_setzero_ps());
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(v, vdupq_n_f32(0.0f));
 #else
   v[0] = 0.0f;
   v[1] = 0.0f;
@@ -175,6 +196,8 @@ void
 glm_vec4_one(vec4 v) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(v, _mm_set1_ps(1.0f));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(v, vdupq_n_f32(1.0f));
 #else
   v[0] = 1.0f;
   v[1] = 1.0f;
@@ -194,11 +217,8 @@ glm_vec4_one(vec4 v) {
 CGLM_INLINE
 float
 glm_vec4_dot(vec4 a, vec4 b) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
-  __m128 x0;
-  x0 = _mm_mul_ps(glmm_load(a), glmm_load(b));
-  x0 = _mm_add_ps(x0, glmm_shuff1(x0, 1, 0, 3, 2));
-  return _mm_cvtss_f32(_mm_add_ss(x0, glmm_shuff1(x0, 0, 1, 0, 1)));
+#if defined(CGLM_SIMD)
+  return glmm_dot(glmm_load(a), glmm_load(b));
 #else
   return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
 #endif
@@ -218,19 +238,12 @@ glm_vec4_dot(vec4 a, vec4 b) {
 CGLM_INLINE
 float
 glm_vec4_norm2(vec4 v) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
-  __m128 x0;
-  x0 = glmm_load(v);
-  x0 = _mm_mul_ps(x0, x0);
-  x0 = _mm_add_ps(x0, glmm_shuff1(x0, 1, 0, 3, 2));
-  return _mm_cvtss_f32(_mm_add_ss(x0, glmm_shuff1(x0, 0, 1, 0, 1)));
-#else
-  return v[0] * v[0] + v[1] * v[1] + v[2] * v[2] + v[3] * v[3];
-#endif
+  return glm_vec4_dot(v, 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
  *
@@ -239,12 +252,61 @@ glm_vec4_norm2(vec4 v) {
 CGLM_INLINE
 float
 glm_vec4_norm(vec4 v) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
-  __m128 x0;
-  x0 = glmm_load(v);
-  return _mm_cvtss_f32(_mm_sqrt_ss(glmm_dot(x0, x0)));
+#if defined(CGLM_SIMD)
+  return glmm_norm(glmm_load(v));
 #else
-  return sqrtf(glm_vec4_norm2(v));
+  return sqrtf(glm_vec4_dot(v, 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
 }
 
@@ -260,6 +322,8 @@ void
 glm_vec4_add(vec4 a, vec4 b, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_add_ps(glmm_load(a), glmm_load(b)));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, vaddq_f32(vld1q_f32(a), vld1q_f32(b)));
 #else
   dest[0] = a[0] + b[0];
   dest[1] = a[1] + b[1];
@@ -280,6 +344,8 @@ void
 glm_vec4_adds(vec4 v, float s, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_add_ps(glmm_load(v), _mm_set1_ps(s)));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, vaddq_f32(vld1q_f32(v), vdupq_n_f32(s)));
 #else
   dest[0] = v[0] + s;
   dest[1] = v[1] + s;
@@ -300,6 +366,8 @@ void
 glm_vec4_sub(vec4 a, vec4 b, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_sub_ps(glmm_load(a), glmm_load(b)));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, vsubq_f32(vld1q_f32(a), vld1q_f32(b)));
 #else
   dest[0] = a[0] - b[0];
   dest[1] = a[1] - b[1];
@@ -320,6 +388,8 @@ void
 glm_vec4_subs(vec4 v, float s, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_sub_ps(glmm_load(v), _mm_set1_ps(s)));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, vsubq_f32(vld1q_f32(v), vdupq_n_f32(s)));
 #else
   dest[0] = v[0] - s;
   dest[1] = v[1] - s;
@@ -331,15 +401,17 @@ glm_vec4_subs(vec4 v, float s, vec4 dest) {
 /*!
  * @brief multiply two vector (component-wise multiplication)
  *
- * @param a vector1
- * @param b vector2
- * @param d dest = (a[0] * b[0], a[1] * b[1], a[2] * b[2], a[3] * b[3])
+ * @param a    vector1
+ * @param b    vector2
+ * @param dest dest = (a[0] * b[0], a[1] * b[1], a[2] * b[2], a[3] * b[3])
  */
 CGLM_INLINE
 void
 glm_vec4_mul(vec4 a, vec4 b, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_mul_ps(glmm_load(a), glmm_load(b)));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, vmulq_f32(vld1q_f32(a), vld1q_f32(b)));
 #else
   dest[0] = a[0] * b[0];
   dest[1] = a[1] * b[1];
@@ -360,6 +432,8 @@ void
 glm_vec4_scale(vec4 v, float s, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_mul_ps(glmm_load(v), _mm_set1_ps(s)));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, vmulq_f32(vld1q_f32(v), vdupq_n_f32(s)));
 #else
   dest[0] = v[0] * s;
   dest[1] = v[1] * s;
@@ -426,7 +500,6 @@ glm_vec4_divs(vec4 v, float s, vec4 dest) {
 #endif
 }
 
-
 /*!
  * @brief add two vectors and add result to sum
  *
@@ -443,6 +516,10 @@ glm_vec4_addadd(vec4 a, vec4 b, vec4 dest) {
   glmm_store(dest, _mm_add_ps(glmm_load(dest),
                               _mm_add_ps(glmm_load(a),
                                          glmm_load(b))));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, vaddq_f32(vld1q_f32(dest),
+                            vaddq_f32(vld1q_f32(a),
+                                      vld1q_f32(b))));
 #else
   dest[0] += a[0] + b[0];
   dest[1] += a[1] + b[1];
@@ -467,6 +544,10 @@ glm_vec4_subadd(vec4 a, vec4 b, vec4 dest) {
   glmm_store(dest, _mm_add_ps(glmm_load(dest),
                               _mm_sub_ps(glmm_load(a),
                                          glmm_load(b))));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, vaddq_f32(vld1q_f32(dest),
+                            vsubq_f32(vld1q_f32(a),
+                                      vld1q_f32(b))));
 #else
   dest[0] += a[0] - b[0];
   dest[1] += a[1] - b[1];
@@ -491,6 +572,10 @@ glm_vec4_muladd(vec4 a, vec4 b, vec4 dest) {
   glmm_store(dest, _mm_add_ps(glmm_load(dest),
                               _mm_mul_ps(glmm_load(a),
                                          glmm_load(b))));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, vaddq_f32(vld1q_f32(dest),
+                            vmulq_f32(vld1q_f32(a),
+                                      vld1q_f32(b))));
 #else
   dest[0] += a[0] * b[0];
   dest[1] += a[1] * b[1];
@@ -515,6 +600,10 @@ glm_vec4_muladds(vec4 a, float s, vec4 dest) {
   glmm_store(dest, _mm_add_ps(glmm_load(dest),
                               _mm_mul_ps(glmm_load(a),
                                          _mm_set1_ps(s))));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, vaddq_f32(vld1q_f32(dest),
+                            vsubq_f32(vld1q_f32(a),
+                                      vdupq_n_f32(s))));
 #else
   dest[0] += a[0] * s;
   dest[1] += a[1] * s;
@@ -539,6 +628,10 @@ glm_vec4_maxadd(vec4 a, vec4 b, vec4 dest) {
   glmm_store(dest, _mm_add_ps(glmm_load(dest),
                               _mm_max_ps(glmm_load(a),
                                          glmm_load(b))));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, vaddq_f32(vld1q_f32(dest),
+                            vmaxq_f32(vld1q_f32(a),
+                                      vld1q_f32(b))));
 #else
   dest[0] += glm_max(a[0], b[0]);
   dest[1] += glm_max(a[1], b[1]);
@@ -552,8 +645,8 @@ glm_vec4_maxadd(vec4 a, vec4 b, vec4 dest) {
  *
  * it applies += operator so dest must be initialized
  *
- * @param[in]  a    vector
- * @param[in]  s    scalar
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
  * @param[out] dest dest += min(a, b)
  */
 CGLM_INLINE
@@ -563,6 +656,10 @@ glm_vec4_minadd(vec4 a, vec4 b, vec4 dest) {
   glmm_store(dest, _mm_add_ps(glmm_load(dest),
                               _mm_min_ps(glmm_load(a),
                                          glmm_load(b))));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, vaddq_f32(vld1q_f32(dest),
+                            vminq_f32(vld1q_f32(a),
+                                      vld1q_f32(b))));
 #else
   dest[0] += glm_min(a[0], b[0]);
   dest[1] += glm_min(a[1], b[1]);
@@ -582,6 +679,8 @@ void
 glm_vec4_negate_to(vec4 v, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_xor_ps(glmm_load(v), _mm_set1_ps(-0.0f)));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, veorq_s32(vld1q_f32(v), vdupq_n_f32(-0.0f)));
 #else
   dest[0] = -v[0];
   dest[1] = -v[1];
@@ -615,7 +714,7 @@ glm_vec4_normalize_to(vec4 v, vec4 dest) {
   float  dot;
 
   x0   = glmm_load(v);
-  xdot = glmm_dot(x0, x0);
+  xdot = glmm_vdot(x0, x0);
   dot  = _mm_cvtss_f32(xdot);
 
   if (dot == 0.0f) {
@@ -659,10 +758,38 @@ glm_vec4_normalize(vec4 v) {
 CGLM_INLINE
 float
 glm_vec4_distance(vec4 a, vec4 b) {
-  return sqrtf(glm_pow2(b[0] - a[0])
-             + glm_pow2(b[1] - a[1])
-             + glm_pow2(b[2] - a[2])
-             + glm_pow2(b[3] - a[3]));
+#if defined( __SSE__ ) || defined( __SSE2__ )
+  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(a[0] - b[0])
+             + glm_pow2(a[1] - b[1])
+             + glm_pow2(a[2] - b[2])
+             + 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
 }
 
 /*!
@@ -677,6 +804,8 @@ void
 glm_vec4_maxv(vec4 a, vec4 b, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_max_ps(glmm_load(a), glmm_load(b)));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, vmaxq_f32(vld1q_f32(a), vld1q_f32(b)));
 #else
   dest[0] = glm_max(a[0], b[0]);
   dest[1] = glm_max(a[1], b[1]);
@@ -697,6 +826,8 @@ void
 glm_vec4_minv(vec4 a, vec4 b, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_min_ps(glmm_load(a), glmm_load(b)));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(dest, vminq_f32(vld1q_f32(a), vld1q_f32(b)));
 #else
   dest[0] = glm_min(a[0], b[0]);
   dest[1] = glm_min(a[1], b[1]);
@@ -718,6 +849,9 @@ glm_vec4_clamp(vec4 v, float minVal, float maxVal) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(v, _mm_min_ps(_mm_max_ps(glmm_load(v), _mm_set1_ps(minVal)),
                            _mm_set1_ps(maxVal)));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(v, vminq_f32(vmaxq_f32(vld1q_f32(v), vdupq_n_f32(minVal)),
+                         vdupq_n_f32(maxVal)));
 #else
   v[0] = glm_clamp(v[0], minVal, maxVal);
   v[1] = glm_clamp(v[1], minVal, maxVal);
@@ -727,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
@@ -742,10 +876,203 @@ 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]
+ *
+ * @param[in]   s    parameter
+ * @param[out]  dest destination
+ */
+CGLM_INLINE
+void
+glm_vec4_cubic(float s, vec4 dest) {
+  float ss;
+
+  ss = s * s;
+
+  dest[0] = ss * s;
+  dest[1] = ss;
+  dest[2] = s;
+  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_PATCH 0
+#define CGLM_VERSION_MINOR 7
+#define CGLM_VERSION_PATCH 1
 
 #endif /* cglm_version_h */

makefile.am

@@ -1,127 +0,0 @@
-#******************************************************************************
-# Copyright (c), Recep Aslantas.                                              *
-#                                                                             *
-# MIT License (MIT), http://opensource.org/licenses/MIT                       *
-# Full license can be found in the LICENSE file                               *
-#                                                                             *
-#******************************************************************************
-
-ACLOCAL_AMFLAGS = -I m4
-
-AM_CFLAGS = -Wall \
-            -std=gnu99 \
-            -O3 \
-            -Wstrict-aliasing=2 \
-            -fstrict-aliasing \
-            -pedantic
-
-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 \
-              -I./include
-
-check_PROGRAMS = test/tests
-TESTS = $(check_PROGRAMS)
-
-test_tests_LDFLAGS = $(checkLDFLAGS)
-test_tests_CFLAGS  = $(checkCFLAGS)
-
-cglmdir=$(includedir)/cglm
-cglm_HEADERS = include/cglm/version.h \
-                  include/cglm/cglm.h \
-                  include/cglm/call.h \
-                  include/cglm/cam.h \
-                  include/cglm/io.h \
-                  include/cglm/mat4.h \
-                  include/cglm/mat3.h \
-                  include/cglm/types.h \
-                  include/cglm/common.h \
-                  include/cglm/affine.h \
-                  include/cglm/vec3.h \
-                  include/cglm/vec3-ext.h \
-                  include/cglm/vec4.h \
-                  include/cglm/vec4-ext.h \
-                  include/cglm/euler.h \
-                  include/cglm/util.h \
-                  include/cglm/quat.h \
-                  include/cglm/affine-mat.h \
-                  include/cglm/plane.h \
-                  include/cglm/frustum.h \
-                  include/cglm/box.h \
-                  include/cglm/color.h \
-                  include/cglm/project.h \
-                  include/cglm/sphere.h \
-                  include/cglm/ease.h
-
-cglm_calldir=$(includedir)/cglm/call
-cglm_call_HEADERS = include/cglm/call/mat4.h \
-                    include/cglm/call/mat3.h \
-                    include/cglm/call/vec3.h \
-                    include/cglm/call/vec4.h \
-                    include/cglm/call/affine.h \
-                    include/cglm/call/io.h \
-                    include/cglm/call/cam.h \
-                    include/cglm/call/quat.h \
-                    include/cglm/call/euler.h \
-                    include/cglm/call/plane.h \
-                    include/cglm/call/frustum.h \
-                    include/cglm/call/box.h \
-                    include/cglm/call/project.h \
-                    include/cglm/call/sphere.h \
-                    include/cglm/call/ease.h
-
-cglm_simddir=$(includedir)/cglm/simd
-cglm_simd_HEADERS = include/cglm/simd/intrin.h
-
-cglm_simd_sse2dir=$(includedir)/cglm/simd/sse2
-cglm_simd_sse2_HEADERS = include/cglm/simd/sse2/affine.h \
-                         include/cglm/simd/sse2/mat4.h \
-                         include/cglm/simd/sse2/mat3.h \
-                         include/cglm/simd/sse2/quat.h
-
-cglm_simd_avxdir=$(includedir)/cglm/simd/avx
-cglm_simd_avx_HEADERS = include/cglm/simd/avx/mat4.h \
-                        include/cglm/simd/avx/affine.h
-
-cglm_simd_neondir=$(includedir)/cglm/simd/neon
-cglm_simd_neon_HEADERS = include/cglm/simd/neon/mat4.h
-
-libcglm_la_SOURCES=\
-    src/euler.c \
-    src/affine.c \
-    src/io.c \
-    src/quat.c \
-    src/cam.c \
-    src/vec3.c \
-    src/vec4.c \
-    src/mat3.c \
-    src/mat4.c \
-    src/plane.c \
-    src/frustum.c \
-    src/box.c \
-    src/project.c \
-    src/sphere.c \
-    src/ease.c
-
-test_tests_SOURCES=\
-    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 \
-    test/src/test_clamp.c \
-    test/src/test_euler.c \
-    test/src/test_quat.c \
-    test/src/test_vec4.c \
-    test/src/test_vec3.c \
-    test/src/test_mat3.c \
-    test/src/test_affine.c
-
-all-local:
-	sh ./post-build.sh

post-build.sh

@@ -1,19 +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 .libs
-
-if [ "$(uname)" = "Darwin" ]; then
-  ln -sf $(pwd)/test/lib/cmocka/build/src/libcmocka.0.dylib \
-      .libs/libcmocka.0.dylib;
-else
-  ln -sf $(pwd)/test/lib/cmocka/build/src/libcmocka.so.0 \
-      .libs/libcmocka.so.0;
-fi