Merge branch 'master' into fix-simd-signmask

wasm: replace usage of -0.f to 0x80000000

.github/FUNDING.yml

@@ -1,7 +1,7 @@
 # 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
+github: [recp]
+patreon: recp
 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

.github/workflows/cmake-wasm.yml

@@ -0,0 +1,97 @@
+name: CMake WebAssembly
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+env:
+  wasmtime_version: v7.0.0
+  wasmer_version: v3.1.1
+
+jobs:
+  build_wasi_sdk:
+    strategy:
+      matrix:
+        BUILD_TYPE: [Release, Debug, RelWithDebInfo, MinSizeRel]
+        C_FLAGS: ['', '-msimd128']
+        wasi_sdk_version: [19, 20]
+    # The CMake configure and build commands are platform agnostic and should work equally well on Windows or Mac.
+    # You can convert this to a matrix build if you need cross-platform coverage.
+    # See: https://docs.github.com/en/free-pro-team@latest/actions/learn-github-actions/managing-complex-workflows#using-a-build-matrix
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Downloading wasi-sdk
+      run: |
+        cd ${{github.workspace}}
+        wget --no-verbose https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-${{matrix.wasi_sdk_version}}/wasi-sdk-${{matrix.wasi_sdk_version}}.0-linux.tar.gz
+        tar xf wasi-sdk-${{matrix.wasi_sdk_version}}.0-linux.tar.gz
+
+    - name: Configure CMake
+      # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
+      # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
+      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{matrix.BUILD_TYPE}} -DCMAKE_C_FLAGS="${{matrix.C_FLAGS}}" -DCMAKE_TOOLCHAIN_FILE=${{github.workspace}}/wasi-sdk-${{matrix.wasi_sdk_version}}.0/share/cmake/wasi-sdk.cmake -DWASI_SDK_PREFIX=${{github.workspace}}/wasi-sdk-${{matrix.wasi_sdk_version}}.0 -DCGLM_USE_TEST=ON
+
+    - name: Build
+      # Build your program with the given configuration
+      run: cmake --build ${{github.workspace}}/build --config ${{matrix.BUILD_TYPE}}
+
+    - name: Test with wasmtime
+      run: |
+        cd ${{github.workspace}}
+        ls -lh ${{github.workspace}}/build/
+        wget --no-verbose https://github.com/bytecodealliance/wasmtime/releases/download/${{env.wasmtime_version}}/wasmtime-${{env.wasmtime_version}}-x86_64-linux.tar.xz
+        tar xf wasmtime-${{env.wasmtime_version}}-x86_64-linux.tar.xz
+        ./wasmtime-${{env.wasmtime_version}}-x86_64-linux/wasmtime run --wasm-features simd ${{github.workspace}}/build/tests
+
+    - name: Test with wasmer
+      run: |
+        cd ${{github.workspace}}
+        mkdir wasmer
+        cd wasmer
+        wget --no-verbose https://github.com/wasmerio/wasmer/releases/download/${{env.wasmer_version}}/wasmer-linux-amd64.tar.gz
+        tar xf wasmer-linux-amd64.tar.gz
+        ./bin/wasmer run --enable-simd ${{github.workspace}}/build/tests
+
+  build_emsdk:
+    strategy:
+      matrix:
+        BUILD_TYPE: [Release, Debug, RelWithDebInfo, MinSizeRel]
+        C_FLAGS: ['', '-msimd128', '-msse -msse2 -msimd128', '-msse -msse2 -msse3 -msse4 -msimd128']
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - name: Setup emsdk
+      uses: mymindstorm/setup-emsdk@v11
+
+    - name: Verify emsdk
+      run: emcc -v
+
+    - name: Configure CMake
+      # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
+      # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
+      run: emcmake cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{matrix.BUILD_TYPE}} -DCMAKE_C_FLAGS="${{matrix.C_FLAGS}}" -DCMAKE_EXE_LINKER_FLAGS="-s STANDALONE_WASM" -DCGLM_STATIC=ON -DCGLM_USE_TEST=ON
+
+    - name: Build
+      # Build your program with the given configuration
+      run: cmake --build ${{github.workspace}}/build --config ${{matrix.BUILD_TYPE}}
+
+    - name: Test with wasmtime
+      run: |
+        cd ${{github.workspace}}
+        ls -lh ${{github.workspace}}/build/
+        wget --no-verbose https://github.com/bytecodealliance/wasmtime/releases/download/${{env.wasmtime_version}}/wasmtime-${{env.wasmtime_version}}-x86_64-linux.tar.xz
+        tar xf wasmtime-${{env.wasmtime_version}}-x86_64-linux.tar.xz
+        ./wasmtime-${{env.wasmtime_version}}-x86_64-linux/wasmtime run --wasm-features simd ${{github.workspace}}/build/tests.wasm
+    - name: Test with wasmer
+      run: |
+        cd ${{github.workspace}}
+        mkdir wasmer
+        cd wasmer
+        wget --no-verbose https://github.com/wasmerio/wasmer/releases/download/${{env.wasmer_version}}/wasmer-linux-amd64.tar.gz
+        tar xf wasmer-linux-amd64.tar.gz
+        ./bin/wasmer run --enable-simd ${{github.workspace}}/build/tests.wasm

.gitignore

@@ -79,3 +79,4 @@ confdefs.h
 .idea
 cmake-build-debug
 *.o.tmp
+xcode/*

.vscode/c_cpp_properties.json

@@ -0,0 +1,20 @@
+{
+    "configurations": [
+        {
+            "name": "Mac",
+            "includePath": [
+                "${workspaceFolder}/**"
+            ],
+            "defines": [],
+            "macFrameworkPath": [
+                "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks"
+            ],
+            "compilerPath": "/usr/bin/clang",
+            "cStandard": "c23",
+            "cppStandard": "c++23",
+            "intelliSenseMode": "macos-clang-arm64",
+            "configurationProvider": "vector-of-bool.cmake-tools"
+        }
+    ],
+    "version": 4
+}

.vscode/settings.json

@@ -1,4 +1,31 @@
 {
   "C_Cpp.default.configurationProvider": "vector-of-bool.cmake-tools",
-  "restructuredtext.confPath": "${workspaceFolder}/docs/source"
+  "restructuredtext.confPath": "${workspaceFolder}/docs/source",
+  "workbench.colorTheme": "Default Light+ Experimental",
+  "editor.fontSize": 14,
+  "workbench.colorCustomizations": {
+	"[Default Light*]": {
+  	    "editor.background": "#fefefe",
+  	    "sideBar.background": "#fefefe",
+  	    "sideBar.foreground": "#343436",
+  	    "sideBarTitle.foreground": "#343436",
+  	    "sideBar.border": "#e2e2e4",
+  	    "statusBar.background": "#fefefe",
+  	    "titleBar.activeBackground": "#fefefe",
+  	    "tab.activeBackground": "#f4fff4aa",
+  	    "tab.inactiveBackground": "#fefefe",
+  	    "activityBar.background": "#fefefe",
+  	    "editorGroupHeader.tabsBackground": "#fefefe"
+	},
+	"[Default Dark*]": {
+		"editor.background": "#1D1D25",
+		"sideBar.background": "#1D1D25",
+		"statusBar.background": "#1D1D25",
+		"titleBar.activeBackground": "#1D1D25",
+		"tab.activeBackground": "#2C2C3A",
+		"tab.inactiveBackground": "#1D1D25",
+		"activityBar.background": "#1D1D25",
+		"editorGroupHeader.tabsBackground": "#1D1D25"
+    }
+  },
 }

CMakeLists.txt

@@ -1,5 +1,10 @@
 cmake_minimum_required(VERSION 3.8.2)
-project(cglm VERSION 0.8.5 LANGUAGES C)
+project(cglm
+  VERSION 0.9.0
+  HOMEPAGE_URL https://github.com/recp/cglm
+  DESCRIPTION "OpenGL Mathematics (glm) for C"
+  LANGUAGES C
+)
 
 set(CMAKE_C_STANDARD 11)
 set(CMAKE_C_STANDARD_REQUIRED YES)
@@ -11,6 +16,11 @@ option(CGLM_STATIC "Static build" OFF)
 option(CGLM_USE_C99 "" OFF)
 option(CGLM_USE_TEST "Enable Tests" OFF)
 
+if(CMAKE_SYSTEM_NAME STREQUAL WASI)
+  set(CGLM_STATIC ON CACHE BOOL "Static option" FORCE)
+  set(CGLM_SHARED OFF CACHE BOOL "Shared option" FORCE)
+endif()
+
 if(NOT CGLM_STATIC AND CGLM_SHARED)
   set(CGLM_BUILD SHARED)
 else(CGLM_STATIC)
@@ -36,7 +46,9 @@ else()
   add_compile_options(-Wall -Werror -O3)
 endif()
 
-if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+get_directory_property(hasParent PARENT_DIRECTORY)
+
+if(NOT hasParent AND NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
   message(STATUS "Setting build type to '${DEFAULT_BUILD_TYPE}' as none was specified.")
   set(CMAKE_BUILD_TYPE "${DEFAULT_BUILD_TYPE}" CACHE STRING "Choose the type of build." FORCE)
   # Set the possible values of build type for cmake-gui
@@ -61,8 +73,11 @@ add_library(${PROJECT_NAME}
   src/quat.c
   src/cam.c
   src/vec2.c
+  src/ivec2.c
   src/vec3.c
+  src/ivec3.c
   src/vec4.c
+  src/ivec4.c
   src/mat2.c
   src/mat3.c
   src/mat4.c
@@ -76,18 +91,20 @@ add_library(${PROJECT_NAME}
   src/bezier.c
   src/ray.c
   src/affine2d.c
-  src/clipspace/persp_lh_zo.c
-  src/clipspace/persp_rh_zo.c
-  src/clipspace/persp_lh_no.c
-  src/clipspace/persp_rh_no.c
-  src/clipspace/ortho_lh_zo.c
-  src/clipspace/ortho_rh_zo.c
   src/clipspace/ortho_lh_no.c
+  src/clipspace/ortho_lh_zo.c
   src/clipspace/ortho_rh_no.c
-  src/clipspace/view_lh_zo.c
-  src/clipspace/view_rh_zo.c
+  src/clipspace/ortho_rh_zo.c
+  src/clipspace/persp_lh_no.c
+  src/clipspace/persp_lh_zo.c
+  src/clipspace/persp_rh_no.c
+  src/clipspace/persp_rh_zo.c
   src/clipspace/view_lh_no.c
+  src/clipspace/view_lh_zo.c
   src/clipspace/view_rh_no.c
+  src/clipspace/view_rh_zo.c
+  src/clipspace/project_no.c
+  src/clipspace/project_zo.c
   )
 
 if(CGLM_SHARED)
@@ -150,10 +167,18 @@ install(EXPORT      ${PROJECT_NAME}
 set(PACKAGE_NAME ${PROJECT_NAME})
 set(prefix ${CMAKE_INSTALL_PREFIX})
 set(exec_prefix ${CMAKE_INSTALL_PREFIX})
-set(includedir "\${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")
-set(libdir "\${prefix}/${CMAKE_INSTALL_LIBDIR}")
+if (IS_ABSOLUTE "${CMAKE_INSTALL_INCLUDEDIR}")
+  set(includedir "${CMAKE_INSTALL_INCLUDEDIR}")
+else()
+  set(includedir "\${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")
+endif()
+if (IS_ABSOLUTE "${CMAKE_INSTALL_LIBDIR}")
+  set(libdir "${CMAKE_INSTALL_LIBDIR}")
+else()
+  set(libdir "\${exec_prefix}/${CMAKE_INSTALL_LIBDIR}")
+endif()
 set(PACKAGE_VERSION "${PROJECT_VERSION}")
-configure_file(${CMAKE_CURRENT_LIST_DIR}/cglm.pc.in ${CMAKE_BINARY_DIR}/cglm.pc @ONLY)
+configure_file(cglm.pc.in cglm.pc @ONLY)
 
-install(FILES ${CMAKE_BINARY_DIR}/cglm.pc
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/cglm.pc
   DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)

Makefile.am

@@ -45,17 +45,22 @@ cglm_HEADERS = include/cglm/version.h \
                include/cglm/mat4.h \
                include/cglm/mat3.h \
                include/cglm/mat2.h \
+               include/cglm/affine-pre.h \
+               include/cglm/affine-post.h \
                include/cglm/affine.h \
+               include/cglm/affine-mat.h \
                include/cglm/vec2.h \
                include/cglm/vec2-ext.h \
+               include/cglm/ivec2.h \
                include/cglm/vec3.h \
                include/cglm/vec3-ext.h \
+               include/cglm/ivec3.h \
                include/cglm/vec4.h \
                include/cglm/vec4-ext.h \
+               include/cglm/ivec4.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 \
@@ -71,22 +76,22 @@ cglm_HEADERS = include/cglm/version.h \
 
 cglm_clipspacedir=$(includedir)/cglm/clipspace
 cglm_clipspace_HEADERS = include/cglm/clipspace/persp.h \
-                         include/cglm/clipspace/persp_lh_zo.h \
-                         include/cglm/clipspace/persp_rh_zo.h \
                          include/cglm/clipspace/persp_lh_no.h \
+                         include/cglm/clipspace/persp_lh_zo.h \
                          include/cglm/clipspace/persp_rh_no.h \
-                         include/cglm/clipspace/ortho_lh_zo.h \
-                         include/cglm/clipspace/ortho_rh_zo.h \
+                         include/cglm/clipspace/persp_rh_zo.h \
                          include/cglm/clipspace/ortho_lh_no.h \
+                         include/cglm/clipspace/ortho_lh_zo.h \
                          include/cglm/clipspace/ortho_rh_no.h \
+                         include/cglm/clipspace/ortho_rh_zo.h \
                          include/cglm/clipspace/view_lh.h \
                          include/cglm/clipspace/view_rh.h \
-                         include/cglm/clipspace/view_lh_zo.h \
-                         include/cglm/clipspace/view_rh_zo.h \
                          include/cglm/clipspace/view_lh_no.h \
+                         include/cglm/clipspace/view_lh_zo.h \
                          include/cglm/clipspace/view_rh_no.h \
-                         include/cglm/clipspace/project_zo.h \
-                         include/cglm/clipspace/project_no.h
+                         include/cglm/clipspace/view_rh_zo.h \
+                         include/cglm/clipspace/project_no.h \
+                         include/cglm/clipspace/project_zo.h
 
 cglm_calldir=$(includedir)/cglm/call
 cglm_call_HEADERS = include/cglm/call/mat4.h \
@@ -95,7 +100,9 @@ cglm_call_HEADERS = include/cglm/call/mat4.h \
                     include/cglm/call/vec2.h \
                     include/cglm/call/vec3.h \
                     include/cglm/call/vec4.h \
-                    include/cglm/call/affine.h \
+                    include/cglm/call/ivec2.h \
+                    include/cglm/call/ivec3.h \
+                    include/cglm/call/ivec4.h \
                     include/cglm/call/io.h \
                     include/cglm/call/cam.h \
                     include/cglm/call/quat.h \
@@ -109,21 +116,22 @@ cglm_call_HEADERS = include/cglm/call/mat4.h \
                     include/cglm/call/curve.h \
                     include/cglm/call/bezier.h \
                     include/cglm/call/ray.h \
+                    include/cglm/call/affine.h \
                     include/cglm/call/affine2d.h
 
 cglm_call_clipspacedir=$(includedir)/cglm/call/clipspace
-cglm_call_clipspace_HEADERS = include/cglm/call/clipspace/persp_lh_zo.h \
-                              include/cglm/call/clipspace/persp_rh_zo.h \
-                              include/cglm/call/clipspace/persp_lh_no.h \
+cglm_call_clipspace_HEADERS = include/cglm/call/clipspace/persp_lh_no.h \
+                              include/cglm/call/clipspace/persp_lh_zo.h \
                               include/cglm/call/clipspace/persp_rh_no.h \
-                              include/cglm/call/clipspace/ortho_lh_zo.h \
-                              include/cglm/call/clipspace/ortho_rh_zo.h \
+                              include/cglm/call/clipspace/persp_rh_zo.h \
                               include/cglm/call/clipspace/ortho_lh_no.h \
+                              include/cglm/call/clipspace/ortho_lh_zo.h \
                               include/cglm/call/clipspace/ortho_rh_no.h \
-                              include/cglm/call/clipspace/view_lh_zo.h \
-                              include/cglm/call/clipspace/view_rh_zo.h \
+                              include/cglm/call/clipspace/ortho_rh_zo.h \
                               include/cglm/call/clipspace/view_lh_no.h \
+                              include/cglm/call/clipspace/view_lh_zo.h \
                               include/cglm/call/clipspace/view_rh_no.h \
+                              include/cglm/call/clipspace/view_rh_zo.h \
                               include/cglm/call/clipspace/project_no.h \
                               include/cglm/call/clipspace/project_zo.h
 
@@ -144,22 +152,25 @@ 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_simd_neon_HEADERS = include/cglm/simd/neon/affine.h \
                          include/cglm/simd/neon/mat2.h \
-                         include/cglm/simd/neon/affine.h \
+                         include/cglm/simd/neon/mat4.h \
                          include/cglm/simd/neon/quat.h
 
 cglm_structdir=$(includedir)/cglm/struct
 cglm_struct_HEADERS = include/cglm/struct/mat4.h \
                       include/cglm/struct/mat3.h \
                       include/cglm/struct/mat2.h \
+                      include/cglm/struct/affine-pre.h \
+                      include/cglm/struct/affine-post.h \
+                      include/cglm/struct/affine.h \
+                      include/cglm/struct/affine2d.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 \
@@ -170,22 +181,23 @@ cglm_struct_HEADERS = include/cglm/struct/mat4.h \
                       include/cglm/struct/project.h \
                       include/cglm/struct/sphere.h \
                       include/cglm/struct/color.h \
-                      include/cglm/struct/curve.h \
-                      include/cglm/struct/affine2d.h
+                      include/cglm/struct/curve.h
 
 cglm_struct_clipspacedir=$(includedir)/cglm/struct/clipspace
-cglm_struct_clipspace_HEADERS = include/cglm/struct/clipspace/persp_lh_zo.h \
-                                include/cglm/struct/clipspace/persp_rh_zo.h \
-                                include/cglm/struct/clipspace/persp_lh_no.h \
+cglm_struct_clipspace_HEADERS = include/cglm/struct/clipspace/persp_lh_no.h \
+                                include/cglm/struct/clipspace/persp_lh_zo.h \
                                 include/cglm/struct/clipspace/persp_rh_no.h \
-                                include/cglm/struct/clipspace/ortho_lh_zo.h \
-                                include/cglm/struct/clipspace/ortho_rh_zo.h \
+                                include/cglm/struct/clipspace/persp_rh_zo.h \
                                 include/cglm/struct/clipspace/ortho_lh_no.h \
+                                include/cglm/struct/clipspace/ortho_lh_zo.h \
                                 include/cglm/struct/clipspace/ortho_rh_no.h \
-                                include/cglm/struct/clipspace/view_lh_zo.h \
-                                include/cglm/struct/clipspace/view_rh_zo.h \
+                                include/cglm/struct/clipspace/ortho_rh_zo.h \
                                 include/cglm/struct/clipspace/view_lh_no.h \
-                                include/cglm/struct/clipspace/view_rh_no.h
+                                include/cglm/struct/clipspace/view_lh_zo.h \
+                                include/cglm/struct/clipspace/view_rh_no.h \
+                                include/cglm/struct/clipspace/view_rh_zo.h \
+                                include/cglm/struct/clipspace/project_no.h \
+                                include/cglm/struct/clipspace/project_zo.h
 
 libcglm_la_SOURCES=\
     src/euler.c \
@@ -194,8 +206,11 @@ libcglm_la_SOURCES=\
     src/quat.c \
     src/cam.c \
     src/vec2.c \
+    src/ivec2.c \
     src/vec3.c \
+    src/ivec3.c \
     src/vec4.c \
+    src/ivec4.c \
     src/mat2.c \
     src/mat3.c \
     src/mat4.c \
@@ -228,11 +243,6 @@ test_tests_SOURCES=\
     test/runner.c \
     test/src/test_common.c \
     test/src/tests.c \
-    test/src/test_cam.c \
-    test/src/test_cam_lh_zo.c \
-    test/src/test_cam_rh_zo.c \
-    test/src/test_cam_lh_no.c \
-    test/src/test_cam_rh_no.c \
     test/src/test_clamp.c \
     test/src/test_euler.c \
     test/src/test_bezier.c \

README.md

@@ -431,7 +431,7 @@ You can pass matrices the same way to other APIs e.g. Vulkan, DX...
 
 ## Notes
 
-- This library uses float types only, does not support Integers, Double... yet
+- This library does not support double type... yet
 - If headers are not working properly with your compiler, IDE please open an issue, because I'm using GCC and clang to test it maybe sometimes MSVC
 
 **TODO:**

cglm.podspec

@@ -2,7 +2,7 @@ Pod::Spec.new do |s|
 
   # Description
   s.name         = "cglm"
-  s.version      = "0.8.4"
+  s.version      = "0.8.9"
   s.summary      = "📽 Highly Optimized Graphics Math (glm) for C"
   s.description  = <<-DESC
 cglm is math library for graphics programming for C. See the documentation or README for all features.

configure.ac

@@ -7,7 +7,7 @@
 #*****************************************************************************
 
 AC_PREREQ([2.69])
-AC_INIT([cglm], [0.8.5], [info@recp.me])
+AC_INIT([cglm], [0.9.0], [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.

docs/source/affine-common.rst

@@ -0,0 +1,129 @@
+.. default-domain:: C
+
+3D Affine Transforms (common)
+================================================================================
+
+Common transfrom functions.
+
+Table of contents (click to go):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Functions:
+
+1. :c:func:`glm_translate_make`
+#. :c:func:`glm_scale_to`
+#. :c:func:`glm_scale_make`
+#. :c:func:`glm_scale`
+#. :c:func:`glm_scale_uni`
+#. :c:func:`glm_rotate_make`
+#. :c:func:`glm_rotate_atm`
+#. :c:func:`glm_decompose_scalev`
+#. :c:func:`glm_uniscaled`
+#. :c:func:`glm_decompose_rs`
+#. :c:func:`glm_decompose`
+
+Functions documentation
+~~~~~~~~~~~~~~~~~~~~~~~
+
+.. c:function:: void  glm_translate_make(mat4 m, vec3 v)
+
+    creates NEW translate transform matrix by *v* vector.
+
+    Parameters:
+      | *[in, out]* **m**  affine transfrom
+      | *[in]*      **v**  translate vector [x, y, z]
+
+.. c:function:: void  glm_scale_to(mat4 m, vec3 v, mat4 dest)
+
+    scale existing transform matrix by *v* vector and store result in dest
+
+    Parameters:
+      | *[in]*  **m**    affine transfrom
+      | *[in]*  **v**    scale vector [x, y, z]
+      | *[out]* **dest** scaled matrix
+
+.. c:function:: void  glm_scale_make(mat4 m, vec3 v)
+
+    creates NEW scale matrix by v vector
+
+    Parameters:
+      | *[out]* **m** affine transfrom
+      | *[in]*  **v** scale vector [x, y, z]
+
+.. c:function:: void  glm_scale(mat4 m, vec3 v)
+
+    scales existing transform matrix by v vector
+    and stores result in same matrix
+
+    Parameters:
+      | *[in, out]* **m** affine transfrom
+      | *[in]*      **v** scale vector [x, y, z]
+
+.. c:function:: void  glm_scale_uni(mat4 m, float s)
+
+    applies uniform scale to existing transform matrix v = [s, s, s]
+    and stores result in same matrix
+
+    Parameters:
+      | *[in, out]* **m** affine transfrom
+      | *[in]*      **v** scale factor
+
+.. c:function:: void  glm_rotate_make(mat4 m, float angle, vec3 axis)
+
+    creates NEW rotation matrix by angle and axis,
+    axis will be normalized so you don't need to normalize it
+
+    Parameters:
+      | *[out]* **m**    affine transfrom
+      | *[in]*  **axis** angle (radians)
+      | *[in]*  **axis** axis
+
+.. c:function:: void  glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis)
+
+    | 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.
+
+    Parameters:
+      | *[in, out]* **m**     affine transfrom
+      | *[in]*      **pivot** pivot, anchor point, rotation center
+      | *[in]*      **angle** angle (radians)
+      | *[in]*      **axis**  axis
+
+.. c:function:: void  glm_decompose_scalev(mat4 m, vec3 s)
+
+    decompose scale vector
+
+    Parameters:
+      | *[in]*  **m**  affine transform
+      | *[out]* **s**  scale vector (Sx, Sy, Sz)
+
+.. c:function:: bool  glm_uniscaled(mat4 m)
+
+    returns true if matrix is uniform scaled.
+    This is helpful for creating normal matrix.
+
+    Parameters:
+      | *[in]*  **m**   matrix
+
+.. c:function:: void  glm_decompose_rs(mat4 m, mat4 r, vec3 s)
+
+    decompose rotation matrix (mat4) and scale vector [Sx, Sy, Sz]
+    DON'T pass projected matrix here
+
+    Parameters:
+      | *[in]*  **m** affine transform
+      | *[out]* **r** rotation matrix
+      | *[out]* **s** scale matrix
+
+.. c:function:: void  glm_decompose(mat4 m, vec4 t, mat4 r, vec3 s)
+
+    decompose affine transform, TODO: extract shear factors.
+    DON'T pass projected matrix here
+
+    Parameters:
+      | *[in]*  **m** affine transfrom
+      | *[out]* **t** translation vector
+      | *[out]* **r** rotation matrix (mat4)
+      | *[out]* **s** scaling vector [X, Y, Z]

docs/source/affine-post.rst

@@ -0,0 +1,129 @@
+.. default-domain:: C
+
+3D Affine Transforms (post)
+================================================================================
+
+Post transfrom functions are similar to pre transform functions except order of application is reversed.  
+Post transform functions are applied after the object is transformed with given (model matrix) transfrom. 
+
+Ther are named af
+
+Table of contents (click to go):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Functions:
+
+1. :c:func:`glm_translated_to`
+#. :c:func:`glm_translated`
+#. :c:func:`glm_translated_x`
+#. :c:func:`glm_translated_y`
+#. :c:func:`glm_translated_z`
+#. :c:func:`glm_rotated_x`
+#. :c:func:`glm_rotated_y`
+#. :c:func:`glm_rotated_z`
+#. :c:func:`glm_rotated`
+#. :c:func:`glm_rotated_at`
+#. :c:func:`glm_spinned`
+
+Functions documentation
+~~~~~~~~~~~~~~~~~~~~~~~
+
+.. c:function:: void  glm_translated_to(mat4 m, vec3 v, mat4 dest)
+
+    translate existing transform matrix by *v* vector and store result in dest
+
+    Parameters:
+      | *[in]*  **m**    affine transfrom
+      | *[in]*  **v**    translate vector [x, y, z]
+      | *[out]* **dest** translated matrix
+
+.. c:function:: void  glm_translated(mat4 m, vec3 v)
+
+    translate existing transform matrix by *v* vector
+    and stores result in same matrix
+
+    Parameters:
+      | *[in, out]* **m**  affine transfrom
+      | *[in]*      **v**  translate vector [x, y, z]
+
+.. c:function:: void  glm_translated_x(mat4 m, float x)
+
+    translate existing transform matrix by x factor
+
+    Parameters:
+      | *[in, out]* **m**  affine transfrom
+      | *[in]*      **v**  x factor
+
+.. c:function:: void  glm_translated_y(mat4 m, float y)
+
+    translate existing transform matrix by *y* factor
+
+    Parameters:
+      | *[in, out]* **m**  affine transfrom
+      | *[in]*      **v**  y factor
+
+.. c:function:: void  glm_translated_z(mat4 m, float z)
+
+    translate existing transform matrix by *z* factor
+
+    Parameters:
+      | *[in, out]* **m**  affine transfrom
+      | *[in]*      **v**  z factor
+
+.. c:function:: void  glm_rotated_x(mat4 m, float angle, mat4 dest)
+
+    rotate existing transform matrix around X axis by angle
+    and store result in dest
+
+    Parameters:
+      | *[in]*  **m**     affine transfrom
+      | *[in]*  **angle** angle (radians)
+      | *[out]* **dest**  rotated matrix
+
+.. c:function:: void  glm_rotated_y(mat4 m, float angle, mat4 dest)
+
+    rotate existing transform matrix around Y axis by angle
+    and store result in dest
+
+    Parameters:
+      | *[in]*  **m**     affine transfrom
+      | *[in]*  **angle** angle (radians)
+      | *[out]* **dest**  rotated matrix
+
+.. c:function:: void  glm_rotated_z(mat4 m, float angle, mat4 dest)
+
+    rotate existing transform matrix around Z axis by angle
+    and store result in dest
+
+    Parameters:
+      | *[in]*  **m**     affine transfrom
+      | *[in]*  **angle** angle (radians)
+      | *[out]* **dest**  rotated matrix
+
+.. c:function:: void  glm_rotated(mat4 m, float angle, vec3 axis)
+
+    rotate existing transform matrix around Z axis by angle and axis
+
+    Parameters:
+      | *[in, out]* **m**     affine transfrom
+      | *[in]*      **angle** angle (radians)
+      | *[in]*      **axis**  axis
+
+.. c:function:: void  glm_rotated_at(mat4 m, vec3 pivot, float angle, vec3 axis)
+
+    rotate existing transform around given axis by angle at given pivot point (rotation center)
+
+    Parameters:
+      | *[in, out]* **m**     affine transfrom
+      | *[in]*      **pivot** pivot, anchor point, rotation center
+      | *[in]*      **angle** angle (radians)
+      | *[in]*      **axis**  axis
+
+.. c:function:: void  glm_spinned(mat4 m, float angle, vec3 axis)
+
+    | rotate existing transform matrix around given axis by angle around self (doesn't affected by position)
+
+    Parameters:
+      | *[in, out]* **m**     affine transfrom
+      | *[in]*      **angle** angle (radians)
+      | *[in]*      **axis**  axis

docs/source/affine-pre.rst

@@ -0,0 +1,240 @@
+.. default-domain:: C
+
+3D Affine Transforms (pre)
+================================================================================
+
+Pre transfrom functions which are regular transfrom functions.
+
+Table of contents (click to go):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Functions:
+
+1. :c:func:`glm_translate_to`
+#. :c:func:`glm_translate`
+#. :c:func:`glm_translate_x`
+#. :c:func:`glm_translate_y`
+#. :c:func:`glm_translate_z`
+#. :c:func:`glm_translate_make`
+#. :c:func:`glm_scale_to`
+#. :c:func:`glm_scale_make`
+#. :c:func:`glm_scale`
+#. :c:func:`glm_scale_uni`
+#. :c:func:`glm_rotate_x`
+#. :c:func:`glm_rotate_y`
+#. :c:func:`glm_rotate_z`
+#. :c:func:`glm_rotate_make`
+#. :c:func:`glm_rotate`
+#. :c:func:`glm_rotate_at`
+#. :c:func:`glm_rotate_atm`
+#. :c:func:`glm_decompose_scalev`
+#. :c:func:`glm_uniscaled`
+#. :c:func:`glm_decompose_rs`
+#. :c:func:`glm_decompose`
+#. :c:func:`glm_spin`
+
+Functions documentation
+~~~~~~~~~~~~~~~~~~~~~~~
+
+.. c:function:: void  glm_translate_to(mat4 m, vec3 v, mat4 dest)
+
+    translate existing transform matrix by *v* vector and store result in dest
+
+    Parameters:
+      | *[in]*  **m**    affine transfrom
+      | *[in]*  **v**    translate vector [x, y, z]
+      | *[out]* **dest** translated matrix
+
+.. c:function:: void  glm_translate(mat4 m, vec3 v)
+
+    translate existing transform matrix by *v* vector
+    and stores result in same matrix
+
+    Parameters:
+      | *[in, out]* **m**  affine transfrom
+      | *[in]*      **v**  translate vector [x, y, z]
+
+.. c:function:: void  glm_translate_x(mat4 m, float x)
+
+    translate existing transform matrix by x factor
+
+    Parameters:
+      | *[in, out]* **m**  affine transfrom
+      | *[in]*      **v**  x factor
+
+.. c:function:: void  glm_translate_y(mat4 m, float y)
+
+    translate existing transform matrix by *y* factor
+
+    Parameters:
+      | *[in, out]* **m**  affine transfrom
+      | *[in]*      **v**  y factor
+
+.. c:function:: void  glm_translate_z(mat4 m, float z)
+
+    translate existing transform matrix by *z* factor
+
+    Parameters:
+      | *[in, out]* **m**  affine transfrom
+      | *[in]*      **v**  z factor
+
+.. c:function:: void  glm_translate_make(mat4 m, vec3 v)
+
+    creates NEW translate transform matrix by *v* vector.
+
+    Parameters:
+      | *[in, out]* **m**  affine transfrom
+      | *[in]*      **v**  translate vector [x, y, z]
+
+.. c:function:: void  glm_scale_to(mat4 m, vec3 v, mat4 dest)
+
+    scale existing transform matrix by *v* vector and store result in dest
+
+    Parameters:
+      | *[in]*  **m**    affine transfrom
+      | *[in]*  **v**    scale vector [x, y, z]
+      | *[out]* **dest** scaled matrix
+
+.. c:function:: void  glm_scale_make(mat4 m, vec3 v)
+
+    creates NEW scale matrix by v vector
+
+    Parameters:
+      | *[out]* **m** affine transfrom
+      | *[in]*  **v** scale vector [x, y, z]
+
+.. c:function:: void  glm_scale(mat4 m, vec3 v)
+
+    scales existing transform matrix by v vector
+    and stores result in same matrix
+
+    Parameters:
+      | *[in, out]* **m** affine transfrom
+      | *[in]*      **v** scale vector [x, y, z]
+
+.. c:function:: void  glm_scale_uni(mat4 m, float s)
+
+    applies uniform scale to existing transform matrix v = [s, s, s]
+    and stores result in same matrix
+
+    Parameters:
+      | *[in, out]* **m** affine transfrom
+      | *[in]*      **v** scale factor
+
+.. c:function:: void  glm_rotate_x(mat4 m, float angle, mat4 dest)
+
+    rotate existing transform matrix around X axis by angle
+    and store result in dest
+
+    Parameters:
+      | *[in]*  **m**     affine transfrom
+      | *[in]*  **angle** angle (radians)
+      | *[out]* **dest**  rotated matrix
+
+.. c:function:: void  glm_rotate_y(mat4 m, float angle, mat4 dest)
+
+    rotate existing transform matrix around Y axis by angle
+    and store result in dest
+
+    Parameters:
+      | *[in]*  **m**     affine transfrom
+      | *[in]*  **angle** angle (radians)
+      | *[out]* **dest**  rotated matrix
+
+.. c:function:: void  glm_rotate_z(mat4 m, float angle, mat4 dest)
+
+    rotate existing transform matrix around Z axis by angle
+    and store result in dest
+
+    Parameters:
+      | *[in]*  **m**     affine transfrom
+      | *[in]*  **angle** angle (radians)
+      | *[out]* **dest**  rotated matrix
+
+.. c:function:: void  glm_rotate_make(mat4 m, float angle, vec3 axis)
+
+    creates NEW rotation matrix by angle and axis,
+    axis will be normalized so you don't need to normalize it
+
+    Parameters:
+      | *[out]* **m**    affine transfrom
+      | *[in]*  **axis** angle (radians)
+      | *[in]*  **axis** axis
+
+.. c:function:: void  glm_rotate(mat4 m, float angle, vec3 axis)
+
+    rotate existing transform matrix around Z axis by angle and axis
+
+    Parameters:
+      | *[in, out]* **m**     affine transfrom
+      | *[in]*      **angle** angle (radians)
+      | *[in]*      **axis**  axis
+
+.. c:function:: void  glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis)
+
+    rotate existing transform around given axis by angle at given pivot point (rotation center)
+
+    Parameters:
+      | *[in, out]* **m**     affine transfrom
+      | *[in]*      **pivot** pivot, anchor point, rotation center
+      | *[in]*      **angle** angle (radians)
+      | *[in]*      **axis**  axis
+
+.. c:function:: void  glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis)
+
+    | 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.
+
+    Parameters:
+      | *[in, out]* **m**     affine transfrom
+      | *[in]*      **pivot** pivot, anchor point, rotation center
+      | *[in]*      **angle** angle (radians)
+      | *[in]*      **axis**  axis
+
+.. c:function:: void  glm_decompose_scalev(mat4 m, vec3 s)
+
+    decompose scale vector
+
+    Parameters:
+      | *[in]*  **m**  affine transform
+      | *[out]* **s**  scale vector (Sx, Sy, Sz)
+
+.. c:function:: bool  glm_uniscaled(mat4 m)
+
+    returns true if matrix is uniform scaled.
+    This is helpful for creating normal matrix.
+
+    Parameters:
+      | *[in]*  **m**   matrix
+
+.. c:function:: void  glm_decompose_rs(mat4 m, mat4 r, vec3 s)
+
+    decompose rotation matrix (mat4) and scale vector [Sx, Sy, Sz]
+    DON'T pass projected matrix here
+
+    Parameters:
+      | *[in]*  **m** affine transform
+      | *[out]* **r** rotation matrix
+      | *[out]* **s** scale matrix
+
+.. c:function:: void  glm_decompose(mat4 m, vec4 t, mat4 r, vec3 s)
+
+    decompose affine transform, TODO: extract shear factors.
+    DON'T pass projected matrix here
+
+    Parameters:
+      | *[in]*  **m** affine transfrom
+      | *[out]* **t** translation vector
+      | *[out]* **r** rotation matrix (mat4)
+      | *[out]* **s** scaling vector [X, Y, Z]
+
+.. c:function:: void  glm_spin(mat4 m, float angle, vec3 axis)
+
+    | rotate existing transform matrix around given axis by angle around self (doesn't affected by position)
+
+    Parameters:
+      | *[in, out]* **m**     affine transfrom
+      | *[in]*      **angle** angle (radians)
+      | *[in]*      **axis**  axis

docs/source/affine.rst

@@ -5,6 +5,18 @@
 
 Header: cglm/affine.h
 
+Before starting, **cglm** provides two kind of transform functions; pre and post. 
+
+Pre functions (`T' = Tnew * T`) are like `glm_translate`, `glm_rotate` which means it will translate the vector first and then apply the model transformation.
+Post functions (`T' = T * Tnew`) are like `glm_translated`, `glm_rotated` which means it will apply the model transformation first and then translate the vector.
+
+`glm_translate`, `glm_rotate` are pre functions and are similar to C++ **glm** which you are familiar with. 
+
+In new versions of **cglm** we added `glm_translated`, `glm_rotated`... which are post functions, 
+they are useful in some cases, e.g. append transform to existing transform (apply/append transform as last transfrom T' = T * Tnew).
+
+Post functions are named after pre functions with `ed` suffix, e.g. `glm_translate` -> `glm_translated`. So don't mix them up.
+
 Initialize Transform Matrices
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Functions with **_make** prefix expect you don't have a matrix and they create
@@ -25,6 +37,9 @@ since scale factors are stored in rotation matrix, same may also true for scalli
 cglm provides some functions for rotating around at given point e.g.
 **glm_rotate_at**, **glm_quat_rotate_at**. Use them or follow next section for algorihm ("Rotate or Scale around specific Point (Pivot Point / Anchor Point)").
 
+Also **cglm** provides :c:func:`glm_spin` and :c:func:`glm_spinned` functions to rotate around itself. No need to give pivot.
+These functions are useful for rotating around center of object. 
+
 Rotate or Scale around specific Point (Anchor Point)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -34,7 +49,8 @@ If you want to rotate model around arbibtrary point follow these steps:
 2. Apply rotation (or scaling maybe)
 3. Move model back from origin to pivot (reverse of step-1): **translate(pivot.x, pivot.y, pivot.z)**
 
-**glm_rotate_at**, **glm_quat_rotate_at** and their helper functions works that way.
+**glm_rotate_at**, **glm_quat_rotate_at** and their helper functions works that way. 
+So if you use them you don't need to do these steps manually which are done by **cglm**.
 
 The implementation would be:
 
@@ -45,6 +61,13 @@ The implementation would be:
   glm_rotate(m, angle, axis);
   glm_translate(m, pivotInv); /* pivotInv = -pivot */
 
+or just:
+
+.. code-block:: c
+  :linenos:
+
+  glm_rotate_at(m, pivot, angle, axis);
+
 .. _TransformsOrder:
 
 Transforms Order
@@ -54,7 +77,7 @@ It is important to understand this part especially if you call transform
 functions multiple times
 
 `glm_translate`, `glm_rotate`, `glm_scale` and `glm_quat_rotate` and their
-helpers functions works like this (cglm may provide reverse order too as alternative in the future):
+helpers functions works like this (cglm provides reverse order as `ed` suffix e.g `glm_translated`, `glm_rotated` see post transforms):
 
 .. code-block:: c
   :linenos:
@@ -147,199 +170,27 @@ Functions:
 #. :c:func:`glm_decompose_rs`
 #. :c:func:`glm_decompose`
 
+Post functions (**NEW**):
+
+1. :c:func:`glm_translated_to`
+#. :c:func:`glm_translated`
+#. :c:func:`glm_translated_x`
+#. :c:func:`glm_translated_y`
+#. :c:func:`glm_translated_z`
+#. :c:func:`glm_rotated_x`
+#. :c:func:`glm_rotated_y`
+#. :c:func:`glm_rotated_z`
+#. :c:func:`glm_rotated`
+#. :c:func:`glm_rotated_at`
+#. :c:func:`glm_spinned`
+
 Functions documentation
 ~~~~~~~~~~~~~~~~~~~~~~~
 
-.. c:function:: void  glm_translate_to(mat4 m, vec3 v, mat4 dest)
+.. toctree::
+   :maxdepth: 1
+   :caption: Affine categories:
 
-    translate existing transform matrix by *v* vector and store result in dest
-
-    Parameters:
-      | *[in]*  **m**    affine transfrom
-      | *[in]*  **v**    translate vector [x, y, z]
-      | *[out]* **dest** translated matrix
-
-.. c:function:: void  glm_translate(mat4 m, vec3 v)
-
-    translate existing transform matrix by *v* vector
-    and stores result in same matrix
-
-    Parameters:
-      | *[in, out]* **m**  affine transfrom
-      | *[in]*      **v**  translate vector [x, y, z]
-
-.. c:function:: void  glm_translate_x(mat4 m, float x)
-
-    translate existing transform matrix by x factor
-
-    Parameters:
-      | *[in, out]* **m**  affine transfrom
-      | *[in]*      **v**  x factor
-
-.. c:function:: void  glm_translate_y(mat4 m, float y)
-
-    translate existing transform matrix by *y* factor
-
-    Parameters:
-      | *[in, out]* **m**  affine transfrom
-      | *[in]*      **v**  y factor
-
-.. c:function:: void  glm_translate_z(mat4 m, float z)
-
-    translate existing transform matrix by *z* factor
-
-    Parameters:
-      | *[in, out]* **m**  affine transfrom
-      | *[in]*      **v**  z factor
-
-.. c:function:: void  glm_translate_make(mat4 m, vec3 v)
-
-    creates NEW translate transform matrix by *v* vector.
-
-    Parameters:
-      | *[in, out]* **m**  affine transfrom
-      | *[in]*      **v**  translate vector [x, y, z]
-
-.. c:function:: void  glm_scale_to(mat4 m, vec3 v, mat4 dest)
-
-    scale existing transform matrix by *v* vector and store result in dest
-
-    Parameters:
-      | *[in]*  **m**    affine transfrom
-      | *[in]*  **v**    scale vector [x, y, z]
-      | *[out]* **dest** scaled matrix
-
-.. c:function:: void  glm_scale_make(mat4 m, vec3 v)
-
-    creates NEW scale matrix by v vector
-
-    Parameters:
-      | *[out]* **m** affine transfrom
-      | *[in]*  **v** scale vector [x, y, z]
-
-.. c:function:: void  glm_scale(mat4 m, vec3 v)
-
-    scales existing transform matrix by v vector
-    and stores result in same matrix
-
-    Parameters:
-      | *[in, out]* **m** affine transfrom
-      | *[in]*      **v** scale vector [x, y, z]
-
-.. c:function:: void  glm_scale_uni(mat4 m, float s)
-
-    applies uniform scale to existing transform matrix v = [s, s, s]
-    and stores result in same matrix
-
-    Parameters:
-      | *[in, out]* **m** affine transfrom
-      | *[in]*      **v** scale factor
-
-.. c:function:: void  glm_rotate_x(mat4 m, float angle, mat4 dest)
-
-    rotate existing transform matrix around X axis by angle
-    and store result in dest
-
-    Parameters:
-      | *[in]*  **m**     affine transfrom
-      | *[in]*  **angle** angle (radians)
-      | *[out]* **dest**  rotated matrix
-
-.. c:function:: void  glm_rotate_y(mat4 m, float angle, mat4 dest)
-
-    rotate existing transform matrix around Y axis by angle
-    and store result in dest
-
-    Parameters:
-      | *[in]*  **m**     affine transfrom
-      | *[in]*  **angle** angle (radians)
-      | *[out]* **dest**  rotated matrix
-
-.. c:function:: void  glm_rotate_z(mat4 m, float angle, mat4 dest)
-
-    rotate existing transform matrix around Z axis by angle
-    and store result in dest
-
-    Parameters:
-      | *[in]*  **m**     affine transfrom
-      | *[in]*  **angle** angle (radians)
-      | *[out]* **dest**  rotated matrix
-
-.. c:function:: void  glm_rotate_make(mat4 m, float angle, vec3 axis)
-
-    creates NEW rotation matrix by angle and axis,
-    axis will be normalized so you don't need to normalize it
-
-    Parameters:
-      | *[out]* **m**    affine transfrom
-      | *[in]*  **axis** angle (radians)
-      | *[in]*  **axis** axis
-
-.. c:function:: void  glm_rotate(mat4 m, float angle, vec3 axis)
-
-    rotate existing transform matrix around Z axis by angle and axis
-
-    Parameters:
-      | *[in, out]* **m**     affine transfrom
-      | *[in]*      **angle** angle (radians)
-      | *[in]*      **axis**  axis
-
-.. c:function:: void  glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis)
-
-    rotate existing transform around given axis by angle at given pivot point (rotation center)
-
-    Parameters:
-      | *[in, out]* **m**     affine transfrom
-      | *[in]*      **pivot** pivot, anchor point, rotation center
-      | *[in]*      **angle** angle (radians)
-      | *[in]*      **axis**  axis
-
-.. c:function:: void  glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis)
-
-    | 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.
-
-    Parameters:
-      | *[in, out]* **m**     affine transfrom
-      | *[in]*      **pivot** pivot, anchor point, rotation center
-      | *[in]*      **angle** angle (radians)
-      | *[in]*      **axis**  axis
-
-.. c:function:: void  glm_decompose_scalev(mat4 m, vec3 s)
-
-    decompose scale vector
-
-    Parameters:
-      | *[in]*  **m**  affine transform
-      | *[out]* **s**  scale vector (Sx, Sy, Sz)
-
-.. c:function:: bool  glm_uniscaled(mat4 m)
-
-    returns true if matrix is uniform scaled.
-    This is helpful for creating normal matrix.
-
-    Parameters:
-      | *[in]*  **m**   matrix
-
-.. c:function:: void  glm_decompose_rs(mat4 m, mat4 r, vec3 s)
-
-    decompose rotation matrix (mat4) and scale vector [Sx, Sy, Sz]
-    DON'T pass projected matrix here
-
-    Parameters:
-      | *[in]*  **m** affine transform
-      | *[out]* **r** rotation matrix
-      | *[out]* **s** scale matrix
-
-.. c:function:: void  glm_decompose(mat4 m, vec4 t, mat4 r, vec3 s)
-
-    decompose affine transform, TODO: extract shear factors.
-    DON'T pass projected matrix here
-
-    Parameters:
-      | *[in]*  **m** affine transfrom
-      | *[out]* **t** translation vector
-      | *[out]* **r** rotation matrix (mat4)
-      | *[out]* **s** scaling vector [X, Y, Z]
+   affine-common
+   affine-pre
+   affine-post

docs/source/api.rst

@@ -34,15 +34,18 @@ Follow the :doc:`build` documentation for this
    box
    quat
    euler
-   mat4
-   mat3
    mat2
+   mat3
+   mat4
+   vec2
+   vec2-ext
    vec3
    vec3-ext
    vec4
    vec4-ext
-   vec2
-   vec2-ext
+   ivec2
+   ivec3
+   ivec4
    color
    plane
    project

docs/source/cam.rst

@@ -101,7 +101,7 @@ Functions documentation
     Parameters:
       | *[in]*  **box**      AABB
       | *[in]*  **padding**  padding
-      | *[out]* **d**        result matrix
+      | *[out]* **dest**        result matrix
 
 .. c:function:: void  glm_ortho_aabb_pz(vec3 box[2], float padding, mat4 dest)
 
@@ -113,7 +113,7 @@ Functions documentation
     Parameters:
       | *[in]*  **box**      AABB
       | *[in]*  **padding**  padding for near and far
-      | *[out]* **d**        result matrix
+      | *[out]* **dest**        result matrix
 
     Returns:
       square of norm / magnitude

docs/source/conf.py

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

docs/source/index.rst

@@ -6,13 +6,12 @@
 cglm Documentation
 ================================
 
-**cglm** is optimized 3D math library written in C99 (compatible with C89).
-It is similar to original **glm** library except this is mainly for **C**
+**cglm** is an optimized 3D math library written in C99 (compatible with C89).
+It is similar to the original **glm** library, except **cglm** is mainly for
+**C**.
 
-This library stores matrices as column-major order but in the future row-major
-is considered to be supported as optional.
-
-Also currently only **float** type is supported for most operations.
+**cglm** stores matrices as column-major order but in the future row-major is
+considered to be supported as optional.
 
 .. toctree::
    :maxdepth: 2
@@ -46,8 +45,8 @@ Also currently only **float** type is supported for most operations.
 
    troubleshooting
 
-Indices and tables
-==================
+Indices and Tables:
+===================
 
 * :ref:`genindex`
 * :ref:`modindex`

docs/source/ivec2.rst

@@ -0,0 +1,179 @@
+.. default-domain:: C
+
+ivec2
+=====
+
+Header: cglm/ivec2.h
+
+Table of contents (click to go):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Macros:
+
+1. GLM_IVEC2_ONE_INIT
+#. GLM_IVEC2_ZERO_INIT
+#. GLM_IVEC2_ONE
+#. GLM_IVEC2_ZERO
+
+Functions:
+
+1. :c:func:`glm_ivec2`
+#. :c:func:`glm_ivec2_copy`
+#. :c:func:`glm_ivec2_zero`
+#. :c:func:`glm_ivec2_one`
+#. :c:func:`glm_ivec2_add`
+#. :c:func:`glm_ivec2_adds`
+#. :c:func:`glm_ivec2_sub`
+#. :c:func:`glm_ivec2_subs`
+#. :c:func:`glm_ivec2_mul`
+#. :c:func:`glm_ivec2_scale`
+#. :c:func:`glm_ivec2_distance2`
+#. :c:func:`glm_ivec2_distance`
+#. :c:func:`glm_ivec2_maxv`
+#. :c:func:`glm_ivec2_minv`
+#. :c:func:`glm_ivec2_clamp`
+#. :c:func:`glm_ivec2_abs`
+
+Functions documentation
+~~~~~~~~~~~~~~~~~~~~~~~
+
+.. c:function:: void glm_ivec2(int * v, ivec2 dest)
+    
+    init ivec2 using vec3 or vec4
+    
+    Parameters:
+      | *[in]*  **v**    vector
+      | *[out]* **dest** destination
+
+.. c:function:: void glm_ivec2_copy(ivec2 a, ivec2 dest)
+    
+    copy all members of [a] to [dest]
+
+    Parameters:
+      | *[in]*  **a**    source vector
+      | *[out]* **dest** destination
+
+.. c:function:: void glm_ivec2_zero(ivec2 v)
+
+    set all members of [v] to zero
+
+    Parameters:
+      | *[out]* **v** vector
+
+.. c:function:: void glm_ivec2_one(ivec2 v)
+
+    set all members of [v] to one
+
+    Parameters:
+      | *[out]* **v** vector
+
+.. c:function:: void glm_ivec2_add(ivec2 a, ivec2 b, ivec2 dest)
+
+    add vector [a] to vector [b] and store result in [dest]
+
+    Parameters:
+      | *[in]*  **a**    first vector
+      | *[in]*  **b**    second vector
+      | *[out]* **dest** destination
+
+.. c:function:: void glm_ivec2_adds(ivec2 v, int s, ivec2 dest)
+
+    add scalar s to vector [v] and store result in [dest]
+    
+    Parameters:
+      | *[in]*  **v**    vector
+      | *[in]*  **s**    scalar
+      | *[out]* **dest** destination
+
+.. c:function:: void glm_ivec2_sub(ivec2 a, ivec2 b, ivec2 dest)
+
+    subtract vector [b] from vector [a] and store result in [dest]
+
+    Parameters:
+      | *[in]*  **a**    first vector
+      | *[in]*  **b**    second vector
+      | *[out]* **dest** destination
+
+.. c:function:: void glm_ivec2_subs(ivec2 v, int s, ivec2 dest)
+
+    subtract scalar s from vector [v] and store result in [dest]
+    
+    Parameters:
+      | *[in]*  **v**    vector
+      | *[in]*  **s**    scalar
+      | *[out]* **dest** destination
+
+.. c:function:: void glm_ivec2_mul(ivec2 a, ivec2 b, ivec2 dest)
+
+    multiply vector [a] with vector [b] and store result in [dest]
+
+    Parameters:
+      | *[in]*  **a**    first vector
+      | *[in]*  **b**    second vector
+      | *[out]* **dest** destination
+
+.. c:function:: void glm_ivec2_scale(ivec2 v, int s, ivec2 dest)
+
+    multiply vector [a] with scalar s and store result in [dest]
+    
+    Parameters:
+      | *[in]*  **v**    vector
+      | *[in]*  **s**    scalar
+      | *[out]* **dest** destination
+
+.. c:function:: int glm_ivec2_distance2(ivec2 a, ivec2 b)
+
+    squared distance between two vectors
+
+    Parameters:
+      | *[in]*  **a**    first vector
+      | *[in]*  **b**    second vector
+    
+    Returns:
+        squared distance (distance * distance)
+
+.. c:function:: float glm_ivec2_distance(ivec2 a, ivec2 b)
+
+    distance between two vectors
+
+    Parameters:
+      | *[in]*  **a**    first vector
+      | *[in]*  **b**    second vector
+    
+    Returns:
+        distance
+
+.. c:function:: void glm_ivec2_maxv(ivec2 a, ivec2 b, ivec2 dest)
+
+    set each member of dest to greater of vector a and b
+
+    Parameters:
+      | *[in]*  **a**    first vector
+      | *[in]*  **b**    second vector
+      | *[out]* **dest** destination
+
+.. c:function:: void glm_ivec2_minv(ivec2 a, ivec2 b, ivec2 dest)
+
+    set each member of dest to lesser of vector a and b
+
+    Parameters:
+      | *[in]*  **a**    first vector
+      | *[in]*  **b**    second vector
+      | *[out]* **dest** destination
+
+.. c:function:: void glm_ivec2_clamp(ivec2 v, int minVal, int maxVal)
+
+    clamp each member of [v] between minVal and maxVal (inclusive)
+
+    Parameters:
+      | *[in, out]* **v**      vector
+      | *[in]*      **minVal** minimum value
+      | *[in]*      **maxVal** maximum value
+
+.. c:function:: void glm_ivec2_abs(ivec2 v, ivec2 dest)
+
+    absolute value of each vector item
+
+    Parameters:
+      | *[in]*   **v**     vector
+      | *[out]*  **dest**  destination vector

docs/source/ivec3.rst

@@ -0,0 +1,179 @@
+.. default-domain:: C
+
+ivec3
+=====
+
+Header: cglm/ivec3.h
+
+Table of contents (click to go):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Macros:
+
+1. GLM_IVEC3_ONE_INIT
+#. GLM_IVEC3_ZERO_INIT
+#. GLM_IVEC3_ONE
+#. GLM_IVEC3_ZERO
+
+Functions:
+
+1. :c:func:`glm_ivec3`
+#. :c:func:`glm_ivec3_copy`
+#. :c:func:`glm_ivec3_zero`
+#. :c:func:`glm_ivec3_one`
+#. :c:func:`glm_ivec3_add`
+#. :c:func:`glm_ivec3_adds`
+#. :c:func:`glm_ivec3_sub`
+#. :c:func:`glm_ivec3_subs`
+#. :c:func:`glm_ivec3_mul`
+#. :c:func:`glm_ivec3_scale`
+#. :c:func:`glm_ivec3_distance2`
+#. :c:func:`glm_ivec3_distance`
+#. :c:func:`glm_ivec3_maxv`
+#. :c:func:`glm_ivec3_minv`
+#. :c:func:`glm_ivec3_clamp`
+#. :c:func:`glm_ivec2_abs`
+
+Functions documentation
+~~~~~~~~~~~~~~~~~~~~~~~
+
+.. c:function:: void glm_ivec3(ivec4 v4, ivec3 dest)
+    
+    init ivec3 using ivec4
+    
+    Parameters:
+      | *[in]*  **v**    vector
+      | *[out]* **dest** destination
+
+.. c:function:: void glm_ivec3_copy(ivec3 a, ivec3 dest)
+    
+    copy all members of [a] to [dest]
+
+    Parameters:
+      | *[in]*  **a**    source vector
+      | *[out]* **dest** destination
+
+.. c:function:: void glm_ivec3_zero(ivec3 v)
+
+    set all members of [v] to zero
+
+    Parameters:
+      | *[out]* **v** vector
+
+.. c:function:: void glm_ivec3_one(ivec3 v)
+
+    set all members of [v] to one
+
+    Parameters:
+      | *[out]* **v** vector
+
+.. c:function:: void glm_ivec3_add(ivec3 a, ivec3 b, ivec3 dest)
+
+    add vector [a] to vector [b] and store result in [dest]
+
+    Parameters:
+      | *[in]*  **a**    first vector
+      | *[in]*  **b**    second vector
+      | *[out]* **dest** destination
+
+.. c:function:: void glm_ivec3_adds(ivec3 v, int s, ivec3 dest)
+
+    add scalar s to vector [v] and store result in [dest]
+    
+    Parameters:
+      | *[in]*  **v**    vector
+      | *[in]*  **s**    scalar
+      | *[out]* **dest** destination
+
+.. c:function:: void glm_ivec3_sub(ivec3 a, ivec3 b, ivec3 dest)
+
+    subtract vector [b] from vector [a] and store result in [dest]
+
+    Parameters:
+      | *[in]*  **a**    first vector
+      | *[in]*  **b**    second vector
+      | *[out]* **dest** destination
+
+.. c:function:: void glm_ivec3_subs(ivec3 v, int s, ivec3 dest)
+
+    subtract scalar s from vector [v] and store result in [dest]
+    
+    Parameters:
+      | *[in]*  **v**    vector
+      | *[in]*  **s**    scalar
+      | *[out]* **dest** destination
+
+.. c:function:: void glm_ivec3_mul(ivec3 a, ivec3 b, ivec3 dest)
+
+    multiply vector [a] with vector [b] and store result in [dest]
+
+    Parameters:
+      | *[in]*  **a**    first vector
+      | *[in]*  **b**    second vector
+      | *[out]* **dest** destination
+
+.. c:function:: void glm_ivec3_scale(ivec3 v, int s, ivec3 dest)
+
+    multiply vector [a] with scalar s and store result in [dest]
+    
+    Parameters:
+      | *[in]*  **v**    vector
+      | *[in]*  **s**    scalar
+      | *[out]* **dest** destination
+
+.. c:function:: int glm_ivec3_distance2(ivec3 a, ivec3 b)
+
+    squared distance between two vectors
+
+    Parameters:
+      | *[in]*  **a**    first vector
+      | *[in]*  **b**    second vector
+    
+    Returns:
+        squared distance (distance * distance)
+
+.. c:function:: float glm_ivec3_distance(ivec3 a, ivec3 b)
+
+    distance between two vectors
+
+    Parameters:
+      | *[in]*  **a**    first vector
+      | *[in]*  **b**    second vector
+    
+    Returns:
+        distance
+
+.. c:function:: void glm_ivec3_maxv(ivec3 a, ivec3 b, ivec3 dest)
+
+    set each member of dest to greater of vector a and b
+
+    Parameters:
+      | *[in]*  **a**    first vector
+      | *[in]*  **b**    second vector
+      | *[out]* **dest** destination
+
+.. c:function:: void glm_ivec3_minv(ivec3 a, ivec3 b, ivec3 dest)
+
+    set each member of dest to lesser of vector a and b
+
+    Parameters:
+      | *[in]*  **a**    first vector
+      | *[in]*  **b**    second vector
+      | *[out]* **dest** destination
+
+.. c:function:: void glm_ivec3_clamp(ivec3 v, int minVal, int maxVal)
+
+    clamp each member of [v] between minVal and maxVal (inclusive)
+
+    Parameters:
+      | *[in, out]* **v**      vector
+      | *[in]*      **minVal** minimum value
+      | *[in]*      **maxVal** maximum value
+
+.. c:function:: void glm_ivec3_abs(ivec3 v, ivec3 dest)
+
+    absolute value of each vector item
+
+    Parameters:
+      | *[in]*   **v**     vector
+      | *[out]*  **dest**  destination vector

docs/source/ivec4.rst

@@ -0,0 +1,179 @@
+.. default-domain:: C
+
+ivec4
+=====
+
+Header: cglm/ivec4.h
+
+Table of contents (click to go):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Macros:
+
+1. GLM_IVEC4_ONE_INIT
+#. GLM_IVEC4_ZERO_INIT
+#. GLM_IVEC4_ONE
+#. GLM_IVEC4_ZERO
+
+Functions:
+
+1. :c:func:`glm_ivec4`
+#. :c:func:`glm_ivec4_copy`
+#. :c:func:`glm_ivec4_zero`
+#. :c:func:`glm_ivec4_one`
+#. :c:func:`glm_ivec4_add`
+#. :c:func:`glm_ivec4_adds`
+#. :c:func:`glm_ivec4_sub`
+#. :c:func:`glm_ivec4_subs`
+#. :c:func:`glm_ivec4_mul`
+#. :c:func:`glm_ivec4_scale`
+#. :c:func:`glm_ivec4_distance2`
+#. :c:func:`glm_ivec4_distance`
+#. :c:func:`glm_ivec4_maxv`
+#. :c:func:`glm_ivec4_minv`
+#. :c:func:`glm_ivec4_clamp`
+#. :c:func:`glm_ivec4_abs`
+
+Functions documentation
+~~~~~~~~~~~~~~~~~~~~~~~
+
+.. c:function:: void glm_ivec4(ivec3 v3, int last, ivec4 dest)
+    
+    init ivec4 using ivec3
+    
+    Parameters:
+      | *[in]*  **v**    vector
+      | *[out]* **dest** destination
+
+.. c:function:: void glm_ivec4_copy(ivec4 a, ivec4 dest)
+    
+    copy all members of [a] to [dest]
+
+    Parameters:
+      | *[in]*  **a**    source vector
+      | *[out]* **dest** destination
+
+.. c:function:: void glm_ivec4_zero(ivec4 v)
+
+    set all members of [v] to zero
+
+    Parameters:
+      | *[out]* **v** vector
+
+.. c:function:: void glm_ivec4_one(ivec4 v)
+
+    set all members of [v] to one
+
+    Parameters:
+      | *[out]* **v** vector
+
+.. c:function:: void glm_ivec4_add(ivec4 a, ivec4 b, ivec4 dest)
+
+    add vector [a] to vector [b] and store result in [dest]
+
+    Parameters:
+      | *[in]*  **a**    first vector
+      | *[in]*  **b**    second vector
+      | *[out]* **dest** destination
+
+.. c:function:: void glm_ivec4_adds(ivec4 v, int s, ivec4 dest)
+
+    add scalar s to vector [v] and store result in [dest]
+    
+    Parameters:
+      | *[in]*  **v**    vector
+      | *[in]*  **s**    scalar
+      | *[out]* **dest** destination
+
+.. c:function:: void glm_ivec4_sub(ivec4 a, ivec4 b, ivec4 dest)
+
+    subtract vector [b] from vector [a] and store result in [dest]
+
+    Parameters:
+      | *[in]*  **a**    first vector
+      | *[in]*  **b**    second vector
+      | *[out]* **dest** destination
+
+.. c:function:: void glm_ivec4_subs(ivec4 v, int s, ivec4 dest)
+
+    subtract scalar s from vector [v] and store result in [dest]
+    
+    Parameters:
+      | *[in]*  **v**    vector
+      | *[in]*  **s**    scalar
+      | *[out]* **dest** destination
+
+.. c:function:: void glm_ivec4_mul(ivec4 a, ivec4 b, ivec4 dest)
+
+    multiply vector [a] with vector [b] and store result in [dest]
+
+    Parameters:
+      | *[in]*  **a**    first vector
+      | *[in]*  **b**    second vector
+      | *[out]* **dest** destination
+
+.. c:function:: void glm_ivec4_scale(ivec4 v, int s, ivec4 dest)
+
+    multiply vector [a] with scalar s and store result in [dest]
+    
+    Parameters:
+      | *[in]*  **v**    vector
+      | *[in]*  **s**    scalar
+      | *[out]* **dest** destination
+
+.. c:function:: int glm_ivec4_distance2(ivec4 a, ivec4 b)
+
+    squared distance between two vectors
+
+    Parameters:
+      | *[in]*  **a**    first vector
+      | *[in]*  **b**    second vector
+    
+    Returns:
+        squared distance (distance * distance)
+
+.. c:function:: float glm_ivec4_distance(ivec4 a, ivec4 b)
+
+    distance between two vectors
+
+    Parameters:
+      | *[in]*  **a**    first vector
+      | *[in]*  **b**    second vector
+    
+    Returns:
+        distance
+
+.. c:function:: void glm_ivec4_maxv(ivec4 a, ivec4 b, ivec4 dest)
+
+    set each member of dest to greater of vector a and b
+
+    Parameters:
+      | *[in]*  **a**    first vector
+      | *[in]*  **b**    second vector
+      | *[out]* **dest** destination
+
+.. c:function:: void glm_ivec4_minv(ivec4 a, ivec4 b, ivec4 dest)
+
+    set each member of dest to lesser of vector a and b
+
+    Parameters:
+      | *[in]*  **a**    first vector
+      | *[in]*  **b**    second vector
+      | *[out]* **dest** destination
+
+.. c:function:: void glm_ivec4_clamp(ivec4 v, int minVal, int maxVal)
+
+    clamp each member of [v] between minVal and maxVal (inclusive)
+
+    Parameters:
+      | *[in, out]* **v**      vector
+      | *[in]*      **minVal** minimum value
+      | *[in]*      **maxVal** maximum value
+
+.. c:function:: void glm_ivec4_abs(ivec4 v, ivec4 dest)
+
+    absolute value of each vector item
+
+    Parameters:
+      | *[in]*   **v**     vector
+      | *[out]*  **dest**  destination vector

docs/source/project.rst

@@ -21,14 +21,14 @@ Functions:
 Functions documentation
 ~~~~~~~~~~~~~~~~~~~~~~~
 
-.. c:function:: void  glm_unprojecti(vec3 pos, mat4 invMat, vec4 vp, vec3 dest)
+.. c:function:: void glm_unprojecti(vec3 pos, mat4 invMat, vec4 vp, vec3 dest)
 
     | 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
+    :c:func:`glm_unproject` version. You may use existing inverse of matrix in somewhere
+    else, this is why **glm_unprojecti** exists to save inversion cost
 
     [1] space:
       - if m = invProj:     View Space
@@ -57,7 +57,7 @@ Functions documentation
     | 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
+    this is same as :c:func:`glm_unprojecti` except this function get inverse matrix for
     you.
 
     [1] space:
@@ -80,7 +80,7 @@ Functions documentation
       | *[in]*  **vp**   viewport as [x, y, width, height]
       | *[out]* **dest** unprojected coordinates
 
-.. c:function:: void  glm_project(vec3 pos, mat4 m, vec4 vp, vec3 dest)
+.. c:function:: void glm_project(vec3 pos, mat4 m, vec4 vp, vec3 dest)
 
     | map object coordinates to window coordinates
 
@@ -91,12 +91,29 @@ Functions documentation
        glm_mat4_mul(proj, view, viewProj);
        glm_mat4_mul(viewProj, model, MVP);
 
-    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
-
     Parameters:
       | *[in]*  **pos**      object coordinates
       | *[in]*  **m**        MVP matrix
       | *[in]*  **vp**       viewport as [x, y, width, height]
       | *[out]* **dest**     projected coordinates
+
+.. c:function:: float glm_project_z(vec3 pos, mat4 m)
+
+    | map object's z coordinate to window coordinates
+
+    this is same as :c:func:`glm_project` except this function projects only Z coordinate
+    which reduces a few calculations and parameters.
+
+    Computing MVP:
+
+    .. code-block:: c
+
+       glm_mat4_mul(proj, view, viewProj);
+       glm_mat4_mul(viewProj, model, MVP);
+
+    Parameters:
+      | *[in]*  **pos**      object coordinates
+      | *[in]*  **m**        MVP matrix
+
+    Returns:
+        projected z coordinate

docs/source/vec2-ext.rst

@@ -26,6 +26,7 @@ Functions:
 #. :c:func:`glm_vec2_isinf`
 #. :c:func:`glm_vec2_isvalid`
 #. :c:func:`glm_vec2_sign`
+#. :c:func:`glm_vec2_abs`
 #. :c:func:`glm_vec2_sqrt`
 
 Functions documentation
@@ -125,6 +126,14 @@ Functions documentation
       | *[in]*   **v**     vector
       | *[out]*  **dest**  sign vector (only keeps signs as -1, 0, -1)
 
+.. c:function:: void glm_vec2_abs(vec2 v, vec2 dest)
+
+    absolute value of each vector item
+
+    Parameters:
+      | *[in]*   **v**     vector
+      | *[out]*  **dest**  destination vector
+
 .. c:function:: void glm_vec2_sqrt(vec2 v, vec2 dest)
 
     square root of each vector item

docs/source/vec2.rst

@@ -10,10 +10,10 @@ Table of contents (click to go):
 
 Macros:
 
-1. GLM_vec2_ONE_INIT
-#. GLM_vec2_ZERO_INIT
-#. GLM_vec2_ONE
-#. GLM_vec2_ZERO
+1. GLM_VEC2_ONE_INIT
+#. GLM_VEC2_ZERO_INIT
+#. GLM_VEC2_ONE
+#. GLM_VEC2_ZERO
 
 Functions:
 

docs/source/vec3-ext.rst

@@ -27,6 +27,7 @@ Functions:
 #. :c:func:`glm_vec3_isinf`
 #. :c:func:`glm_vec3_isvalid`
 #. :c:func:`glm_vec3_sign`
+#. :c:func:`glm_vec3_abs`
 #. :c:func:`glm_vec3_sqrt`
 
 Functions documentation
@@ -134,6 +135,14 @@ Functions documentation
       | *[in]*   **v**     vector
       | *[out]*  **dest**  sign vector (only keeps signs as -1, 0, -1)
 
+.. c:function:: void glm_vec3_abs(vec3 v, vec3 dest)
+
+    absolute value of each vector item
+
+    Parameters:
+      | *[in]*   **v**     vector
+      | *[out]*  **dest**  destination vector
+
 .. c:function:: void glm_vec3_sqrt(vec3 v, vec3 dest)
 
     square root of each vector item

include/cglm/affine-mat.h

@@ -30,6 +30,10 @@
 #  include "simd/neon/affine.h"
 #endif
 
+#ifdef CGLM_SIMD_WASM
+#  include "simd/wasm/affine.h"
+#endif
+
 /*!
  * @brief this is similar to glm_mat4_mul but specialized to affine transform
  *
@@ -49,7 +53,9 @@
 CGLM_INLINE
 void
 glm_mul(mat4 m1, mat4 m2, mat4 dest) {
-#ifdef __AVX__
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glm_mul_wasm(m1, m2, dest);
+#elif defined(__AVX__)
   glm_mul_avx(m1, m2, dest);
 #elif defined( __SSE__ ) || defined( __SSE2__ )
   glm_mul_sse2(m1, m2, dest);
@@ -107,7 +113,9 @@ glm_mul(mat4 m1, mat4 m2, mat4 dest) {
 CGLM_INLINE
 void
 glm_mul_rot(mat4 m1, mat4 m2, mat4 dest) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glm_mul_rot_wasm(m1, m2, dest);
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glm_mul_rot_sse2(m1, m2, dest);
 #elif defined(CGLM_NEON_FP)
   glm_mul_rot_neon(m1, m2, dest);
@@ -156,7 +164,9 @@ glm_mul_rot(mat4 m1, mat4 m2, mat4 dest) {
 CGLM_INLINE
 void
 glm_inv_tr(mat4 mat) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glm_inv_tr_wasm(mat);
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glm_inv_tr_sse2(mat);
 #elif defined(CGLM_NEON_FP)
   glm_inv_tr_neon(mat);

include/cglm/affine-post.h

@@ -0,0 +1,247 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglm_affine_post_h
+#define cglm_affine_post_h
+
+/*
+ Functions:
+   CGLM_INLINE void glm_translated_to(mat4 m, vec3 v, mat4 dest);
+   CGLM_INLINE void glm_translated(mat4 m, vec3 v);
+   CGLM_INLINE void glm_translated_x(mat4 m, float to);
+   CGLM_INLINE void glm_translated_y(mat4 m, float to);
+   CGLM_INLINE void glm_translated_z(mat4 m, float to);
+   CGLM_INLINE void glm_rotated_x(mat4 m, float angle, mat4 dest);
+   CGLM_INLINE void glm_rotated_y(mat4 m, float angle, mat4 dest);
+   CGLM_INLINE void glm_rotated_z(mat4 m, float angle, mat4 dest);
+   CGLM_INLINE void glm_rotated(mat4 m, float angle, vec3 axis);
+   CGLM_INLINE void glm_rotated_at(mat4 m, vec3 pivot, float angle, vec3 axis);
+   CGLM_INLINE void glm_spinned(mat4 m, float angle, vec3 axis);
+ */
+
+#include "common.h"
+#include "util.h"
+#include "vec3.h"
+#include "vec4.h"
+#include "mat4.h"
+#include "affine-mat.h"
+
+/*!
+ * @brief translate existing transform matrix by v vector
+ *        and stores result in same matrix
+ *
+ *  this is POST transform, applies to existing transform as last transfrom
+ *
+ * @param[in, out]  m  affine transfrom
+ * @param[in]       v  translate vector [x, y, z]
+ */
+CGLM_INLINE
+void
+glm_translated(mat4 m, vec3 v) {
+  glm_vec3_add(m[3], v, m[3]);
+}
+
+/*!
+ * @brief translate existing transform matrix by v vector
+ *        and store result in dest
+ *
+ * source matrix will remain same
+ *
+ *  this is POST transform, applies to existing transform as last transfrom
+ *
+ * @param[in]  m    affine transfrom
+ * @param[in]  v    translate vector [x, y, z]
+ * @param[out] dest translated matrix
+ */
+CGLM_INLINE
+void
+glm_translated_to(mat4 m, vec3 v, mat4 dest) {
+  glm_mat4_copy(m, dest);
+  glm_translated(dest, v);
+}
+
+/*!
+ * @brief translate existing transform matrix by x factor
+ *
+ *  this is POST transform, applies to existing transform as last transfrom
+ *
+ * @param[in, out]  m  affine transfrom
+ * @param[in]       x  x factor
+ */
+CGLM_INLINE
+void
+glm_translated_x(mat4 m, float x) {
+  m[3][0] += x;
+}
+
+/*!
+ * @brief translate existing transform matrix by y factor
+ *
+ *  this is POST transform, applies to existing transform as last transfrom
+ *
+ * @param[in, out]  m  affine transfrom
+ * @param[in]       y  y factor
+ */
+CGLM_INLINE
+void
+glm_translated_y(mat4 m, float y) {
+  m[3][1] += y;
+}
+
+/*!
+ * @brief translate existing transform matrix by z factor
+ *
+ *  this is POST transform, applies to existing transform as last transfrom
+ *
+ * @param[in, out]  m  affine transfrom
+ * @param[in]       z  z factor
+ */
+CGLM_INLINE
+void
+glm_translated_z(mat4 m, float z) {
+  m[3][2] += z;
+}
+
+/*!
+ * @brief rotate existing transform matrix around X axis by angle
+ *        and store result in dest
+ *
+ *  this is POST transform, applies to existing transform as last transfrom
+ *
+ * @param[in]   m      affine transfrom
+ * @param[in]   angle  angle (radians)
+ * @param[out]  dest   rotated matrix
+ */
+CGLM_INLINE
+void
+glm_rotated_x(mat4 m, float angle, mat4 dest) {
+  CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
+  float c, s;
+
+  c = cosf(angle);
+  s = sinf(angle);
+
+  t[1][1] =  c;
+  t[1][2] =  s;
+  t[2][1] = -s;
+  t[2][2] =  c;
+
+  glm_mul_rot(t, m, dest);
+}
+
+/*!
+ * @brief rotate existing transform matrix around Y axis by angle
+ *        and store result in dest
+ *
+ *  this is POST transform, applies to existing transform as last transfrom
+ *
+ * @param[in]   m      affine transfrom
+ * @param[in]   angle  angle (radians)
+ * @param[out]  dest   rotated matrix
+ */
+CGLM_INLINE
+void
+glm_rotated_y(mat4 m, float angle, mat4 dest) {
+  CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
+  float c, s;
+
+  c = cosf(angle);
+  s = sinf(angle);
+
+  t[0][0] =  c;
+  t[0][2] = -s;
+  t[2][0] =  s;
+  t[2][2] =  c;
+
+  glm_mul_rot(t, m, dest);
+}
+
+/*!
+ * @brief rotate existing transform matrix around Z axis by angle
+ *        and store result in dest
+ *
+ *  this is POST transform, applies to existing transform as last transfrom
+ *
+ * @param[in]   m      affine transfrom
+ * @param[in]   angle  angle (radians)
+ * @param[out]  dest   rotated matrix
+ */
+CGLM_INLINE
+void
+glm_rotated_z(mat4 m, float angle, mat4 dest) {
+  CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
+  float c, s;
+
+  c = cosf(angle);
+  s = sinf(angle);
+
+  t[0][0] =  c;
+  t[0][1] =  s;
+  t[1][0] = -s;
+  t[1][1] =  c;
+
+  glm_mul_rot(t, m, dest);
+}
+
+/*!
+ * @brief rotate existing transform matrix around given axis by angle
+ *
+ *  this is POST transform, applies to existing transform as last transfrom
+ *
+ * @param[in, out]  m      affine transfrom
+ * @param[in]       angle  angle (radians)
+ * @param[in]       axis   axis
+ */
+CGLM_INLINE
+void
+glm_rotated(mat4 m, float angle, vec3 axis) {
+  CGLM_ALIGN_MAT mat4 rot;
+  glm_rotate_make(rot, angle, axis);
+  glm_mul_rot(rot, m, m);
+}
+
+/*!
+ * @brief rotate existing transform
+ *        around given axis by angle at given pivot point (rotation center)
+ *
+ *  this is POST transform, applies to existing transform as last transfrom
+ *
+ * @param[in, out]  m      affine transfrom
+ * @param[in]       pivot  rotation center
+ * @param[in]       angle  angle (radians)
+ * @param[in]       axis   axis
+ */
+CGLM_INLINE
+void
+glm_rotated_at(mat4 m, vec3 pivot, float angle, vec3 axis) {
+  CGLM_ALIGN(8) vec3 pivotInv;
+
+  glm_vec3_negate_to(pivot, pivotInv);
+
+  glm_translated(m, pivot);
+  glm_rotated(m, angle, axis);
+  glm_translated(m, pivotInv);
+}
+
+/*!
+ * @brief rotate existing transform matrix around given axis by angle around self (doesn't affected by position)
+ *
+ *  this is POST transform, applies to existing transform as last transfrom
+ *
+ * @param[in, out]  m      affine transfrom
+ * @param[in]       angle  angle (radians)
+ * @param[in]       axis   axis
+ */
+CGLM_INLINE
+void
+glm_spinned(mat4 m, float angle, vec3 axis) {
+  CGLM_ALIGN_MAT mat4 rot;
+  glm_rotate_atm(rot, m[3], angle, axis);
+  glm_mat4_mul(rot, m, m);
+}
+
+#endif /* cglm_affine_post_h */

include/cglm/affine-pre.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
+ */
+
+#ifndef cglm_affine_pre_h
+#define cglm_affine_pre_h
+
+/*
+ Functions:
+   CGLM_INLINE void glm_translate_to(mat4 m, vec3 v, mat4 dest);
+   CGLM_INLINE void glm_translate(mat4 m, vec3 v);
+   CGLM_INLINE void glm_translate_x(mat4 m, float to);
+   CGLM_INLINE void glm_translate_y(mat4 m, float to);
+   CGLM_INLINE void glm_translate_z(mat4 m, float to);
+   CGLM_INLINE void glm_rotate_x(mat4 m, float angle, mat4 dest);
+   CGLM_INLINE void glm_rotate_y(mat4 m, float angle, mat4 dest);
+   CGLM_INLINE void glm_rotate_z(mat4 m, float angle, mat4 dest);
+   CGLM_INLINE void glm_rotate(mat4 m, float angle, vec3 axis);
+   CGLM_INLINE void glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis);
+   CGLM_INLINE void glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis);
+   CGLM_INLINE void glm_spin(mat4 m, float angle, vec3 axis);
+ */
+
+#include "common.h"
+#include "util.h"
+#include "vec3.h"
+#include "vec4.h"
+#include "mat4.h"
+#include "affine-mat.h"
+
+/*!
+ * @brief translate existing transform matrix by v vector
+ *        and stores result in same matrix
+ *
+ * @param[in, out]  m  affine transfrom
+ * @param[in]       v  translate vector [x, y, z]
+ */
+CGLM_INLINE
+void
+glm_translate(mat4 m, vec3 v) {
+#if defined(CGLM_SIMD)
+  glmm_128 m0, m1, m2, m3;
+
+  m0 = glmm_load(m[0]);
+  m1 = glmm_load(m[1]);
+  m2 = glmm_load(m[2]);
+  m3 = glmm_load(m[3]);
+
+  glmm_store(m[3],
+             glmm_fmadd(m0, glmm_set1(v[0]),
+                        glmm_fmadd(m1, glmm_set1(v[1]),
+                                   glmm_fmadd(m2, glmm_set1(v[2]), m3))));
+#else
+  glm_vec4_muladds(m[0], v[0], m[3]);
+  glm_vec4_muladds(m[1], v[1], m[3]);
+  glm_vec4_muladds(m[2], v[2], m[3]);
+#endif
+}
+
+/*!
+ * @brief translate existing transform matrix by v vector
+ *        and store result in dest
+ *
+ * source matrix will remain same
+ *
+ * @param[in]  m    affine transfrom
+ * @param[in]  v    translate vector [x, y, z]
+ * @param[out] dest translated matrix
+ */
+CGLM_INLINE
+void
+glm_translate_to(mat4 m, vec3 v, mat4 dest) {
+  glm_mat4_copy(m, dest);
+  glm_translate(dest, v);
+}
+
+/*!
+ * @brief translate existing transform matrix by x factor
+ *
+ * @param[in, out]  m  affine transfrom
+ * @param[in]       x  x factor
+ */
+CGLM_INLINE
+void
+glm_translate_x(mat4 m, float x) {
+#if defined(CGLM_SIMD)
+  glmm_store(m[3], glmm_fmadd(glmm_load(m[0]), glmm_set1(x), glmm_load(m[3])));
+#else
+  vec4 v1;
+  glm_vec4_scale(m[0], x, v1);
+  glm_vec4_add(v1, m[3], m[3]);
+#endif
+}
+
+/*!
+ * @brief translate existing transform matrix by y factor
+ *
+ * @param[in, out]  m  affine transfrom
+ * @param[in]       y  y factor
+ */
+CGLM_INLINE
+void
+glm_translate_y(mat4 m, float y) {
+#if defined(CGLM_SIMD)
+  glmm_store(m[3], glmm_fmadd(glmm_load(m[1]), glmm_set1(y), glmm_load(m[3])));
+#else
+  vec4 v1;
+  glm_vec4_scale(m[1], y, v1);
+  glm_vec4_add(v1, m[3], m[3]);
+#endif
+}
+
+/*!
+ * @brief translate existing transform matrix by z factor
+ *
+ * @param[in, out]  m  affine transfrom
+ * @param[in]       z  z factor
+ */
+CGLM_INLINE
+void
+glm_translate_z(mat4 m, float z) {
+#if defined(CGLM_SIMD)
+  glmm_store(m[3], glmm_fmadd(glmm_load(m[2]), glmm_set1(z), glmm_load(m[3])));
+#else
+  vec4 v1;
+  glm_vec4_scale(m[2], z, v1);
+  glm_vec4_add(v1, m[3], m[3]);
+#endif
+}
+
+/*!
+ * @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)
+ * @param[out]  dest   rotated matrix
+ */
+CGLM_INLINE
+void
+glm_rotate_x(mat4 m, float angle, mat4 dest) {
+  CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
+  float c, s;
+
+  c = cosf(angle);
+  s = sinf(angle);
+
+  t[1][1] =  c;
+  t[1][2] =  s;
+  t[2][1] = -s;
+  t[2][2] =  c;
+
+  glm_mul_rot(m, t, dest);
+}
+
+/*!
+ * @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)
+ * @param[out]  dest   rotated matrix
+ */
+CGLM_INLINE
+void
+glm_rotate_y(mat4 m, float angle, mat4 dest) {
+  CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
+  float c, s;
+
+  c = cosf(angle);
+  s = sinf(angle);
+
+  t[0][0] =  c;
+  t[0][2] = -s;
+  t[2][0] =  s;
+  t[2][2] =  c;
+
+  glm_mul_rot(m, t, dest);
+}
+
+/*!
+ * @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)
+ * @param[out]  dest   rotated matrix
+ */
+CGLM_INLINE
+void
+glm_rotate_z(mat4 m, float angle, mat4 dest) {
+  CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
+  float c, s;
+
+  c = cosf(angle);
+  s = sinf(angle);
+
+  t[0][0] =  c;
+  t[0][1] =  s;
+  t[1][0] = -s;
+  t[1][1] =  c;
+
+  glm_mul_rot(m, t, dest);
+}
+
+/*!
+ * @brief rotate existing transform matrix around given axis by angle
+ *
+ * @param[in, out]  m      affine transfrom
+ * @param[in]       angle  angle (radians)
+ * @param[in]       axis   axis
+ */
+CGLM_INLINE
+void
+glm_rotate(mat4 m, float angle, vec3 axis) {
+  CGLM_ALIGN_MAT mat4 rot;
+  glm_rotate_make(rot, angle, axis);
+  glm_mul_rot(m, rot, m);
+}
+
+/*!
+ * @brief rotate existing transform
+ *        around given axis by angle at given pivot point (rotation center)
+ *
+ * @param[in, out]  m      affine transfrom
+ * @param[in]       pivot  rotation center
+ * @param[in]       angle  angle (radians)
+ * @param[in]       axis   axis
+ */
+CGLM_INLINE
+void
+glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis) {
+  CGLM_ALIGN(8) vec3 pivotInv;
+
+  glm_vec3_negate_to(pivot, pivotInv);
+
+  glm_translate(m, pivot);
+  glm_rotate(m, angle, axis);
+  glm_translate(m, pivotInv);
+}
+
+/*!
+ * @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[out] m      affine transfrom
+ * @param[in]  pivot  rotation center
+ * @param[in]  angle  angle (radians)
+ * @param[in]  axis   axis
+ */
+CGLM_INLINE
+void
+glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis) {
+  CGLM_ALIGN(8) vec3 pivotInv;
+
+  glm_vec3_negate_to(pivot, pivotInv);
+
+  glm_translate_make(m, pivot);
+  glm_rotate(m, angle, axis);
+  glm_translate(m, pivotInv);
+}
+
+/*!
+ * @brief rotate existing transform matrix around given axis by angle around self (doesn't affected by position)
+ *
+ * @param[in, out]  m      affine transfrom
+ * @param[in]       angle  angle (radians)
+ * @param[in]       axis   axis
+ */
+CGLM_INLINE
+void
+glm_spin(mat4 m, float angle, vec3 axis) {
+  CGLM_ALIGN_MAT mat4 rot;
+  glm_rotate_atm(rot, m[3], angle, axis);
+  glm_mat4_mul(m, rot, m);
+}
+
+#endif /* cglm_affine_pre_h */

include/cglm/affine.h

@@ -24,6 +24,7 @@
    CGLM_INLINE void glm_rotate(mat4 m, float angle, vec3 axis);
    CGLM_INLINE void glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis);
    CGLM_INLINE void glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis);
+   CGLM_INLINE void glm_spin(mat4 m, float angle, vec3 axis);
    CGLM_INLINE void glm_decompose_scalev(mat4 m, vec3 s);
    CGLM_INLINE bool glm_uniscaled(mat4 m);
    CGLM_INLINE void glm_decompose_rs(mat4 m, mat4 r, vec3 s);
@@ -40,106 +41,6 @@
 #include "mat4.h"
 #include "affine-mat.h"
 
-/*!
- * @brief translate existing transform matrix by v vector
- *        and stores result in same matrix
- *
- * @param[in, out]  m  affine transfrom
- * @param[in]       v  translate vector [x, y, z]
- */
-CGLM_INLINE
-void
-glm_translate(mat4 m, vec3 v) {
-#if defined(CGLM_SIMD)
-  glmm_128 m0, m1, m2, m3;
-
-  m0 = glmm_load(m[0]);
-  m1 = glmm_load(m[1]);
-  m2 = glmm_load(m[2]);
-  m3 = glmm_load(m[3]);
-
-  glmm_store(m[3],
-             glmm_fmadd(m0, glmm_set1(v[0]),
-                        glmm_fmadd(m1, glmm_set1(v[1]),
-                                   glmm_fmadd(m2, glmm_set1(v[2]), m3))));
-#else
-  glm_vec4_muladds(m[0], v[0], m[3]);
-  glm_vec4_muladds(m[1], v[1], m[3]);
-  glm_vec4_muladds(m[2], v[2], m[3]);
-#endif
-}
-
-/*!
- * @brief translate existing transform matrix by v vector
- *        and store result in dest
- *
- * source matrix will remain same
- *
- * @param[in]  m    affine transfrom
- * @param[in]  v    translate vector [x, y, z]
- * @param[out] dest translated matrix
- */
-CGLM_INLINE
-void
-glm_translate_to(mat4 m, vec3 v, mat4 dest) {
-  glm_mat4_copy(m, dest);
-  glm_translate(dest, v);
-}
-
-/*!
- * @brief translate existing transform matrix by x factor
- *
- * @param[in, out]  m  affine transfrom
- * @param[in]       x  x factor
- */
-CGLM_INLINE
-void
-glm_translate_x(mat4 m, float x) {
-#if defined(CGLM_SIMD)
-  glmm_store(m[3], glmm_fmadd(glmm_load(m[0]), glmm_set1(x), glmm_load(m[3])));
-#else
-  vec4 v1;
-  glm_vec4_scale(m[0], x, v1);
-  glm_vec4_add(v1, m[3], m[3]);
-#endif
-}
-
-/*!
- * @brief translate existing transform matrix by y factor
- *
- * @param[in, out]  m  affine transfrom
- * @param[in]       y  y factor
- */
-CGLM_INLINE
-void
-glm_translate_y(mat4 m, float y) {
-#if defined(CGLM_SIMD)
-  glmm_store(m[3], glmm_fmadd(glmm_load(m[1]), glmm_set1(y), glmm_load(m[3])));
-#else
-  vec4 v1;
-  glm_vec4_scale(m[1], y, v1);
-  glm_vec4_add(v1, m[3], m[3]);
-#endif
-}
-
-/*!
- * @brief translate existing transform matrix by z factor
- *
- * @param[in, out]  m  affine transfrom
- * @param[in]       z  z factor
- */
-CGLM_INLINE
-void
-glm_translate_z(mat4 m, float z) {
-#if defined(CGLM_SIMD)
-  glmm_store(m[3], glmm_fmadd(glmm_load(m[2]), glmm_set1(z), glmm_load(m[3])));
-#else
-  vec4 v1;
-  glm_vec4_scale(m[2], z, v1);
-  glm_vec4_add(v1, m[3], m[3]);
-#endif
-}
-
 /*!
  * @brief creates NEW translate transform matrix by v vector
  *
@@ -213,81 +114,6 @@ glm_scale_uni(mat4 m, float s) {
   glm_scale_to(m, v, 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)
- * @param[out]  dest   rotated matrix
- */
-CGLM_INLINE
-void
-glm_rotate_x(mat4 m, float angle, mat4 dest) {
-  CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
-  float c, s;
-
-  c = cosf(angle);
-  s = sinf(angle);
-
-  t[1][1] =  c;
-  t[1][2] =  s;
-  t[2][1] = -s;
-  t[2][2] =  c;
-
-  glm_mul_rot(m, t, dest);
-}
-
-/*!
- * @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)
- * @param[out]  dest   rotated matrix
- */
-CGLM_INLINE
-void
-glm_rotate_y(mat4 m, float angle, mat4 dest) {
-  CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
-  float c, s;
-
-  c = cosf(angle);
-  s = sinf(angle);
-
-  t[0][0] =  c;
-  t[0][2] = -s;
-  t[2][0] =  s;
-  t[2][2] =  c;
-
-  glm_mul_rot(m, t, dest);
-}
-
-/*!
- * @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)
- * @param[out]  dest   rotated matrix
- */
-CGLM_INLINE
-void
-glm_rotate_z(mat4 m, float angle, mat4 dest) {
-  CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
-  float c, s;
-
-  c = cosf(angle);
-  s = sinf(angle);
-
-  t[0][0] =  c;
-  t[0][1] =  s;
-  t[1][0] = -s;
-  t[1][1] =  c;
-
-  glm_mul_rot(m, t, dest);
-}
-
 /*!
  * @brief creates NEW rotation matrix by angle and axis
  *
@@ -321,67 +147,6 @@ glm_rotate_make(mat4 m, float angle, vec3 axis) {
   m[3][3] = 1.0f;
 }
 
-/*!
- * @brief rotate existing transform matrix around given axis by angle
- *
- * @param[in, out]  m      affine transfrom
- * @param[in]       angle  angle (radians)
- * @param[in]       axis   axis
- */
-CGLM_INLINE
-void
-glm_rotate(mat4 m, float angle, vec3 axis) {
-  CGLM_ALIGN_MAT mat4 rot;
-  glm_rotate_make(rot, angle, axis);
-  glm_mul_rot(m, rot, m);
-}
-
-/*!
- * @brief rotate existing transform
- *        around given axis by angle at given pivot point (rotation center)
- *
- * @param[in, out]  m      affine transfrom
- * @param[in]       pivot  rotation center
- * @param[in]       angle  angle (radians)
- * @param[in]       axis   axis
- */
-CGLM_INLINE
-void
-glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis) {
-  CGLM_ALIGN(8) vec3 pivotInv;
-
-  glm_vec3_negate_to(pivot, pivotInv);
-
-  glm_translate(m, pivot);
-  glm_rotate(m, angle, axis);
-  glm_translate(m, pivotInv);
-}
-
-/*!
- * @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[out] m      affine transfrom
- * @param[in]  pivot  rotation center
- * @param[in]  angle  angle (radians)
- * @param[in]  axis   axis
- */
-CGLM_INLINE
-void
-glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis) {
-  CGLM_ALIGN(8) vec3 pivotInv;
-
-  glm_vec3_negate_to(pivot, pivotInv);
-
-  glm_translate_make(m, pivot);
-  glm_rotate(m, angle, axis);
-  glm_translate(m, pivotInv);
-}
-
 /*!
  * @brief decompose scale vector
  *
@@ -467,4 +232,7 @@ glm_decompose(mat4 m, vec4 t, mat4 r, vec3 s) {
   glm_decompose_rs(m, r, s);
 }
 
+#include "affine-pre.h"
+#include "affine-post.h"
+
 #endif /* cglm_affine_h */

include/cglm/call.h

@@ -15,6 +15,9 @@ extern "C" {
 #include "call/vec2.h"
 #include "call/vec3.h"
 #include "call/vec4.h"
+#include "call/ivec2.h"
+#include "call/ivec3.h"
+#include "call/ivec4.h"
 #include "call/mat2.h"
 #include "call/mat3.h"
 #include "call/mat4.h"

include/cglm/call/affine.h

@@ -81,6 +81,10 @@ CGLM_EXPORT
 void
 glmc_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis);
 
+CGLM_EXPORT
+void
+glmc_spin(mat4 m, float angle, vec3 axis);
+
 CGLM_EXPORT
 void
 glmc_decompose_scalev(mat4 m, vec3 s);
@@ -97,6 +101,52 @@ CGLM_EXPORT
 void
 glmc_decompose(mat4 m, vec4 t, mat4 r, vec3 s);
 
+/* affine-post */
+
+CGLM_EXPORT
+void
+glmc_translated(mat4 m, vec3 v);
+
+CGLM_EXPORT
+void
+glmc_translated_to(mat4 m, vec3 v, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_translated_x(mat4 m, float x);
+
+CGLM_EXPORT
+void
+glmc_translated_y(mat4 m, float y);
+
+CGLM_EXPORT
+void
+glmc_translated_z(mat4 m, float z);
+
+CGLM_EXPORT
+void
+glmc_rotated_x(mat4 m, float angle, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_rotated_y(mat4 m, float angle, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_rotated_z(mat4 m, float angle, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_rotated(mat4 m, float angle, vec3 axis);
+
+CGLM_EXPORT
+void
+glmc_rotated_at(mat4 m, vec3 pivot, float angle, vec3 axis);
+
+CGLM_EXPORT
+void
+glmc_spinned(mat4 m, float angle, vec3 axis);
+
 /* affine-mat */
 
 CGLM_EXPORT

include/cglm/call/clipspace/project_no.h

@@ -21,6 +21,10 @@ CGLM_EXPORT
 void
 glmc_project_no(vec3 pos, mat4 m, vec4 vp, vec3 dest);
 
+CGLM_EXPORT
+float
+glmc_project_z_no(vec3 pos, mat4 m);
+
 #ifdef __cplusplus
 }
 #endif

include/cglm/call/clipspace/project_zo.h

@@ -21,6 +21,10 @@ CGLM_EXPORT
 void
 glmc_project_zo(vec3 pos, mat4 m, vec4 vp, vec3 dest);
 
+CGLM_EXPORT
+float
+glmc_project_z_zo(vec3 pos, mat4 m);
+
 #ifdef __cplusplus
 }
 #endif

include/cglm/call/ivec2.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 cglmc_ivec2_h
+#define cglmc_ivec2_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_ivec2(int * __restrict v, ivec2 dest);
+
+CGLM_EXPORT
+void
+glmc_ivec2_copy(ivec2 a, ivec2 dest);
+
+CGLM_EXPORT
+void
+glmc_ivec2_zero(ivec2 v);
+
+CGLM_EXPORT
+void
+glmc_ivec2_one(ivec2 v);
+
+CGLM_EXPORT
+void
+glmc_ivec2_add(ivec2 a, ivec2 b, ivec2 dest);
+
+CGLM_EXPORT
+void
+glmc_ivec2_adds(ivec2 v, int s, ivec2 dest);
+
+CGLM_EXPORT
+void
+glmc_ivec2_sub(ivec2 a, ivec2 b, ivec2 dest);
+
+CGLM_EXPORT
+void
+glmc_ivec2_subs(ivec2 v, int s, ivec2 dest);
+
+CGLM_EXPORT
+void
+glmc_ivec2_mul(ivec2 a, ivec2 b, ivec2 dest);
+
+CGLM_EXPORT
+void
+glmc_ivec2_scale(ivec2 v, int s, ivec2 dest);
+
+CGLM_EXPORT
+int
+glmc_ivec2_distance2(ivec2 a, ivec2 b);
+
+CGLM_EXPORT
+float
+glmc_ivec2_distance(ivec2 a, ivec2 b);
+
+CGLM_EXPORT
+void
+glmc_ivec2_maxv(ivec2 a, ivec2 b, ivec2 dest);
+
+CGLM_EXPORT
+void
+glmc_ivec2_minv(ivec2 a, ivec2 b, ivec2 dest);
+
+CGLM_EXPORT
+void
+glmc_ivec2_clamp(ivec2 v, int minVal, int maxVal);
+
+CGLM_EXPORT
+void
+glmc_ivec2_abs(ivec2 v, ivec2 dest);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_ivec2_h */

include/cglm/call/ivec3.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 cglmc_ivec3_h
+#define cglmc_ivec3_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_ivec3(ivec4 v4, ivec3 dest);
+
+CGLM_EXPORT
+void
+glmc_ivec3_copy(ivec3 a, ivec3 dest);
+
+CGLM_EXPORT
+void 
+glmc_ivec3_zero(ivec3 v);
+
+CGLM_EXPORT
+void
+glmc_ivec3_one(ivec3 v);
+
+CGLM_EXPORT
+void
+glmc_ivec3_add(ivec3 a, ivec3 b, ivec3 dest);
+
+CGLM_EXPORT
+void
+glmc_ivec3_adds(ivec3 v, int s, ivec3 dest);
+
+CGLM_EXPORT
+void
+glmc_ivec3_sub(ivec3 a, ivec3 b, ivec3 dest);
+
+CGLM_EXPORT
+void
+glmc_ivec3_subs(ivec3 v, int s, ivec3 dest);
+
+CGLM_EXPORT
+void
+glmc_ivec3_mul(ivec3 a, ivec3 b, ivec3 dest);
+
+CGLM_EXPORT
+void
+glmc_ivec3_scale(ivec3 v, int s, ivec3 dest);
+
+CGLM_EXPORT
+int
+glmc_ivec3_distance2(ivec3 a, ivec3 b);
+
+CGLM_EXPORT
+float
+glmc_ivec3_distance(ivec3 a, ivec3 b);
+
+CGLM_EXPORT
+void
+glmc_ivec3_maxv(ivec3 a, ivec3 b, ivec3 dest);
+
+CGLM_EXPORT
+void
+glmc_ivec3_minv(ivec3 a, ivec3 b, ivec3 dest);
+
+CGLM_EXPORT
+void
+glmc_ivec3_clamp(ivec3 v, int minVal, int maxVal);
+
+CGLM_EXPORT
+void
+glmc_ivec3_abs(ivec3 v, ivec3 dest);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_ivec3_h */

include/cglm/call/ivec4.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 cglmc_ivec4_h
+#define cglmc_ivec4_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_ivec4(ivec3 v3, int last, ivec4 dest);
+
+CGLM_EXPORT
+void
+glmc_ivec4_copy(ivec4 a, ivec4 dest);
+
+CGLM_EXPORT
+void 
+glmc_ivec4_zero(ivec4 v);
+
+CGLM_EXPORT
+void
+glmc_ivec4_one(ivec4 v);
+
+CGLM_EXPORT
+void
+glmc_ivec4_add(ivec4 a, ivec4 b, ivec4 dest);
+
+CGLM_EXPORT
+void
+glmc_ivec4_adds(ivec4 v, int s, ivec4 dest);
+
+CGLM_EXPORT
+void
+glmc_ivec4_sub(ivec4 a, ivec4 b, ivec4 dest);
+
+CGLM_EXPORT
+void
+glmc_ivec4_subs(ivec4 v, int s, ivec4 dest);
+
+CGLM_EXPORT
+void
+glmc_ivec4_mul(ivec4 a, ivec4 b, ivec4 dest);
+
+CGLM_EXPORT
+void
+glmc_ivec4_scale(ivec4 v, int s, ivec4 dest);
+
+CGLM_EXPORT
+int
+glmc_ivec4_distance2(ivec4 a, ivec4 b);
+
+CGLM_EXPORT
+float
+glmc_ivec4_distance(ivec4 a, ivec4 b);
+
+CGLM_EXPORT
+void
+glmc_ivec4_maxv(ivec4 a, ivec4 b, ivec4 dest);
+
+CGLM_EXPORT
+void
+glmc_ivec4_minv(ivec4 a, ivec4 b, ivec4 dest);
+
+CGLM_EXPORT
+void
+glmc_ivec4_clamp(ivec4 v, int minVal, int maxVal);
+
+CGLM_EXPORT
+void
+glmc_ivec4_abs(ivec4 v, ivec4 dest);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_ivec4_h */

include/cglm/call/project.h

@@ -25,6 +25,10 @@ CGLM_EXPORT
 void
 glmc_project(vec3 pos, mat4 m, vec4 vp, vec3 dest);
 
+CGLM_EXPORT
+float
+glmc_project_z(vec3 pos, mat4 m);
+
 CGLM_EXPORT
 void
 glmc_pickmatrix(vec2 center, vec2 size, vec4 vp, mat4 dest);

include/cglm/call/vec2.h

@@ -145,6 +145,10 @@ CGLM_EXPORT
 void
 glmc_vec2_clamp(vec2 v, float minval, float maxval);
 
+CGLM_EXPORT
+void
+glmc_vec2_abs(vec2 v, vec2 dest);
+
 CGLM_EXPORT
 void
 glmc_vec2_lerp(vec2 from, vec2 to, float t, vec2 dest);

include/cglm/cglm.h

@@ -12,6 +12,9 @@
 #include "vec2.h"
 #include "vec3.h"
 #include "vec4.h"
+#include "ivec2.h"
+#include "ivec3.h"
+#include "ivec4.h"
 #include "mat4.h"
 #include "mat3.h"
 #include "mat2.h"

include/cglm/clipspace/project_no.h

@@ -83,4 +83,27 @@ glm_project_no(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
   dest[2] = pos4[2];
 }
 
+/*!
+ * @brief map object's z coordinate to window coordinates
+ *
+ * Computing MVP:
+ *   glm_mat4_mul(proj, view, viewProj);
+ *   glm_mat4_mul(viewProj, model, MVP);
+ *
+ * @param[in]  v  object coordinates
+ * @param[in]  m  MVP matrix
+ *
+ * @returns projected z coordinate
+ */
+CGLM_INLINE
+float
+glm_project_z_no(vec3 v, mat4 m) {
+  float z, w;
+
+  z = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2] + m[3][2];
+  w = m[0][3] * v[0] + m[1][3] * v[1] + m[2][3] * v[2] + m[3][3];
+
+  return 0.5f * (z / w) + 0.5f;
+}
+
 #endif /* cglm_project_no_h */

include/cglm/clipspace/project_zo.h

@@ -85,4 +85,27 @@ glm_project_zo(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
   dest[1] = pos4[1] * vp[3] + vp[1];
 }
 
+/*!
+ * @brief map object's z coordinate to window coordinates
+ *
+ * Computing MVP:
+ *   glm_mat4_mul(proj, view, viewProj);
+ *   glm_mat4_mul(viewProj, model, MVP);
+ *
+ * @param[in]  v  object coordinates
+ * @param[in]  m  MVP matrix
+ *
+ * @returns projected z coordinate
+ */
+CGLM_INLINE
+float
+glm_project_z_zo(vec3 v, mat4 m) {
+  float z, w;
+
+  z = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2] + m[3][2];
+  w = m[0][3] * v[0] + m[1][3] * v[1] + m[2][3] * v[2] + m[3][3];
+
+  return z / w;
+}
+
 #endif /* cglm_project_zo_h */

include/cglm/clipspace/view_lh.h

@@ -37,8 +37,8 @@ glm_lookat_lh(vec3 eye, vec3 center, vec3 up, mat4 dest) {
   glm_vec3_sub(center, eye, f);
   glm_vec3_normalize(f);
 
-  glm_vec3_crossn(f, up, s);
-  glm_vec3_cross(s, f, u);
+  glm_vec3_crossn(up, f, s);
+  glm_vec3_cross(f, s, u);
 
   dest[0][0] = s[0];
   dest[0][1] = u[0];

include/cglm/common.h

@@ -18,6 +18,7 @@
 
 #include <stdint.h>
 #include <stddef.h>
+#include <stdlib.h>
 #include <math.h>
 #include <float.h>
 #include <stdbool.h>
@@ -44,16 +45,16 @@
 
 #ifndef CGLM_USE_DEFAULT_EPSILON
 #  ifndef GLM_FLT_EPSILON
-#    define GLM_FLT_EPSILON 1e-5
+#    define GLM_FLT_EPSILON 1e-5f
 #  endif
 #else
 #  define GLM_FLT_EPSILON FLT_EPSILON
 #endif
 
 /*
- * Clip control: define GLM_FORCE_DEPTH_ZERO_TO_ONE before including
+ * Clip control: define CGLM_FORCE_DEPTH_ZERO_TO_ONE before including
  * CGLM to use a clip space between 0 to 1.
- * Coordinate system: define GLM_FORCE_LEFT_HANDED before including
+ * Coordinate system: define CGLM_FORCE_LEFT_HANDED before including
  * CGLM to use the left handed coordinate system by default.
  */
 
@@ -81,4 +82,34 @@
 #  endif
 #endif
 
+/* struct API configurator */
+/* TODO: move struct/common.h? */
+/* WARN: dont use concant helpers outside cglm headers, because they may be changed */
+
+#define CGLM_MACRO_CONCAT_HELPER(A, B, C, D, E, ...) A ## B ## C ## D ## E ## __VA_ARGS__
+#define CGLM_MACRO_CONCAT(A, B, C, D, E, ...) CGLM_MACRO_CONCAT_HELPER(A, B, C, D, E,__VA_ARGS__)
+
+#ifndef CGLM_OMIT_NS_FROM_STRUCT_API
+#  ifndef CGLM_STRUCT_API_NS
+#    define CGLM_STRUCT_API_NS glms
+#  endif
+#  ifndef CGLM_STRUCT_API_NS_SEPERATOR
+#    define CGLM_STRUCT_API_NS_SEPERATOR _
+#  endif
+#else
+#  define CGLM_STRUCT_API_NS
+#  define CGLM_STRUCT_API_NS_SEPERATOR
+#endif
+
+#ifndef CGLM_STRUCT_API_NAME_SUFFIX
+#  define CGLM_STRUCT_API_NAME_SUFFIX
+#endif
+
+#define CGLM_STRUCTAPI(A, ...) CGLM_MACRO_CONCAT(CGLM_STRUCT_API_NS,             \
+                                                 CGLM_STRUCT_API_NS_SEPERATOR,   \
+                                                 A,                              \
+                                                 CGLM_STRUCT_API_NAME_SUFFIX,    \
+                                                 _,                              \
+                                                 __VA_ARGS__)
+
 #endif /* cglm_common_h */

include/cglm/io.h

@@ -39,6 +39,7 @@
    || defined(CGLM_NO_PRINTS_NOOP)
 
 #include "common.h"
+#include "util.h"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -48,7 +49,7 @@
 #endif
 
 #ifndef CGLM_PRINT_MAX_TO_SHORT
-#  define CGLM_PRINT_MAX_TO_SHORT 1e5
+#  define CGLM_PRINT_MAX_TO_SHORT 1e5f
 #endif
 
 #ifndef CGLM_PRINT_COLOR
@@ -59,6 +60,35 @@
 #  define CGLM_PRINT_COLOR_RESET  "\033[0m"
 #endif
 
+/*!
+ * @brief prints current SIMD path in general
+ *
+ * @param[in] ostream    stream to print e.g. stdout, stderr, FILE ...
+ */
+CGLM_INLINE
+void
+glm_arch_print_name(FILE* __restrict ostream) {
+#if defined(CGLM_SIMD_WASM)
+  fprintf(ostream, CGLM_PRINT_COLOR "\ncglm arch: wasm SIMD128"
+    "\n\n" CGLM_PRINT_COLOR_RESET);
+#elif defined(CGLM_SIMD_x86)
+  fprintf(ostream, CGLM_PRINT_COLOR "\ncglm arch: x86 SSE*" 
+#ifdef __AVX__
+    " AVX"
+#endif
+    "\n\n" CGLM_PRINT_COLOR_RESET);
+#elif defined(CGLM_SIMD_ARM) 
+  fprintf(ostream, CGLM_PRINT_COLOR "\ncglm arch: arm"
+#ifndef __ARM_NEON_FP
+    " NEON_FP"
+#endif
+#ifdef CGLM_ARM64
+    " ARM64"
+#endif
+    "\n\n" CGLM_PRINT_COLOR_RESET);
+#endif
+}
+
 CGLM_INLINE
 void
 glm_mat4_print(mat4              matrix,
@@ -76,9 +106,9 @@ glm_mat4_print(mat4              matrix,
   for (i = 0; i < m; i++) {
     for (j = 0; j < n; j++) {
       if (matrix[i][j] < CGLM_PRINT_MAX_TO_SHORT)
-        cwi = sprintf(buff, "% .*f", CGLM_PRINT_PRECISION, matrix[i][j]);
+        cwi = sprintf(buff, "% .*f", CGLM_PRINT_PRECISION, (double)matrix[i][j]);
       else
-        cwi = sprintf(buff, "% g", matrix[i][j]);
+        cwi = sprintf(buff, "% g", (double)matrix[i][j]);
       cw[i] = GLM_MAX(cw[i], cwi);
     }
   }
@@ -88,9 +118,9 @@ glm_mat4_print(mat4              matrix,
 
     for (j = 0; j < n; j++)
       if (matrix[i][j] < CGLM_PRINT_MAX_TO_SHORT)
-        fprintf(ostream, " % *.*f", cw[j], CGLM_PRINT_PRECISION, matrix[j][i]);
+        fprintf(ostream, " % *.*f", cw[j], CGLM_PRINT_PRECISION, (double)matrix[j][i]);
       else
-        fprintf(ostream, " % *g", cw[j], matrix[j][i]);
+        fprintf(ostream, " % *g", cw[j], (double)matrix[j][i]);
 
     fprintf(ostream, "  |\n");
   }
@@ -119,22 +149,22 @@ glm_mat3_print(mat3              matrix,
   for (i = 0; i < m; i++) {
     for (j = 0; j < n; j++) {
       if (matrix[i][j] < CGLM_PRINT_MAX_TO_SHORT)
-        cwi = sprintf(buff, "% .*f", CGLM_PRINT_PRECISION, matrix[i][j]);
+        cwi = sprintf(buff, "% .*f", CGLM_PRINT_PRECISION, (double)matrix[i][j]);
       else
-        cwi = sprintf(buff, "% g", matrix[i][j]);
+        cwi = sprintf(buff, "% g", (double)matrix[i][j]);
       cw[i] = GLM_MAX(cw[i], cwi);
     }
   }
 
   for (i = 0; i < m; i++) {
     fprintf(ostream, "  |");
-    
+
     for (j = 0; j < n; j++)
       if (matrix[i][j] < CGLM_PRINT_MAX_TO_SHORT)
-        fprintf(ostream, " % *.*f", cw[j], CGLM_PRINT_PRECISION, matrix[j][i]);
+        fprintf(ostream, " % *.*f", cw[j], CGLM_PRINT_PRECISION, (double)matrix[j][i]);
       else
-        fprintf(ostream, " % *g", cw[j], matrix[j][i]);
-    
+        fprintf(ostream, " % *g", cw[j], (double)matrix[j][i]);
+
     fprintf(ostream, "  |\n");
   }
 
@@ -161,22 +191,22 @@ glm_mat2_print(mat2              matrix,
   for (i = 0; i < m; i++) {
     for (j = 0; j < n; j++) {
       if (matrix[i][j] < CGLM_PRINT_MAX_TO_SHORT)
-        cwi = sprintf(buff, "% .*f", CGLM_PRINT_PRECISION, matrix[i][j]);
+        cwi = sprintf(buff, "% .*f", CGLM_PRINT_PRECISION, (double)matrix[i][j]);
       else
-        cwi = sprintf(buff, "% g", matrix[i][j]);
+        cwi = sprintf(buff, "% g", (double)matrix[i][j]);
       cw[i] = GLM_MAX(cw[i], cwi);
     }
   }
 
   for (i = 0; i < m; i++) {
     fprintf(ostream, "  |");
-    
+
     for (j = 0; j < n; j++)
       if (matrix[i][j] < CGLM_PRINT_MAX_TO_SHORT)
-        fprintf(ostream, " % *.*f", cw[j], CGLM_PRINT_PRECISION, matrix[j][i]);
+        fprintf(ostream, " % *.*f", cw[j], CGLM_PRINT_PRECISION, (double)matrix[j][i]);
       else
-        fprintf(ostream, " % *g", cw[j], matrix[j][i]);
-    
+        fprintf(ostream, " % *g", cw[j], (double)matrix[j][i]);
+
     fprintf(ostream, "  |\n");
   }
 
@@ -198,9 +228,9 @@ glm_vec4_print(vec4              vec,
 
   for (i = 0; i < m; i++) {
     if (vec[i] < CGLM_PRINT_MAX_TO_SHORT)
-      fprintf(ostream, " % .*f", CGLM_PRINT_PRECISION, vec[i]);
+      fprintf(ostream, " % .*f", CGLM_PRINT_PRECISION, (double)vec[i]);
     else
-      fprintf(ostream, " % g", vec[i]);
+      fprintf(ostream, " % g", (double)vec[i]);
   }
 
   fprintf(ostream, "  )" CGLM_PRINT_COLOR_RESET "\n\n");
@@ -220,9 +250,9 @@ glm_vec3_print(vec3              vec,
 
   for (i = 0; i < m; i++) {
     if (vec[i] < CGLM_PRINT_MAX_TO_SHORT)
-      fprintf(ostream, " % .*f", CGLM_PRINT_PRECISION, vec[i]);
+      fprintf(ostream, " % .*f", CGLM_PRINT_PRECISION, (double)vec[i]);
     else
-      fprintf(ostream, " % g", vec[i]);
+      fprintf(ostream, " % g", (double)vec[i]);
   }
 
   fprintf(ostream, "  )" CGLM_PRINT_COLOR_RESET "\n\n");
@@ -244,7 +274,7 @@ glm_ivec3_print(ivec3             vec,
     fprintf(ostream, " % d", vec[i]);
 
   fprintf(ostream, "  )" CGLM_PRINT_COLOR_RESET "\n\n");
-  
+
 #undef m
 }
 
@@ -260,9 +290,9 @@ glm_vec2_print(vec2              vec,
 
   for (i = 0; i < m; i++) {
     if (vec[i] < CGLM_PRINT_MAX_TO_SHORT)
-      fprintf(ostream, " % .*f", CGLM_PRINT_PRECISION, vec[i]);
+      fprintf(ostream, " % .*f", CGLM_PRINT_PRECISION, (double)vec[i]);
     else
-      fprintf(ostream, " % g", vec[i]);
+      fprintf(ostream, " % g", (double)vec[i]);
   }
 
   fprintf(ostream, "  )" CGLM_PRINT_COLOR_RESET "\n\n");
@@ -282,9 +312,9 @@ glm_versor_print(versor            vec,
 
   for (i = 0; i < m; i++) {
     if (vec[i] < CGLM_PRINT_MAX_TO_SHORT)
-      fprintf(ostream, " % .*f", CGLM_PRINT_PRECISION, vec[i]);
+      fprintf(ostream, " % .*f", CGLM_PRINT_PRECISION, (double)vec[i]);
     else
-      fprintf(ostream, " % g", vec[i]);
+      fprintf(ostream, " % g", (double)vec[i]);
   }
 
 
@@ -306,12 +336,12 @@ glm_aabb_print(vec3                    bbox[2],
 
   for (i = 0; i < 2; i++) {
     fprintf(ostream, "  (");
-    
+
     for (j = 0; j < m; j++) {
       if (bbox[i][j] < CGLM_PRINT_MAX_TO_SHORT)
-        fprintf(ostream, " % .*f", CGLM_PRINT_PRECISION, bbox[i][j]);
+        fprintf(ostream, " % .*f", CGLM_PRINT_PRECISION, (double)bbox[i][j]);
       else
-        fprintf(ostream, " % g", bbox[i][j]);
+        fprintf(ostream, " % g", (double)bbox[i][j]);
     }
 
     fprintf(ostream, "  )\n");

include/cglm/ivec2.h

@@ -0,0 +1,268 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   GLM_IVEC2_ONE_INIT
+   GLM_IVEC2_ZERO_INIT
+   GLM_IVEC2_ONE
+   GLM_IVEC2_ZERO
+
+ Functions:
+  CGLM_INLINE void glm_ivec2(int * __restrict v, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_copy(ivec2 a, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_zero(ivec2 v)
+  CGLM_INLINE void glm_ivec2_one(ivec2 v)
+  CGLM_INLINE void glm_ivec2_add(ivec2 a, ivec2 b, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_adds(ivec2 v, int s, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_sub(ivec2 a, ivec2 b, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_subs(ivec2 v, int s, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_mul(ivec2 a, ivec2 b, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_scale(ivec2 v, int s, ivec2 dest)
+  CGLM_INLINE int glm_ivec2_distance2(ivec2 a, ivec2 b)
+  CGLM_INLINE float glm_ivec2_distance(ivec2 a, ivec2 b)
+  CGLM_INLINE void glm_ivec2_maxv(ivec2 a, ivec2 b, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_minv(ivec2 a, ivec2 b, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_clamp(ivec2 v, int minVal, int maxVal)
+  CGLM_INLINE void glm_ivec2_abs(ivec2 v, ivec2 dest)
+ */
+
+#ifndef cglm_ivec2_h
+#define cglm_ivec2_h
+
+#include "common.h"
+
+#define GLM_IVEC2_ONE_INIT   {1, 1}
+#define GLM_IVEC2_ZERO_INIT  {0, 0}
+
+#define GLM_IVEC2_ONE  ((ivec2)GLM_IVEC2_ONE_INIT)
+#define GLM_IVEC2_ZERO ((ivec2)GLM_IVEC2_ZERO_INIT)
+
+/*!
+ * @brief init ivec2 using vec3 or vec4
+ *
+ * @param[in]  v    vector
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_ivec2(int * __restrict v, ivec2 dest) {
+  dest[0] = v[0];
+  dest[1] = v[1];
+}
+
+/*!
+ * @brief copy all members of [a] to [dest]
+ *
+ * @param[in]  a    source vector
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_ivec2_copy(ivec2 a, ivec2 dest) {
+  dest[0] = a[0];
+  dest[1] = a[1];
+}
+
+/*!
+ * @brief set all members of [v] to zero
+ *
+ * @param[out] v vector
+ */
+CGLM_INLINE
+void 
+glm_ivec2_zero(ivec2 v) {
+  v[0] = v[1] = 0;
+}
+
+/*!
+ * @brief set all members of [v] to one
+ *
+ * @param[out] v vector
+ */
+CGLM_INLINE
+void
+glm_ivec2_one(ivec2 v) {
+  v[0] = v[1] = 1;
+}
+
+/*!
+ * @brief add vector [a] to vector [b] and store result in [dest]
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_ivec2_add(ivec2 a, ivec2 b, ivec2 dest) {
+  dest[0] = a[0] + b[0];
+  dest[1] = a[1] + b[1];
+}
+
+/*!
+ * @brief add scalar s to vector [v] and store result in [dest]
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_ivec2_adds(ivec2 v, int s, ivec2 dest) {
+  dest[0] = v[0] + s;
+  dest[1] = v[1] + s;
+}
+
+/*!
+ * @brief subtract vector [b] from vector [a] and store result in [dest]
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_ivec2_sub(ivec2 a, ivec2 b, ivec2 dest) {
+  dest[0] = a[0] - b[0];
+  dest[1] = a[1] - b[1];
+}
+
+/*!
+ * @brief subtract scalar s from vector [v] and store result in [dest]
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_ivec2_subs(ivec2 v, int s, ivec2 dest) {
+  dest[0] = v[0] - s;
+  dest[1] = v[1] - s;
+}
+
+/*!
+ * @brief multiply vector [a] with vector [b] and store result in [dest]
+ *
+ * @param[in]  a    frist vector
+ * @param[in]  b    second vector
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_ivec2_mul(ivec2 a, ivec2 b, ivec2 dest) {
+  dest[0] = a[0] * b[0];
+  dest[1] = a[1] * b[1];
+}
+
+/*!
+ * @brief multiply vector [a] with scalar s and store result in [dest]
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_ivec2_scale(ivec2 v, int s, ivec2 dest) {
+  dest[0] = v[0] * s;
+  dest[1] = v[1] * s;
+}
+
+/*!
+ * @brief squared distance between two vectors
+ *
+ * @param[in] a first vector
+ * @param[in] b second vector
+ * @return returns squared distance (distance * distance)
+ */
+CGLM_INLINE
+int
+glm_ivec2_distance2(ivec2 a, ivec2 b) {
+  int xd, yd;
+  xd = a[0] - b[0];
+  yd = a[1] - b[1];
+  return xd * xd + yd * yd;
+}
+
+/*!
+ * @brief distance between two vectors
+ *
+ * @param[in] a first vector
+ * @param[in] b second vector
+ * @return returns distance
+ */
+CGLM_INLINE
+float
+glm_ivec2_distance(ivec2 a, ivec2 b) {
+  return sqrtf((float)glm_ivec2_distance2(a, b));
+}
+
+/*!
+ * @brief set each member of dest to greater of vector a and b
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_ivec2_maxv(ivec2 a, ivec2 b, ivec2 dest) {
+  dest[0] = a[0] > b[0] ? a[0] : b[0];
+  dest[1] = a[1] > b[1] ? a[1] : b[1];
+}
+
+/*!
+ * @brief set each member of dest to lesser of vector a and b
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_ivec2_minv(ivec2 a, ivec2 b, ivec2 dest) {
+  dest[0] = a[0] < b[0] ? a[0] : b[0];
+  dest[1] = a[1] < b[1] ? a[1] : b[1];
+}
+
+/*!
+ * @brief clamp each member of [v] between minVal and maxVal (inclusive)
+ *
+ * @param[in, out] v      vector
+ * @param[in]      minVal minimum value
+ * @param[in]      maxVal maximum value
+ */
+CGLM_INLINE
+void
+glm_ivec2_clamp(ivec2 v, int minVal, int maxVal) {
+  if (v[0] < minVal)
+    v[0] = minVal;
+  else if(v[0] > maxVal)
+    v[0] = maxVal;
+
+  if (v[1] < minVal)
+    v[1] = minVal;
+  else if(v[1] > maxVal)
+    v[1] = maxVal;
+}
+
+/*!
+ * @brief absolute value of v
+ *
+ * @param[in]	v	vector
+ * @param[out]	dest	destination
+ */
+CGLM_INLINE
+void
+glm_ivec2_abs(ivec2 v, ivec2 dest) {
+  dest[0] = abs(v[0]);
+  dest[1] = abs(v[1]);
+}
+
+#endif /* cglm_ivec2_h */

include/cglm/ivec3.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:
+   GLM_IVEC3_ONE_INIT
+   GLM_IVEC3_ZERO_INIT
+   GLM_IVEC3_ONE
+   GLM_IVEC3_ZERO
+
+ Functions:
+  CGLM_INLINE void glm_ivec3(ivec4 v4, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_copy(ivec3 a, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_zero(ivec3 v)
+  CGLM_INLINE void glm_ivec3_one(ivec3 v)
+  CGLM_INLINE void glm_ivec3_add(ivec3 a, ivec3 b, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_adds(ivec3 v, int s, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_sub(ivec3 a, ivec3 b, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_subs(ivec3 v, int s, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_mul(ivec3 a, ivec3 b, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_scale(ivec3 v, int s, ivec3 dest)
+  CGLM_INLINE int glm_ivec3_distance2(ivec3 a, ivec3 b)
+  CGLM_INLINE float glm_ivec3_distance(ivec3 a, ivec3 b)
+  CGLM_INLINE void glm_ivec3_maxv(ivec3 a, ivec3 b, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_minv(ivec3 a, ivec3 b, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_clamp(ivec3 v, int minVal, int maxVal)
+  CGLM_INLINE void glm_ivec3_abs(ivec3 v, ivec3 dest)
+ */
+
+#ifndef cglm_ivec3_h
+#define cglm_ivec3_h
+
+#include "common.h"
+
+#define GLM_IVEC3_ONE_INIT   {1, 1, 1}
+#define GLM_IVEC3_ZERO_INIT  {0, 0, 0}
+
+#define GLM_IVEC3_ONE  ((ivec3)GLM_IVEC3_ONE_INIT)
+#define GLM_IVEC3_ZERO ((ivec3)GLM_IVEC3_ZERO_INIT)
+
+/*!
+ * @brief init ivec3 using ivec4
+ *
+ * @param[in]  v4   vector4
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_ivec3(ivec4 v4, ivec3 dest) {
+  dest[0] = v4[0];
+  dest[1] = v4[1];
+  dest[2] = v4[2];
+}
+
+/*!
+ * @brief copy all members of [a] to [dest]
+ *
+ * @param[in]  a    source vector
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_ivec3_copy(ivec3 a, ivec3 dest) {
+  dest[0] = a[0];
+  dest[1] = a[1];
+  dest[2] = a[2];
+}
+
+/*!
+ * @brief set all members of [v] to zero
+ *
+ * @param[out] v vector
+ */
+CGLM_INLINE
+void 
+glm_ivec3_zero(ivec3 v) {
+  v[0] = v[1] = v[2] = 0;
+}
+
+/*!
+ * @brief set all members of [v] to one
+ *
+ * @param[out] v vector
+ */
+CGLM_INLINE
+void
+glm_ivec3_one(ivec3 v) {
+  v[0] = v[1] = v[2] = 1;
+}
+
+/*!
+ * @brief add vector [a] to vector [b] and store result in [dest]
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_ivec3_add(ivec3 a, ivec3 b, ivec3 dest) {
+  dest[0] = a[0] + b[0];
+  dest[1] = a[1] + b[1];
+  dest[2] = a[2] + b[2];
+}
+
+/*!
+ * @brief add scalar s to vector [v] and store result in [dest]
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_ivec3_adds(ivec3 v, int s, ivec3 dest) {
+  dest[0] = v[0] + s;
+  dest[1] = v[1] + s;
+  dest[2] = v[2] + s;
+}
+
+/*!
+ * @brief subtract vector [b] from vector [a] and store result in [dest]
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_ivec3_sub(ivec3 a, ivec3 b, ivec3 dest) {
+  dest[0] = a[0] - b[0];
+  dest[1] = a[1] - b[1];
+  dest[2] = a[2] - b[2];
+}
+
+/*!
+ * @brief subtract scalar s from vector [v] and store result in [dest]
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_ivec3_subs(ivec3 v, int s, ivec3 dest) {
+  dest[0] = v[0] - s;
+  dest[1] = v[1] - s;
+  dest[2] = v[2] - s;
+}
+
+/*!
+ * @brief multiply vector [a] with vector [b] and store result in [dest]
+ *
+ * @param[in]  a    frist vector
+ * @param[in]  b    second vector
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_ivec3_mul(ivec3 a, ivec3 b, ivec3 dest) {
+  dest[0] = a[0] * b[0];
+  dest[1] = a[1] * b[1];
+  dest[2] = a[2] * b[2];
+}
+
+/*!
+ * @brief multiply vector [a] with scalar s and store result in [dest]
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_ivec3_scale(ivec3 v, int s, ivec3 dest) {
+  dest[0] = v[0] * s;
+  dest[1] = v[1] * s;
+  dest[2] = v[2] * s;
+}
+
+/*!
+ * @brief squared distance between two vectors
+ *
+ * @param[in] a first vector
+ * @param[in] b second vector
+ * @return returns squared distance (distance * distance)
+ */
+CGLM_INLINE
+int
+glm_ivec3_distance2(ivec3 a, ivec3 b) {
+  int xd, yd, zd;
+  xd = a[0] - b[0];
+  yd = a[1] - b[1];
+  zd = a[2] - b[2];
+  return xd * xd + yd * yd + zd * zd;
+}
+
+/*!
+ * @brief distance between two vectors
+ *
+ * @param[in] a first vector
+ * @param[in] b second vector
+ * @return returns distance
+ */
+CGLM_INLINE
+float
+glm_ivec3_distance(ivec3 a, ivec3 b) {
+  return sqrtf((float)glm_ivec3_distance2(a, b));
+}
+
+/*!
+ * @brief set each member of dest to greater of vector a and b
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_ivec3_maxv(ivec3 a, ivec3 b, ivec3 dest) {
+  dest[0] = a[0] > b[0] ? a[0] : b[0];
+  dest[1] = a[1] > b[1] ? a[1] : b[1];
+  dest[2] = a[2] > b[2] ? a[2] : b[2];
+}
+
+/*!
+ * @brief set each member of dest to lesser of vector a and b
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_ivec3_minv(ivec3 a, ivec3 b, ivec3 dest) {
+  dest[0] = a[0] < b[0] ? a[0] : b[0];
+  dest[1] = a[1] < b[1] ? a[1] : b[1];
+  dest[2] = a[2] < b[2] ? a[2] : b[2];
+}
+
+/*!
+ * @brief clamp each member of [v] between minVal and maxVal (inclusive)
+ *
+ * @param[in, out] v      vector
+ * @param[in]      minVal minimum value
+ * @param[in]      maxVal maximum value
+ */
+CGLM_INLINE
+void
+glm_ivec3_clamp(ivec3 v, int minVal, int maxVal) {
+  if (v[0] < minVal)
+    v[0] = minVal;
+  else if(v[0] > maxVal)
+    v[0] = maxVal;
+
+  if (v[1] < minVal)
+    v[1] = minVal;
+  else if(v[1] > maxVal)
+    v[1] = maxVal;
+
+  if (v[2] < minVal)
+    v[2] = minVal;
+  else if(v[2] > maxVal)
+    v[2] = maxVal;
+}
+
+/*!
+ * @brief absolute value of v
+ *
+ * @param[in]	v	vector
+ * @param[out]	dest	destination
+ */
+CGLM_INLINE
+void
+glm_ivec3_abs(ivec3 v, ivec3 dest) {
+  dest[0] = abs(v[0]);
+  dest[1] = abs(v[1]);
+  dest[2] = abs(v[2]);
+}
+
+#endif /* cglm_ivec3_h */

include/cglm/ivec4.h

@@ -0,0 +1,303 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   GLM_IVEC4_ONE_INIT
+   GLM_IVEC4_ZERO_INIT
+   GLM_IVEC4_ONE
+   GLM_IVEC4_ZERO
+
+ Functions:
+  CGLM_INLINE void glm_ivec4(ivec3 v3, int last, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_copy(ivec4 a, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_zero(ivec4 v)
+  CGLM_INLINE void glm_ivec4_one(ivec4 v)
+  CGLM_INLINE void glm_ivec4_add(ivec4 a, ivec4 b, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_adds(ivec4 v, int s, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_sub(ivec4 a, ivec4 b, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_subs(ivec4 v, int s, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_mul(ivec4 a, ivec4 b, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_scale(ivec4 v, int s, ivec4 dest)
+  CGLM_INLINE int glm_ivec4_distance2(ivec4 a, ivec4 b)
+  CGLM_INLINE float glm_ivec4_distance(ivec4 a, ivec4 b)
+  CGLM_INLINE void glm_ivec4_maxv(ivec4 a, ivec4 b, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_minv(ivec4 a, ivec4 b, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_clamp(ivec4 v, int minVal, int maxVal)
+  CGLM_INLINE void glm_ivec4_abs(ivec4 v, ivec4 dest)
+ */
+
+#ifndef cglm_ivec4_h
+#define cglm_ivec4_h
+
+#include "common.h"
+
+#define GLM_IVEC4_ONE_INIT   {1, 1, 1, 1}
+#define GLM_IVEC4_ZERO_INIT  {0, 0, 0, 0}
+
+#define GLM_IVEC4_ONE  ((ivec4)GLM_IVEC4_ONE_INIT)
+#define GLM_IVEC4_ZERO ((ivec4)GLM_IVEC4_ZERO_INIT)
+
+/*!
+ * @brief init ivec4 using ivec3
+ *
+ * @param[in]  v3   vector3
+ * @param[in]  last last item
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_ivec4(ivec3 v3, int last, ivec4 dest) {
+  dest[0] = v3[0];
+  dest[1] = v3[1];
+  dest[2] = v3[2];
+  dest[3] = last;
+}
+
+/*!
+ * @brief copy all members of [a] to [dest]
+ *
+ * @param[in]  a    source vector
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_ivec4_copy(ivec4 a, ivec4 dest) {
+  dest[0] = a[0];
+  dest[1] = a[1];
+  dest[2] = a[2];
+  dest[3] = a[3];
+}
+
+/*!
+ * @brief set all members of [v] to zero
+ *
+ * @param[out] v vector
+ */
+CGLM_INLINE
+void 
+glm_ivec4_zero(ivec4 v) {
+  v[0] = v[1] = v[2] = v[3] = 0;
+}
+
+/*!
+ * @brief set all members of [v] to one
+ *
+ * @param[out] v vector
+ */
+CGLM_INLINE
+void
+glm_ivec4_one(ivec4 v) {
+  v[0] = v[1] = v[2] = v[3] = 1;
+}
+
+/*!
+ * @brief add vector [a] to vector [b] and store result in [dest]
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_ivec4_add(ivec4 a, ivec4 b, ivec4 dest) {
+  dest[0] = a[0] + b[0];
+  dest[1] = a[1] + b[1];
+  dest[2] = a[2] + b[2];
+  dest[3] = a[3] + b[3];
+}
+
+/*!
+ * @brief add scalar s to vector [v] and store result in [dest]
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_ivec4_adds(ivec4 v, int s, ivec4 dest) {
+  dest[0] = v[0] + s;
+  dest[1] = v[1] + s;
+  dest[2] = v[2] + s;
+  dest[3] = v[3] + s;
+}
+
+/*!
+ * @brief subtract vector [b] from vector [a] and store result in [dest]
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_ivec4_sub(ivec4 a, ivec4 b, ivec4 dest) {
+  dest[0] = a[0] - b[0];
+  dest[1] = a[1] - b[1];
+  dest[2] = a[2] - b[2];
+  dest[3] = a[3] - b[3];
+}
+
+/*!
+ * @brief subtract scalar s from vector [v] and store result in [dest]
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_ivec4_subs(ivec4 v, int s, ivec4 dest) {
+  dest[0] = v[0] - s;
+  dest[1] = v[1] - s;
+  dest[2] = v[2] - s;
+  dest[3] = v[3] - s;
+}
+
+/*!
+ * @brief multiply vector [a] with vector [b] and store result in [dest]
+ *
+ * @param[in]  a    frist vector
+ * @param[in]  b    second vector
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_ivec4_mul(ivec4 a, ivec4 b, ivec4 dest) {
+  dest[0] = a[0] * b[0];
+  dest[1] = a[1] * b[1];
+  dest[2] = a[2] * b[2];
+  dest[3] = a[3] * b[3];
+}
+
+/*!
+ * @brief multiply vector [a] with scalar s and store result in [dest]
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_ivec4_scale(ivec4 v, int s, ivec4 dest) {
+  dest[0] = v[0] * s;
+  dest[1] = v[1] * s;
+  dest[2] = v[2] * s;
+  dest[3] = v[3] * s;
+}
+
+/*!
+ * @brief squared distance between two vectors
+ *
+ * @param[in] a first vector
+ * @param[in] b second vector
+ * @return returns squared distance (distance * distance)
+ */
+CGLM_INLINE
+int
+glm_ivec4_distance2(ivec4 a, ivec4 b) {
+  int xd, yd, zd, wd;
+  xd = a[0] - b[0];
+  yd = a[1] - b[1];
+  zd = a[2] - b[2];
+  wd = a[3] - b[3];
+  return xd * xd + yd * yd + zd * zd + wd * wd;
+}
+
+/*!
+ * @brief distance between two vectors
+ *
+ * @param[in] a first vector
+ * @param[in] b second vector
+ * @return returns distance
+ */
+CGLM_INLINE
+float
+glm_ivec4_distance(ivec4 a, ivec4 b) {
+  return sqrtf((float)glm_ivec4_distance2(a, b));
+}
+
+/*!
+ * @brief set each member of dest to greater of vector a and b
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_ivec4_maxv(ivec4 a, ivec4 b, ivec4 dest) {
+  dest[0] = a[0] > b[0] ? a[0] : b[0];
+  dest[1] = a[1] > b[1] ? a[1] : b[1];
+  dest[2] = a[2] > b[2] ? a[2] : b[2];
+  dest[3] = a[3] > b[3] ? a[3] : b[3];
+}
+
+/*!
+ * @brief set each member of dest to lesser of vector a and b
+ *
+ * @param[in]  a    first vector
+ * @param[in]  b    second vector
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_ivec4_minv(ivec4 a, ivec4 b, ivec4 dest) {
+  dest[0] = a[0] < b[0] ? a[0] : b[0];
+  dest[1] = a[1] < b[1] ? a[1] : b[1];
+  dest[2] = a[2] < b[2] ? a[2] : b[2];
+  dest[3] = a[3] < b[3] ? a[3] : b[3];
+}
+
+/*!
+ * @brief clamp each member of [v] between minVal and maxVal (inclusive)
+ *
+ * @param[in, out] v      vector
+ * @param[in]      minVal minimum value
+ * @param[in]      maxVal maximum value
+ */
+CGLM_INLINE
+void
+glm_ivec4_clamp(ivec4 v, int minVal, int maxVal) {
+  if (v[0] < minVal)
+    v[0] = minVal;
+  else if(v[0] > maxVal)
+    v[0] = maxVal;
+
+  if (v[1] < minVal)
+    v[1] = minVal;
+  else if(v[1] > maxVal)
+    v[1] = maxVal;
+
+  if (v[2] < minVal)
+    v[2] = minVal;
+  else if(v[2] > maxVal)
+    v[2] = maxVal;
+
+  if (v[3] < minVal)
+    v[3] = minVal;
+  else if(v[3] > maxVal)
+    v[3] = maxVal;
+}
+
+/*!
+ * @brief absolute value of v
+ *
+ * @param[in]	v	vector
+ * @param[out]	dest	destination
+ */
+CGLM_INLINE
+void
+glm_ivec4_abs(ivec4 v, ivec4 dest) {
+  dest[0] = abs(v[0]);
+  dest[1] = abs(v[1]);
+  dest[2] = abs(v[2]);
+  dest[3] = abs(v[3]);
+}
+
+#endif /* cglm_ivec4_h */

include/cglm/mat2.h

@@ -44,6 +44,10 @@
 #  include "simd/neon/mat2.h"
 #endif
 
+#ifdef CGLM_SIMD_WASM
+#  include "simd/wasm/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}}
 
@@ -132,7 +136,9 @@ glm_mat2_zero(mat2 mat) {
 CGLM_INLINE
 void
 glm_mat2_mul(mat2 m1, mat2 m2, mat2 dest) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glm_mat2_mul_wasm(m1, m2, dest);
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glm_mat2_mul_sse2(m1, m2, dest);
 #elif defined(CGLM_NEON_FP)
   glm_mat2_mul_neon(m1, m2, dest);
@@ -160,7 +166,9 @@ glm_mat2_mul(mat2 m1, mat2 m2, mat2 dest) {
 CGLM_INLINE
 void
 glm_mat2_transpose_to(mat2 m, mat2 dest) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glm_mat2_transp_wasm(m, dest);
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glm_mat2_transp_sse2(m, dest);
 #else
   dest[0][0] = m[0][0];
@@ -222,7 +230,10 @@ glm_mat2_trace(mat2 m) {
 CGLM_INLINE
 void
 glm_mat2_scale(mat2 m, float s) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glmm_store(m[0], wasm_f32x4_mul(wasm_v128_load(m[0]),
+                                  wasm_f32x4_splat(s)));
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(m[0], _mm_mul_ps(_mm_loadu_ps(m[0]), _mm_set1_ps(s)));
 #elif defined(CGLM_NEON_FP)
   vst1q_f32(m[0], vmulq_f32(vld1q_f32(m[0]), vdupq_n_f32(s)));

include/cglm/mat3.h

@@ -42,6 +42,10 @@
 #  include "simd/sse2/mat3.h"
 #endif
 
+#ifdef CGLM_SIMD_WASM
+#  include "simd/wasm/mat3.h"
+#endif
+
 #define GLM_MAT3_IDENTITY_INIT  {{1.0f, 0.0f, 0.0f},                          \
                                  {0.0f, 1.0f, 0.0f},                          \
                                  {0.0f, 0.0f, 1.0f}}
@@ -148,7 +152,9 @@ glm_mat3_zero(mat3 mat) {
 CGLM_INLINE
 void
 glm_mat3_mul(mat3 m1, mat3 m2, mat3 dest) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glm_mat3_mul_wasm(m1, m2, dest);
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glm_mat3_mul_sse2(m1, m2, dest);
 #else
   float a00 = m1[0][0], a01 = m1[0][1], a02 = m1[0][2],

include/cglm/mat4.h

@@ -29,7 +29,7 @@
    CGLM_INLINE void  glm_mat4_mul(mat4 m1, mat4 m2, mat4 dest);
    CGLM_INLINE void  glm_mat4_mulN(mat4 *matrices[], int len, mat4 dest);
    CGLM_INLINE void  glm_mat4_mulv(mat4 m, vec4 v, vec4 dest);
-   CGLM_INLINE void  glm_mat4_mulv3(mat4 m, vec3 v, vec3 dest);
+   CGLM_INLINE void  glm_mat4_mulv3(mat4 m, vec3 v, float last, 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) ;
@@ -64,6 +64,10 @@
 #  include "simd/neon/mat4.h"
 #endif
 
+#ifdef CGLM_SIMD_WASM
+#  include "simd/wasm/mat4.h"
+#endif
+
 #ifdef DEBUG
 # include <assert.h>
 #endif
@@ -121,7 +125,12 @@ glm_mat4_ucopy(mat4 mat, mat4 dest) {
 CGLM_INLINE
 void
 glm_mat4_copy(mat4 mat, mat4 dest) {
-#ifdef __AVX__
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glmm_store(dest[0], glmm_load(mat[0]));
+  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(__AVX__)
   glmm_store256(dest[0], glmm_load256(mat[0]));
   glmm_store256(dest[2], glmm_load256(mat[2]));
 #elif defined( __SSE__ ) || defined( __SSE2__ )
@@ -187,7 +196,14 @@ glm_mat4_identity_array(mat4 * __restrict mat, size_t count) {
 CGLM_INLINE
 void
 glm_mat4_zero(mat4 mat) {
-#ifdef __AVX__
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glmm_128 x0;
+  x0 = wasm_f32x4_const_splat(0.f);
+  glmm_store(mat[0], x0);
+  glmm_store(mat[1], x0);
+  glmm_store(mat[2], x0);
+  glmm_store(mat[3], x0);
+#elif defined(__AVX__)
   __m256 y0;
   y0 = _mm256_setzero_ps();
   glmm_store256(mat[0], y0);
@@ -297,7 +313,9 @@ glm_mat4_ins3(mat3 mat, mat4 dest) {
 CGLM_INLINE
 void
 glm_mat4_mul(mat4 m1, mat4 m2, mat4 dest) {
-#ifdef __AVX__
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glm_mat4_mul_wasm(m1, m2, dest);
+#elif defined(__AVX__)
   glm_mat4_mul_avx(m1, m2, dest);
 #elif defined( __SSE__ ) || defined( __SSE2__ )
   glm_mat4_mul_sse2(m1, m2, dest);
@@ -377,7 +395,9 @@ glm_mat4_mulN(mat4 * __restrict matrices[], uint32_t len, mat4 dest) {
 CGLM_INLINE
 void
 glm_mat4_mulv(mat4 m, vec4 v, vec4 dest) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glm_mat4_mulv_wasm(m, v, dest);
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glm_mat4_mulv_sse2(m, v, dest);
 #elif defined(CGLM_NEON_FP)
   glm_mat4_mulv_neon(m, v, dest);
@@ -497,7 +517,9 @@ glm_mat4_mulv3(mat4 m, vec3 v, float last, vec3 dest) {
 CGLM_INLINE
 void
 glm_mat4_transpose_to(mat4 m, mat4 dest) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glm_mat4_transp_wasm(m, dest);
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glm_mat4_transp_sse2(m, dest);
 #elif defined(CGLM_NEON_FP)
   glm_mat4_transp_neon(m, dest);
@@ -521,7 +543,9 @@ glm_mat4_transpose_to(mat4 m, mat4 dest) {
 CGLM_INLINE
 void
 glm_mat4_transpose(mat4 m) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glm_mat4_transp_wasm(m, m);
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glm_mat4_transp_sse2(m, m);
 #elif defined(CGLM_NEON_FP)
   glm_mat4_transp_neon(m, m);
@@ -560,7 +584,9 @@ glm_mat4_scale_p(mat4 m, float s) {
 CGLM_INLINE
 void
 glm_mat4_scale(mat4 m, float s) {
-#ifdef __AVX__
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glm_mat4_scale_wasm(m, s);
+#elif defined(__AVX__)
   glm_mat4_scale_avx(m, s);
 #elif defined( __SSE__ ) || defined( __SSE2__ )
   glm_mat4_scale_sse2(m, s);
@@ -581,7 +607,9 @@ glm_mat4_scale(mat4 m, float s) {
 CGLM_INLINE
 float
 glm_mat4_det(mat4 mat) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  return glm_mat4_det_wasm(mat);
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   return glm_mat4_det_sse2(mat);
 #elif defined(CGLM_NEON_FP)
   return glm_mat4_det_neon(mat);
@@ -679,7 +707,9 @@ glm_mat4_inv(mat4 mat, mat4 dest) {
 CGLM_INLINE
 void
 glm_mat4_inv_fast(mat4 mat, mat4 dest) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glm_mat4_inv_fast_wasm(mat, dest);
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glm_mat4_inv_fast_sse2(mat, dest);
 #else
   glm_mat4_inv(mat, dest);

include/cglm/project.h

@@ -114,6 +114,28 @@ glm_project(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
 #endif
 }
 
+/*!
+ * @brief map object's z coordinate to window coordinates
+ *
+ * Computing MVP:
+ *   glm_mat4_mul(proj, view, viewProj);
+ *   glm_mat4_mul(viewProj, model, MVP);
+ *
+ * @param[in]  v  object coordinates
+ * @param[in]  m  MVP matrix
+ *
+ * @returns projected z coordinate
+ */
+CGLM_INLINE
+float
+glm_project_z(vec3 v, mat4 m) {
+#if CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_ZO_BIT
+  return glm_project_z_zo(v, m);
+#elif CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_NO_BIT
+  return glm_project_z_no(v, m);
+#endif
+}
+
 /*!
  * @brief define a picking region
  *
@@ -124,7 +146,7 @@ glm_project(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_pickmatrix(vec3 center, vec2 size, vec4 vp, mat4 dest) {
+glm_pickmatrix(vec2 center, vec2 size, vec4 vp, mat4 dest) {
   mat4 res;
   vec3 v;
 

include/cglm/quat.h

@@ -70,6 +70,10 @@
 #  include "simd/neon/quat.h"
 #endif
 
+#ifdef CGLM_SIMD_WASM
+#  include "simd/wasm/quat.h"
+#endif
+
 CGLM_INLINE void glm_quat_normalize(versor q);
 
 /*
@@ -238,7 +242,22 @@ glm_quat_norm(versor q) {
 CGLM_INLINE
 void
 glm_quat_normalize_to(versor q, versor dest) {
-#if defined( __SSE2__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glmm_128 xdot, x0;
+  float  dot;
+
+  x0   = glmm_load(q);
+  xdot = glmm_vdot(x0, x0);
+  /* dot  = _mm_cvtss_f32(xdot); */
+  dot  = wasm_f32x4_extract_lane(xdot, 0);
+
+  if (dot <= 0.0f) {
+    glm_quat_identity(dest);
+    return;
+  }
+
+  glmm_store(dest, wasm_f32x4_div(x0, wasm_f32x4_sqrt(xdot)));
+#elif defined( __SSE2__ ) || defined( __SSE2__ )
   __m128 xdot, x0;
   float  dot;
 
@@ -438,7 +457,9 @@ glm_quat_mul(versor p, versor q, versor dest) {
     + (a1 d2 + b1 c2 − c1 b2 + d1 a2)k
        a1 a2 − b1 b2 − c1 c2 − d1 d2
    */
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glm_quat_mul_wasm(p, q, dest);
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glm_quat_mul_sse2(p, q, dest);
 #elif defined(CGLM_NEON_FP)
   glm_quat_mul_neon(p, q, dest);

include/cglm/simd/arm.h

@@ -12,6 +12,8 @@
 
 #if defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || defined(__aarch64__)
 # define CGLM_ARM64 1
+#else
+# define CGLM_ARM64 0
 #endif
 
 #define glmm_load(p)      vld1q_f32(p)
@@ -38,6 +40,22 @@
 #define glmm_combine_lh(x, y) vcombine_f32(vget_low_f32(x),  vget_high_f32(y))
 #define glmm_combine_hh(x, y) vcombine_f32(vget_high_f32(x), vget_high_f32(y))
 
+#if defined(_WIN32) && defined(_MSC_VER)
+/* #  define glmm_float32x4_init(x, y, z, w) { .n128_f32 = { x, y, z, w } } */
+CGLM_INLINE
+float32x4_t
+glmm_float32x4_init(float x, float y, float z, float w) {
+  CGLM_ALIGN(16) float v[4] = {x, y, z, w};
+  return vld1q_f32(v);
+}
+#else
+#  define glmm_float32x4_init(x, y, z, w) { x, y, z, w }
+#endif
+
+#define glmm_float32x4_SIGNMASK_PNPN glmm_float32x4_init( 0.f, -0.f,  0.f, -0.f)
+#define glmm_float32x4_SIGNMASK_NPNP glmm_float32x4_init(-0.f,  0.f, -0.f,  0.f)
+#define glmm_float32x4_SIGNMASK_NPPN glmm_float32x4_init(-0.f,  0.f,  0.f, -0.f)
+
 static inline
 float32x4_t
 glmm_abs(float32x4_t v) {

include/cglm/simd/intrin.h

@@ -17,7 +17,7 @@
 #    ifndef __SSE__
 #      define __SSE__
 #    endif
-#  endif
+#endif
 /* do not use alignment for older visual studio versions */
 #  if _MSC_VER < 1913     /* Visual Studio 2017 version 15.6 */
 #    define CGLM_ALL_UNALIGNED
@@ -63,23 +63,56 @@
 #endif
 
 /* ARM Neon */
-#if defined(__ARM_NEON)
-#  include <arm_neon.h>
-#  if defined(__ARM_NEON_FP)
-#    define CGLM_NEON_FP 1
+#if defined(_WIN32)
+/* TODO: non-ARM stuff already inported, will this be better option */
+/* #  include <intrin.h> */
+
+#  if defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC)
+#    include <arm64intr.h>
+#    include <arm64_neon.h>
+#    ifndef CGLM_NEON_FP
+#      define CGLM_NEON_FP  1
+#    endif
+#    ifndef CGLM_SIMD_ARM
+#      define CGLM_SIMD_ARM
+#    endif
+#  elif defined(_M_ARM)
+#    include <armintr.h>
+#    include <arm_neon.h>
+#    ifndef CGLM_NEON_FP
+#      define CGLM_NEON_FP 1
+#    endif
+#    ifndef CGLM_SIMD_ARM
+#      define CGLM_SIMD_ARM
+#    endif
+#  endif
+
+#else /* non-windows */
+#  if defined(__ARM_NEON) || defined(__ARM_NEON__)
+#    include <arm_neon.h>
+#    if defined(__ARM_NEON_FP)
+#      define CGLM_NEON_FP 1
+#    endif
 #    ifndef CGLM_SIMD_ARM
 #      define CGLM_SIMD_ARM
 #    endif
 #  endif
 #endif
 
-#if defined(CGLM_SIMD_x86) || defined(CGLM_NEON_FP)
+/* WebAssembly */
+#if defined(__wasm__) && defined(__wasm_simd128__)
+#  ifndef CGLM_SIMD_WASM
+#    define CGLM_SIMD_WASM
+#  endif
+#endif
+
+#if defined(CGLM_SIMD_x86) || defined(CGLM_SIMD_ARM) || defined(CGLM_SIMD_WASM)
 #  ifndef CGLM_SIMD
 #    define CGLM_SIMD
 #  endif
 #endif
 
-#if defined(CGLM_SIMD_x86)
+#if defined(CGLM_SIMD_x86) && !defined(CGLM_SIMD_WASM)
 #  include "x86.h"
 #endif
 
@@ -87,4 +120,8 @@
 #  include "arm.h"
 #endif
 
+#if defined(CGLM_SIMD_WASM)
+#  include "wasm.h"
+#endif
+
 #endif /* cglm_intrin_h */

include/cglm/simd/neon/affine.h

@@ -7,7 +7,7 @@
 
 #ifndef cglm_affine_neon_h
 #define cglm_affine_neon_h
-#if defined(__ARM_NEON_FP)
+#if defined(CGLM_NEON_FP)
 
 #include "../../common.h"
 #include "../intrin.h"
@@ -86,13 +86,12 @@ CGLM_INLINE
 void
 glm_inv_tr_neon(mat4 mat) {
   float32x4x4_t vmat;
-  glmm_128      r0, r1, r2, r3, x0;
+  glmm_128      r0, r1, r2, x0;
 
   vmat = vld4q_f32(mat[0]);
   r0   = vmat.val[0];
   r1   = vmat.val[1];
   r2   = vmat.val[2];
-  r3   = vmat.val[3];
 
   x0 = glmm_fmadd(r0, glmm_splat_w(r0),
                   glmm_fmadd(r1, glmm_splat_w(r1),

include/cglm/simd/neon/mat2.h

@@ -7,7 +7,7 @@
 
 #ifndef cglm_mat2_neon_h
 #define cglm_mat2_neon_h
-#if defined(__ARM_NEON_FP)
+#if defined(CGLM_NEON_FP)
 
 #include "../../common.h"
 #include "../intrin.h"

include/cglm/simd/neon/mat4.h

@@ -7,7 +7,7 @@
 
 #ifndef cglm_mat4_neon_h
 #define cglm_mat4_neon_h
-#if defined(__ARM_NEON_FP)
+#if defined(CGLM_NEON_FP)
 
 #include "../../common.h"
 #include "../intrin.h"
@@ -108,7 +108,7 @@ glm_mat4_det_neon(mat4 mat) {
   float32x4_t   r0, r1, r2, r3, x0, x1, x2;
   float32x2_t   ij, op, mn, kl, nn, mm, jj, ii, gh, ef, t12, t34;
   float32x4x2_t a1;
-  float32x4_t   x3 = { 0.f, -0.f, 0.f, -0.f };
+  float32x4_t   x3 = glmm_float32x4_SIGNMASK_PNPN;
 
   /* 127 <- 0, [square] det(A) = det(At) */
   r0 = glmm_load(mat[0]);              /* d c b a */
@@ -181,7 +181,7 @@ glm_mat4_inv_neon(mat4 mat, mat4 dest) {
                 x0, x1, x2, x3, x4, x5, x6, x7, x8;
   float32x4x2_t a1;
   float32x2_t   lp, ko, hg, jn, im, fe, ae, bf, cg, dh;
-  float32x4_t   x9 = { -0.f, 0.f, -0.f, 0.f };
+  float32x4_t   x9 = glmm_float32x4_SIGNMASK_NPNP;
 
   x8 = vrev64q_f32(x9);
 

include/cglm/simd/neon/quat.h

@@ -7,7 +7,7 @@
 
 #ifndef cglm_quat_neon_h
 #define cglm_quat_neon_h
-#if defined(__ARM_NEON_FP)
+#if defined(CGLM_NEON_FP)
 
 #include "../../common.h"
 #include "../intrin.h"
@@ -23,7 +23,8 @@ glm_quat_mul_neon(versor p, versor q, versor dest) {
    */
 
   glmm_128 xp, xq, xqr, r, x, y, z, s2, s3;
-  glmm_128 s1 = {-0.f, 0.f, 0.f, -0.f};
+  glmm_128 s1 = glmm_float32x4_SIGNMASK_NPPN;
+
   float32x2_t   qh, ql;
   
   xp  = glmm_load(p); /* 3 2 1 0 */

include/cglm/simd/sse2/affine.h

@@ -98,7 +98,7 @@ glm_inv_tr_sse2(mat4 mat) {
   x2 = glmm_shuff1(r3, 0, 0, 0, 0);
   x3 = glmm_shuff1(r3, 1, 1, 1, 1);
   x4 = glmm_shuff1(r3, 2, 2, 2, 2);
-  x5 = _mm_set1_ps(-0.f);
+  x5 = glmm_float32x4_SIGNMASK_NEG;
 
   x0 = glmm_fmadd(r0, x2, glmm_fmadd(r1, x3, _mm_mul_ps(r2, x4)));
   x0 = _mm_xor_ps(x0, x5);

include/cglm/simd/sse2/mat4.h

@@ -153,7 +153,7 @@ glm_mat4_det_sse2(mat4 mat) {
                   _mm_shuffle_ps(x0, x1, _MM_SHUFFLE(2, 2, 3, 1)),
                   x2);
   
-  x2 = _mm_xor_ps(x2, _mm_set_ps(-0.f, 0.f, -0.f, 0.f));
+  x2 = _mm_xor_ps(x2, glmm_float32x4_SIGNMASK_NPNP);
   
   return glmm_hadd(_mm_mul_ps(x2, r0));
 }
@@ -166,7 +166,8 @@ glm_mat4_inv_fast_sse2(mat4 mat, mat4 dest) {
          t0, t1, t2, t3, t4, t5,
          x0, x1, x2, x3, x4, x5, x6, x7, x8, x9;
 
-  x8 = _mm_set_ps(-0.f, 0.f, -0.f, 0.f);
+  /* x8 = _mm_set_ps(-0.f, 0.f, -0.f, 0.f); */
+  x8 = glmm_float32x4_SIGNMASK_NPNP;
   x9 = glmm_shuff1(x8, 2, 1, 2, 1);
 
   /* 127 <- 0 */
@@ -302,7 +303,8 @@ glm_mat4_inv_sse2(mat4 mat, mat4 dest) {
          t0, t1, t2, t3, t4, t5,
          x0, x1, x2, x3, x4, x5, x6, x7, x8, x9;
 
-  x8 = _mm_set_ps(-0.f, 0.f, -0.f, 0.f);
+  /* x8 = _mm_set_ps(-0.f, 0.f, -0.f, 0.f); */
+  x8 = glmm_float32x4_SIGNMASK_NPNP;
   x9 = glmm_shuff1(x8, 2, 1, 2, 1);
 
   /* 127 <- 0 */

include/cglm/simd/sse2/quat.h

@@ -26,9 +26,9 @@ glm_quat_mul_sse2(versor p, versor q, versor dest) {
 
   xp = glmm_load(p); /* 3 2 1 0 */
   xq = glmm_load(q);
-  x1 = _mm_set_ps(-0.f, 0.f, -0.f, 0.f); /* TODO: _mm_set1_ss() + shuff ? */
+  x1 = glmm_float32x4_SIGNMASK_NPNP; /* TODO: _mm_set1_ss() + shuff ? */
   r  = _mm_mul_ps(glmm_splat_w(xp), xq);
-  
+
   x2 = _mm_unpackhi_ps(x1, x1);
   x3 = glmm_shuff1(x1, 3, 2, 0, 1);
   x  = glmm_splat_x(xp);

include/cglm/simd/wasm.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
+ */
+
+#ifndef cglm_simd_wasm_h
+#define cglm_simd_wasm_h
+#include "intrin.h"
+#ifdef CGLM_SIMD_WASM
+#include <wasm_simd128.h>
+
+#define glmm_load(p)      wasm_v128_load(p)
+#define glmm_store(p, a)  wasm_v128_store(p, (a))
+
+#define glmm_set1(x) wasm_f32x4_splat(x)
+#define glmm_128     v128_t
+
+#define glmm_shuff1(xmm, z, y, x, w) wasm_i32x4_shuffle(xmm, xmm, w, x, y, z)
+
+#define glmm_splat(x, lane) glmm_shuff1(x, lane, lane, lane, lane)
+
+#define glmm_splat_x(x) glmm_splat(x, 0)
+#define glmm_splat_y(x) glmm_splat(x, 1)
+#define glmm_splat_z(x) glmm_splat(x, 2)
+#define glmm_splat_w(x) glmm_splat(x, 3)
+
+#define GLMM_NEGZEROf 0x80000000 /*  0x80000000 ---> -0.0f  */
+
+/* _mm_set_ps(X, Y, Z, W); */
+#define GLMM__SIGNMASKf(X, Y, Z, W) wasm_i32x4_const(X, Y, Z, W)
+
+#define glmm_float32x4_SIGNMASK_PNPN GLMM__SIGNMASKf(0, GLMM_NEGZEROf, 0, GLMM_NEGZEROf)
+#define glmm_float32x4_SIGNMASK_NPNP GLMM__SIGNMASKf(GLMM_NEGZEROf, 0, GLMM_NEGZEROf, 0)
+#define glmm_float32x4_SIGNMASK_NPPN GLMM__SIGNMASKf(GLMM_NEGZEROf, 0, 0, GLMM_NEGZEROf)
+#define glmm_float32x4_SIGNMASK_NEG wasm_i32x4_const_splat(GLMM_NEGZEROf)
+
+static inline
+glmm_128
+glmm_abs(glmm_128 x) {
+  return wasm_f32x4_abs(x);
+}
+
+static inline
+glmm_128
+glmm_vhadd(glmm_128 v) {
+  glmm_128 x0;
+  x0 = wasm_f32x4_add(v,  glmm_shuff1(v, 0, 1, 2, 3));
+  x0 = wasm_f32x4_add(x0, glmm_shuff1(x0, 1, 0, 0, 1));
+  return x0;
+}
+
+static inline
+glmm_128
+glmm_vhadds(glmm_128 v) {
+  glmm_128 shuf, sums;
+  shuf = glmm_shuff1(v, 2, 3, 0, 1);
+  sums = wasm_f32x4_add(v, shuf);
+  /* shuf = _mm_movehl_ps(shuf, sums); */
+  shuf = wasm_i32x4_shuffle(shuf, sums, 6, 7, 2, 3);
+  sums = wasm_i32x4_shuffle(sums, wasm_f32x4_add(sums, shuf), 4, 1, 2, 3);
+  return sums;
+}
+
+static inline
+float
+glmm_hadd(glmm_128 v) {
+  return wasm_f32x4_extract_lane(glmm_vhadds(v), 0);
+}
+
+static inline
+glmm_128
+glmm_vhmin(glmm_128 v) {
+  glmm_128 x0, x1, x2;
+  x0 = glmm_shuff1(v, 2, 3, 2, 3);     /* [2, 3, 2, 3] */
+  x1 = wasm_f32x4_pmin(x0, v);   /* [0|2, 1|3, 2|2, 3|3] */
+  x2 = glmm_splat(x1, 1);              /* [1|3, 1|3, 1|3, 1|3] */
+  return wasm_f32x4_pmin(x1, x2);
+}
+
+static inline
+float
+glmm_hmin(glmm_128 v) {
+  return wasm_f32x4_extract_lane(glmm_vhmin(v), 0);
+}
+
+static inline
+glmm_128
+glmm_vhmax(glmm_128 v) {
+  glmm_128 x0, x1, x2;
+  x0 = glmm_shuff1(v, 2, 3, 2, 3);     /* [2, 3, 2, 3] */
+  x1 = wasm_f32x4_pmax(x0, v);   /* [0|2, 1|3, 2|2, 3|3] */
+  x2 = glmm_splat(x1, 1);              /* [1|3, 1|3, 1|3, 1|3] */
+  /* _mm_max_ss */
+  return wasm_i32x4_shuffle(x1, wasm_f32x4_pmax(x1, x2), 4, 1, 2, 3);
+}
+
+static inline
+float
+glmm_hmax(glmm_128 v) {
+  return wasm_f32x4_extract_lane(glmm_vhmax(v), 0);
+}
+
+static inline
+glmm_128
+glmm_vdots(glmm_128 a, glmm_128 b) {
+  return glmm_vhadds(wasm_f32x4_mul(a, b));
+}
+
+static inline
+glmm_128
+glmm_vdot(glmm_128 a, glmm_128 b) {
+  glmm_128 x0;
+  x0 = wasm_f32x4_mul(a, b);
+  x0 = wasm_f32x4_add(x0, glmm_shuff1(x0, 1, 0, 3, 2));
+  return wasm_f32x4_add(x0, glmm_shuff1(x0, 0, 1, 0, 1));
+}
+
+static inline
+float
+glmm_dot(glmm_128 a, glmm_128 b) {
+  return wasm_f32x4_extract_lane(glmm_vdots(a, b), 0);
+}
+
+static inline
+float
+glmm_norm(glmm_128 a) {
+  glmm_128 x0;
+  x0 = glmm_vhadds(wasm_f32x4_mul(a, a));
+  return wasm_f32x4_extract_lane(
+          wasm_i32x4_shuffle(x0, wasm_f32x4_sqrt(x0),4, 1, 2, 3), 0);
+}
+
+static inline
+float
+glmm_norm2(glmm_128 a) {
+  return wasm_f32x4_extract_lane(glmm_vhadds(wasm_f32x4_mul(a, a)), 0);
+}
+
+static inline
+float
+glmm_norm_one(glmm_128 a) {
+  return wasm_f32x4_extract_lane(glmm_vhadds(glmm_abs(a)), 0);
+}
+
+static inline
+float
+glmm_norm_inf(glmm_128 a) {
+  return wasm_f32x4_extract_lane(glmm_vhmax(glmm_abs(a)), 0);
+}
+
+static inline
+glmm_128
+glmm_load3(float v[3]) {
+  glmm_128 xy = wasm_v128_load64_zero(v);
+  return wasm_f32x4_replace_lane(xy, 2, v[2]);
+}
+
+static inline
+void
+glmm_store3(float v[3], glmm_128 vx) {
+  wasm_v128_store64_lane(v, vx, 0);
+  wasm_v128_store32_lane(&v[2], vx, 2);
+}
+
+static inline
+glmm_128
+glmm_div(glmm_128 a, glmm_128 b) {
+  return wasm_f32x4_div(a, b);
+}
+
+static inline
+glmm_128
+glmm_fmadd(glmm_128 a, glmm_128 b, glmm_128 c) {
+  return wasm_f32x4_add(c, wasm_f32x4_mul(a, b));
+}
+
+static inline
+glmm_128
+glmm_fnmadd(glmm_128 a, glmm_128 b, glmm_128 c) {
+  return wasm_f32x4_sub(c, wasm_f32x4_mul(a, b));
+}
+
+static inline
+glmm_128
+glmm_fmsub(glmm_128 a, glmm_128 b, glmm_128 c) {
+  return wasm_f32x4_sub(wasm_f32x4_mul(a, b), c);
+}
+
+static inline
+glmm_128
+glmm_fnmsub(glmm_128 a, glmm_128 b, glmm_128 c) {
+  return wasm_f32x4_neg(wasm_f32x4_add(wasm_f32x4_mul(a, b), c));
+}
+
+#endif
+#endif /* cglm_simd_wasm_h */

include/cglm/simd/wasm/affine.h

@@ -0,0 +1,127 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglm_affine_mat_wasm_h
+#define cglm_affine_mat_wasm_h
+#if defined(__wasm__) && defined(__wasm_simd128__)
+
+#include "../../common.h"
+#include "../intrin.h"
+
+CGLM_INLINE
+void
+glm_mul_wasm(mat4 m1, mat4 m2, mat4 dest) {
+  /* D = R * L (Column-Major) */
+  glmm_128 l, r0, r1, r2, r3, v0, v1, v2, v3;
+
+  l  = glmm_load(m1[0]);
+  r0 = glmm_load(m2[0]);
+  r1 = glmm_load(m2[1]);
+  r2 = glmm_load(m2[2]);
+  r3 = glmm_load(m2[3]);
+
+  v0 = wasm_f32x4_mul(glmm_splat_x(r0), l);
+  v1 = wasm_f32x4_mul(glmm_splat_x(r1), l);
+  v2 = wasm_f32x4_mul(glmm_splat_x(r2), l);
+  v3 = wasm_f32x4_mul(glmm_splat_x(r3), l);
+
+  l  = glmm_load(m1[1]);
+  v0 = glmm_fmadd(glmm_splat_y(r0), l, v0);
+  v1 = glmm_fmadd(glmm_splat_y(r1), l, v1);
+  v2 = glmm_fmadd(glmm_splat_y(r2), l, v2);
+  v3 = glmm_fmadd(glmm_splat_y(r3), l, v3);
+
+  l  = glmm_load(m1[2]);
+  v0 = glmm_fmadd(glmm_splat_z(r0), l, v0);
+  v1 = glmm_fmadd(glmm_splat_z(r1), l, v1);
+  v2 = glmm_fmadd(glmm_splat_z(r2), l, v2);
+  v3 = glmm_fmadd(glmm_splat_z(r3), l, v3);
+
+  l  = glmm_load(m1[3]);
+  v3 = glmm_fmadd(glmm_splat_w(r3), l, v3);
+
+  glmm_store(dest[0], v0);
+  glmm_store(dest[1], v1);
+  glmm_store(dest[2], v2);
+  glmm_store(dest[3], v3);
+}
+
+CGLM_INLINE
+void
+glm_mul_rot_wasm(mat4 m1, mat4 m2, mat4 dest) {
+  /* D = R * L (Column-Major) */
+
+  glmm_128 l, r0, r1, r2, v0, v1, v2;
+
+  l  = glmm_load(m1[0]);
+  r0 = glmm_load(m2[0]);
+  r1 = glmm_load(m2[1]);
+  r2 = glmm_load(m2[2]);
+
+  v0 = wasm_f32x4_mul(glmm_splat_x(r0), l);
+  v1 = wasm_f32x4_mul(glmm_splat_x(r1), l);
+  v2 = wasm_f32x4_mul(glmm_splat_x(r2), l);
+
+  l  = glmm_load(m1[1]);
+  v0 = glmm_fmadd(glmm_splat_y(r0), l, v0);
+  v1 = glmm_fmadd(glmm_splat_y(r1), l, v1);
+  v2 = glmm_fmadd(glmm_splat_y(r2), l, v2);
+
+  l  = glmm_load(m1[2]);
+  v0 = glmm_fmadd(glmm_splat_z(r0), l, v0);
+  v1 = glmm_fmadd(glmm_splat_z(r1), l, v1);
+  v2 = glmm_fmadd(glmm_splat_z(r2), l, v2);
+
+  glmm_store(dest[0], v0);
+  glmm_store(dest[1], v1);
+  glmm_store(dest[2], v2);
+  glmm_store(dest[3], glmm_load(m1[3]));
+}
+
+CGLM_INLINE
+void
+glm_inv_tr_wasm(mat4 mat) {
+  glmm_128 r0, r1, r2, r3, x0, x1, x2, x3, x4, x5;
+
+  r0 = glmm_load(mat[0]);
+  r1 = glmm_load(mat[1]);
+  r2 = glmm_load(mat[2]);
+  r3 = glmm_load(mat[3]);
+  x1 = wasm_f32x4_const(0.0f, 0.0f, 0.0f, 1.0f);
+
+  /* _MM_TRANSPOSE4_PS(r0, r1, r2, x1); */
+  x2 = wasm_i32x4_shuffle(r0, r1, 0, 4, 1, 5);
+  x3 = wasm_i32x4_shuffle(r0, r1, 2, 6, 3, 7);
+  x4 = wasm_i32x4_shuffle(r2, x1, 0, 4, 1, 5);
+  x5 = wasm_i32x4_shuffle(r2, x1, 2, 6, 3, 7);
+  /* r0 = _mm_movelh_ps(x2, x4); */
+  r0 = wasm_i32x4_shuffle(x2, x4, 0, 1, 4, 5);
+  /* r1 = _mm_movehl_ps(x4, x2); */
+  r1 = wasm_i32x4_shuffle(x4, x2, 6, 7, 2, 3);
+  /* r2 = _mm_movelh_ps(x3, x5); */
+  r2 = wasm_i32x4_shuffle(x3, x5, 0, 1, 4, 5);
+  /* x1 = _mm_movehl_ps(x5, x3); */
+  x1 = wasm_i32x4_shuffle(x5, x3, 6, 7, 2, 3);
+
+  x2 = glmm_shuff1(r3, 0, 0, 0, 0);
+  x3 = glmm_shuff1(r3, 1, 1, 1, 1);
+  x4 = glmm_shuff1(r3, 2, 2, 2, 2);
+
+  x0 = glmm_fmadd(r0, x2,
+                  glmm_fmadd(r1, x3, wasm_f32x4_mul(r2, x4)));
+  x0 = wasm_f32x4_neg(x0);
+
+  x0 = wasm_f32x4_add(x0, x1);
+
+  glmm_store(mat[0], r0);
+  glmm_store(mat[1], r1);
+  glmm_store(mat[2], r2);
+  glmm_store(mat[3], x0);
+}
+
+#endif
+#endif /* cglm_affine_mat_wasm_h */

include/cglm/simd/wasm/mat2.h

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglm_mat2_wasm_h
+#define cglm_mat2_wasm_h
+#if defined(__wasm__) && defined(__wasm_simd128__)
+
+#include "../../common.h"
+#include "../intrin.h"
+
+CGLM_INLINE
+void
+glm_mat2_mul_wasm(mat2 m1, mat2 m2, mat2 dest) {
+  glmm_128 x0, x1, x2, x3, x4;
+
+  x1 = glmm_load(m1[0]); /* d c b a */
+  x2 = glmm_load(m2[0]); /* h g f e */
+
+  x3 = glmm_shuff1(x2, 2, 2, 0, 0);
+  x4 = glmm_shuff1(x2, 3, 3, 1, 1);
+  /* x0 = _mm_movelh_ps(x1, x1); */
+  x0 = wasm_i32x4_shuffle(x1, x1, 0, 1, 4, 5);
+  /* x2 = _mm_movehl_ps(x1, x1); */
+  x2 = wasm_i32x4_shuffle(x1, x1, 6, 7, 2, 3);
+
+  /*
+   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 = glmm_fmadd(x0, x3, wasm_f32x4_mul(x2, x4));
+
+  glmm_store(dest[0], x0);
+}
+
+CGLM_INLINE
+void
+glm_mat2_transp_wasm(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_wasm_h */

include/cglm/simd/wasm/mat3.h

@@ -0,0 +1,85 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglm_mat3_wasm_h
+#define cglm_mat3_wasm_h
+#if defined(__wasm__) && defined(__wasm_simd128__)
+
+#include "../../common.h"
+#include "../intrin.h"
+
+CGLM_INLINE
+void
+glm_mat3_mul_wasm(mat3 m1, mat3 m2, mat3 dest) {
+  glmm_128 l0, l1, l2, r0, r1, r2, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9;
+  
+  l0 = wasm_v128_load(m1[0]);
+  l1 = wasm_v128_load(&m1[1][1]);
+
+  r0 = wasm_v128_load(m2[0]);
+  r1 = wasm_v128_load(&m2[1][1]);
+
+  x8 = glmm_shuff1(l0, 0, 2, 1, 0);                     /* a00 a02 a01 a00 */
+  x1 = glmm_shuff1(r0, 3, 0, 0, 0);                     /* b10 b00 b00 b00 */
+  x2 = wasm_i32x4_shuffle(l0, l1, 3, 3, 4, 5);          /* a12 a11 a10 a10 */
+  x3 = wasm_i32x4_shuffle(r0, r1, 1, 3, 4, 6);          /* b20 b11 b10 b01 */
+  x0 = wasm_f32x4_mul(x8, x1);
+
+  x6 = glmm_shuff1(l0, 1, 0, 2, 1);                     /* a01 a00 a02 a01 */
+  x7 = glmm_shuff1(x3, 3, 3, 1, 1);                     /* b20 b20 b10 b10 */
+  l2 = wasm_v128_load32_zero(&m1[2][2]);
+  r2 = wasm_v128_load32_zero(&m2[2][2]);
+  x1 = wasm_f32x4_mul(x6, x7);
+  l2 = glmm_shuff1(l2, 0, 0, 1, 0);                     /* a22 a22 0.f a22 */
+  r2 = glmm_shuff1(r2, 0, 0, 1, 0);                     /* b22 b22 0.f b22 */
+
+  x4 = glmm_shuff1(x2, 0, 3, 2, 0);                     /* a10 a12 a11 a10 */
+  x5 = glmm_shuff1(x2, 2, 0, 3, 2);                     /* a11 a10 a12 a11 */
+  x6 = glmm_shuff1(x3, 2, 0, 0, 0);                     /* b11 b01 b01 b01 */
+  x2 = glmm_shuff1(r1, 3, 3, 0, 0);                     /* b21 b21 b11 b11 */
+
+  /* x8 = _mm_unpackhi_ps(x8, x4); */
+  /* x9 = _mm_unpackhi_ps(x7, x2); */
+  x8 = wasm_i32x4_shuffle(x8, x4, 2, 6, 3, 7);          /* a10 a00 a12 a02 */
+  x9 = wasm_i32x4_shuffle(x7, x2, 2, 6, 3, 7);          /* b21 b20 b21 b20 */
+
+  x0 = glmm_fmadd(x4, x6, x0);
+  x1 = glmm_fmadd(x5, x2, x1);
+
+  /* x2 = _mm_movehl_ps(l2, l1); */
+  x2 = wasm_i32x4_shuffle(l2, l1, 6, 7, 2, 3);          /* a22 a22 a21 a20 */
+  x3 = glmm_shuff1(x2, 0, 2, 1, 0);                     /* a20 a22 a21 a20 */
+  x2 = glmm_shuff1(x2, 1, 0, 2, 1);                     /* a21 a20 a22 a21 */
+  x4 = wasm_i32x4_shuffle(r0, r1, 2, 2, 5, 5);          /* b12 b12 b02 b02 */
+  
+  x5 = glmm_shuff1(x4, 3, 0, 0, 0);                     /* b12 b02 b02 b02 */
+  /* x4 = _mm_movehl_ps(r2, x4); */
+  x4 = wasm_i32x4_shuffle(r2, x4, 6, 7, 2, 3);          /* b22 b22 b12 b12 */
+  x0 = glmm_fmadd(x3, x5, x0);
+  x1 = glmm_fmadd(x2, x4, x1);
+
+  /*
+   Dot Product : dest[2][2] =  a02 * b20 +
+                               a12 * b21 +
+                               a22 * b22 +
+                               0   * 00                                    */
+  /* x2 = _mm_movelh_ps(x8, l2); */
+  /* x3 = _mm_movelh_ps(x9, r2); */
+  x2 = wasm_i32x4_shuffle(x8, l2, 0, 1, 4, 5);           /* 0.f a22 a12 a02 */
+  x3 = wasm_i32x4_shuffle(x9, r2, 0, 1, 4, 5);           /* 0.f b22 b21 b20 */
+  x2 = glmm_vdots(x2, x3);
+
+  /* _mm_storeu_ps(&dest[0][0], x0); */
+  wasm_v128_store(&dest[0][0], x0);
+  /* _mm_storeu_ps(&dest[1][1], x1); */
+  wasm_v128_store(&dest[1][1], x1);
+  /* _mm_store_ss (&dest[2][2], x2); */
+  wasm_v128_store32_lane(&dest[2][2], x2, 0);
+}
+
+#endif
+#endif /* cglm_mat3_wasm_h */

include/cglm/simd/wasm/mat4.h

@@ -0,0 +1,454 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglm_mat_wasm_h
+#define cglm_mat_wasm_h
+#if defined(__wasm__) && defined(__wasm_simd128__)
+
+#include "../../common.h"
+#include "../intrin.h"
+
+#define glm_mat4_inv_precise_wasm(mat, dest) glm_mat4_inv_wasm(mat, dest)
+
+CGLM_INLINE
+void
+glm_mat4_scale_wasm(mat4 m, float s) {
+  glmm_128 x0;
+  x0 = wasm_f32x4_splat(s);
+
+  glmm_store(m[0], wasm_f32x4_mul(glmm_load(m[0]), x0));
+  glmm_store(m[1], wasm_f32x4_mul(glmm_load(m[1]), x0));
+  glmm_store(m[2], wasm_f32x4_mul(glmm_load(m[2]), x0));
+  glmm_store(m[3], wasm_f32x4_mul(glmm_load(m[3]), x0));
+}
+
+CGLM_INLINE
+void
+glm_mat4_transp_wasm(mat4 m, mat4 dest) {
+  glmm_128 r0, r1, r2, r3, tmp0, tmp1, tmp2, tmp3;
+
+  r0 = glmm_load(m[0]);
+  r1 = glmm_load(m[1]);
+  r2 = glmm_load(m[2]);
+  r3 = glmm_load(m[3]);
+
+  /* _MM_TRANSPOSE4_PS(r0, r1, r2, r3); */
+  tmp0 = wasm_i32x4_shuffle(r0, r1, 0, 4, 1, 5);
+  tmp1 = wasm_i32x4_shuffle(r0, r1, 2, 6, 3, 7);
+  tmp2 = wasm_i32x4_shuffle(r2, r3, 0, 4, 1, 5);
+  tmp3 = wasm_i32x4_shuffle(r2, r3, 2, 6, 3, 7);
+  /* r0 = _mm_movelh_ps(tmp0, tmp2); */
+  r0 = wasm_i32x4_shuffle(tmp0, tmp2, 0, 1, 4, 5);
+  /* r1 = _mm_movehl_ps(tmp2, tmp0); */
+  r1 = wasm_i32x4_shuffle(tmp2, tmp0, 6, 7, 2, 3);
+  /* r2 = _mm_movelh_ps(tmp1, tmp3); */
+  r2 = wasm_i32x4_shuffle(tmp1, tmp3, 0, 1, 4, 5);
+  /* r3 = _mm_movehl_ps(tmp3, tmp1); */
+  r3 = wasm_i32x4_shuffle(tmp3, tmp1, 6, 7, 2, 3);
+
+  glmm_store(dest[0], r0);
+  glmm_store(dest[1], r1);
+  glmm_store(dest[2], r2);
+  glmm_store(dest[3], r3);
+}
+
+CGLM_INLINE
+void
+glm_mat4_mul_wasm(mat4 m1, mat4 m2, mat4 dest) {
+  /* D = R * L (Column-Major) */
+
+  glmm_128 l, r0, r1, r2, r3, v0, v1, v2, v3;
+
+  l  = glmm_load(m1[0]);
+  r0 = glmm_load(m2[0]);
+  r1 = glmm_load(m2[1]);
+  r2 = glmm_load(m2[2]);
+  r3 = glmm_load(m2[3]);
+
+  v0 = wasm_f32x4_mul(glmm_splat_x(r0), l);
+  v1 = wasm_f32x4_mul(glmm_splat_x(r1), l);
+  v2 = wasm_f32x4_mul(glmm_splat_x(r2), l);
+  v3 = wasm_f32x4_mul(glmm_splat_x(r3), l);
+
+  l  = glmm_load(m1[1]);
+  v0 = glmm_fmadd(glmm_splat_y(r0), l, v0);
+  v1 = glmm_fmadd(glmm_splat_y(r1), l, v1);
+  v2 = glmm_fmadd(glmm_splat_y(r2), l, v2);
+  v3 = glmm_fmadd(glmm_splat_y(r3), l, v3);
+
+  l  = glmm_load(m1[2]);
+  v0 = glmm_fmadd(glmm_splat_z(r0), l, v0);
+  v1 = glmm_fmadd(glmm_splat_z(r1), l, v1);
+  v2 = glmm_fmadd(glmm_splat_z(r2), l, v2);
+  v3 = glmm_fmadd(glmm_splat_z(r3), l, v3);
+
+  l  = glmm_load(m1[3]);
+  v0 = glmm_fmadd(glmm_splat_w(r0), l, v0);
+  v1 = glmm_fmadd(glmm_splat_w(r1), l, v1);
+  v2 = glmm_fmadd(glmm_splat_w(r2), l, v2);
+  v3 = glmm_fmadd(glmm_splat_w(r3), l, v3);
+
+  glmm_store(dest[0], v0);
+  glmm_store(dest[1], v1);
+  glmm_store(dest[2], v2);
+  glmm_store(dest[3], v3);
+}
+
+CGLM_INLINE
+void
+glm_mat4_mulv_wasm(mat4 m, vec4 v, vec4 dest) {
+  glmm_128 x0, x1, m0, m1, m2, m3, v0, v1, v2, v3;
+
+  m0 = glmm_load(m[0]);
+  m1 = glmm_load(m[1]);
+  m2 = glmm_load(m[2]);
+  m3 = glmm_load(m[3]);
+
+  x0 = glmm_load(v);
+  v0 = glmm_splat_x(x0);
+  v1 = glmm_splat_y(x0);
+  v2 = glmm_splat_z(x0);
+  v3 = glmm_splat_w(x0);
+
+  x1 = wasm_f32x4_mul(m3, v3);
+  x1 = glmm_fmadd(m2, v2, x1);
+  x1 = glmm_fmadd(m1, v1, x1);
+  x1 = glmm_fmadd(m0, v0, x1);
+
+  glmm_store(dest, x1);
+}
+
+CGLM_INLINE
+float
+glm_mat4_det_wasm(mat4 mat) {
+  glmm_128 r0, r1, r2, r3, x0, x1, x2;
+
+  /* 127 <- 0, [square] det(A) = det(At) */
+  r0 = glmm_load(mat[0]); /* d c b a */
+  r1 = glmm_load(mat[1]); /* h g f e */
+  r2 = glmm_load(mat[2]); /* l k j i */
+  r3 = glmm_load(mat[3]); /* p o n m */
+
+  /*
+   t[1] = j * p - n * l;
+   t[2] = j * o - n * k;
+   t[3] = i * p - m * l;
+   t[4] = i * o - m * k;
+   */
+  x0 = glmm_fnmadd(glmm_shuff1(r3, 0, 0, 1, 1), glmm_shuff1(r2, 2, 3, 2, 3),
+                   wasm_f32x4_mul(glmm_shuff1(r2, 0, 0, 1, 1),
+                              glmm_shuff1(r3, 2, 3, 2, 3)));
+  /*
+   t[0] = k * p - o * l;
+   t[0] = k * p - o * l;
+   t[5] = i * n - m * j;
+   t[5] = i * n - m * j;
+   */
+  x1 = glmm_fnmadd(glmm_shuff1(r3, 0, 0, 2, 2), glmm_shuff1(r2, 1, 1, 3, 3),
+                   wasm_f32x4_mul(glmm_shuff1(r2, 0, 0, 2, 2),
+                              glmm_shuff1(r3, 1, 1, 3, 3)));
+
+  /*
+     a * (f * t[0] - g * t[1] + h * t[2])
+   - b * (e * t[0] - g * t[3] + h * t[4])
+   + c * (e * t[1] - f * t[3] + h * t[5])
+   - d * (e * t[2] - f * t[4] + g * t[5])
+   */
+  x2 = glmm_fnmadd(glmm_shuff1(r1, 1, 1, 2, 2), glmm_shuff1(x0, 3, 2, 2, 0),
+                   wasm_f32x4_mul(glmm_shuff1(r1, 0, 0, 0, 1),
+                              wasm_i32x4_shuffle(x1, x0, 0, 0, 4, 5)));
+  x2 = glmm_fmadd(glmm_shuff1(r1, 2, 3, 3, 3),
+                  wasm_i32x4_shuffle(x0, x1, 1, 3, 6, 6),
+                  x2);
+  /* x2 = wasm_v128_xor(x2, wasm_f32x4_const(0.f, -0.f, 0.f, -0.f)); */
+  x2 = wasm_v128_xor(x2, glmm_float32x4_SIGNMASK_PNPN);
+  
+  return glmm_hadd(wasm_f32x4_mul(x2, r0));
+}
+
+CGLM_INLINE
+void
+glm_mat4_inv_fast_wasm(mat4 mat, mat4 dest) {
+  glmm_128 r0, r1, r2, r3,
+         v0, v1, v2, v3,
+         t0, t1, t2, t3, t4, t5,
+         x0, x1, x2, x3, x4, x5, x6, x7, x8, x9;
+
+  /* x8 = wasm_f32x4_const(0.f, -0.f, 0.f, -0.f); */
+  x8 = glmm_float32x4_SIGNMASK_PNPN;
+  x9 = glmm_shuff1(x8, 2, 1, 2, 1);
+
+  /* 127 <- 0 */
+  r0 = glmm_load(mat[0]); /* d c b a */
+  r1 = glmm_load(mat[1]); /* h g f e */
+  r2 = glmm_load(mat[2]); /* l k j i */
+  r3 = glmm_load(mat[3]); /* p o n m */
+  /* x0 = _mm_movehl_ps(r3, r2); */
+  x0 = wasm_i32x4_shuffle(r3, r2, 6, 7, 2, 3);           /* p o l k */
+  /* x3 = _mm_movelh_ps(r2, r3); */
+  x3 = wasm_i32x4_shuffle(r2, r3, 0, 1, 4, 5);           /* n m j i */
+  x1 = glmm_shuff1(x0, 1, 3, 3 ,3);                      /* l p p p */
+  x2 = glmm_shuff1(x0, 0, 2, 2, 2);                      /* k o o o */
+  x4 = glmm_shuff1(x3, 1, 3, 3, 3);                      /* j n n n */
+  x7 = glmm_shuff1(x3, 0, 2, 2, 2);                      /* i m m m */
+
+  x6 = wasm_i32x4_shuffle(r2, r1, 0, 0, 4, 4);           /* e e i i */
+  x5 = wasm_i32x4_shuffle(r2, r1, 1, 1, 5, 5);           /* f f j j */
+  x3 = wasm_i32x4_shuffle(r2, r1, 2, 2, 6, 6);           /* g g k k */
+  x0 = wasm_i32x4_shuffle(r2, r1, 3, 3, 7, 7);           /* h h l l */
+  
+  t0 = wasm_f32x4_mul(x3, x1);
+  t1 = wasm_f32x4_mul(x5, x1);
+  t2 = wasm_f32x4_mul(x5, x2);
+  t3 = wasm_f32x4_mul(x6, x1);
+  t4 = wasm_f32x4_mul(x6, x2);
+  t5 = wasm_f32x4_mul(x6, x4);
+  
+  /* t1[0] = k * p - o * l;
+     t1[0] = k * p - o * l;
+     t2[0] = g * p - o * h;
+     t3[0] = g * l - k * h; */
+  t0 = glmm_fnmadd(x2, x0, t0);
+  
+  /* t1[1] = j * p - n * l;
+     t1[1] = j * p - n * l;
+     t2[1] = f * p - n * h;
+     t3[1] = f * l - j * h; */
+   t1 = glmm_fnmadd(x4, x0, t1);
+  
+  /* t1[2] = j * o - n * k
+     t1[2] = j * o - n * k;
+     t2[2] = f * o - n * g;
+     t3[2] = f * k - j * g; */
+  t2 = glmm_fnmadd(x4, x3, t2);
+  
+  /* t1[3] = i * p - m * l;
+     t1[3] = i * p - m * l;
+     t2[3] = e * p - m * h;
+     t3[3] = e * l - i * h; */
+  t3 = glmm_fnmadd(x7, x0, t3);
+  
+  /* t1[4] = i * o - m * k;
+     t1[4] = i * o - m * k;
+     t2[4] = e * o - m * g;
+     t3[4] = e * k - i * g; */
+  t4 = glmm_fnmadd(x7, x3, t4);
+  
+  /* t1[5] = i * n - m * j;
+     t1[5] = i * n - m * j;
+     t2[5] = e * n - m * f;
+     t3[5] = e * j - i * f; */
+  t5 = glmm_fnmadd(x7, x5, t5);
+  /* x4 = _mm_movelh_ps(r0, r1); */
+  x4 = wasm_i32x4_shuffle(r0, r1, 0, 1, 4, 5);           /* f e b a */
+  /* x5 = _mm_movehl_ps(r1, r0); */
+  x5 = wasm_i32x4_shuffle(r1, r0, 6, 7, 2, 3);           /* h g d c */
+  
+  x0 = glmm_shuff1(x4, 0, 0, 0, 2);                      /* a a a e */
+  x1 = glmm_shuff1(x4, 1, 1, 1, 3);                      /* b b b f */
+  x2 = glmm_shuff1(x5, 0, 0, 0, 2);                      /* c c c g */
+  x3 = glmm_shuff1(x5, 1, 1, 1, 3);                      /* d d d h */
+  
+  v2 = wasm_f32x4_mul(x0, t1);
+  v1 = wasm_f32x4_mul(x0, t0);
+  v3 = wasm_f32x4_mul(x0, t2);
+  v0 = wasm_f32x4_mul(x1, t0);
+  
+  v2 = glmm_fnmadd(x1, t3, v2);
+  v3 = glmm_fnmadd(x1, t4, v3);
+  v0 = glmm_fnmadd(x2, t1, v0);
+  v1 = glmm_fnmadd(x2, t3, v1);
+  
+  v3 = glmm_fmadd(x2, t5, v3);
+  v0 = glmm_fmadd(x3, t2, v0);
+  v2 = glmm_fmadd(x3, t5, v2);
+  v1 = glmm_fmadd(x3, t4, v1);
+
+  /*
+   dest[0][0] =  f * t1[0] - g * t1[1] + h * t1[2];
+   dest[0][1] =-(b * t1[0] - c * t1[1] + d * t1[2]);
+   dest[0][2] =  b * t2[0] - c * t2[1] + d * t2[2];
+   dest[0][3] =-(b * t3[0] - c * t3[1] + d * t3[2]); */
+  v0 = wasm_v128_xor(v0, x8);
+  
+  /*
+   dest[2][0] =  e * t1[1] - f * t1[3] + h * t1[5];
+   dest[2][1] =-(a * t1[1] - b * t1[3] + d * t1[5]);
+   dest[2][2] =  a * t2[1] - b * t2[3] + d * t2[5];
+   dest[2][3] =-(a * t3[1] - b * t3[3] + d * t3[5]);*/
+  v2 = wasm_v128_xor(v2, x8);
+
+  /*
+   dest[1][0] =-(e * t1[0] - g * t1[3] + h * t1[4]);
+   dest[1][1] =  a * t1[0] - c * t1[3] + d * t1[4];
+   dest[1][2] =-(a * t2[0] - c * t2[3] + d * t2[4]);
+   dest[1][3] =  a * t3[0] - c * t3[3] + d * t3[4]; */
+  v1 = wasm_v128_xor(v1, x9);
+
+  /*
+   dest[3][0] =-(e * t1[2] - f * t1[4] + g * t1[5]);
+   dest[3][1] =  a * t1[2] - b * t1[4] + c * t1[5];
+   dest[3][2] =-(a * t2[2] - b * t2[4] + c * t2[5]);
+   dest[3][3] =  a * t3[2] - b * t3[4] + c * t3[5]; */
+  v3 = wasm_v128_xor(v3, x9);
+
+  /* determinant */
+  x0 = wasm_i32x4_shuffle(v0, v1, 0, 0, 4, 4);
+  x1 = wasm_i32x4_shuffle(v2, v3, 0, 0, 4, 4);
+  x0 = wasm_i32x4_shuffle(x0, x1, 0, 2, 4, 6);
+
+  /* x0 = _mm_rcp_ps(glmm_vhadd(wasm_f32x4_mul(x0, r0))); */
+  x0 = wasm_f32x4_div(wasm_f32x4_const_splat(1.0f),
+                      glmm_vhadd(wasm_f32x4_mul(x0, r0)));
+
+  glmm_store(dest[0], wasm_f32x4_mul(v0, x0));
+  glmm_store(dest[1], wasm_f32x4_mul(v1, x0));
+  glmm_store(dest[2], wasm_f32x4_mul(v2, x0));
+  glmm_store(dest[3], wasm_f32x4_mul(v3, x0));
+}
+
+CGLM_INLINE
+void
+glm_mat4_inv_wasm(mat4 mat, mat4 dest) {
+  glmm_128 r0, r1, r2, r3,
+         v0, v1, v2, v3,
+         t0, t1, t2, t3, t4, t5,
+         x0, x1, x2, x3, x4, x5, x6, x7, x8, x9;
+
+  /* x8 = wasm_f32x4_const(0.f, -0.f, 0.f, -0.f); */
+  x8 = glmm_float32x4_SIGNMASK_PNPN;
+  x9 = glmm_shuff1(x8, 2, 1, 2, 1);
+
+  /* 127 <- 0 */
+  r0 = glmm_load(mat[0]); /* d c b a */
+  r1 = glmm_load(mat[1]); /* h g f e */
+  r2 = glmm_load(mat[2]); /* l k j i */
+  r3 = glmm_load(mat[3]); /* p o n m */
+  /* x0 = _mm_movehl_ps(r3, r2); */
+  x0 = wasm_i32x4_shuffle(r3, r2, 6, 7, 2, 3);           /* p o l k */
+  /* x3 = _mm_movelh_ps(r2, r3); */
+  x3 = wasm_i32x4_shuffle(r2, r3, 0, 1, 4, 5);           /* n m j i */
+  x1 = glmm_shuff1(x0, 1, 3, 3 ,3);                      /* l p p p */
+  x2 = glmm_shuff1(x0, 0, 2, 2, 2);                      /* k o o o */
+  x4 = glmm_shuff1(x3, 1, 3, 3, 3);                      /* j n n n */
+  x7 = glmm_shuff1(x3, 0, 2, 2, 2);                      /* i m m m */
+
+  x6 = wasm_i32x4_shuffle(r2, r1, 0, 0, 4, 4);           /* e e i i */
+  x5 = wasm_i32x4_shuffle(r2, r1, 1, 1, 5, 5);           /* f f j j */
+  x3 = wasm_i32x4_shuffle(r2, r1, 2, 2, 6, 6);           /* g g k k */
+  x0 = wasm_i32x4_shuffle(r2, r1, 3, 3, 7, 7);           /* h h l l */
+  
+  t0 = wasm_f32x4_mul(x3, x1);
+  t1 = wasm_f32x4_mul(x5, x1);
+  t2 = wasm_f32x4_mul(x5, x2);
+  t3 = wasm_f32x4_mul(x6, x1);
+  t4 = wasm_f32x4_mul(x6, x2);
+  t5 = wasm_f32x4_mul(x6, x4);
+  
+  /* t1[0] = k * p - o * l;
+     t1[0] = k * p - o * l;
+     t2[0] = g * p - o * h;
+     t3[0] = g * l - k * h; */
+  t0 = glmm_fnmadd(x2, x0, t0);
+  
+  /* t1[1] = j * p - n * l;
+     t1[1] = j * p - n * l;
+     t2[1] = f * p - n * h;
+     t3[1] = f * l - j * h; */
+   t1 = glmm_fnmadd(x4, x0, t1);
+  
+  /* t1[2] = j * o - n * k
+     t1[2] = j * o - n * k;
+     t2[2] = f * o - n * g;
+     t3[2] = f * k - j * g; */
+  t2 = glmm_fnmadd(x4, x3, t2);
+  
+  /* t1[3] = i * p - m * l;
+     t1[3] = i * p - m * l;
+     t2[3] = e * p - m * h;
+     t3[3] = e * l - i * h; */
+  t3 = glmm_fnmadd(x7, x0, t3);
+  
+  /* t1[4] = i * o - m * k;
+     t1[4] = i * o - m * k;
+     t2[4] = e * o - m * g;
+     t3[4] = e * k - i * g; */
+  t4 = glmm_fnmadd(x7, x3, t4);
+  
+  /* t1[5] = i * n - m * j;
+     t1[5] = i * n - m * j;
+     t2[5] = e * n - m * f;
+     t3[5] = e * j - i * f; */
+  t5 = glmm_fnmadd(x7, x5, t5);
+  /* x4 = _mm_movelh_ps(r0, r1); */
+  x4 = wasm_i32x4_shuffle(r0, r1, 0, 1, 4, 5);           /* f e b a */
+  /* x5 = _mm_movehl_ps(r1, r0); */
+  x5 = wasm_i32x4_shuffle(r1, r0, 6, 7, 2, 3);           /* h g d c */
+  
+  x0 = glmm_shuff1(x4, 0, 0, 0, 2);                      /* a a a e */
+  x1 = glmm_shuff1(x4, 1, 1, 1, 3);                      /* b b b f */
+  x2 = glmm_shuff1(x5, 0, 0, 0, 2);                      /* c c c g */
+  x3 = glmm_shuff1(x5, 1, 1, 1, 3);                      /* d d d h */
+  
+  v2 = wasm_f32x4_mul(x0, t1);
+  v1 = wasm_f32x4_mul(x0, t0);
+  v3 = wasm_f32x4_mul(x0, t2);
+  v0 = wasm_f32x4_mul(x1, t0);
+  
+  v2 = glmm_fnmadd(x1, t3, v2);
+  v3 = glmm_fnmadd(x1, t4, v3);
+  v0 = glmm_fnmadd(x2, t1, v0);
+  v1 = glmm_fnmadd(x2, t3, v1);
+  
+  v3 = glmm_fmadd(x2, t5, v3);
+  v0 = glmm_fmadd(x3, t2, v0);
+  v2 = glmm_fmadd(x3, t5, v2);
+  v1 = glmm_fmadd(x3, t4, v1);
+
+  /*
+   dest[0][0] =  f * t1[0] - g * t1[1] + h * t1[2];
+   dest[0][1] =-(b * t1[0] - c * t1[1] + d * t1[2]);
+   dest[0][2] =  b * t2[0] - c * t2[1] + d * t2[2];
+   dest[0][3] =-(b * t3[0] - c * t3[1] + d * t3[2]); */
+  v0 = wasm_v128_xor(v0, x8);
+  
+  /*
+   dest[2][0] =  e * t1[1] - f * t1[3] + h * t1[5];
+   dest[2][1] =-(a * t1[1] - b * t1[3] + d * t1[5]);
+   dest[2][2] =  a * t2[1] - b * t2[3] + d * t2[5];
+   dest[2][3] =-(a * t3[1] - b * t3[3] + d * t3[5]);*/
+  v2 = wasm_v128_xor(v2, x8);
+
+  /*
+   dest[1][0] =-(e * t1[0] - g * t1[3] + h * t1[4]);
+   dest[1][1] =  a * t1[0] - c * t1[3] + d * t1[4];
+   dest[1][2] =-(a * t2[0] - c * t2[3] + d * t2[4]);
+   dest[1][3] =  a * t3[0] - c * t3[3] + d * t3[4]; */
+  v1 = wasm_v128_xor(v1, x9);
+
+  /*
+   dest[3][0] =-(e * t1[2] - f * t1[4] + g * t1[5]);
+   dest[3][1] =  a * t1[2] - b * t1[4] + c * t1[5];
+   dest[3][2] =-(a * t2[2] - b * t2[4] + c * t2[5]);
+   dest[3][3] =  a * t3[2] - b * t3[4] + c * t3[5]; */
+  v3 = wasm_v128_xor(v3, x9);
+
+  /* determinant */
+  x0 = wasm_i32x4_shuffle(v0, v1, 0, 0, 4, 4);
+  x1 = wasm_i32x4_shuffle(v2, v3, 0, 0, 4, 4);
+  x0 = wasm_i32x4_shuffle(x0, x1, 0, 2, 4, 6);
+
+  x0 = wasm_f32x4_div(wasm_f32x4_splat(1.0f), glmm_vhadd(wasm_f32x4_mul(x0, r0)));
+
+  glmm_store(dest[0], wasm_f32x4_mul(v0, x0));
+  glmm_store(dest[1], wasm_f32x4_mul(v1, x0));
+  glmm_store(dest[2], wasm_f32x4_mul(v2, x0));
+  glmm_store(dest[3], wasm_f32x4_mul(v3, x0));
+}
+
+#endif
+#endif /* cglm_mat_wasm_h */

include/cglm/simd/wasm/quat.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglm_quat_wasm_h
+#define cglm_quat_wasm_h
+#if defined(__wasm__) && defined(__wasm_simd128__)
+
+#include "../../common.h"
+#include "../intrin.h"
+
+CGLM_INLINE
+void
+glm_quat_mul_wasm(versor p, versor q, versor dest) {
+  /*
+   + (a1 b2 + b1 a2 + c1 d2 − d1 c2)i
+   + (a1 c2 − b1 d2 + c1 a2 + d1 b2)j
+   + (a1 d2 + b1 c2 − c1 b2 + d1 a2)k
+     a1 a2 − b1 b2 − c1 c2 − d1 d2
+   */
+
+  glmm_128 xp, xq, x1, x2, x3, r, x, y, z;
+
+  xp = glmm_load(p); /* 3 2 1 0 */
+  xq = glmm_load(q);
+  /* x1 = wasm_f32x4_const(0.f, -0.f, 0.f, -0.f); */
+  x1 = glmm_float32x4_SIGNMASK_PNPN; /* TODO: _mm_set1_ss() + shuff ? */
+  r  = wasm_f32x4_mul(glmm_splat_w(xp), xq);
+  /* x2 = _mm_unpackhi_ps(x1, x1); */
+  x2 = wasm_i32x4_shuffle(x1, x1, 2, 6, 3, 7);
+  x3 = glmm_shuff1(x1, 3, 2, 0, 1);
+  x  = glmm_splat_x(xp);
+  y  = glmm_splat_y(xp);
+  z  = glmm_splat_z(xp);
+
+  x  = wasm_v128_xor(x, x1);
+  y  = wasm_v128_xor(y, x2);
+  z  = wasm_v128_xor(z, x3);
+  
+  x1 = glmm_shuff1(xq, 0, 1, 2, 3);
+  x2 = glmm_shuff1(xq, 1, 0, 3, 2);
+  x3 = glmm_shuff1(xq, 2, 3, 0, 1);
+  
+  r  = glmm_fmadd(x, x1, r);
+  r  = glmm_fmadd(y, x2, r);
+  r  = glmm_fmadd(z, x3, r);
+
+  glmm_store(dest, r);
+}
+
+#endif
+#endif /* cglm_quat_wasm_h */

include/cglm/simd/x86.h

@@ -54,10 +54,23 @@
 #  endif
 #endif
 
+#define GLMM_NEGZEROf 0x80000000 /*  0x80000000 ---> -0.0f  */
+
+#define GLMM__SIGNMASKf(X, Y, Z, W)                                           \
+   _mm_castsi128_ps(_mm_set_epi32(X, Y, Z, W))
+  /* _mm_set_ps(X, Y, Z, W); */
+
+#define glmm_float32x4_SIGNMASK_PNPN GLMM__SIGNMASKf(0, GLMM_NEGZEROf, 0, GLMM_NEGZEROf)
+#define glmm_float32x4_SIGNMASK_NPNP GLMM__SIGNMASKf(GLMM_NEGZEROf, 0, GLMM_NEGZEROf, 0)
+#define glmm_float32x4_SIGNMASK_NPPN GLMM__SIGNMASKf(GLMM_NEGZEROf, 0, 0, GLMM_NEGZEROf)
+
+#define glmm_float32x4_SIGNMASK_NEG _mm_castsi128_ps(_mm_set1_epi32(0x80000000)) /* _mm_set1_ps(-0.0f) */
+#define glmm_float32x8_SIGNMASK_NEG _mm256_castsi256_ps(_mm256_set1_epi32(GLMM_NEGZEROf))
+
 static inline
 __m128
 glmm_abs(__m128 x) {
-  return _mm_andnot_ps(_mm_set1_ps(-0.0f), x);
+  return _mm_andnot_ps(glmm_float32x4_SIGNMASK_NEG, x);
 }
 
 static inline
@@ -256,7 +269,8 @@ glmm_fnmsub(__m128 a, __m128 b, __m128 c) {
 #ifdef __FMA__
   return _mm_fnmsub_ps(a, b, c);
 #else
-  return _mm_xor_ps(_mm_add_ps(_mm_mul_ps(a, b), c), _mm_set1_ps(-0.0f));
+  return _mm_xor_ps(_mm_add_ps(_mm_mul_ps(a, b), c),
+                    glmm_float32x4_SIGNMASK_NEG);
 #endif
 }
 
@@ -298,7 +312,7 @@ glmm256_fnmsub(__m256 a, __m256 b, __m256 c) {
   return _mm256_fmsub_ps(a, b, c);
 #else
   return _mm256_xor_ps(_mm256_sub_ps(_mm256_mul_ps(a, b), c),
-                       _mm256_set1_ps(-0.0f));
+                       glmm_float32x8_SIGNMASK_NEG);
 #endif
 }
 #endif

include/cglm/struct/affine-post.h

@@ -0,0 +1,184 @@
+/*
+ * 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_translated(mat4s m, vec3s v);
+   CGLM_INLINE mat4s glms_translated_x(mat4s m, float x);
+   CGLM_INLINE mat4s glms_translated_y(mat4s m, float y);
+   CGLM_INLINE mat4s glms_translated_z(mat4s m, float z);
+   CGLM_INLINE mat4s glms_rotated_x(mat4s m, float angle);
+   CGLM_INLINE mat4s glms_rotated_y(mat4s m, float angle);
+   CGLM_INLINE mat4s glms_rotated_z(mat4s m, float angle);
+   CGLM_INLINE mat4s glms_rotated(mat4s m, float angle, vec3s axis);
+   CGLM_INLINE mat4s glms_rotated_at(mat4s m, vec3s pivot, float angle, vec3s axis);
+   CGLM_INLINE mat4s glms_spinned(mat4s m, float angle, vec3s axis);
+ */
+
+#ifndef cglms_affines_post_h
+#define cglms_affines_post_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../affine.h"
+#include "vec3.h"
+#include "vec4.h"
+#include "mat4.h"
+
+/*!
+ * @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_translated(mat4s m, vec3s v) {
+  glm_translated(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_translated_x(mat4s m, float x) {
+  glm_translated_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_translated_y(mat4s m, float y) {
+  glm_translated_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_translated_z(mat4s m, float z) {
+  glm_translated_z(m.raw, z);
+  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_rotated_x(mat4s m, float angle) {
+  mat4s r;
+  glm_rotated_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_rotated_y(mat4s m, float angle) {
+  mat4s r;
+  glm_rotated_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_rotated_z(mat4s m, float angle) {
+  mat4s r;
+  glm_rotated_z(m.raw, angle, r.raw);
+  return r;
+}
+
+/*!
+ * @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_rotated(mat4s m, float angle, vec3s axis) {
+  glm_rotated(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_rotated_at(mat4s m, vec3s pivot, float angle, vec3s axis) {
+  glm_rotated_at(m.raw, pivot.raw, angle, axis.raw);
+  return m;
+}
+
+/*!
+ * @brief rotate existing transform matrix around given axis by angle around self (doesn't affected by position)
+ *
+ * @param[in]       m       affine transfrom
+ * @param[in]       angle   angle (radians)
+ * @param[in]       axis    axis
+ * @returns                affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_spinned(mat4s m, float angle, vec3s axis) {
+  glm_spinned(m.raw, angle, axis.raw);
+  return m;
+}
+
+#endif /* cglms_affines_post_h */

include/cglm/struct/affine-pre.h

@@ -0,0 +1,184 @@
+/*
+ * 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_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(mat4s m, float angle, vec3s axis);
+   CGLM_INLINE mat4s glms_rotate_at(mat4s m, vec3s pivot, float angle, vec3s axis);
+   CGLM_INLINE mat4s glms_spin(mat4s m, float angle, vec3s axis);
+ */
+
+#ifndef cglms_affines_pre_h
+#define cglms_affines_pre_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../affine.h"
+#include "vec3.h"
+#include "vec4.h"
+#include "mat4.h"
+
+/*!
+ * @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 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 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 rotate existing transform matrix around given axis by angle around self (doesn't affected by position)
+ *
+ * @param[in]       m       affine transfrom
+ * @param[in]       angle   angle (radians)
+ * @param[in]       axis    axis
+ * @returns                affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_spin(mat4s m, float angle, vec3s axis) {
+  glm_spin(m.raw, angle, axis.raw);
+  return m;
+}
+
+#endif /* cglms_affines_pre_h */

include/cglm/struct/affine.h

@@ -23,6 +23,7 @@
    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 mat4s glms_spin(mat4s m, 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);
@@ -39,63 +40,6 @@
 #include "vec4.h"
 #include "mat4.h"
 
-/*!
- * @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
  *
@@ -155,54 +99,6 @@ glms_scale_uni(mat4s m, float 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
  *
@@ -220,38 +116,6 @@ glms_rotate_make(float angle, vec3s axis) {
   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
  *
@@ -330,4 +194,7 @@ glms_decompose(mat4s m, vec4s * __restrict t, mat4s * __restrict r, vec3s * __re
   glm_decompose(m.raw, t->raw, r->raw, s->raw);
 }
 
+#include "affine-pre.h"
+#include "affine-post.h"
+
 #endif /* cglms_affines_h */

include/cglm/struct/box.h

@@ -15,6 +15,9 @@
 #include "vec4.h"
 #include "mat4.h"
 
+/* api definition */
+#define glms_aabb_(NAME) CGLM_STRUCTAPI(aabb, NAME)
+
 /*!
  * @brief apply transform to Axis-Aligned Bounding Box
  *
@@ -24,11 +27,11 @@
  */
 CGLM_INLINE
 void
-glms_aabb_transform(vec3s box[2], mat4s m, vec3s dest[2]) {
+glms_aabb_(transform)(vec3s box[2], mat4s m, vec3s dest[2]) {
   vec3 rawBox[2];
   vec3 rawDest[2];
 
-  glms_vec3_unpack(rawBox, box, 2);
+  glms_vec3_(unpack)(rawBox, box, 2);
   glm_aabb_transform(rawBox, m.raw, rawDest);
   glms_vec3_pack(dest, rawDest, 2);
 }
@@ -45,15 +48,15 @@ glms_aabb_transform(vec3s box[2], mat4s m, vec3s dest[2]) {
  */
 CGLM_INLINE
 void
-glms_aabb_merge(vec3s box1[2], vec3s box2[2], vec3s dest[2]) {
+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);
+  glms_vec3_(unpack)(rawBox1, box1, 2);
+  glms_vec3_(unpack)(rawBox2, box2, 2);
   glm_aabb_merge(rawBox1, rawBox2, rawDest);
-  glms_vec3_pack(dest, rawDest, 2);
+  glms_vec3_(pack)(dest, rawDest, 2);
 }
 
 /*!
@@ -69,15 +72,15 @@ glms_aabb_merge(vec3s box1[2], vec3s box2[2], vec3s dest[2]) {
  */
 CGLM_INLINE
 void
-glms_aabb_crop(vec3s box[2], vec3s cropBox[2], vec3s dest[2]) {
+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);
+  glms_vec3_(unpack)(rawBox, box, 2);
+  glms_vec3_(unpack)(rawCropBox, cropBox, 2);
   glm_aabb_crop(rawBox, rawCropBox, rawDest);
-  glms_vec3_pack(dest, rawDest, 2);
+  glms_vec3_(pack)(dest, rawDest, 2);
 }
 
 /*!
@@ -94,12 +97,12 @@ glms_aabb_crop(vec3s box[2], vec3s cropBox[2], vec3s dest[2]) {
  */
 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);
+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);
 }
 
 /*!
@@ -118,12 +121,12 @@ glms_aabb_crop_until(vec3s box[2],
  */
 CGLM_INLINE
 bool
-glms_aabb_frustum(vec3s box[2], vec4s planes[6]) {
+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);
+  glms_vec3_(unpack)(rawBox, box, 2);
+  glms_vec4_(unpack)(rawPlanes, planes, 6);
   return glm_aabb_frustum(rawBox, rawPlanes);
 }
 
@@ -134,9 +137,9 @@ glms_aabb_frustum(vec3s box[2], vec4s planes[6]) {
  */
 CGLM_INLINE
 void
-glms_aabb_invalidate(vec3s box[2]) {
-  box[0] = glms_vec3_broadcast(FLT_MAX);
-  box[1] = glms_vec3_broadcast(-FLT_MAX);
+glms_aabb_(invalidate)(vec3s box[2]) {
+  box[0] = glms_vec3_(broadcast)(FLT_MAX);
+  box[1] = glms_vec3_(broadcast)(-FLT_MAX);
 }
 
 /*!
@@ -146,9 +149,9 @@ glms_aabb_invalidate(vec3s box[2]) {
  */
 CGLM_INLINE
 bool
-glms_aabb_isvalid(vec3s box[2]) {
+glms_aabb_(isvalid)(vec3s box[2]) {
   vec3 rawBox[2];
-  glms_vec3_unpack(rawBox, box, 2);
+  glms_vec3_(unpack)(rawBox, box, 2);
   return glm_aabb_isvalid(rawBox);
 }
 
@@ -159,7 +162,7 @@ glms_aabb_isvalid(vec3s box[2]) {
  */
 CGLM_INLINE
 float
-glms_aabb_size(vec3s box[2]) {
+glms_aabb_(size)(vec3s box[2]) {
   return glm_vec3_distance(box[0].raw, box[1].raw);
 }
 
@@ -170,8 +173,8 @@ glms_aabb_size(vec3s box[2]) {
  */
 CGLM_INLINE
 float
-glms_aabb_radius(vec3s box[2]) {
-  return glms_aabb_size(box) * 0.5f;
+glms_aabb_(radius)(vec3s box[2]) {
+  return glms_aabb_(size)(box) * 0.5f;
 }
 
 /*!
@@ -182,8 +185,8 @@ glms_aabb_radius(vec3s box[2]) {
  */
 CGLM_INLINE
 vec3s
-glms_aabb_center(vec3s box[2]) {
-  return glms_vec3_center(box[0], box[1]);
+glms_aabb_(center)(vec3s box[2]) {
+  return glms_vec3_(center)(box[0], box[1]);
 }
 
 /*!
@@ -194,12 +197,12 @@ glms_aabb_center(vec3s box[2]) {
  */
 CGLM_INLINE
 bool
-glms_aabb_aabb(vec3s box[2], vec3s other[2]) {
+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);
+  glms_vec3_(unpack)(rawBox, box, 2);
+  glms_vec3_(unpack)(rawOther, other, 2);
   return glm_aabb_aabb(rawBox, rawOther);
 }
 
@@ -214,10 +217,10 @@ glms_aabb_aabb(vec3s box[2], vec3s other[2]) {
  */
 CGLM_INLINE
 bool
-glms_aabb_sphere(vec3s box[2], vec4s s) {
+glms_aabb_(sphere)(vec3s box[2], vec4s s) {
   vec3 rawBox[2];
 
-  glms_vec3_unpack(rawBox, box, 2);
+  glms_vec3_(unpack)(rawBox, box, 2);
   return glm_aabb_sphere(rawBox, s.raw);
 }
 
@@ -229,10 +232,10 @@ glms_aabb_sphere(vec3s box[2], vec4s s) {
  */
 CGLM_INLINE
 bool
-glms_aabb_point(vec3s box[2], vec3s point) {
+glms_aabb_(point)(vec3s box[2], vec3s point) {
   vec3 rawBox[2];
 
-  glms_vec3_unpack(rawBox, box, 2);
+  glms_vec3_(unpack)(rawBox, box, 2);
   return glm_aabb_point(rawBox, point.raw);
 }
 
@@ -244,12 +247,12 @@ glms_aabb_point(vec3s box[2], vec3s point) {
  */
 CGLM_INLINE
 bool
-glms_aabb_contains(vec3s box[2], vec3s other[2]) {
+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);
+  glms_vec3_(unpack)(rawBox, box, 2);
+  glms_vec3_(unpack)(rawOther, other, 2);
   return glm_aabb_contains(rawBox, rawOther);
 }
 

include/cglm/struct/clipspace/ortho_lh_no.h

@@ -1,7 +1,7 @@
 /*
  * Copyright (c), Recep Aslantas.
  *
- * MIT License (MIT), htt../opensource.org/licenses/MIT
+ * MIT License (MIT), http://opensource.org/licenses/MIT
  * Full license can be found in the LICENSE file
  */
 
@@ -64,7 +64,7 @@ glms_ortho_aabb_lh_no(vec3s box[2]) {
   mat4s dest;
   vec3  rawBox[2];
 
-  glms_vec3_unpack(rawBox, box, 2);
+  glms_vec3_(unpack)(rawBox, box, 2);
   glm_ortho_aabb_lh_no(rawBox, dest.raw);
 
   return dest;
@@ -87,7 +87,7 @@ glms_ortho_aabb_p_lh_no(vec3s box[2], float padding) {
   mat4s dest;
   vec3  rawBox[2];
 
-  glms_vec3_unpack(rawBox, box, 2);
+  glms_vec3_(unpack)(rawBox, box, 2);
   glm_ortho_aabb_p_lh_no(rawBox, padding, dest.raw);
 
   return dest;
@@ -110,7 +110,7 @@ glms_ortho_aabb_pz_lh_no(vec3s box[2], float padding) {
   mat4s dest;
   vec3  rawBox[2];
 
-  glms_vec3_unpack(rawBox, box, 2);
+  glms_vec3_(unpack)(rawBox, box, 2);
   glm_ortho_aabb_pz_lh_no(rawBox, padding, dest.raw);
 
   return dest;

include/cglm/struct/clipspace/ortho_lh_zo.h

@@ -1,7 +1,7 @@
 /*
  * Copyright (c), Recep Aslantas.
  *
- * MIT License (MIT), htt../opensource.org/licenses/MIT
+ * MIT License (MIT), http://opensource.org/licenses/MIT
  * Full license can be found in the LICENSE file
  */
 
@@ -64,7 +64,7 @@ glms_ortho_aabb_lh_zo(vec3s box[2]) {
   mat4s dest;
   vec3  rawBox[2];
 
-  glms_vec3_unpack(rawBox, box, 2);
+  glms_vec3_(unpack)(rawBox, box, 2);
   glm_ortho_aabb_lh_zo(rawBox, dest.raw);
 
   return dest;
@@ -87,7 +87,7 @@ glms_ortho_aabb_p_lh_zo(vec3s box[2], float padding) {
   mat4s dest;
   vec3  rawBox[2];
 
-  glms_vec3_unpack(rawBox, box, 2);
+  glms_vec3_(unpack)(rawBox, box, 2);
   glm_ortho_aabb_p_lh_zo(rawBox, padding, dest.raw);
 
   return dest;
@@ -110,7 +110,7 @@ glms_ortho_aabb_pz_lh_zo(vec3s box[2], float padding) {
   mat4s dest;
   vec3  rawBox[2];
 
-  glms_vec3_unpack(rawBox, box, 2);
+  glms_vec3_(unpack)(rawBox, box, 2);
   glm_ortho_aabb_pz_lh_zo(rawBox, padding, dest.raw);
 
   return dest;

include/cglm/struct/clipspace/ortho_rh_no.h

@@ -1,7 +1,7 @@
 /*
  * Copyright (c), Recep Aslantas.
  *
- * MIT License (MIT), htt../opensource.org/licenses/MIT
+ * MIT License (MIT), http://opensource.org/licenses/MIT
  * Full license can be found in the LICENSE file
  */
 
@@ -64,7 +64,7 @@ glms_ortho_aabb_rh_no(vec3s box[2]) {
   mat4s dest;
   vec3  rawBox[2];
 
-  glms_vec3_unpack(rawBox, box, 2);
+  glms_vec3_(unpack)(rawBox, box, 2);
   glm_ortho_aabb_rh_no(rawBox, dest.raw);
 
   return dest;
@@ -87,7 +87,7 @@ glms_ortho_aabb_p_rh_no(vec3s box[2], float padding) {
   mat4s dest;
   vec3  rawBox[2];
 
-  glms_vec3_unpack(rawBox, box, 2);
+  glms_vec3_(unpack)(rawBox, box, 2);
   glm_ortho_aabb_p_rh_no(rawBox, padding, dest.raw);
 
   return dest;
@@ -110,7 +110,7 @@ glms_ortho_aabb_pz_rh_no(vec3s box[2], float padding) {
   mat4s dest;
   vec3  rawBox[2];
 
-  glms_vec3_unpack(rawBox, box, 2);
+  glms_vec3_(unpack)(rawBox, box, 2);
   glm_ortho_aabb_pz_rh_no(rawBox, padding, dest.raw);
 
   return dest;

include/cglm/struct/clipspace/ortho_rh_zo.h

@@ -1,7 +1,7 @@
 /*
  * Copyright (c), Recep Aslantas.
  *
- * MIT License (MIT), htt../opensource.org/licenses/MIT
+ * MIT License (MIT), http://opensource.org/licenses/MIT
  * Full license can be found in the LICENSE file
  */
 
@@ -64,7 +64,7 @@ glms_ortho_aabb_rh_zo(vec3s box[2]) {
   mat4s dest;
   vec3  rawBox[2];
 
-  glms_vec3_unpack(rawBox, box, 2);
+  glms_vec3_(unpack)(rawBox, box, 2);
   glm_ortho_aabb_rh_zo(rawBox, dest.raw);
 
   return dest;
@@ -87,7 +87,7 @@ glms_ortho_aabb_p_rh_zo(vec3s box[2], float padding) {
   mat4s dest;
   vec3  rawBox[2];
 
-  glms_vec3_unpack(rawBox, box, 2);
+  glms_vec3_(unpack)(rawBox, box, 2);
   glm_ortho_aabb_p_rh_zo(rawBox, padding, dest.raw);
 
   return dest;
@@ -110,7 +110,7 @@ glms_ortho_aabb_pz_rh_zo(vec3s box[2], float padding) {
   mat4s dest;
   vec3  rawBox[2];
 
-  glms_vec3_unpack(rawBox, box, 2);
+  glms_vec3_(unpack)(rawBox, box, 2);
   glm_ortho_aabb_pz_rh_zo(rawBox, padding, dest.raw);
 
   return dest;

include/cglm/struct/clipspace/persp_lh_no.h

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

include/cglm/struct/clipspace/persp_lh_zo.h

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

include/cglm/struct/clipspace/persp_rh_no.h

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

include/cglm/struct/clipspace/persp_rh_zo.h

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

include/cglm/struct/clipspace/project_no.h

@@ -0,0 +1,96 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE vec3s glms_unprojecti_no(vec3s pos, mat4s invMat, vec4s vp, vec3 dest)
+   CGLM_INLINE vec3s glms_project_no(vec3s pos, mat4s m, vec4s vp, vec3s dest)
+ */
+
+#ifndef cglms_project_no_h
+#define cglms_project_no_h
+
+#include "../../common.h"
+#include "../../types-struct.h"
+#include "../../plane.h"
+#include "../../cam.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_no(vec3s pos, mat4s invMat, vec4s vp, vec3 dest) {
+  vec3s dest;
+  glm_unprojecti_no(pos.raw, invMat.raw, vp.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @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_no(vec3s pos, mat4s m, vec4s vp, vec3s dest) {
+  vec3s dest;
+  glm_project_no(pos.raw, m.raw, vp.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief map object's z coordinate to window coordinates
+ *
+ * Computing MVP:
+ *   glm_mat4_mul(proj, view, viewProj);
+ *   glm_mat4_mul(viewProj, model, MVP);
+ *
+ * @param[in]  v object coordinates
+ * @param[in]  m MVP matrix
+ *
+ * @returns projected z coordinate
+ */
+CGLM_INLINE
+vec3s
+glms_project_z_no(vec3s v, mat4s m) {
+  return glm_project_z_no(v.raw, m.raw);
+}
+
+#endif /* cglms_project_rh_no_h */

include/cglm/struct/clipspace/project_zo.h

@@ -0,0 +1,96 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE vec3s glms_unprojecti_no(vec3s pos, mat4s invMat, vec4s vp, vec3 dest)
+   CGLM_INLINE vec3s glms_project_no(vec3s pos, mat4s m, vec4s vp, vec3s dest)
+ */
+
+#ifndef cglms_project_zo_h
+#define cglms_project_zo_h
+
+#include "../../common.h"
+#include "../../types-struct.h"
+#include "../../plane.h"
+#include "../../cam.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_zo(vec3s pos, mat4s invMat, vec4s vp, vec3 dest) {
+  vec3s dest;
+  glm_unprojecti_zo(pos.raw, invMat.raw, vp.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @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_zo(vec3s pos, mat4s m, vec4s vp, vec3 dest) {
+  vec3s dest;
+  glm_project_zo(pos.raw, m.raw, vp.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief map object's z coordinate to window coordinates
+ *
+ * Computing MVP:
+ *   glm_mat4_mul(proj, view, viewProj);
+ *   glm_mat4_mul(viewProj, model, MVP);
+ *
+ * @param[in]  v object coordinates
+ * @param[in]  m MVP matrix
+ *
+ * @returns projected z coordinate
+ */
+CGLM_INLINE
+vec3s
+glms_project_z_zo(vec3s v, mat4s m) {
+  return glm_project_z_zo(v.raw, m.raw);
+}
+
+#endif /* cglm_project_zo_h */

include/cglm/struct/clipspace/view_lh_no.h

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

include/cglm/struct/clipspace/view_lh_zo.h

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

include/cglm/struct/clipspace/view_rh_no.h

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

include/cglm/struct/clipspace/view_rh_zo.h

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

include/cglm/struct/frustum.h

@@ -57,7 +57,7 @@ void
 glms_frustum_planes(mat4s m, vec4s dest[6]) {
   vec4 rawDest[6];
   glm_frustum_planes(m.raw, rawDest);
-  glms_vec4_pack(dest, rawDest, 6);
+  glms_vec4_(pack)(dest, rawDest, 6);
 }
 
 /*!
@@ -88,7 +88,7 @@ void
 glms_frustum_corners(mat4s invMat, vec4s dest[8]) {
   vec4 rawDest[8];
   glm_frustum_corners(invMat.raw, rawDest);
-  glms_vec4_pack(dest, rawDest, 8);
+  glms_vec4_(pack)(dest, rawDest, 8);
 }
 
 /*!
@@ -103,7 +103,7 @@ glms_frustum_center(vec4s corners[8]) {
   vec4 rawCorners[8];
   vec4s r;
 
-  glms_vec4_unpack(rawCorners, corners, 8);
+  glms_vec4_(unpack)(rawCorners, corners, 8);
   glm_frustum_center(rawCorners, r.raw);
   return r;
 }
@@ -121,9 +121,9 @@ glms_frustum_box(vec4s corners[8], mat4s m, vec3s box[2]) {
   vec4 rawCorners[8];
   vec3 rawBox[2];
 
-  glms_vec4_unpack(rawCorners, corners, 8);
+  glms_vec4_(unpack)(rawCorners, corners, 8);
   glm_frustum_box(rawCorners, m.raw, rawBox);
-  glms_vec3_pack(box, rawBox, 2);
+  glms_vec3_(pack)(box, rawBox, 2);
 }
 
 /*!
@@ -147,9 +147,9 @@ glms_frustum_corners_at(vec4s corners[8],
   vec4 rawCorners[8];
   vec4 rawPlaneCorners[4];
 
-  glms_vec4_unpack(rawCorners, corners, 8);
+  glms_vec4_(unpack)(rawCorners, corners, 8);
   glm_frustum_corners_at(rawCorners, splitDist, farDist, rawPlaneCorners);
-  glms_vec4_pack(planeCorners, rawPlaneCorners, 8);
+  glms_vec4_(pack)(planeCorners, rawPlaneCorners, 8);
 }
 
 #endif /* cglms_frustums_h */

include/cglm/struct/io.h

@@ -75,7 +75,7 @@ glms_aabb_print(vec3s                   bbox[2],
                 FILE       * __restrict ostream) {
   vec3 rawBbox[2];
 
-  glms_vec3_unpack(rawBbox, bbox, 2);
+  glms_vec3_(unpack)(rawBbox, bbox, 2);
   glm_aabb_print(rawBbox, tag, ostream);
 }
 

include/cglm/struct/mat2.h

@@ -36,6 +36,9 @@
 #include "../types-struct.h"
 #include "../mat2.h"
 
+/* api definition */
+#define glms_mat2_(NAME) CGLM_STRUCTAPI(mat2, NAME)
+
 #define GLMS_MAT2_IDENTITY_INIT {GLM_MAT2_IDENTITY_INIT}
 #define GLMS_MAT2_ZERO_INIT     {GLM_MAT2_ZERO_INIT}
 
@@ -59,7 +62,7 @@
  */
 CGLM_INLINE
 mat2s
-glms_mat2_identity(void) {
+glms_mat2_(identity)(void) {
   mat2s r;
   glm_mat2_identity(r.raw);
   return r;
@@ -75,7 +78,7 @@ glms_mat2_identity(void) {
  */
 CGLM_INLINE
 void
-glms_mat2_identity_array(mat2s * __restrict mat, size_t count) {
+glms_mat2_(identity_array)(mat2s * __restrict mat, size_t count) {
   CGLM_ALIGN_MAT mat2s t = GLMS_MAT2_IDENTITY_INIT;
   size_t i;
 
@@ -91,7 +94,7 @@ glms_mat2_identity_array(mat2s * __restrict mat, size_t count) {
  */
 CGLM_INLINE
 mat2s
-glms_mat2_zero(void) {
+glms_mat2_(zero)(void) {
   mat2s r;
   glm_mat2_zero(r.raw);
   return r;
@@ -114,7 +117,7 @@ glms_mat2_zero(void) {
  */
 CGLM_INLINE
 mat2s
-glms_mat2_mul(mat2s m1, mat2s m2) {
+glms_mat2_(mul)(mat2s m1, mat2s m2) {
   mat2s r;
   glm_mat2_mul(m1.raw, m2.raw, r.raw);
   return r;
@@ -129,7 +132,7 @@ glms_mat2_mul(mat2s m1, mat2s m2) {
  */
 CGLM_INLINE
 mat2s
-glms_mat2_transpose(mat2s m) {
+glms_mat2_(transpose)(mat2s m) {
   glm_mat2_transpose(m.raw);
   return m;
 }
@@ -143,7 +146,7 @@ glms_mat2_transpose(mat2s m) {
  */
 CGLM_INLINE
 vec2s
-glms_mat2_mulv(mat2s m, vec2s v) {
+glms_mat2_(mulv)(mat2s m, vec2s v) {
   vec2s r;
   glm_mat2_mulv(m.raw, v.raw, r.raw);
   return r;
@@ -158,7 +161,7 @@ glms_mat2_mulv(mat2s m, vec2s v) {
  */
 CGLM_INLINE
 float
-glms_mat2_trace(mat2s m) {
+glms_mat2_(trace)(mat2s m) {
   return glm_mat2_trace(m.raw);
 }
 
@@ -173,7 +176,7 @@ glms_mat2_trace(mat2s m) {
  */
 CGLM_INLINE
 mat2s
-glms_mat2_scale(mat2s m, float s) {
+glms_mat2_(scale)(mat2s m, float s) {
   glm_mat2_scale(m.raw, s);
   return m;
 }
@@ -187,7 +190,7 @@ glms_mat2_scale(mat2s m, float s) {
  */
 CGLM_INLINE
 float
-glms_mat2_det(mat2s mat) {
+glms_mat2_(det)(mat2s mat) {
   return glm_mat2_det(mat.raw);
 }
 
@@ -199,7 +202,7 @@ glms_mat2_det(mat2s mat) {
  */
 CGLM_INLINE
 mat2s
-glms_mat2_inv(mat2s mat) {
+glms_mat2_(inv)(mat2s mat) {
   mat2s r;
   glm_mat2_inv(mat.raw, r.raw);
   return r;
@@ -215,7 +218,7 @@ glms_mat2_inv(mat2s mat) {
  */
 CGLM_INLINE
 mat2s
-glms_mat2_swap_col(mat2s mat, int col1, int col2) {
+glms_mat2_(swap_col)(mat2s mat, int col1, int col2) {
   glm_mat2_swap_col(mat.raw, col1, col2);
   return mat;
 }
@@ -230,7 +233,7 @@ glms_mat2_swap_col(mat2s mat, int col1, int col2) {
  */
 CGLM_INLINE
 mat2s
-glms_mat2_swap_row(mat2s mat, int row1, int row2) {
+glms_mat2_(swap_row)(mat2s mat, int row1, int row2) {
   glm_mat2_swap_row(mat.raw, row1, row2);
   return mat;
 }
@@ -251,7 +254,7 @@ glms_mat2_swap_row(mat2s mat, int row1, int row2) {
  */
 CGLM_INLINE
 float
-glms_mat2_rmc(vec2s r, mat2s m, vec2s c) {
+glms_mat2_(rmc)(vec2s r, mat2s m, vec2s c) {
   return glm_mat2_rmc(r.raw, m.raw, c.raw);
 }
 

include/cglm/struct/mat3.h

@@ -38,6 +38,9 @@
 #include "../mat3.h"
 #include "vec3.h"
 
+/* api definition */
+#define glms_mat3_(NAME) CGLM_STRUCTAPI(mat3, NAME)
+
 #define GLMS_MAT3_IDENTITY_INIT  {GLM_MAT3_IDENTITY_INIT}
 #define GLMS_MAT3_ZERO_INIT      {GLM_MAT3_ZERO_INIT}
 
@@ -53,7 +56,7 @@
  */
 CGLM_INLINE
 mat3s
-glms_mat3_copy(mat3s mat) {
+glms_mat3_(copy)(mat3s mat) {
   mat3s r;
   glm_mat3_copy(mat.raw, r.raw);
   return r;
@@ -75,7 +78,7 @@ glms_mat3_copy(mat3s mat) {
  */
 CGLM_INLINE
 mat3s
-glms_mat3_identity(void) {
+glms_mat3_(identity)(void) {
   mat3s r;
   glm_mat3_identity(r.raw);
   return r;
@@ -91,7 +94,7 @@ glms_mat3_identity(void) {
  */
 CGLM_INLINE
 void
-glms_mat3_identity_array(mat3s * __restrict mat, size_t count) {
+glms_mat3_(identity_array)(mat3s * __restrict mat, size_t count) {
   CGLM_ALIGN_MAT mat3s t = GLMS_MAT3_IDENTITY_INIT;
   size_t i;
 
@@ -107,7 +110,7 @@ glms_mat3_identity_array(mat3s * __restrict mat, size_t count) {
  */
 CGLM_INLINE
 mat3s
-glms_mat3_zero(void) {
+glms_mat3_(zero)(void) {
   mat3s r;
   glm_mat3_zero(r.raw);
   return r;
@@ -129,7 +132,7 @@ glms_mat3_zero(void) {
  */
 CGLM_INLINE
 mat3s
-glms_mat3_mul(mat3s m1, mat3s m2) {
+glms_mat3_(mul)(mat3s m1, mat3s m2) {
   mat3s r;
   glm_mat3_mul(m1.raw, m2.raw, r.raw);
   return r;
@@ -142,7 +145,7 @@ glms_mat3_mul(mat3s m1, mat3s m2) {
  */
 CGLM_INLINE
 mat3s
-glms_mat3_transpose(mat3s m) {
+glms_mat3_(transpose)(mat3s m) {
   glm_mat3_transpose(m.raw);
   return m;
 }
@@ -156,7 +159,7 @@ glms_mat3_transpose(mat3s m) {
  */
 CGLM_INLINE
 vec3s
-glms_mat3_mulv(mat3s m, vec3s v) {
+glms_mat3_(mulv)(mat3s m, vec3s v) {
   vec3s r;
   glm_mat3_mulv(m.raw, v.raw, r.raw);
   return r;
@@ -171,7 +174,7 @@ glms_mat3_mulv(mat3s m, vec3s v) {
  */
 CGLM_INLINE
 float
-glms_mat3_trace(mat3s m) {
+glms_mat3_(trace)(mat3s m) {
   return glm_mat3_trace(m.raw);
 }
 
@@ -183,7 +186,7 @@ glms_mat3_trace(mat3s m) {
  */
 CGLM_INLINE
 versors
-glms_mat3_quat(mat3s m) {
+glms_mat3_(quat)(mat3s m) {
   versors r;
   glm_mat3_quat(m.raw, r.raw);
   return r;
@@ -200,7 +203,7 @@ glms_mat3_quat(mat3s m) {
  */
 CGLM_INLINE
 mat3s
-glms_mat3_scale(mat3s m, float s) {
+glms_mat3_(scale)(mat3s m, float s) {
   glm_mat3_scale(m.raw, s);
   return m;
 }
@@ -214,7 +217,7 @@ glms_mat3_scale(mat3s m, float s) {
  */
 CGLM_INLINE
 float
-glms_mat3_det(mat3s mat) {
+glms_mat3_(det)(mat3s mat) {
   return glm_mat3_det(mat.raw);
 }
 
@@ -226,7 +229,7 @@ glms_mat3_det(mat3s mat) {
  */
 CGLM_INLINE
 mat3s
-glms_mat3_inv(mat3s mat) {
+glms_mat3_(inv)(mat3s mat) {
   mat3s r;
   glm_mat3_inv(mat.raw, r.raw);
   return r;
@@ -242,7 +245,7 @@ glms_mat3_inv(mat3s mat) {
  */
 CGLM_INLINE
 mat3s
-glms_mat3_swap_col(mat3s mat, int col1, int col2) {
+glms_mat3_(swap_col)(mat3s mat, int col1, int col2) {
   glm_mat3_swap_col(mat.raw, col1, col2);
   return mat;
 }
@@ -257,7 +260,7 @@ glms_mat3_swap_col(mat3s mat, int col1, int col2) {
  */
 CGLM_INLINE
 mat3s
-glms_mat3_swap_row(mat3s mat, int row1, int row2) {
+glms_mat3_(swap_row)(mat3s mat, int row1, int row2) {
   glm_mat3_swap_row(mat.raw, row1, row2);
   return mat;
 }
@@ -278,7 +281,7 @@ glms_mat3_swap_row(mat3s mat, int row1, int row2) {
  */
 CGLM_INLINE
 float
-glms_mat3_rmc(vec3s r, mat3s m, vec3s c) {
+glms_mat3_(rmc)(vec3s r, mat3s m, vec3s c) {
   return glm_mat3_rmc(r.raw, m.raw, c.raw);
 }
 

include/cglm/struct/mat4.h

@@ -53,6 +53,9 @@
 #include "vec4.h"
 #include "vec3.h"
 
+/* api definition */ 
+#define glms_mat4_(NAME) CGLM_STRUCTAPI(mat4, NAME)
+
 #define GLMS_MAT4_IDENTITY_INIT  {GLM_MAT4_IDENTITY_INIT}
 #define GLMS_MAT4_ZERO_INIT      {GLM_MAT4_ZERO_INIT}
 
@@ -71,7 +74,7 @@
  */
 CGLM_INLINE
 mat4s
-glms_mat4_ucopy(mat4s mat) {
+glms_mat4_(ucopy)(mat4s mat) {
   mat4s r;
   glm_mat4_ucopy(mat.raw, r.raw);
   return r;
@@ -85,7 +88,7 @@ glms_mat4_ucopy(mat4s mat) {
  */
 CGLM_INLINE
 mat4s
-glms_mat4_copy(mat4s mat) {
+glms_mat4_(copy)(mat4s mat) {
   mat4s r;
   glm_mat4_copy(mat.raw, r.raw);
   return r;
@@ -107,7 +110,7 @@ glms_mat4_copy(mat4s mat) {
  */
 CGLM_INLINE
 mat4s
-glms_mat4_identity(void) {
+glms_mat4_(identity)(void) {
   mat4s r;
   glm_mat4_identity(r.raw);
   return r;
@@ -123,7 +126,7 @@ glms_mat4_identity(void) {
  */
 CGLM_INLINE
 void
-glms_mat4_identity_array(mat4s * __restrict mat, size_t count) {
+glms_mat4_(identity_array)(mat4s * __restrict mat, size_t count) {
   CGLM_ALIGN_MAT mat4s t = GLMS_MAT4_IDENTITY_INIT;
   size_t i;
 
@@ -139,7 +142,7 @@ glms_mat4_identity_array(mat4s * __restrict mat, size_t count) {
  */
 CGLM_INLINE
 mat4s
-glms_mat4_zero(void) {
+glms_mat4_(zero)(void) {
   mat4s r;
   glm_mat4_zero(r.raw);
   return r;
@@ -153,7 +156,7 @@ glms_mat4_zero(void) {
  */
 CGLM_INLINE
 mat3s
-glms_mat4_pick3(mat4s mat) {
+glms_mat4_(pick3)(mat4s mat) {
   mat3s r;
   glm_mat4_pick3(mat.raw, r.raw);
   return r;
@@ -169,7 +172,7 @@ glms_mat4_pick3(mat4s mat) {
  */
 CGLM_INLINE
 mat3s
-glms_mat4_pick3t(mat4s mat) {
+glms_mat4_(pick3t)(mat4s mat) {
   mat3s r;
   glm_mat4_pick3t(mat.raw, r.raw);
   return r;
@@ -183,7 +186,7 @@ glms_mat4_pick3t(mat4s mat) {
  */
 CGLM_INLINE
 mat4s
-glms_mat4_ins3(mat3s mat) {
+glms_mat4_(ins3)(mat3s mat) {
   mat4s r;
   glm_mat4_ins3(mat.raw, r.raw);
   return r;
@@ -205,7 +208,7 @@ glms_mat4_ins3(mat3s mat) {
  */
 CGLM_INLINE
 mat4s
-glms_mat4_mul(mat4s m1, mat4s m2) {
+glms_mat4_(mul)(mat4s m1, mat4s m2) {
   mat4s r;
   glm_mat4_mul(m1.raw, m2.raw, r.raw);
   return r;
@@ -232,12 +235,12 @@ glms_mat4_mul(mat4s m1, mat4s m2) {
  */
 CGLM_INLINE
 mat4s
-glms_mat4_mulN(mat4s * __restrict matrices[], uint32_t len) {
+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]);
+    r = glms_mat4_(mul)(r, *matrices[i]);
   }
   
   return r;
@@ -252,7 +255,7 @@ glms_mat4_mulN(mat4s * __restrict matrices[], uint32_t len) {
  */
 CGLM_INLINE
 vec4s
-glms_mat4_mulv(mat4s m, vec4s v) {
+glms_mat4_(mulv)(mat4s m, vec4s v) {
   vec4s r;
   glm_mat4_mulv(m.raw, v.raw, r.raw);
   return r;
@@ -267,7 +270,7 @@ glms_mat4_mulv(mat4s m, vec4s v) {
  */
 CGLM_INLINE
 float
-glms_mat4_trace(mat4s m) {
+glms_mat4_(trace)(mat4s m) {
   return glm_mat4_trace(m.raw);
 }
 
@@ -280,7 +283,7 @@ glms_mat4_trace(mat4s m) {
  */
 CGLM_INLINE
 float
-glms_mat4_trace3(mat4s m) {
+glms_mat4_(trace3)(mat4s m) {
   return glm_mat4_trace3(m.raw);
 }
 
@@ -292,7 +295,7 @@ glms_mat4_trace3(mat4s m) {
  */
 CGLM_INLINE
 versors
-glms_mat4_quat(mat4s m) {
+glms_mat4_(quat)(mat4s m) {
   versors r;
   glm_mat4_quat(m.raw, r.raw);
   return r;
@@ -308,7 +311,7 @@ glms_mat4_quat(mat4s m) {
  */
 CGLM_INLINE
 vec3s
-glms_mat4_mulv3(mat4s m, vec3s v, float last) {
+glms_mat4_(mulv3)(mat4s m, vec3s v, float last) {
   vec3s r;
   glm_mat4_mulv3(m.raw, v.raw, last, r.raw);
   return r;
@@ -322,7 +325,7 @@ glms_mat4_mulv3(mat4s m, vec3s v, float last) {
  */
 CGLM_INLINE
 mat4s
-glms_mat4_transpose(mat4s m) {
+glms_mat4_(transpose)(mat4s m) {
   glm_mat4_transpose(m.raw);
   return m;
 }
@@ -338,7 +341,7 @@ glms_mat4_transpose(mat4s m) {
  */
 CGLM_INLINE
 mat4s
-glms_mat4_scale_p(mat4s m, float s) {
+glms_mat4_(scale_p)(mat4s m, float s) {
   glm_mat4_scale_p(m.raw, s);
   return m;
 }
@@ -354,7 +357,7 @@ glms_mat4_scale_p(mat4s m, float s) {
  */
 CGLM_INLINE
 mat4s
-glms_mat4_scale(mat4s m, float s) {
+glms_mat4_(scale)(mat4s m, float s) {
   glm_mat4_scale(m.raw, s);
   return m;
 }
@@ -368,7 +371,7 @@ glms_mat4_scale(mat4s m, float s) {
  */
 CGLM_INLINE
 float
-glms_mat4_det(mat4s mat) {
+glms_mat4_(det)(mat4s mat) {
   return glm_mat4_det(mat.raw);
 }
 
@@ -380,7 +383,7 @@ glms_mat4_det(mat4s mat) {
  */
 CGLM_INLINE
 mat4s
-glms_mat4_inv(mat4s mat) {
+glms_mat4_(inv)(mat4s mat) {
   mat4s r;
   glm_mat4_inv(mat.raw, r.raw);
   return r;
@@ -400,7 +403,7 @@ glms_mat4_inv(mat4s mat) {
  */
 CGLM_INLINE
 mat4s
-glms_mat4_inv_fast(mat4s mat) {
+glms_mat4_(inv_fast)(mat4s mat) {
   mat4s r;
   glm_mat4_inv_fast(mat.raw, r.raw);
   return r;
@@ -416,7 +419,7 @@ glms_mat4_inv_fast(mat4s mat) {
  */
 CGLM_INLINE
 mat4s
-glms_mat4_swap_col(mat4s mat, int col1, int col2) {
+glms_mat4_(swap_col)(mat4s mat, int col1, int col2) {
   glm_mat4_swap_col(mat.raw, col1, col2);
   return mat;
 }
@@ -431,7 +434,7 @@ glms_mat4_swap_col(mat4s mat, int col1, int col2) {
  */
 CGLM_INLINE
 mat4s
-glms_mat4_swap_row(mat4s mat, int row1, int row2) {
+glms_mat4_(swap_row)(mat4s mat, int row1, int row2) {
   glm_mat4_swap_row(mat.raw, row1, row2);
   return mat;
 }
@@ -452,7 +455,7 @@ glms_mat4_swap_row(mat4s mat, int row1, int row2) {
  */
 CGLM_INLINE
 float
-glms_mat4_rmc(vec4s r, mat4s m, vec4s c) {
+glms_mat4_(rmc)(vec4s r, mat4s m, vec4s c) {
   return glm_mat4_rmc(r.raw, m.raw, c.raw);
 }
 

include/cglm/struct/project.h

@@ -111,7 +111,7 @@ glms_project(vec3s pos, mat4s m, vec4s vp) {
  */
 CGLM_INLINE
 mat4s
-glms_pickmatrix(vec3s center, vec2s size, vec4s vp) {
+glms_pickmatrix(vec2s center, vec2s size, vec4s vp) {
   mat4s res;
   glm_pickmatrix(center.raw, size.raw, vp.raw, res.raw);
   return res;

include/cglm/struct/quat.h

@@ -54,6 +54,9 @@
 #include "../plane.h"
 #include "../quat.h"
 
+/* api definition */
+#define glms_quat_(NAME) CGLM_STRUCTAPI(quat, NAME)
+
 /*
  * IMPORTANT:
  * ----------------------------------------------------------------------------
@@ -74,7 +77,7 @@
  */
 CGLM_INLINE
 versors
-glms_quat_identity(void) {
+glms_quat_(identity)(void) {
   versors dest;
   glm_quat_identity(dest.raw);
   return dest;
@@ -90,7 +93,7 @@ glms_quat_identity(void) {
  */
 CGLM_INLINE
 void
-glms_quat_identity_array(versors * __restrict q, size_t count) {
+glms_quat_(identity_array)(versors * __restrict q, size_t count) {
   CGLM_ALIGN(16) versor v = GLM_QUAT_IDENTITY_INIT;
   size_t i;
 
@@ -110,7 +113,7 @@ glms_quat_identity_array(versors * __restrict q, size_t count) {
  */
 CGLM_INLINE
 versors
-glms_quat_init(float x, float y, float z, float w) {
+glms_quat_(init)(float x, float y, float z, float w) {
   versors dest;
   glm_quat_init(dest.raw, x, y, z, w);
   return dest;
@@ -157,7 +160,7 @@ glms_quat(float angle, float x, float y, float z) {
  */
 CGLM_INLINE
 versors
-glms_quat_from_vecs(vec3s a, vec3s b) {
+glms_quat_(from_vecs)(vec3s a, vec3s b) {
   versors dest;
   glm_quat_from_vecs(a.raw, b.raw, dest.raw);
   return dest;
@@ -170,7 +173,7 @@ glms_quat_from_vecs(vec3s a, vec3s b) {
  */
 CGLM_INLINE
 float
-glms_quat_norm(versors q) {
+glms_quat_(norm)(versors q) {
   return glm_quat_norm(q.raw);
 }
 
@@ -182,7 +185,7 @@ glms_quat_norm(versors q) {
  */
 CGLM_INLINE
 versors
-glms_quat_normalize(versors q) {
+glms_quat_(normalize)(versors q) {
   versors dest;
   glm_quat_normalize_to(q.raw, dest.raw);
   return dest;
@@ -197,7 +200,7 @@ glms_quat_normalize(versors q) {
  */
 CGLM_INLINE
 float
-glms_quat_dot(versors p, versors q) {
+glms_quat_(dot)(versors p, versors q) {
   return glm_quat_dot(p.raw, q.raw);
 }
 
@@ -209,7 +212,7 @@ glms_quat_dot(versors p, versors q) {
  */
 CGLM_INLINE
 versors
-glms_quat_conjugate(versors q) {
+glms_quat_(conjugate)(versors q) {
   versors dest;
   glm_quat_conjugate(q.raw, dest.raw);
   return dest;
@@ -223,7 +226,7 @@ glms_quat_conjugate(versors q) {
  */
 CGLM_INLINE
 versors
-glms_quat_inv(versors q) {
+glms_quat_(inv)(versors q) {
   versors dest;
   glm_quat_inv(q.raw, dest.raw);
   return dest;
@@ -238,7 +241,7 @@ glms_quat_inv(versors q) {
  */
 CGLM_INLINE
 versors
-glms_quat_add(versors p, versors q) {
+glms_quat_(add)(versors p, versors q) {
   versors dest;
   glm_quat_add(p.raw, q.raw, dest.raw);
   return dest;
@@ -253,7 +256,7 @@ glms_quat_add(versors p, versors q) {
  */
 CGLM_INLINE
 versors
-glms_quat_sub(versors p, versors q) {
+glms_quat_(sub)(versors p, versors q) {
   versors dest;
   glm_quat_sub(p.raw, q.raw, dest.raw);
   return dest;
@@ -266,7 +269,7 @@ glms_quat_sub(versors p, versors q) {
  */
 CGLM_INLINE
 vec3s
-glms_quat_imagn(versors q) {
+glms_quat_(imagn)(versors q) {
   vec3s dest;
   glm_normalize_to(q.raw, dest.raw);
   return dest;
@@ -279,7 +282,7 @@ glms_quat_imagn(versors q) {
  */
 CGLM_INLINE
 float
-glms_quat_imaglen(versors q) {
+glms_quat_(imaglen)(versors q) {
   return glm_quat_imaglen(q.raw);
 }
 
@@ -290,7 +293,7 @@ glms_quat_imaglen(versors q) {
  */
 CGLM_INLINE
 float
-glms_quat_angle(versors q) {
+glms_quat_(angle)(versors q) {
   return glm_quat_angle(q.raw);
 }
 
@@ -302,7 +305,7 @@ glms_quat_angle(versors q) {
  */
 CGLM_INLINE
 vec3s
-glms_quat_axis(versors q) {
+glms_quat_(axis)(versors q) {
   vec3s dest;
   glm_quat_axis(q.raw, dest.raw);
   return dest;
@@ -322,7 +325,7 @@ glms_quat_axis(versors q) {
  */
 CGLM_INLINE
 versors
-glms_quat_mul(versors p, versors q) {
+glms_quat_(mul)(versors p, versors q) {
   versors dest;
   glm_quat_mul(p.raw, q.raw, dest.raw);
   return dest;
@@ -336,7 +339,7 @@ glms_quat_mul(versors p, versors q) {
  */
 CGLM_INLINE
 mat4s
-glms_quat_mat4(versors q) {
+glms_quat_(mat4)(versors q) {
   mat4s dest;
   glm_quat_mat4(q.raw, dest.raw);
   return dest;
@@ -350,7 +353,7 @@ glms_quat_mat4(versors q) {
  */
 CGLM_INLINE
 mat4s
-glms_quat_mat4t(versors q) {
+glms_quat_(mat4t)(versors q) {
   mat4s dest;
   glm_quat_mat4t(q.raw, dest.raw);
   return dest;
@@ -364,7 +367,7 @@ glms_quat_mat4t(versors q) {
  */
 CGLM_INLINE
 mat3s
-glms_quat_mat3(versors q) {
+glms_quat_(mat3)(versors q) {
   mat3s dest;
   glm_quat_mat3(q.raw, dest.raw);
   return dest;
@@ -378,7 +381,7 @@ glms_quat_mat3(versors q) {
  */
 CGLM_INLINE
 mat3s
-glms_quat_mat3t(versors q) {
+glms_quat_(mat3t)(versors q) {
   mat3s dest;
   glm_quat_mat3t(q.raw, dest.raw);
   return dest;
@@ -395,7 +398,7 @@ glms_quat_mat3t(versors q) {
  */
 CGLM_INLINE
 versors
-glms_quat_lerp(versors from, versors to, float t) {
+glms_quat_(lerp)(versors from, versors to, float t) {
   versors dest;
   glm_quat_lerp(from.raw, to.raw, t, dest.raw);
   return dest;
@@ -412,7 +415,7 @@ glms_quat_lerp(versors from, versors to, float t) {
  */
 CGLM_INLINE
 versors
-glms_quat_lerpc(versors from, versors to, float t) {
+glms_quat_(lerpc)(versors from, versors to, float t) {
   versors dest;
   glm_quat_lerpc(from.raw, to.raw, t, dest.raw);
   return dest;
@@ -430,7 +433,7 @@ glms_quat_lerpc(versors from, versors to, float t) {
  */
 CGLM_INLINE
 versors
-glms_quat_nlerp(versors from, versors to, float t) {
+glms_quat_(nlerp)(versors from, versors to, float t) {
   versors dest;
   glm_quat_nlerp(from.raw, to.raw, t, dest.raw);
   return dest;
@@ -447,7 +450,7 @@ glms_quat_nlerp(versors from, versors to, float t) {
  */
 CGLM_INLINE
 versors
-glms_quat_slerp(versors from, versors to, float t) {
+glms_quat_(slerp)(versors from, versors to, float t) {
   versors dest;
   glm_quat_slerp(from.raw, to.raw, t, dest.raw);
   return dest;
@@ -462,7 +465,7 @@ glms_quat_slerp(versors from, versors to, float t) {
  */
 CGLM_INLINE
 mat4s
-glms_quat_look(vec3s eye, versors ori) {
+glms_quat_(look)(vec3s eye, versors ori) {
   mat4s dest;
   glm_quat_look(eye.raw, ori.raw, dest.raw);
   return dest;
@@ -477,7 +480,7 @@ glms_quat_look(vec3s eye, versors ori) {
  */
 CGLM_INLINE
 versors
-glms_quat_for(vec3s dir, vec3s up) {
+glms_quat_(for)(vec3s dir, vec3s up) {
   versors dest;
   glm_quat_for(dir.raw, up.raw, dest.raw);
   return dest;
@@ -494,7 +497,7 @@ glms_quat_for(vec3s dir, vec3s up) {
  */
 CGLM_INLINE
 versors
-glms_quat_forp(vec3s from, vec3s to, vec3s up) {
+glms_quat_(forp)(vec3s from, vec3s to, vec3s up) {
   versors dest;
   glm_quat_forp(from.raw, to.raw, up.raw, dest.raw);
   return dest;
@@ -509,7 +512,7 @@ glms_quat_forp(vec3s from, vec3s to, vec3s up) {
  */
 CGLM_INLINE
 vec3s
-glms_quat_rotatev(versors q, vec3s v) {
+glms_quat_(rotatev)(versors q, vec3s v) {
   vec3s dest;
   glm_quat_rotatev(q.raw, v.raw, dest.raw);
   return dest;
@@ -524,7 +527,7 @@ glms_quat_rotatev(versors q, vec3s v) {
  */
 CGLM_INLINE
 mat4s
-glms_quat_rotate(mat4s m, versors q) {
+glms_quat_(rotate)(mat4s m, versors q) {
   glm_quat_rotate(m.raw, q.raw, m.raw);
   return m;
 }
@@ -538,7 +541,7 @@ glms_quat_rotate(mat4s m, versors q) {
  */
 CGLM_INLINE
 mat4s
-glms_quat_rotate_at(mat4s m, versors q, vec3s pivot) {
+glms_quat_(rotate_at)(mat4s m, versors q, vec3s pivot) {
   glm_quat_rotate_at(m.raw, q.raw, pivot.raw);
   return m;
 }
@@ -556,7 +559,7 @@ glms_quat_rotate_at(mat4s m, versors q, vec3s pivot) {
  */
 CGLM_INLINE
 mat4s
-glms_quat_rotate_atm(versors q, vec3s pivot) {
+glms_quat_(rotate_atm)(versors q, vec3s pivot) {
   mat4s dest;
   glm_quat_rotate_atm(dest.raw, q.raw, pivot.raw);
   return dest;

include/cglm/struct/vec2-ext.h

@@ -34,6 +34,9 @@
 #include "../util.h"
 #include "../vec2-ext.h"
 
+/* api definition */
+#define glms_vec2_(NAME) CGLM_STRUCTAPI(vec2, NAME)
+
 /*!
  * @brief fill a vector with specified value
  *
@@ -42,7 +45,7 @@
  */
 CGLM_INLINE
 vec2s
-glms_vec2_fill(float val) {
+glms_vec2_(fill)(float val) {
   vec2s r;
   glm_vec2_fill(r.raw, val);
   return r;
@@ -56,7 +59,7 @@ glms_vec2_fill(float val) {
  */
 CGLM_INLINE
 bool
-glms_vec2_eq(vec2s v, float val) {
+glms_vec2_(eq)(vec2s v, float val) {
   return glm_vec2_eq(v.raw, val);
 }
 
@@ -68,7 +71,7 @@ glms_vec2_eq(vec2s v, float val) {
  */
 CGLM_INLINE
 bool
-glms_vec2_eq_eps(vec2s v, float val) {
+glms_vec2_(eq_eps)(vec2s v, float val) {
   return glm_vec2_eq_eps(v.raw, val);
 }
 
@@ -79,7 +82,7 @@ glms_vec2_eq_eps(vec2s v, float val) {
  */
 CGLM_INLINE
 bool
-glms_vec2_eq_all(vec2s v) {
+glms_vec2_(eq_all)(vec2s v) {
   return glm_vec2_eq_all(v.raw);
 }
 
@@ -91,7 +94,7 @@ glms_vec2_eq_all(vec2s v) {
  */
 CGLM_INLINE
 bool
-glms_vec2_eqv(vec2s a, vec2s b) {
+glms_vec2_(eqv)(vec2s a, vec2s b) {
   return glm_vec2_eqv(a.raw, b.raw);
 }
 
@@ -103,7 +106,7 @@ glms_vec2_eqv(vec2s a, vec2s b) {
  */
 CGLM_INLINE
 bool
-glms_vec2_eqv_eps(vec2s a, vec2s b) {
+glms_vec2_(eqv_eps)(vec2s a, vec2s b) {
   return glm_vec2_eqv_eps(a.raw, b.raw);
 }
 
@@ -114,7 +117,7 @@ glms_vec2_eqv_eps(vec2s a, vec2s b) {
  */
 CGLM_INLINE
 float
-glms_vec2_max(vec2s v) {
+glms_vec2_(max)(vec2s v) {
   return glm_vec2_max(v.raw);
 }
 
@@ -137,7 +140,7 @@ glms_vec2_min(vec2s v) {
  */
 CGLM_INLINE
 bool
-glms_vec2_isnan(vec2s v) {
+glms_vec2_(isnan)(vec2s v) {
   return glm_vec2_isnan(v.raw);
 }
 
@@ -149,7 +152,7 @@ glms_vec2_isnan(vec2s v) {
  */
 CGLM_INLINE
 bool
-glms_vec2_isinf(vec2s v) {
+glms_vec2_(isinf)(vec2s v) {
   return glm_vec2_isinf(v.raw);
 }
 
@@ -175,7 +178,7 @@ glms_vec2_isvalid(vec2s v) {
  */
 CGLM_INLINE
 vec2s
-glms_vec2_sign(vec2s v) {
+glms_vec2_(sign)(vec2s v) {
   vec2s r;
   glm_vec2_sign(v.raw, r.raw);
   return r;
@@ -189,7 +192,7 @@ glms_vec2_sign(vec2s v) {
  */
 CGLM_INLINE
 vec2s
-glms_vec2_sqrt(vec2s v) {
+glms_vec2_(sqrt)(vec2s v) {
   vec2s r;
   glm_vec2_sqrt(v.raw, r.raw);
   return r;
@@ -204,7 +207,7 @@ glms_vec2_sqrt(vec2s v) {
  */
 CGLM_INLINE
 vec2s
-glms_vec2_complex_mul(vec2s a, vec2s b, vec2s dest) {
+glms_vec2_(complex_mul)(vec2s a, vec2s b, vec2s dest) {
   glm_vec2_complex_mul(a.raw, b.raw, dest.raw);
   return dest;
 }
@@ -218,7 +221,7 @@ glms_vec2_complex_mul(vec2s a, vec2s b, vec2s dest) {
  */
 CGLM_INLINE
 vec2s
-glms_vec2_complex_div(vec2s a, vec2s b, vec2s dest) {
+glms_vec2_(complex_div)(vec2s a, vec2s b, vec2s dest) {
   glm_vec2_complex_div(a.raw, b.raw, dest.raw);
   return dest;
 }
@@ -231,7 +234,7 @@ glms_vec2_complex_div(vec2s a, vec2s b, vec2s dest) {
  */
 CGLM_INLINE
 vec2s
-glms_vec2_complex_conjugate(vec2s a, vec2s dest) {
+glms_vec2_(complex_conjugate)(vec2s a, vec2s dest) {
   glm_vec2_complex_conjugate(a.raw, dest.raw);
   return dest;
 }

include/cglm/struct/vec2.h

@@ -86,7 +86,7 @@ glms_vec2(vec3s v3) {
  */
 CGLM_INLINE
 void
-glms_vec2_pack(vec2s dst[], vec2 src[], size_t len) {
+glms_vec2_(pack)(vec2s dst[], vec2 src[], size_t len) {
   size_t i;
 
   for (i = 0; i < len; i++) {
@@ -103,7 +103,7 @@ glms_vec2_pack(vec2s dst[], vec2 src[], size_t len) {
  */
 CGLM_INLINE
 void
-glms_vec2_unpack(vec2 dst[], vec2s src[], size_t len) {
+glms_vec2_(unpack)(vec2 dst[], vec2s src[], size_t len) {
   size_t i;
 
   for (i = 0; i < len; i++) {
@@ -118,7 +118,7 @@ glms_vec2_unpack(vec2 dst[], vec2s src[], size_t len) {
  */
 CGLM_INLINE
 vec2s
-glms_vec2_zero(void) {
+glms_vec2_(zero)(void) {
   vec2s r;
   glm_vec2_zero(r.raw);
   return r;
@@ -131,7 +131,7 @@ glms_vec2_zero(void) {
  */
 CGLM_INLINE
 vec2s
-glms_vec2_one(void) {
+glms_vec2_(one)(void) {
   vec2s r;
   glm_vec2_one(r.raw);
   return r;
@@ -147,7 +147,7 @@ glms_vec2_one(void) {
  */
 CGLM_INLINE
 float
-glms_vec2_dot(vec2s a, vec2s b) {
+glms_vec2_(dot)(vec2s a, vec2s b) {
   return glm_vec2_dot(a.raw, b.raw);
 }
 
@@ -163,7 +163,7 @@ glms_vec2_dot(vec2s a, vec2s b) {
  */
 CGLM_INLINE
 float
-glms_vec2_cross(vec2s a, vec2s b) {
+glms_vec2_(cross)(vec2s a, vec2s b) {
   return glm_vec2_cross(a.raw, b.raw);
 }
 
@@ -180,7 +180,7 @@ glms_vec2_cross(vec2s a, vec2s b) {
  */
 CGLM_INLINE
 float
-glms_vec2_norm2(vec2s v) {
+glms_vec2_(norm2)(vec2s v) {
   return glm_vec2_norm2(v.raw);
 }
 
@@ -193,7 +193,7 @@ glms_vec2_norm2(vec2s v) {
  */
 CGLM_INLINE
 float
-glms_vec2_norm(vec2s v) {
+glms_vec2_(norm)(vec2s v) {
   return glm_vec2_norm(v.raw);
 }
 
@@ -206,7 +206,7 @@ glms_vec2_norm(vec2s v) {
  */
 CGLM_INLINE
 vec2s
-glms_vec2_add(vec2s a, vec2s b) {
+glms_vec2_(add)(vec2s a, vec2s b) {
   vec2s r;
   glm_vec2_add(a.raw, b.raw, r.raw);
   return r;
@@ -221,7 +221,7 @@ glms_vec2_add(vec2s a, vec2s b) {
  */
 CGLM_INLINE
 vec2s
-glms_vec2_adds(vec2s a, float s) {
+glms_vec2_(adds)(vec2s a, float s) {
   vec2s r;
   glm_vec2_adds(a.raw, s, r.raw);
   return r;
@@ -236,7 +236,7 @@ glms_vec2_adds(vec2s a, float s) {
  */
 CGLM_INLINE
 vec2s
-glms_vec2_sub(vec2s a, vec2s b) {
+glms_vec2_(sub)(vec2s a, vec2s b) {
   vec2s r;
   glm_vec2_sub(a.raw, b.raw, r.raw);
   return r;
@@ -251,7 +251,7 @@ glms_vec2_sub(vec2s a, vec2s b) {
  */
 CGLM_INLINE
 vec2s
-glms_vec2_subs(vec2s a, float s) {
+glms_vec2_(subs)(vec2s a, float s) {
   vec2s r;
   glm_vec2_subs(a.raw, s, r.raw);
   return r;
@@ -266,7 +266,7 @@ glms_vec2_subs(vec2s a, float s) {
  */
 CGLM_INLINE
 vec2s
-glms_vec2_mul(vec2s a, vec2s b) {
+glms_vec2_(mul)(vec2s a, vec2s b) {
   vec2s r;
   glm_vec2_mul(a.raw, b.raw, r.raw);
   return r;
@@ -281,7 +281,7 @@ glms_vec2_mul(vec2s a, vec2s b) {
  */
 CGLM_INLINE
 vec2s
-glms_vec2_scale(vec2s v, float s) {
+glms_vec2_(scale)(vec2s v, float s) {
   vec2s r;
   glm_vec2_scale(v.raw, s, r.raw);
   return r;
@@ -296,7 +296,7 @@ glms_vec2_scale(vec2s v, float s) {
  */
 CGLM_INLINE
 vec2s
-glms_vec2_scale_as(vec2s v, float s) {
+glms_vec2_(scale_as)(vec2s v, float s) {
   vec2s r;
   glm_vec2_scale_as(v.raw, s, r.raw);
   return r;
@@ -311,7 +311,7 @@ glms_vec2_scale_as(vec2s v, float s) {
  */
 CGLM_INLINE
 vec2s
-glms_vec2_div(vec2s a, vec2s b) {
+glms_vec2_(div)(vec2s a, vec2s b) {
   vec2s r;
   glm_vec2_div(a.raw, b.raw, r.raw);
   return r;
@@ -326,7 +326,7 @@ glms_vec2_div(vec2s a, vec2s b) {
  */
 CGLM_INLINE
 vec2s
-glms_vec2_divs(vec2s a, float s) {
+glms_vec2_(divs)(vec2s a, float s) {
   vec2s r;
   glm_vec2_divs(a.raw, s, r.raw);
   return r;
@@ -343,7 +343,7 @@ glms_vec2_divs(vec2s a, float s) {
  */
 CGLM_INLINE
 vec2s
-glms_vec2_addadd(vec2s a, vec2s b, vec2s dest) {
+glms_vec2_(addadd)(vec2s a, vec2s b, vec2s dest) {
   glm_vec2_addadd(a.raw, b.raw, dest.raw);
   return dest;
 }
@@ -359,7 +359,7 @@ glms_vec2_addadd(vec2s a, vec2s b, vec2s dest) {
  */
 CGLM_INLINE
 vec2s
-glms_vec2_subadd(vec2s a, vec2s b, vec2s dest) {
+glms_vec2_(subadd)(vec2s a, vec2s b, vec2s dest) {
   glm_vec2_subadd(a.raw, b.raw, dest.raw);
   return dest;
 }
@@ -375,7 +375,7 @@ glms_vec2_subadd(vec2s a, vec2s b, vec2s dest) {
  */
 CGLM_INLINE
 vec2s
-glms_vec2_muladd(vec2s a, vec2s b, vec2s dest) {
+glms_vec2_(muladd)(vec2s a, vec2s b, vec2s dest) {
   glm_vec2_muladd(a.raw, b.raw, dest.raw);
   return dest;
 }
@@ -391,7 +391,7 @@ glms_vec2_muladd(vec2s a, vec2s b, vec2s dest) {
  */
 CGLM_INLINE
 vec2s
-glms_vec2_muladds(vec2s a, float s, vec2s dest) {
+glms_vec2_(muladds)(vec2s a, float s, vec2s dest) {
   glm_vec2_muladds(a.raw, s, dest.raw);
   return dest;
 }
@@ -407,7 +407,7 @@ glms_vec2_muladds(vec2s a, float s, vec2s dest) {
  */
 CGLM_INLINE
 vec2s
-glms_vec2_maxadd(vec2s a, vec2s b, vec2s dest) {
+glms_vec2_(maxadd)(vec2s a, vec2s b, vec2s dest) {
   glm_vec2_maxadd(a.raw, b.raw, dest.raw);
   return dest;
 }
@@ -423,7 +423,7 @@ glms_vec2_maxadd(vec2s a, vec2s b, vec2s dest) {
  */
 CGLM_INLINE
 vec2s
-glms_vec2_minadd(vec2s a, vec2s b, vec2s dest) {
+glms_vec2_(minadd)(vec2s a, vec2s b, vec2s dest) {
   glm_vec2_minadd(a.raw, b.raw, dest.raw);
   return dest;
 }
@@ -436,7 +436,7 @@ glms_vec2_minadd(vec2s a, vec2s b, vec2s dest) {
  */
 CGLM_INLINE
 vec2s
-glms_vec2_negate(vec2s v) {
+glms_vec2_(negate)(vec2s v) {
   glm_vec2_negate(v.raw);
   return v;
 }
@@ -449,7 +449,7 @@ glms_vec2_negate(vec2s v) {
  */
 CGLM_INLINE
 vec2s
-glms_vec2_normalize(vec2s v) {
+glms_vec2_(normalize)(vec2s v) {
   glm_vec2_normalize(v.raw);
   return v;
 }
@@ -463,7 +463,7 @@ glms_vec2_normalize(vec2s v) {
  */
 CGLM_INLINE
 vec2s
-glms_vec2_rotate(vec2s v, float angle) {
+glms_vec2_(rotate)(vec2s v, float angle) {
   vec2s r;
   glm_vec2_rotate(v.raw, angle, r.raw);
   return r;
@@ -478,7 +478,7 @@ glms_vec2_rotate(vec2s v, float angle) {
  */
 CGLM_INLINE
 float
-glms_vec2_distance(vec2s a, vec2s b) {
+glms_vec2_(distance)(vec2s a, vec2s b) {
   return glm_vec2_distance(a.raw, b.raw);
 }
 
@@ -491,7 +491,7 @@ glms_vec2_distance(vec2s a, vec2s b) {
  */
 CGLM_INLINE
 float
-glms_vec2_distance2(vec2s a, vec2s b) {
+glms_vec2_(distance2)(vec2s a, vec2s b) {
   return glm_vec2_distance2(a.raw, b.raw);
 }
 
@@ -504,7 +504,7 @@ glms_vec2_distance2(vec2s a, vec2s b) {
  */
 CGLM_INLINE
 vec2s
-glms_vec2_maxv(vec2s a, vec2s b) {
+glms_vec2_(maxv)(vec2s a, vec2s b) {
   vec2s r;
   glm_vec2_maxv(a.raw, b.raw, r.raw);
   return r;
@@ -519,7 +519,7 @@ glms_vec2_maxv(vec2s a, vec2s b) {
  */
 CGLM_INLINE
 vec2s
-glms_vec2_minv(vec2s a, vec2s b) {
+glms_vec2_(minv)(vec2s a, vec2s b) {
   vec2s r;
   glm_vec2_minv(a.raw, b.raw, r.raw);
   return r;
@@ -535,7 +535,7 @@ glms_vec2_minv(vec2s a, vec2s b) {
  */
 CGLM_INLINE
 vec2s
-glms_vec2_clamp(vec2s v, float minVal, float maxVal) {
+glms_vec2_(clamp)(vec2s v, float minVal, float maxVal) {
   glm_vec2_clamp(v.raw, minVal, maxVal);
   return v;
 }
@@ -552,7 +552,7 @@ glms_vec2_clamp(vec2s v, float minVal, float maxVal) {
  */
 CGLM_INLINE
 vec2s
-glms_vec2_lerp(vec2s from, vec2s to, float t) {
+glms_vec2_(lerp)(vec2s from, vec2s to, float t) {
   vec2s r;
   glm_vec2_lerp(from.raw, to.raw, t, r.raw);
   return r;

include/cglm/struct/vec3-ext.h

@@ -38,6 +38,9 @@
 #include "../util.h"
 #include "../vec3-ext.h"
 
+/* api definition */
+#define glms_vec3_(NAME) CGLM_STRUCTAPI(vec3, NAME)
+
 /*!
  * @brief fill a vector with specified value
  *
@@ -46,7 +49,7 @@
  */
 CGLM_INLINE
 vec3s
-glms_vec3_broadcast(float val) {
+glms_vec3_(broadcast)(float val) {
   vec3s r;
   glm_vec3_broadcast(val, r.raw);
   return r;
@@ -60,7 +63,7 @@ glms_vec3_broadcast(float val) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_fill(float val) {
+glms_vec3_(fill)(float val) {
   vec3s r;
   glm_vec3_fill(r.raw, val);
   return r;
@@ -74,7 +77,7 @@ glms_vec3_fill(float val) {
  */
 CGLM_INLINE
 bool
-glms_vec3_eq(vec3s v, float val) {
+glms_vec3_(eq)(vec3s v, float val) {
   return glm_vec3_eq(v.raw, val);
 }
 
@@ -86,7 +89,7 @@ glms_vec3_eq(vec3s v, float val) {
  */
 CGLM_INLINE
 bool
-glms_vec3_eq_eps(vec3s v, float val) {
+glms_vec3_(eq_eps)(vec3s v, float val) {
   return glm_vec3_eq_eps(v.raw, val);
 }
 
@@ -97,7 +100,7 @@ glms_vec3_eq_eps(vec3s v, float val) {
  */
 CGLM_INLINE
 bool
-glms_vec3_eq_all(vec3s v) {
+glms_vec3_(eq_all)(vec3s v) {
   return glm_vec3_eq_all(v.raw);
 }
 
@@ -109,7 +112,7 @@ glms_vec3_eq_all(vec3s v) {
  */
 CGLM_INLINE
 bool
-glms_vec3_eqv(vec3s a, vec3s b) {
+glms_vec3_(eqv)(vec3s a, vec3s b) {
   return glm_vec3_eqv(a.raw, b.raw);
 }
 
@@ -121,7 +124,7 @@ glms_vec3_eqv(vec3s a, vec3s b) {
  */
 CGLM_INLINE
 bool
-glms_vec3_eqv_eps(vec3s a, vec3s b) {
+glms_vec3_(eqv_eps)(vec3s a, vec3s b) {
   return glm_vec3_eqv_eps(a.raw, b.raw);
 }
 
@@ -132,7 +135,7 @@ glms_vec3_eqv_eps(vec3s a, vec3s b) {
  */
 CGLM_INLINE
 float
-glms_vec3_max(vec3s v) {
+glms_vec3_(max)(vec3s v) {
   return glm_vec3_max(v.raw);
 }
 
@@ -143,7 +146,7 @@ glms_vec3_max(vec3s v) {
  */
 CGLM_INLINE
 float
-glms_vec3_min(vec3s v) {
+glms_vec3_(min)(vec3s v) {
   return glm_vec3_min(v.raw);
 }
 
@@ -155,7 +158,7 @@ glms_vec3_min(vec3s v) {
  */
 CGLM_INLINE
 bool
-glms_vec3_isnan(vec3s v) {
+glms_vec3_(isnan)(vec3s v) {
   return glm_vec3_isnan(v.raw);
 }
 
@@ -167,7 +170,7 @@ glms_vec3_isnan(vec3s v) {
  */
 CGLM_INLINE
 bool
-glms_vec3_isinf(vec3s v) {
+glms_vec3_(isinf)(vec3s v) {
   return glm_vec3_isinf(v.raw);
 }
 
@@ -179,7 +182,7 @@ glms_vec3_isinf(vec3s v) {
  */
 CGLM_INLINE
 bool
-glms_vec3_isvalid(vec3s v) {
+glms_vec3_(isvalid)(vec3s v) {
   return glm_vec3_isvalid(v.raw);
 }
 
@@ -193,7 +196,7 @@ glms_vec3_isvalid(vec3s v) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_sign(vec3s v) {
+glms_vec3_(sign)(vec3s v) {
   vec3s r;
   glm_vec3_sign(v.raw, r.raw);
   return r;
@@ -207,7 +210,7 @@ glms_vec3_sign(vec3s v) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_abs(vec3s v) {
+glms_vec3_(abs)(vec3s v) {
   vec3s r;
   glm_vec3_abs(v.raw, r.raw);
   return r;
@@ -221,7 +224,7 @@ glms_vec3_abs(vec3s v) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_fract(vec3s v) {
+glms_vec3_(fract)(vec3s v) {
   vec3s r;
   glm_vec3_fract(v.raw, r.raw);
   return r;
@@ -236,7 +239,7 @@ glms_vec3_fract(vec3s v) {
  */
 CGLM_INLINE
 float
-glms_vec3_hadd(vec3s v) {
+glms_vec3_(hadd)(vec3s v) {
   return glm_vec3_hadd(v.raw);
 }
 
@@ -248,7 +251,7 @@ glms_vec3_hadd(vec3s v) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_sqrt(vec3s v) {
+glms_vec3_(sqrt)(vec3s v) {
   vec3s r;
   glm_vec3_sqrt(v.raw, r.raw);
   return r;

include/cglm/struct/vec3.h

@@ -119,7 +119,7 @@ glms_vec3(vec4s v4) {
  */
 CGLM_INLINE
 void
-glms_vec3_pack(vec3s dst[], vec3 src[], size_t len) {
+glms_vec3_(pack)(vec3s dst[], vec3 src[], size_t len) {
   size_t i;
 
   for (i = 0; i < len; i++) {
@@ -136,7 +136,7 @@ glms_vec3_pack(vec3s dst[], vec3 src[], size_t len) {
  */
 CGLM_INLINE
 void
-glms_vec3_unpack(vec3 dst[], vec3s src[], size_t len) {
+glms_vec3_(unpack)(vec3 dst[], vec3s src[], size_t len) {
   size_t i;
 
   for (i = 0; i < len; i++) {
@@ -151,7 +151,7 @@ glms_vec3_unpack(vec3 dst[], vec3s src[], size_t len) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_zero(void) {
+glms_vec3_(zero)(void) {
   vec3s r;
   glm_vec3_zero(r.raw);
   return r;
@@ -164,7 +164,7 @@ glms_vec3_zero(void) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_one(void) {
+glms_vec3_(one)(void) {
   vec3s r;
   glm_vec3_one(r.raw);
   return r;
@@ -180,7 +180,7 @@ glms_vec3_one(void) {
  */
 CGLM_INLINE
 float
-glms_vec3_dot(vec3s a, vec3s b) {
+glms_vec3_(dot)(vec3s a, vec3s b) {
   return glm_vec3_dot(a.raw, b.raw);
 }
 
@@ -197,7 +197,7 @@ glms_vec3_dot(vec3s a, vec3s b) {
  */
 CGLM_INLINE
 float
-glms_vec3_norm2(vec3s v) {
+glms_vec3_(norm2)(vec3s v) {
   return glm_vec3_norm2(v.raw);
 }
 
@@ -210,7 +210,7 @@ glms_vec3_norm2(vec3s v) {
  */
 CGLM_INLINE
 float
-glms_vec3_norm(vec3s v) {
+glms_vec3_(norm)(vec3s v) {
   return glm_vec3_norm(v.raw);
 }
 
@@ -230,7 +230,7 @@ glms_vec3_norm(vec3s v) {
  */
 CGLM_INLINE
 float
-glms_vec3_norm_one(vec3s v) {
+glms_vec3_(norm_one)(vec3s v) {
   return glm_vec3_norm_one(v.raw);
 }
 
@@ -249,7 +249,7 @@ glms_vec3_norm_one(vec3s v) {
  */
 CGLM_INLINE
 float
-glms_vec3_norm_inf(vec3s v) {
+glms_vec3_(norm_inf)(vec3s v) {
   return glm_vec3_norm_inf(v.raw);
 }
 
@@ -262,7 +262,7 @@ glms_vec3_norm_inf(vec3s v) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_add(vec3s a, vec3s b) {
+glms_vec3_(add)(vec3s a, vec3s b) {
   vec3s r;
   glm_vec3_add(a.raw, b.raw, r.raw);
   return r;
@@ -277,7 +277,7 @@ glms_vec3_add(vec3s a, vec3s b) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_adds(vec3s a, float s) {
+glms_vec3_(adds)(vec3s a, float s) {
   vec3s r;
   glm_vec3_adds(a.raw, s, r.raw);
   return r;
@@ -292,7 +292,7 @@ glms_vec3_adds(vec3s a, float s) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_sub(vec3s a, vec3s b) {
+glms_vec3_(sub)(vec3s a, vec3s b) {
   vec3s r;
   glm_vec3_sub(a.raw, b.raw, r.raw);
   return r;
@@ -307,7 +307,7 @@ glms_vec3_sub(vec3s a, vec3s b) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_subs(vec3s a, float s) {
+glms_vec3_(subs)(vec3s a, float s) {
   vec3s r;
   glm_vec3_subs(a.raw, s, r.raw);
   return r;
@@ -322,7 +322,7 @@ glms_vec3_subs(vec3s a, float s) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_mul(vec3s a, vec3s b) {
+glms_vec3_(mul)(vec3s a, vec3s b) {
   vec3s r;
   glm_vec3_mul(a.raw, b.raw, r.raw);
   return r;
@@ -337,7 +337,7 @@ glms_vec3_mul(vec3s a, vec3s b) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_scale(vec3s v, float s) {
+glms_vec3_(scale)(vec3s v, float s) {
   vec3s r;
   glm_vec3_scale(v.raw, s, r.raw);
   return r;
@@ -352,7 +352,7 @@ glms_vec3_scale(vec3s v, float s) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_scale_as(vec3s v, float s) {
+glms_vec3_(scale_as)(vec3s v, float s) {
   vec3s r;
   glm_vec3_scale_as(v.raw, s, r.raw);
   return r;
@@ -367,7 +367,7 @@ glms_vec3_scale_as(vec3s v, float s) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_div(vec3s a, vec3s b) {
+glms_vec3_(div)(vec3s a, vec3s b) {
   vec3s r;
   glm_vec3_div(a.raw, b.raw, r.raw);
   return r;
@@ -382,7 +382,7 @@ glms_vec3_div(vec3s a, vec3s b) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_divs(vec3s a, float s) {
+glms_vec3_(divs)(vec3s a, float s) {
   vec3s r;
   glm_vec3_divs(a.raw, s, r.raw);
   return r;
@@ -399,7 +399,7 @@ glms_vec3_divs(vec3s a, float s) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_addadd(vec3s a, vec3s b, vec3s dest) {
+glms_vec3_(addadd)(vec3s a, vec3s b, vec3s dest) {
   glm_vec3_addadd(a.raw, b.raw, dest.raw);
   return dest;
 }
@@ -415,7 +415,7 @@ glms_vec3_addadd(vec3s a, vec3s b, vec3s dest) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_subadd(vec3s a, vec3s b, vec3s dest) {
+glms_vec3_(subadd)(vec3s a, vec3s b, vec3s dest) {
   glm_vec3_subadd(a.raw, b.raw, dest.raw);
   return dest;
 }
@@ -431,7 +431,7 @@ glms_vec3_subadd(vec3s a, vec3s b, vec3s dest) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_muladd(vec3s a, vec3s b, vec3s dest) {
+glms_vec3_(muladd)(vec3s a, vec3s b, vec3s dest) {
   glm_vec3_muladd(a.raw, b.raw, dest.raw);
   return dest;
 }
@@ -447,7 +447,7 @@ glms_vec3_muladd(vec3s a, vec3s b, vec3s dest) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_muladds(vec3s a, float s, vec3s dest) {
+glms_vec3_(muladds)(vec3s a, float s, vec3s dest) {
   glm_vec3_muladds(a.raw, s, dest.raw);
   return dest;
 }
@@ -463,7 +463,7 @@ glms_vec3_muladds(vec3s a, float s, vec3s dest) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_maxadd(vec3s a, vec3s b, vec3s dest) {
+glms_vec3_(maxadd)(vec3s a, vec3s b, vec3s dest) {
   glm_vec3_maxadd(a.raw, b.raw, dest.raw);
   return dest;
 }
@@ -479,7 +479,7 @@ glms_vec3_maxadd(vec3s a, vec3s b, vec3s dest) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_minadd(vec3s a, vec3s b, vec3s dest) {
+glms_vec3_(minadd)(vec3s a, vec3s b, vec3s dest) {
   glm_vec3_minadd(a.raw, b.raw, dest.raw);
   return dest;
 }
@@ -492,7 +492,7 @@ glms_vec3_minadd(vec3s a, vec3s b, vec3s dest) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_flipsign(vec3s v) {
+glms_vec3_(flipsign)(vec3s v) {
   glm_vec3_flipsign(v.raw);
   return v;
 }
@@ -505,7 +505,7 @@ glms_vec3_flipsign(vec3s v) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_negate(vec3s v) {
+glms_vec3_(negate)(vec3s v) {
   glm_vec3_negate(v.raw);
   return v;
 }
@@ -518,7 +518,7 @@ glms_vec3_negate(vec3s v) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_normalize(vec3s v) {
+glms_vec3_(normalize)(vec3s v) {
   glm_vec3_normalize(v.raw);
   return v;
 }
@@ -532,7 +532,7 @@ glms_vec3_normalize(vec3s v) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_cross(vec3s a, vec3s b) {
+glms_vec3_(cross)(vec3s a, vec3s b) {
   vec3s r;
   glm_vec3_cross(a.raw, b.raw, r.raw);
   return r;
@@ -547,7 +547,7 @@ glms_vec3_cross(vec3s a, vec3s b) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_crossn(vec3s a, vec3s b) {
+glms_vec3_(crossn)(vec3s a, vec3s b) {
   vec3s r;
   glm_vec3_crossn(a.raw, b.raw, r.raw);
   return r;
@@ -563,7 +563,7 @@ glms_vec3_crossn(vec3s a, vec3s b) {
  */
 CGLM_INLINE
 float
-glms_vec3_angle(vec3s a, vec3s b) {
+glms_vec3_(angle)(vec3s a, vec3s b) {
   return glm_vec3_angle(a.raw, b.raw);
 }
 
@@ -577,7 +577,7 @@ glms_vec3_angle(vec3s a, vec3s b) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_rotate(vec3s v, float angle, vec3s axis) {
+glms_vec3_(rotate)(vec3s v, float angle, vec3s axis) {
   glm_vec3_rotate(v.raw, angle, axis.raw);
   return v;
 }
@@ -597,7 +597,7 @@ glms_vec3_rotate(vec3s v, float angle, vec3s axis) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_rotate_m4(mat4s m, vec3s v) {
+glms_vec3_(rotate_m4)(mat4s m, vec3s v) {
   vec3s r;
   glm_vec3_rotate_m4(m.raw, v.raw, r.raw);
   return r;
@@ -612,7 +612,7 @@ glms_vec3_rotate_m4(mat4s m, vec3s v) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_rotate_m3(mat3s m, vec3s v) {
+glms_vec3_(rotate_m3)(mat3s m, vec3s v) {
   vec3s r;
   glm_vec3_rotate_m3(m.raw, v.raw, r.raw);
   return r;
@@ -627,7 +627,7 @@ glms_vec3_rotate_m3(mat3s m, vec3s v) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_proj(vec3s a, vec3s b) {
+glms_vec3_(proj)(vec3s a, vec3s b) {
   vec3s r;
   glm_vec3_proj(a.raw, b.raw, r.raw);
   return r;
@@ -642,7 +642,7 @@ glms_vec3_proj(vec3s a, vec3s b) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_center(vec3s a, vec3s b) {
+glms_vec3_(center)(vec3s a, vec3s b) {
   vec3s r;
   glm_vec3_center(a.raw, b.raw, r.raw);
   return r;
@@ -657,7 +657,7 @@ glms_vec3_center(vec3s a, vec3s b) {
  */
 CGLM_INLINE
 float
-glms_vec3_distance(vec3s a, vec3s b) {
+glms_vec3_(distance)(vec3s a, vec3s b) {
   return glm_vec3_distance(a.raw, b.raw);
 }
 
@@ -670,7 +670,7 @@ glms_vec3_distance(vec3s a, vec3s b) {
  */
 CGLM_INLINE
 float
-glms_vec3_distance2(vec3s a, vec3s b) {
+glms_vec3_(distance2)(vec3s a, vec3s b) {
   return glm_vec3_distance2(a.raw, b.raw);
 }
 
@@ -683,7 +683,7 @@ glms_vec3_distance2(vec3s a, vec3s b) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_maxv(vec3s a, vec3s b) {
+glms_vec3_(maxv)(vec3s a, vec3s b) {
   vec3s r;
   glm_vec3_maxv(a.raw, b.raw, r.raw);
   return r;
@@ -698,7 +698,7 @@ glms_vec3_maxv(vec3s a, vec3s b) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_minv(vec3s a, vec3s b) {
+glms_vec3_(minv)(vec3s a, vec3s b) {
   vec3s r;
   glm_vec3_minv(a.raw, b.raw, r.raw);
   return r;
@@ -712,7 +712,7 @@ glms_vec3_minv(vec3s a, vec3s b) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_ortho(vec3s v) {
+glms_vec3_(ortho)(vec3s v) {
   vec3s r;
   glm_vec3_ortho(v.raw, r.raw);
   return r;
@@ -728,7 +728,7 @@ glms_vec3_ortho(vec3s v) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_clamp(vec3s v, float minVal, float maxVal) {
+glms_vec3_(clamp)(vec3s v, float minVal, float maxVal) {
   glm_vec3_clamp(v.raw, minVal, maxVal);
   return v;
 }
@@ -745,7 +745,7 @@ glms_vec3_clamp(vec3s v, float minVal, float maxVal) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_lerp(vec3s from, vec3s to, float t) {
+glms_vec3_(lerp)(vec3s from, vec3s to, float t) {
   vec3s r;
   glm_vec3_lerp(from.raw, to.raw, t, r.raw);
   return r;
@@ -763,7 +763,7 @@ glms_vec3_lerp(vec3s from, vec3s to, float t) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_lerpc(vec3s from, vec3s to, float t) {
+glms_vec3_(lerpc)(vec3s from, vec3s to, float t) {
   vec3s r;
   glm_vec3_lerpc(from.raw, to.raw, t, r.raw);
   return r;
@@ -781,7 +781,7 @@ glms_vec3_lerpc(vec3s from, vec3s to, float t) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_mix(vec3s from, vec3s to, float t) {
+glms_vec3_(mix)(vec3s from, vec3s to, float t) {
   vec3s r;
   glm_vec3_mix(from.raw, to.raw, t, r.raw);
   return r;
@@ -799,7 +799,7 @@ glms_vec3_mix(vec3s from, vec3s to, float t) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_mixc(vec3s from, vec3s to, float t) {
+glms_vec3_(mixc)(vec3s from, vec3s to, float t) {
   vec3s r;
   glm_vec3_mixc(from.raw, to.raw, t, r.raw);
   return r;
@@ -814,7 +814,7 @@ glms_vec3_mixc(vec3s from, vec3s to, float t) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_step_uni(float edge, vec3s x) {
+glms_vec3_(step_uni)(float edge, vec3s x) {
   vec3s r;
   glm_vec3_step_uni(edge, x.raw, r.raw);
   return r;
@@ -829,7 +829,7 @@ glms_vec3_step_uni(float edge, vec3s x) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_step(vec3s edge, vec3s x) {
+glms_vec3_(step)(vec3s edge, vec3s x) {
   vec3s r;
   glm_vec3_step(edge.raw, x.raw, r.raw);
   return r;
@@ -845,7 +845,7 @@ glms_vec3_step(vec3s edge, vec3s x) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_smoothstep_uni(float edge0, float edge1, vec3s x) {
+glms_vec3_(smoothstep_uni)(float edge0, float edge1, vec3s x) {
   vec3s r;
   glm_vec3_smoothstep_uni(edge0, edge1, x.raw, r.raw);
   return r;
@@ -861,7 +861,7 @@ glms_vec3_smoothstep_uni(float edge0, float edge1, vec3s x) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_smoothstep(vec3s edge0, vec3s edge1, vec3s x) {
+glms_vec3_(smoothstep)(vec3s edge0, vec3s edge1, vec3s x) {
   vec3s r;
   glm_vec3_smoothstep(edge0.raw, edge1.raw, x.raw, r.raw);
   return r;
@@ -879,7 +879,7 @@ glms_vec3_smoothstep(vec3s edge0, vec3s edge1, vec3s x) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_smoothinterp(vec3s from, vec3s to, float t) {
+glms_vec3_(smoothinterp)(vec3s from, vec3s to, float t) {
   vec3s r;
   glm_vec3_smoothinterp(from.raw, to.raw, t, r.raw);
   return r;
@@ -897,7 +897,7 @@ glms_vec3_smoothinterp(vec3s from, vec3s to, float t) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_smoothinterpc(vec3s from, vec3s to, float t) {
+glms_vec3_(smoothinterpc)(vec3s from, vec3s to, float t) {
   vec3s r;
   glm_vec3_smoothinterpc(from.raw, to.raw, t, r.raw);
   return r;
@@ -961,7 +961,7 @@ glms_normalize(vec3s v) {
  */
 CGLM_INLINE
 vec3s
-glms_vec3_swizzle(vec3s v, int mask) {
+glms_vec3_(swizzle)(vec3s v, int mask) {
   vec3s dest;
   glm_vec3_swizzle(v.raw, mask, dest.raw);
   return dest;

include/cglm/struct/vec4-ext.h

@@ -38,6 +38,9 @@
 #include "../util.h"
 #include "../vec4-ext.h"
 
+/* api definition */
+#define glms_vec4_(NAME) CGLM_STRUCTAPI(vec4, NAME)
+
 /*!
  * @brief fill a vector with specified value
  *
@@ -46,7 +49,7 @@
  */
 CGLM_INLINE
 vec4s
-glms_vec4_broadcast(float val) {
+glms_vec4_(broadcast)(float val) {
   vec4s r;
   glm_vec4_broadcast(val, r.raw);
   return r;
@@ -60,7 +63,7 @@ glms_vec4_broadcast(float val) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_fill(float val) {
+glms_vec4_(fill)(float val) {
   vec4s r;
   glm_vec4_fill(r.raw, val);
   return r;
@@ -74,7 +77,7 @@ glms_vec4_fill(float val) {
  */
 CGLM_INLINE
 bool
-glms_vec4_eq(vec4s v, float val) {
+glms_vec4_(eq)(vec4s v, float val) {
   return glm_vec4_eq(v.raw, val);
 }
 
@@ -86,7 +89,7 @@ glms_vec4_eq(vec4s v, float val) {
  */
 CGLM_INLINE
 bool
-glms_vec4_eq_eps(vec4s v, float val) {
+glms_vec4_(eq_eps)(vec4s v, float val) {
   return glm_vec4_eq_eps(v.raw, val);
 }
 
@@ -97,7 +100,7 @@ glms_vec4_eq_eps(vec4s v, float val) {
  */
 CGLM_INLINE
 bool
-glms_vec4_eq_all(vec4s v) {
+glms_vec4_(eq_all)(vec4s v) {
   return glm_vec4_eq_all(v.raw);
 }
 
@@ -109,7 +112,7 @@ glms_vec4_eq_all(vec4s v) {
  */
 CGLM_INLINE
 bool
-glms_vec4_eqv(vec4s a, vec4s b) {
+glms_vec4_(eqv)(vec4s a, vec4s b) {
   return glm_vec4_eqv(a.raw, b.raw);
 }
 
@@ -121,7 +124,7 @@ glms_vec4_eqv(vec4s a, vec4s b) {
  */
 CGLM_INLINE
 bool
-glms_vec4_eqv_eps(vec4s a, vec4s b) {
+glms_vec4_(eqv_eps)(vec4s a, vec4s b) {
   return glm_vec4_eqv_eps(a.raw, b.raw);
 }
 
@@ -132,7 +135,7 @@ glms_vec4_eqv_eps(vec4s a, vec4s b) {
  */
 CGLM_INLINE
 float
-glms_vec4_max(vec4s v) {
+glms_vec4_(max)(vec4s v) {
   return glm_vec4_max(v.raw);
 }
 
@@ -143,7 +146,7 @@ glms_vec4_max(vec4s v) {
  */
 CGLM_INLINE
 float
-glms_vec4_min(vec4s v) {
+glms_vec4_(min)(vec4s v) {
   return glm_vec4_min(v.raw);
 }
 
@@ -155,7 +158,7 @@ glms_vec4_min(vec4s v) {
  */
 CGLM_INLINE
 bool
-glms_vec4_isnan(vec4s v) {
+glms_vec4_(isnan)(vec4s v) {
   return glm_vec4_isnan(v.raw);
 }
 
@@ -167,7 +170,7 @@ glms_vec4_isnan(vec4s v) {
  */
 CGLM_INLINE
 bool
-glms_vec4_isinf(vec4s v) {
+glms_vec4_(isinf)(vec4s v) {
   return glm_vec4_isinf(v.raw);
 }
 
@@ -179,7 +182,7 @@ glms_vec4_isinf(vec4s v) {
  */
 CGLM_INLINE
 bool
-glms_vec4_isvalid(vec4s v) {
+glms_vec4_(isvalid)(vec4s v) {
   return glm_vec4_isvalid(v.raw);
 }
 
@@ -193,7 +196,7 @@ glms_vec4_isvalid(vec4s v) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_sign(vec4s v) {
+glms_vec4_(sign)(vec4s v) {
   vec4s r;
   glm_vec4_sign(v.raw, r.raw);
   return r;
@@ -207,7 +210,7 @@ glms_vec4_sign(vec4s v) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_abs(vec4s v) {
+glms_vec4_(abs)(vec4s v) {
   vec4s r;
   glm_vec4_abs(v.raw, r.raw);
   return r;
@@ -221,7 +224,7 @@ glms_vec4_abs(vec4s v) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_fract(vec4s v) {
+glms_vec4_(fract)(vec4s v) {
   vec4s r;
   glm_vec4_fract(v.raw, r.raw);
   return r;
@@ -236,7 +239,7 @@ glms_vec4_fract(vec4s v) {
  */
 CGLM_INLINE
 float
-glms_vec4_hadd(vec4s v) {
+glms_vec4_(hadd)(vec4s v) {
   return glm_vec4_hadd(v.raw);
 }
 
@@ -248,7 +251,7 @@ glms_vec4_hadd(vec4s v) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_sqrt(vec4s v) {
+glms_vec4_(sqrt)(vec4s v) {
   vec4s r;
   glm_vec4_sqrt(v.raw, r.raw);
   return r;

include/cglm/struct/vec4.h

@@ -103,7 +103,7 @@ glms_vec4(vec3s v3, float last) {
  */
 CGLM_INLINE
 vec3s
-glms_vec4_copy3(vec4s v) {
+glms_vec4_(copy3)(vec4s v) {
   vec3s r;
   glm_vec4_copy3(v.raw, r.raw);
   return r;
@@ -117,7 +117,7 @@ glms_vec4_copy3(vec4s v) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_copy(vec4s v) {
+glms_vec4_(copy)(vec4s v) {
   vec4s r;
   glm_vec4_copy(v.raw, r.raw);
   return r;
@@ -133,7 +133,7 @@ glms_vec4_copy(vec4s v) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_ucopy(vec4s v) {
+glms_vec4_(ucopy)(vec4s v) {
   vec4s r;
   glm_vec4_ucopy(v.raw, r.raw);
   return r;
@@ -148,7 +148,7 @@ glms_vec4_ucopy(vec4s v) {
  */
 CGLM_INLINE
 void
-glms_vec4_pack(vec4s dst[], vec4 src[], size_t len) {
+glms_vec4_(pack)(vec4s dst[], vec4 src[], size_t len) {
   size_t i;
 
   for (i = 0; i < len; i++) {
@@ -165,7 +165,7 @@ glms_vec4_pack(vec4s dst[], vec4 src[], size_t len) {
  */
 CGLM_INLINE
 void
-glms_vec4_unpack(vec4 dst[], vec4s src[], size_t len) {
+glms_vec4_(unpack)(vec4 dst[], vec4s src[], size_t len) {
   size_t i;
 
   for (i = 0; i < len; i++) {
@@ -180,7 +180,7 @@ glms_vec4_unpack(vec4 dst[], vec4s src[], size_t len) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_zero(void) {
+glms_vec4_(zero)(void) {
   vec4s r;
   glm_vec4_zero(r.raw);
   return r;
@@ -193,7 +193,7 @@ glms_vec4_zero(void) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_one(void) {
+glms_vec4_(one)(void) {
   vec4s r;
   glm_vec4_one(r.raw);
   return r;
@@ -209,7 +209,7 @@ glms_vec4_one(void) {
  */
 CGLM_INLINE
 float
-glms_vec4_dot(vec4s a, vec4s b) {
+glms_vec4_(dot)(vec4s a, vec4s b) {
   return glm_vec4_dot(a.raw, b.raw);
 }
 
@@ -226,7 +226,7 @@ glms_vec4_dot(vec4s a, vec4s b) {
  */
 CGLM_INLINE
 float
-glms_vec4_norm2(vec4s v) {
+glms_vec4_(norm2)(vec4s v) {
   return glm_vec4_norm2(v.raw);
 }
 
@@ -239,7 +239,7 @@ glms_vec4_norm2(vec4s v) {
  */
 CGLM_INLINE
 float
-glms_vec4_norm(vec4s v) {
+glms_vec4_(norm)(vec4s v) {
   return glm_vec4_norm(v.raw);
 }
 
@@ -259,7 +259,7 @@ glms_vec4_norm(vec4s v) {
  */
 CGLM_INLINE
 float
-glms_vec4_norm_one(vec4s v) {
+glms_vec4_(norm_one)(vec4s v) {
   return glm_vec4_norm_one(v.raw);
 }
 
@@ -278,7 +278,7 @@ glms_vec4_norm_one(vec4s v) {
  */
 CGLM_INLINE
 float
-glms_vec4_norm_inf(vec4s v) {
+glms_vec4_(norm_inf)(vec4s v) {
   return glm_vec4_norm_inf(v.raw);
 }
 
@@ -291,7 +291,7 @@ glms_vec4_norm_inf(vec4s v) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_add(vec4s a, vec4s b) {
+glms_vec4_(add)(vec4s a, vec4s b) {
   vec4s r;
   glm_vec4_add(a.raw, b.raw, r.raw);
   return r;
@@ -306,7 +306,7 @@ glms_vec4_add(vec4s a, vec4s b) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_adds(vec4s v, float s) {
+glms_vec4_(adds)(vec4s v, float s) {
   vec4s r;
   glm_vec4_adds(v.raw, s, r.raw);
   return r;
@@ -321,7 +321,7 @@ glms_vec4_adds(vec4s v, float s) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_sub(vec4s a, vec4s b) {
+glms_vec4_(sub)(vec4s a, vec4s b) {
   vec4s r;
   glm_vec4_sub(a.raw, b.raw, r.raw);
   return r;
@@ -336,7 +336,7 @@ glms_vec4_sub(vec4s a, vec4s b) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_subs(vec4s v, float s) {
+glms_vec4_(subs)(vec4s v, float s) {
   vec4s r;
   glm_vec4_subs(v.raw, s, r.raw);
   return r;
@@ -351,7 +351,7 @@ glms_vec4_subs(vec4s v, float s) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_mul(vec4s a, vec4s b) {
+glms_vec4_(mul)(vec4s a, vec4s b) {
   vec4s r;
   glm_vec4_mul(a.raw, b.raw, r.raw);
   return r;
@@ -366,7 +366,7 @@ glms_vec4_mul(vec4s a, vec4s b) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_scale(vec4s v, float s) {
+glms_vec4_(scale)(vec4s v, float s) {
   vec4s r;
   glm_vec4_scale(v.raw, s, r.raw);
   return r;
@@ -381,7 +381,7 @@ glms_vec4_scale(vec4s v, float s) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_scale_as(vec4s v, float s) {
+glms_vec4_(scale_as)(vec4s v, float s) {
   vec4s r;
   glm_vec4_scale_as(v.raw, s, r.raw);
   return r;
@@ -396,7 +396,7 @@ glms_vec4_scale_as(vec4s v, float s) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_div(vec4s a, vec4s b) {
+glms_vec4_(div)(vec4s a, vec4s b) {
   vec4s r;
   glm_vec4_div(a.raw, b.raw, r.raw);
   return r;
@@ -411,7 +411,7 @@ glms_vec4_div(vec4s a, vec4s b) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_divs(vec4s v, float s) {
+glms_vec4_(divs)(vec4s v, float s) {
   vec4s r;
   glm_vec4_divs(v.raw, s, r.raw);
   return r;
@@ -428,7 +428,7 @@ glms_vec4_divs(vec4s v, float s) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_addadd(vec4s a, vec4s b, vec4s dest) {
+glms_vec4_(addadd)(vec4s a, vec4s b, vec4s dest) {
   glm_vec4_addadd(a.raw, b.raw, dest.raw);
   return dest;
 }
@@ -444,7 +444,7 @@ glms_vec4_addadd(vec4s a, vec4s b, vec4s dest) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_subadd(vec4s a, vec4s b, vec4s dest) {
+glms_vec4_(subadd)(vec4s a, vec4s b, vec4s dest) {
   glm_vec4_subadd(a.raw, b.raw, dest.raw);
   return dest;
 }
@@ -460,7 +460,7 @@ glms_vec4_subadd(vec4s a, vec4s b, vec4s dest) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_muladd(vec4s a, vec4s b, vec4s dest) {
+glms_vec4_(muladd)(vec4s a, vec4s b, vec4s dest) {
   glm_vec4_muladd(a.raw, b.raw, dest.raw);
   return dest;
 }
@@ -476,7 +476,7 @@ glms_vec4_muladd(vec4s a, vec4s b, vec4s dest) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_muladds(vec4s a, float s, vec4s dest) {
+glms_vec4_(muladds)(vec4s a, float s, vec4s dest) {
   glm_vec4_muladds(a.raw, s, dest.raw);
   return dest;
 }
@@ -492,7 +492,7 @@ glms_vec4_muladds(vec4s a, float s, vec4s dest) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_maxadd(vec4s a, vec4s b, vec4s dest) {
+glms_vec4_(maxadd)(vec4s a, vec4s b, vec4s dest) {
   glm_vec4_maxadd(a.raw, b.raw, dest.raw);
   return dest;
 }
@@ -508,7 +508,7 @@ glms_vec4_maxadd(vec4s a, vec4s b, vec4s dest) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_minadd(vec4s a, vec4s b, vec4s dest) {
+glms_vec4_(minadd)(vec4s a, vec4s b, vec4s dest) {
   glm_vec4_minadd(a.raw, b.raw, dest.raw);
   return dest;
 }
@@ -521,7 +521,7 @@ glms_vec4_minadd(vec4s a, vec4s b, vec4s dest) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_negate(vec4s v) {
+glms_vec4_(negate)(vec4s v) {
   glm_vec4_negate(v.raw);
   return v;
 }
@@ -534,7 +534,7 @@ glms_vec4_negate(vec4s v) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_normalize(vec4s v) {
+glms_vec4_(normalize)(vec4s v) {
   glm_vec4_normalize(v.raw);
   return v;
 }
@@ -548,7 +548,7 @@ glms_vec4_normalize(vec4s v) {
  */
 CGLM_INLINE
 float
-glms_vec4_distance(vec4s a, vec4s b) {
+glms_vec4_(distance)(vec4s a, vec4s b) {
   return glm_vec4_distance(a.raw, b.raw);
 }
 
@@ -561,7 +561,7 @@ glms_vec4_distance(vec4s a, vec4s b) {
  */
 CGLM_INLINE
 float
-glms_vec4_distance2(vec4s a, vec4s b) {
+glms_vec4_(distance2)(vec4s a, vec4s b) {
   return glm_vec4_distance2(a.raw, b.raw);
 }
 
@@ -574,7 +574,7 @@ glms_vec4_distance2(vec4s a, vec4s b) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_maxv(vec4s a, vec4s b) {
+glms_vec4_(maxv)(vec4s a, vec4s b) {
   vec4s r;
   glm_vec4_maxv(a.raw, b.raw, r.raw);
   return r;
@@ -589,7 +589,7 @@ glms_vec4_maxv(vec4s a, vec4s b) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_minv(vec4s a, vec4s b) {
+glms_vec4_(minv)(vec4s a, vec4s b) {
   vec4s r;
   glm_vec4_minv(a.raw, b.raw, r.raw);
   return r;
@@ -605,7 +605,7 @@ glms_vec4_minv(vec4s a, vec4s b) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_clamp(vec4s v, float minVal, float maxVal) {
+glms_vec4_(clamp)(vec4s v, float minVal, float maxVal) {
   glm_vec4_clamp(v.raw, minVal, maxVal);
   return v;
 }
@@ -622,7 +622,7 @@ glms_vec4_clamp(vec4s v, float minVal, float maxVal) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_lerp(vec4s from, vec4s to, float t) {
+glms_vec4_(lerp)(vec4s from, vec4s to, float t) {
   vec4s r;
   glm_vec4_lerp(from.raw, to.raw, t, r.raw);
   return r;
@@ -640,7 +640,7 @@ glms_vec4_lerp(vec4s from, vec4s to, float t) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_lerpc(vec4s from, vec4s to, float t) {
+glms_vec4_(lerpc)(vec4s from, vec4s to, float t) {
   vec4s r;
   glm_vec4_lerpc(from.raw, to.raw, t, r.raw);
   return r;
@@ -658,7 +658,7 @@ glms_vec4_lerpc(vec4s from, vec4s to, float t) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_mix(vec4s from, vec4s to, float t) {
+glms_vec4_(mix)(vec4s from, vec4s to, float t) {
   vec4s r;
   glm_vec4_mix(from.raw, to.raw, t, r.raw);
   return r;
@@ -676,7 +676,7 @@ glms_vec4_mix(vec4s from, vec4s to, float t) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_mixc(vec4s from, vec4s to, float t) {
+glms_vec4_(mixc)(vec4s from, vec4s to, float t) {
   vec4s r;
   glm_vec4_mixc(from.raw, to.raw, t, r.raw);
   return r;
@@ -691,7 +691,7 @@ glms_vec4_mixc(vec4s from, vec4s to, float t) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_step_uni(float edge, vec4s x) {
+glms_vec4_(step_uni)(float edge, vec4s x) {
   vec4s r;
   glm_vec4_step_uni(edge, x.raw, r.raw);
   return r;
@@ -706,7 +706,7 @@ glms_vec4_step_uni(float edge, vec4s x) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_step(vec4s edge, vec4s x) {
+glms_vec4_(step)(vec4s edge, vec4s x) {
   vec4s r;
   glm_vec4_step(edge.raw, x.raw, r.raw);
   return r;
@@ -722,7 +722,7 @@ glms_vec4_step(vec4s edge, vec4s x) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_smoothstep_uni(float edge0, float edge1, vec4s x) {
+glms_vec4_(smoothstep_uni)(float edge0, float edge1, vec4s x) {
   vec4s r;
   glm_vec4_smoothstep_uni(edge0, edge1, x.raw, r.raw);
   return r;
@@ -738,7 +738,7 @@ glms_vec4_smoothstep_uni(float edge0, float edge1, vec4s x) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_smoothstep(vec4s edge0, vec4s edge1, vec4s x) {
+glms_vec4_(smoothstep)(vec4s edge0, vec4s edge1, vec4s x) {
   vec4s r;
   glm_vec4_smoothstep(edge0.raw, edge1.raw, x.raw, r.raw);
   return r;
@@ -756,7 +756,7 @@ glms_vec4_smoothstep(vec4s edge0, vec4s edge1, vec4s x) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_smoothinterp(vec4s from, vec4s to, float t) {
+glms_vec4_(smoothinterp)(vec4s from, vec4s to, float t) {
   vec4s r;
   glm_vec4_smoothinterp(from.raw, to.raw, t, r.raw);
   return r;
@@ -774,7 +774,7 @@ glms_vec4_smoothinterp(vec4s from, vec4s to, float t) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_smoothinterpc(vec4s from, vec4s to, float t) {
+glms_vec4_(smoothinterpc)(vec4s from, vec4s to, float t) {
   vec4s r;
   glm_vec4_smoothinterpc(from.raw, to.raw, t, r.raw);
   return r;
@@ -788,7 +788,7 @@ glms_vec4_smoothinterpc(vec4s from, vec4s to, float t) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_cubic(float s) {
+glms_vec4_(cubic)(float s) {
   vec4s r;
   glm_vec4_cubic(s, r.raw);
   return r;
@@ -805,7 +805,7 @@ glms_vec4_cubic(float s) {
  */
 CGLM_INLINE
 vec4s
-glms_vec4_swizzle(vec4s v, int mask) {
+glms_vec4_(swizzle)(vec4s v, int mask) {
   vec4s dest;
   glm_vec4_swizzle(v.raw, mask, dest.raw);
   return dest;

include/cglm/types.h

@@ -32,9 +32,13 @@
 #  define CGLM_ALIGN_MAT CGLM_ALIGN(16)
 #endif
 
-#ifdef __GNUC__
-#  define CGLM_ASSUME_ALIGNED(expr, alignment) \
-  __builtin_assume_aligned((expr), (alignment))
+#if defined(__has_builtin)
+#  if __has_builtin(__builtin_assume_aligned)
+#    define CGLM_ASSUME_ALIGNED(expr, alignment) \
+    __builtin_assume_aligned((expr), (alignment))
+#  else
+#    define CGLM_ASSUME_ALIGNED(expr, alignment) (expr)
+#  endif
 #else
 #  define CGLM_ASSUME_ALIGNED(expr, alignment) (expr)
 #endif