drop "-Werror" to allow skip warnings on production build

vec2: add new function glm_vec2_make

.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@v12
+
+    - 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

.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,6 +1,6 @@
 cmake_minimum_required(VERSION 3.8.2)
 project(cglm
-  VERSION 0.8.7
+  VERSION 0.9.1
   HOMEPAGE_URL https://github.com/recp/cglm
   DESCRIPTION "OpenGL Mathematics (glm) for C"
   LANGUAGES C
@@ -16,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)
@@ -38,10 +43,12 @@ if(MSVC)
     string(REGEX REPLACE "/RTC(su|[1su])" "" ${flag_var} "${${flag_var}}")
   endforeach(flag_var)
 else()
-  add_compile_options(-Wall -Werror -O3)
+  add_compile_options(-Wall -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
@@ -157,7 +164,21 @@ install(EXPORT      ${PROJECT_NAME}
         NAMESPACE   ${PROJECT_NAME}::
         DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME})
 
+set(PACKAGE_NAME ${PROJECT_NAME})
+set(prefix ${CMAKE_INSTALL_PREFIX})
+set(exec_prefix ${CMAKE_INSTALL_PREFIX})
+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(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

@@ -11,8 +11,7 @@ AM_CFLAGS = -Wall \
             -std=gnu11 \
             -O3 \
             -Wstrict-aliasing=2 \
-            -fstrict-aliasing \
+            -fstrict-aliasing
-            -Werror=strict-prototypes
 
 lib_LTLIBRARIES = libcglm.la
 libcglm_la_LDFLAGS = -no-undefined -version-info 0:1:0
@@ -163,6 +162,7 @@ cglm_struct_HEADERS = include/cglm/struct/mat4.h \
                       include/cglm/struct/mat2.h \
                       include/cglm/struct/affine-pre.h \
                       include/cglm/struct/affine-post.h \
+                      include/cglm/struct/affine-mat.h \
                       include/cglm/struct/affine.h \
                       include/cglm/struct/affine2d.h \
                       include/cglm/struct/vec2.h \
@@ -243,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

@@ -242,6 +242,38 @@ add_subdirectory(external/cglm/)
 # or you can use find_package to configure cglm
 ```
 
+#### Use CMake to build for WebAssembly
+
+Since math functions like `sinf` is used, this can not be targeted at `wasm32-unknown-unknown`, one of [wasi-sdk](https://github.com/WebAssembly/wasi-sdk) or [emscripten](https://github.com/emscripten-core/emsdk) should be used.
+
+Should note that shared build is not yet supported for WebAssembly.
+
+For [simd128](https://github.com/WebAssembly/simd) support, add `-msimd128` to `CMAKE_C_FLAGS`, in command line `-DCMAKE_C_FLAGS="-msimd128"`.
+
+For tests, the cmake option `CGLM_USE_TEST` would still work, you'll need a wasi runtime for running tests, see our [ci config file](.github/workflows/cmake-wasm.yml) for a detailed example.
+
+##### Use CMake and WASI SDK to build for WebAssembly
+
+```bash
+$ cmake .. \
+  -DCMAKE_TOOLCHAIN_FILE=/path/to/wasi-sdk-19.0/share/cmake/wasi-sdk.cmake \
+  -DWASI_SDK_PREFIX=/path/to/wasi-sdk-19.0
+```
+
+Where `/path/to/wasi-sdk-19.0/` is the path to extracted [wasi sdk](https://github.com/WebAssembly/wasi-sdk).
+
+In this case it would by default make a static build.
+
+##### Use CMake and Emscripten SDK to build for WebAssembly
+
+```bash
+$ emcmake cmake .. \
+  -DCMAKE_EXE_LINKER_FLAGS="-s STANDALONE_WASM" \
+  -DCGLM_STATIC=ON
+```
+
+The `emcmake` here is the cmake wrapper for Emscripten from installed [emsdk](https://github.com/emscripten-core/emsdk).
+
 ### Meson (All platforms)
 
 ```bash
@@ -257,7 +289,7 @@ $ sudo ninja install # [Optional]
 c_std=c11
 buildtype=release
 default_library=shared
-enable_tests=false # to run tests: ninja test
+build_tests=true # to run tests: ninja test
 ```
 #### Use with your Meson project
 * Example:

cglm.pc.in

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

cglm.podspec

@@ -2,7 +2,7 @@ Pod::Spec.new do |s|
 
   # Description
   s.name         = "cglm"
-  s.version      = "0.8.4"
+  s.version      = "0.9.0"
   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,8 +7,8 @@
 #*****************************************************************************
 
 AC_PREREQ([2.69])
-AC_INIT([cglm], [0.8.7], [info@recp.me])
+AC_INIT([cglm], [0.9.1], [info@recp.me])
-AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects serial-tests])
+AM_INIT_AUTOMAKE([-Wall foreign subdir-objects serial-tests])
 
 # Don't use the default cflags (-O2 -g), we set ours manually in Makefile.am.
 : ${CFLAGS=""}

docs/source/api.rst

@@ -1,59 +1,28 @@
-API documentation
+📚 API documentation
 ================================
 
-Some functions may exist twice,
+**cglm** provides a few APIs for similar functions.
-once for their namespace and once for global namespace
-to make easier to write very common functions
 
-For instance, in general we use :code:`glm_vec3_dot` to get dot product
+* 📦 **Inline API**: All functions are inline. You can include **cglm/cglm.h** header
-of two **vec3**. Now we can also do this with :code:`glm_dot`,
+  to use this API. This is the default API. `glm_` is namespace/prefix for this API. 
-same for *_cross* and so on...
+* 📦 **Call API**: All functions are not inline. You need to build *cglm* and link it
+  to your project. You can include **cglm/call.h** header to use this API. `glmc_` is namespace/prefix for this API. 
 
-The original function stays where it is, the function in global namespace
+And also there are also sub categories:
-of same name is just an alias, so there is no call version of those functions.
-e.g there is no func like :code:`glmc_dot` because *glm_dot* is just alias for
-:code:`glm_vec3_dot`
 
-By including **cglm/cglm.h** header you will include all inline version
+* 📦 **Array API**: Types are raw arrays and functions takes array as argument. You can include **cglm/cglm.h** header
-of functions. Since functions in this header[s] are inline you don't need to
+  to use this API. This is the default API. `glm_` is namespace/prefix for this API. 
-build or link *cglm* against your project.
+* 📦 **Struct API**: Types are union/struct and functions takes struct as argument and return structs if needed. You can include **cglm/struct.h** header
+  to use this API. This also includes **cglm/cglm.h** header.`glms_` is namespace/prefix for this API but your can omit or change it, see struct api docs.
+* 📦 **SIMD API**: SIMD functions and helpers. `glmm_` is namespace/prefix for this API. 
 
-But by including **cglm/call.h** header you will include all *non-inline*
+📌 Since struct api and call api are built top of inline array api, follow inline array api docs for individual functions. 
-version of functions. You need to build *cglm* and link it.
-Follow the :doc:`build` documentation for this
 
 .. toctree::
    :maxdepth: 1
-   :caption: API categories:
+   :caption: API documentations:
 
-   affine
+   api_inline_array
-   affine-mat
+   api_struct
-   affine2d
+   api_call
-   cam
+   api_simd
-   frustum
-   box
-   quat
-   euler
-   mat2
-   mat3
-   mat4
-   vec2
-   vec2-ext
-   vec3
-   vec3-ext
-   vec4
-   vec4-ext
-   ivec2
-   ivec3
-   ivec4
-   color
-   plane
-   project
-   util
-   io
-   call
-   sphere
-   curve
-   bezier
-   version
-   ray

docs/source/api_call.rst

@@ -0,0 +1,11 @@
+Call API
+================================
+
+Call API is pre-built API for making calls from library. It is built on top of the array api. **glmc_** is the namespace for the call api. 
+**c** stands for call. 
+
+You need to built cglm to use call api. See build instructions (:doc:`build`) for more details.
+
+The functions except namespace **glmc_** are same as inline api. See ( :doc:`api_inline_array` ) for more details.
+
+📌 In the future we can define option to forward inline functions or struct api to call api.

docs/source/api_inline_array.rst

@@ -0,0 +1,70 @@
+Array API - Inline (Default)
+========================================
+
+This is the default API of *cglm*. All functions are forced to be inlined 
+and struct api, call api uses this inline api to share implementation.
+
+📌 Call api is also array api but it is not inlined. 
+In the future there may be option to forward struct api to call api instead of inline api to reduce binary size if needed.
+
+📌 **USE this API docs for similar functions in struct and call api** 
+
+📌 In struct api you can omit namespace e.g :code:`glms_vec3_dot` can be called as :code:`vec3_dot` in struct api, see :doc:`struct-api` to configure struct api for more details. 
+📌 In struct api functions can return struct/union
+📌 In struct api you can access items like **.x**, **.y**, **.z**, **.w**, **.r**, **.g**, **.b**, **.a**, **.m00**, **m01**... 
+
+Some functions may exist twice, once for their namespace and once for global namespace
+to make easier to write very common functions
+
+For instance, in general we use :code:`glm_vec3_dot` to get dot product
+of two **vec3**. Now we can also do this with :code:`glm_dot`,
+same for *_cross* and so on...
+
+The original function stays where it is, the function in global namespace
+of same name is just an alias, so there is no call version of those functions.
+e.g there is no func like :code:`glmc_dot` because *glm_dot* is just alias for
+:code:`glm_vec3_dot`
+
+By including **cglm/cglm.h** header you will include all inline version
+of functions. Since functions in this header[s] are inline you don't need to
+build or link *cglm* against your project.
+
+But by including **cglm/call.h** header you will include all *non-inline*
+version of functions. You need to build *cglm* and link it.
+Follow the :doc:`build` documentation for this
+
+.. toctree::
+   :maxdepth: 1
+   :caption: API categories:
+
+   affine
+   affine-mat
+   affine2d
+   cam
+   frustum
+   box
+   quat
+   euler
+   mat2
+   mat3
+   mat4
+   vec2
+   vec2-ext
+   vec3
+   vec3-ext
+   vec4
+   vec4-ext
+   ivec2
+   ivec3
+   ivec4
+   color
+   plane
+   project
+   util
+   io
+   call
+   sphere
+   curve
+   bezier
+   version
+   ray

docs/source/api_simd.rst

@@ -0,0 +1,12 @@
+SIMD API
+================================
+
+SIMD api is special api for SIMD operations. **glmm_** prefix is used for SIMD operations in cglm. It is used in many places in cglm.
+You can use it for your own SIMD operations too. In the future the api may be extended by time.
+
+Supported SIMD architectures ( may vary by time )
+
+* SSE / SSE2
+* AVX
+* NEON
+* WASM 128

docs/source/api_struct.rst

@@ -0,0 +1,98 @@
+Struct API 
+================================
+
+Struct API is alternative API to array api to use **cglm** with improved type safety and easy to use. 
+Since struct api is built top of array api, every struct API is not documented here. 
+See array api documentation for more information for individual functions.
+
+By default struct api adds `s` suffix to every type name e.g. vec3s, mat4s, versors etc. 
+Also struct api `s` suffix to namespace e.g. `glms_vec3_add`, `glms_mat4_mul` etc.
+
+By starting v0.9.0, struct api namespace is configurable. We can omit **glms_** namespace or 
+even change it with custom name to move existing api integrations to **cglm** more easliy...
+We can also add **s** to functin names if we want e.g. `glms_vec3_add()` -> `vec3_add()` or `vec3s_add()`.
+
+By including **cglm/struct.h** header you will include all struct api. It will also include **cglm/cglm.h** too. 
+Since struct apis are inline you don't need to build or link *cglm* against 
+your project unless if you want to use pre-built call-api too.
+
+Struct API is built top of array api. So you can mix them. 
+Use **.raw** union member to access raw array data to use it with array api. 
+
+Unlike array api ([0], [1], [0][0] ...), it is also possible to use struct api 
+with **.x**, **.y**, **.z**, **.w**, **.r**, **.g**, **.b**, **.a**, **.m00**, **m01**... 
+accessors to access individual elements/properties of vectors and matrices.
+
+Struct API usage:
+-----------------
+
+.. code-block:: c
+
+   #include <cglm/struct.h>
+   
+   mat4s m1  = glms_mat4_identity(); /* init...  */
+   mat4s m2  = glms_mat4_identity(); /* init...  */
+   mat4s m3  = glms_mat4_mul(glms_mat4_mul(m1, m2), glms_mat4_mul(m3, m4));
+   
+   vec3s v1  = { 1.0f, 0.0f, 0.0f };
+   vec3s v2  = { 0.0f, 1.0f, 0.0f };
+   vec4s v4  = { 0.0f, 1.0f, 0.0f, 0.0f };
+   vec4  v5a = { 0.0f, 1.0f, 0.0f, 0.0f };
+   
+   mat4s m4 = glms_rotate(m3, M_PI_2, 
+                          glms_vec3_cross(glms_vec3_add(v1, v6) 
+                                          glms_vec3_add(v1, v7)));
+
+   v1.x = 1.0f; v1.y = 0.0f; v1.z = 0.0f;
+   // or
+   v1.raw[0] = 1.0f; v1.raw[1] = 0.0f; v1.raw[2] = 0.0f;
+
+   /* use struct api with array api (mix them). */
+   /* use .raw to access array and use it with array api */
+
+   glm_vec4_add(m4.col[0].raw, v5a, m4.col[0].raw);
+   glm_mat4_mulv(m4.raw, v4.raw, v5a);
+
+or omit `glms_` namespace completely (see options below):
+
+.. code-block:: c
+
+   #define CGLM_OMIT_NS_FROM_STRUCT_API
+
+   #include <cglm/struct.h>
+
+   mat4s m1  = mat4_identity(); /* init...  */
+   mat4s m2  = mat4_identity(); /* init...  */
+   mat4s m3  = mat4_mul(mat4_mul(m1, m2), mat4_mul(m3, m4));
+   
+   vec3s v1  = { 1.0f, 0.0f, 0.0f };
+   vec3s v2  = { 0.0f, 1.0f, 0.0f };
+   vec4s v4  = { 0.0f, 1.0f, 0.0f, 0.0f };
+   vec4  v5a = { 0.0f, 1.0f, 0.0f, 0.0f };
+   
+   mat4s m4 = glms_rotate(m3, M_PI_2, 
+                          vec3_cross(vec3_add(v1, v6) 
+                                     vec3_add(v1, v7)));
+   
+   v1.x = 1.0f; v1.y = 0.0f; v1.z = 0.0f;
+   // or
+   v1.raw[0] = 1.0f; v1.raw[1] = 0.0f; v1.raw[2] = 0.0f;
+
+   /* use struct api with array api (mix them) */
+   glm_vec4_add(m4.col[0].raw, v5a, m4.col[0].raw);
+   glm_mat4_mulv(m4.raw, v4.raw, v5a);
+   
+Configuring the Struct API:
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+To configure the Struct API namespace, you can define the following macros before including the cglm/struct.h header:
+
+- **CGLM_OMIT_NS_FROM_STRUCT_API**: omits CGLM_STRUCT_API_NS (`glms_`) namespace completely if there is sub namespace e.g `mat4_`, `vec4_` ... DEFAULT is not defined
+- **CGLM_STRUCT_API_NS**:           define name space for struct api, DEFAULT is **glms**
+- **CGLM_STRUCT_API_NAME_SUFFIX**:  define name suffix, DEFAULT is **empty** e.g defining it as #define CGLM_STRUCT_API_NAME_SUFFIX  s will add s suffix to mat4_mul -> mat4s_mul
+
+
+Detailed documentation for Struct API:
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Since struct api if built top of array api, see array api functions for more information about individual functions.

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,16 +62,16 @@ author = u'Recep Aslantas'
 # built documents.
 #
 # The short X.Y version.
-version = u'0.8.7'
+version = u'0.9.1'
 # The full version, including alpha/beta/rc tags.
-release = u'0.8.7'
+release = u'0.9.1'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
 #
 # This is also used if you do content translation via gettext catalogs.
 # Usually you set "language" from the command line for these cases.
-language = None
+language = 'en'
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
@@ -111,7 +111,7 @@ html_theme_options = {
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['_static']
+# html_static_path = ['_static']
 
 
 # -- Options for HTMLHelp output ------------------------------------------

docs/source/features.rst

@@ -1,7 +1,7 @@
 Features
 ================================================================================
 
-* **scalar** and **simd** (sse, avx, neon...) optimizations
+* **scalar** and **simd** (sse, avx, neon, wasm...) optimizations
 * option to use different clipspaces e.g. Left Handed, Zero-to-One... (currrently right handed negative-one is default)
 * array api and struct api, you can use arrays or structs.
 * general purpose matrix operations (mat4, mat3)

docs/source/index.rst

@@ -28,7 +28,7 @@ considered to be supported as optional.
    opengl
 
 .. toctree::
-   :maxdepth: 2
+   :maxdepth: 3
    :caption: API:
 
    api

docs/source/ivec2.rst

@@ -8,6 +8,13 @@ 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`
@@ -25,6 +32,7 @@ Functions:
 #. :c:func:`glm_ivec2_maxv`
 #. :c:func:`glm_ivec2_minv`
 #. :c:func:`glm_ivec2_clamp`
+#. :c:func:`glm_ivec2_abs`
 
 Functions documentation
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -161,3 +169,11 @@ Functions documentation
       | *[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

@@ -8,6 +8,13 @@ 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`
@@ -25,6 +32,7 @@ Functions:
 #. :c:func:`glm_ivec3_maxv`
 #. :c:func:`glm_ivec3_minv`
 #. :c:func:`glm_ivec3_clamp`
+#. :c:func:`glm_ivec2_abs`
 
 Functions documentation
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -161,3 +169,11 @@ Functions documentation
       | *[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

@@ -8,6 +8,13 @@ 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`
@@ -25,6 +32,7 @@ Functions:
 #. :c:func:`glm_ivec4_maxv`
 #. :c:func:`glm_ivec4_minv`
 #. :c:func:`glm_ivec4_clamp`
+#. :c:func:`glm_ivec4_abs`
 
 Functions documentation
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -161,3 +169,11 @@ Functions documentation
       | *[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/mat2.rst

@@ -32,6 +32,7 @@ Functions:
 #. :c:func:`glm_mat2_swap_col`
 #. :c:func:`glm_mat2_swap_row`
 #. :c:func:`glm_mat2_rmc`
+#. :c:func:`glm_mat2_make`
 
 Functions documentation
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -177,3 +178,13 @@ Functions documentation
 
     Returns:
         scalar value e.g. Matrix1x1
+
+.. c:function:: void glm_mat2_make(float * __restrict src, mat2 dest)
+
+    Create mat2 matrix from pointer
+
+    | NOTE: **@src** must contain 4 elements.
+
+    Parameters:
+      | *[in]*  **src**  pointer to an array of floats
+      | *[out]* **dest** destination matrix2x2

docs/source/mat3.rst

@@ -34,6 +34,7 @@ Functions:
 #. :c:func:`glm_mat3_swap_col`
 #. :c:func:`glm_mat3_swap_row`
 #. :c:func:`glm_mat3_rmc`
+#. :c:func:`glm_mat3_make`
 
 Functions documentation
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -187,3 +188,13 @@ Functions documentation
 
     Returns:
         scalar value e.g. Matrix1x1
+
+.. c:function:: void glm_mat3_make(float * __restrict src, mat3 dest)
+
+    Create mat3 matrix from pointer
+
+    | NOTE: **@src** must contain 9 elements.
+
+    Parameters:
+      | *[in]*  **src**  pointer to an array of floats
+      | *[out]* **dest** destination matrix3x3

docs/source/mat4.rst

@@ -47,6 +47,7 @@ Functions:
 #. :c:func:`glm_mat4_swap_col`
 #. :c:func:`glm_mat4_swap_row`
 #. :c:func:`glm_mat4_rmc`
+#. :c:func:`glm_mat4_make`
 
 Functions documentation
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -302,3 +303,13 @@ Functions documentation
 
     Returns:
         scalar value e.g. Matrix1x1
+
+.. c:function:: void glm_mat4_make(float * __restrict src, mat4 dest)
+
+    Create mat4 matrix from pointer
+
+    | NOTE: **@src** must contain 16 elements.
+
+    Parameters:
+      | *[in]*  **src**  pointer to an array of floats
+      | *[out]* **dest** destination matrix4x4

docs/source/opt.rst

@@ -1,6 +1,6 @@
 .. default-domain:: C
 
-Options
+🛠️ Options
 ===============================================================================
 
 A few options are provided via macros.
@@ -90,6 +90,16 @@ You have to extra options for dot product: **CGLM_SSE4_DOT** and **CGLM_SSE3_DOT
 
 otherwise cglm will use custom cglm's hadd functions which are optimized too.
 
+Struct API Options
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+To configure the Struct API namespace, you can define the following macros before including the cglm/struct.h header:
+
+- **CGLM_OMIT_NS_FROM_STRUCT_API**: omits CGLM_STRUCT_API_NS (`glms_`) namespace completely if there is sub namespace e.g `mat4_`, `vec4_` ... DEFAULT is not defined
+- **CGLM_STRUCT_API_NS**:           define name space for struct api, DEFAULT is **glms**
+- **CGLM_STRUCT_API_NAME_SUFFIX**:  define name suffix, DEFAULT is **empty** e.g defining it as #define CGLM_STRUCT_API_NAME_SUFFIX  s will add s suffix to mat4_mul -> mat4s_mul
+
+
 Print Options
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

docs/source/quat.rst

@@ -62,6 +62,7 @@ Functions:
 #. :c:func:`glm_quat_rotate`
 #. :c:func:`glm_quat_rotate_at`
 #. :c:func:`glm_quat_rotate_atm`
+#. :c:func:`glm_quat_make`
 
 Functions documentation
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -420,3 +421,13 @@ Functions documentation
       | *[in, out]*  **m**      existing transform matrix to rotate
       | *[in]*       **q**      quaternion
       | *[in]*       **pivot**  pivot
+
+.. c:function:: void glm_quat_make(float * __restrict src, versor dest)
+
+    Create quaternion from pointer
+
+    | NOTE: **@src** must contain at least 4 elements. cglm store quaternions as [x, y, z, w].
+
+    Parameters:
+      | *[in]*  **src**  pointer to an array of floats
+      | *[out]* **dest** destination quaternion

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
+1. GLM_VEC2_ONE_INIT
-#. GLM_vec2_ZERO_INIT
+#. GLM_VEC2_ZERO_INIT
-#. GLM_vec2_ONE
+#. GLM_VEC2_ONE
-#. GLM_vec2_ZERO
+#. GLM_VEC2_ZERO
 
 Functions:
 
@@ -51,6 +51,7 @@ Functions:
 #. :c:func:`glm_vec2_minv`
 #. :c:func:`glm_vec2_clamp`
 #. :c:func:`glm_vec2_lerp`
+#. :c:func:`glm_vec2_make`
 
 Functions documentation
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -373,3 +374,12 @@ Functions documentation
       | *[in]*  **to**     to value
       | *[in]*  **t**      interpolant (amount) clamped between 0 and 1
       | *[out]* **dest**   destination
+
+.. c:function:: void glm_vec2_make(float * __restrict src, vec2 dest)
+
+    Create two dimensional vector from pointer
+
+    | NOTE: **@src** must contain at least 2 elements.
+    Parameters:
+      | *[in]*  **src**  pointer to an array of floats
+      | *[out]* **dest** destination vector

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

docs/source/vec3.rst

@@ -79,6 +79,7 @@ Functions:
 #. :c:func:`glm_vec3_ortho`
 #. :c:func:`glm_vec3_clamp`
 #. :c:func:`glm_vec3_lerp`
+#. :c:func:`glm_vec3_make`
 
 Functions documentation
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -501,3 +502,13 @@ Functions documentation
       | *[in]*  **to**     to value
       | *[in]*  **t**      interpolant (amount) clamped between 0 and 1
       | *[out]* **dest**   destination
+
+.. c:function:: void glm_vec3_make(float * __restrict src, vec3 dest)
+
+    Create three dimensional vector from pointer
+
+    | NOTE: **@src** must contain at least 3 elements.
+
+    Parameters:
+      | *[in]*  **src**  pointer to an array of floats
+      | *[out]* **dest** destination vector

docs/source/vec4.rst

@@ -59,6 +59,7 @@ Functions:
 #. :c:func:`glm_vec4_clamp`
 #. :c:func:`glm_vec4_lerp`
 #. :c:func:`glm_vec4_cubic`
+#. :c:func:`glm_vec4_make`
 
 Functions documentation
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -406,3 +407,12 @@ Functions documentation
     Parameters:
       | *[in]*  **s**      parameter
       | *[out]* **dest**   destination
+
+.. c:function:: void glm_vec4_make(float * __restrict src, vec4 dest)
+
+    Create four dimensional vector from pointer
+
+    | NOTE: **@src** must contain at least 4 elements.
+    Parameters:
+      | *[in]*  **src**  pointer to an array of floats
+      | *[out]* **dest** destination vector

include/cglm/affine-mat.h

@@ -8,6 +8,7 @@
 /*
  Functions:
    CGLM_INLINE void glm_mul(mat4 m1, mat4 m2, mat4 dest);
+   CGLM_INLINE void glm_mul_rot(mat4 m1, mat4 m2, mat4 dest);
    CGLM_INLINE void glm_inv_tr(mat4 mat);
  */
 
@@ -30,6 +31,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 +54,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 +114,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 +165,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/bezier.h

@@ -23,7 +23,7 @@
 #define GLM_HERMITE_MAT ((mat4)GLM_HERMITE_MAT_INIT)
 
 #define CGLM_DECASTEL_EPS   1e-9f
-#define CGLM_DECASTEL_MAX   1000.0f
+#define CGLM_DECASTEL_MAX   1000
 #define CGLM_DECASTEL_SMALL 1e-20f
 
 /*!

include/cglm/call/ivec2.h

@@ -73,6 +73,10 @@ 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

include/cglm/call/ivec3.h

@@ -73,6 +73,10 @@ 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

include/cglm/call/ivec4.h

@@ -73,6 +73,10 @@ 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

include/cglm/call/mat2.h

@@ -73,6 +73,10 @@ CGLM_EXPORT
 float
 glmc_mat2_rmc(vec2 r, mat2 m, vec2 c);
 
+CGLM_EXPORT
+void
+glmc_mat2_make(float * __restrict src, mat2 dest);
+
 #ifdef __cplusplus
 }
 #endif

include/cglm/call/mat3.h

@@ -80,6 +80,10 @@ CGLM_EXPORT
 float
 glmc_mat3_rmc(vec3 r, mat3 m, vec3 c);
 
+CGLM_EXPORT
+void
+glmc_mat3_make(float * __restrict src, mat3 dest);
+
 #ifdef __cplusplus
 }
 #endif

include/cglm/call/mat4.h

@@ -121,6 +121,10 @@ CGLM_EXPORT
 float
 glmc_mat4_rmc(vec4 r, mat4 m, vec4 c);
 
+CGLM_EXPORT
+void
+glmc_mat4_make(float * __restrict src, mat4 dest);
+
 #ifdef __cplusplus
 }
 #endif

include/cglm/call/quat.h

@@ -161,6 +161,10 @@ CGLM_EXPORT
 void
 glmc_quat_rotate_atm(mat4 m, versor q, vec3 pivot);
 
+CGLM_EXPORT
+void
+glmc_quat_make(float * __restrict src, versor dest);
+
 #ifdef __cplusplus
 }
 #endif

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);
@@ -161,6 +165,10 @@ CGLM_EXPORT
 void
 glmc_vec2_complex_conjugate(vec2 a, vec2 dest);
 
+CGLM_EXPORT
+void
+glmc_vec2_make(float * __restrict src, vec2 dest);
+
 #ifdef __cplusplus
 }
 #endif

include/cglm/call/vec3.h

@@ -306,6 +306,10 @@ CGLM_EXPORT
 void
 glmc_vec3_sqrt(vec3 v, vec3 dest);
 
+CGLM_EXPORT
+void
+glmc_vec3_make(float * __restrict src, vec3 dest);
+
 #ifdef __cplusplus
 }
 #endif

include/cglm/call/vec4.h

@@ -283,6 +283,10 @@ CGLM_EXPORT
 void
 glmc_vec4_sqrt(vec4 v, vec4 dest);
 
+CGLM_EXPORT
+void
+glmc_vec4_make(float * __restrict src, vec4 dest);
+
 #ifdef __cplusplus
 }
 #endif

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,7 +45,7 @@
 
 #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
@@ -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

@@ -13,6 +13,7 @@
    CGLM_INLINE void glm_vec3_print(vec3 vec, FILE *ostream);
    CGLM_INLINE void glm_ivec3_print(ivec3 vec, FILE *ostream);
    CGLM_INLINE void glm_versor_print(versor vec, FILE *ostream);
+   CGLM_INLINE void glm_arch_print(FILE *ostream);
  */
 
 /*
@@ -49,16 +50,67 @@
 #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
+#ifndef GLM_TESTS_NO_COLORFUL_OUTPUT
-#  define CGLM_PRINT_COLOR        "\033[36m"
+#  ifndef CGLM_PRINT_COLOR
+#    define CGLM_PRINT_COLOR        "\033[36m"
+#  endif
+#  ifndef CGLM_PRINT_COLOR_RESET
+#    define CGLM_PRINT_COLOR_RESET  "\033[0m"
+#  endif
+#else
+#  ifndef CGLM_PRINT_COLOR
+#    define CGLM_PRINT_COLOR
+#  endif
+#  ifndef CGLM_PRINT_COLOR_RESET
+#    define CGLM_PRINT_COLOR_RESET
+#  endif
 #endif
 
-#ifndef CGLM_PRINT_COLOR_RESET
+/*!
-#  define CGLM_PRINT_COLOR_RESET  "\033[0m"
+ * @brief prints current SIMD path in general
+ *
+ * @param[in] ostream    stream to print e.g. stdout, stderr, FILE ...
+ */
+CGLM_INLINE
+void
+glm_arch_print(FILE* __restrict ostream) {
+  fprintf(ostream, CGLM_PRINT_COLOR "arch: "
+#if defined(CGLM_SIMD_WASM)
+  "wasm SIMD128"
+#elif defined(CGLM_SIMD_x86)
+  "x86 SSE* "
+#  ifdef __AVX__
+  " AVX"
+#  endif
+#elif defined(CGLM_SIMD_ARM)
+  "arm"
+#  ifndef __ARM_NEON_FP
+    " NEON_FP"
+#  endif
+#  ifdef CGLM_ARM64
+    " ARM64"
+#  endif
+#else
+  "uncommon"
 #endif
+  CGLM_PRINT_COLOR_RESET);
+}
+
+/*!
+ * @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) {
+  fprintf(ostream, CGLM_PRINT_COLOR "\ncglm ");
+  glm_arch_print(ostream);
+  fprintf(ostream, "\n\n" CGLM_PRINT_COLOR_RESET);
+}
 
 CGLM_INLINE
 void
@@ -77,9 +129,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);
     }
   }
@@ -89,9 +141,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");
   }
@@ -120,22 +172,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");
   }
 
@@ -162,22 +214,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");
   }
 
@@ -199,9 +251,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");
@@ -221,9 +273,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");
@@ -245,7 +297,7 @@ glm_ivec3_print(ivec3             vec,
     fprintf(ostream, " % d", vec[i]);
 
   fprintf(ostream, "  )" CGLM_PRINT_COLOR_RESET "\n\n");
-  
+
 #undef m
 }
 
@@ -261,9 +313,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");
@@ -283,9 +335,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]);
   }
 
 
@@ -307,12 +359,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");
@@ -340,6 +392,8 @@ glm_aabb_print(vec3                    bbox[2],
 #define glm_vec2_print(v, s) (void)v; (void)s;
 #define glm_versor_print(v, s) (void)v; (void)s;
 #define glm_aabb_print(v, t, s) (void)v; (void)t; (void)s;
+#define glm_arch_print(s) (void)s;
+#define glm_arch_print_name(s) (void)s;
 
 #endif
 #endif /* cglm_io_h */

include/cglm/ivec2.h

@@ -6,7 +6,13 @@
  */
 
 /*
-FUNCTIONS:
+ 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)
@@ -22,6 +28,7 @@ FUNCTIONS:
   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
@@ -29,6 +36,12 @@ FUNCTIONS:
 
 #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
  *
@@ -239,4 +252,17 @@ glm_ivec2_clamp(ivec2 v, int minVal, int 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

@@ -6,7 +6,13 @@
  */
 
 /*
-FUNCTIONS:
+ 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)
@@ -22,6 +28,7 @@ FUNCTIONS:
   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
@@ -29,6 +36,12 @@ FUNCTIONS:
 
 #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
  *
@@ -255,4 +268,18 @@ glm_ivec3_clamp(ivec3 v, int minVal, int 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

@@ -6,7 +6,13 @@
  */
 
 /*
-FUNCTIONS:
+ 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)
@@ -22,6 +28,7 @@ FUNCTIONS:
   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
@@ -29,6 +36,12 @@ FUNCTIONS:
 
 #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
  *
@@ -272,4 +285,19 @@ glm_ivec4_clamp(ivec4 v, int minVal, int 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

@@ -28,6 +28,7 @@
    CGLM_INLINE void  glm_mat2_swap_col(mat2 mat, int col1, int col2)
    CGLM_INLINE void  glm_mat2_swap_row(mat2 mat, int row1, int row2)
    CGLM_INLINE float glm_mat2_rmc(vec2 r, mat2 m, vec2 c)
+   CGLM_INLINE void  glm_mat2_make(float * restrict src, mat2 dest)
  */
 
 #ifndef cglm_mat2_h
@@ -44,6 +45,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 +137,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 +167,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 +231,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)));
@@ -334,4 +346,19 @@ glm_mat2_rmc(vec2 r, mat2 m, vec2 c) {
   return glm_vec2_dot(r, tmp);
 }
 
+/*!
+ * @brief Create mat2 matrix from pointer
+ *
+ * @param[in]  src  pointer to an array of floats
+ * @param[out] dest matrix
+ */
+CGLM_INLINE
+void
+glm_mat2_make(float * __restrict src, mat2 dest) {
+  dest[0][0] = src[0];
+  dest[0][1] = src[1];
+  dest[1][0] = src[2];
+  dest[1][1] = src[3];
+}
+
 #endif /* cglm_mat2_h */

include/cglm/mat3.h

@@ -30,6 +30,7 @@
    CGLM_INLINE void  glm_mat3_swap_col(mat3 mat, int col1, int col2);
    CGLM_INLINE void  glm_mat3_swap_row(mat3 mat, int row1, int row2);
    CGLM_INLINE float glm_mat3_rmc(vec3 r, mat3 m, vec3 c);
+   CGLM_INLINE void  glm_mat3_make(float * restrict src, mat3 dest);
  */
 
 #ifndef cglm_mat3_h
@@ -42,6 +43,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 +153,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],
@@ -421,4 +428,26 @@ glm_mat3_rmc(vec3 r, mat3 m, vec3 c) {
   return glm_vec3_dot(r, tmp);
 }
 
+/*!
+ * @brief Create mat3 matrix from pointer
+ *
+ * @param[in]  src  pointer to an array of floats
+ * @param[out] dest matrix
+ */
+CGLM_INLINE
+void
+glm_mat3_make(float * __restrict src, mat3 dest) {
+  dest[0][0] = src[0];
+  dest[0][1] = src[1];
+  dest[0][2] = src[2];
+
+  dest[1][0] = src[3];
+  dest[1][1] = src[4];
+  dest[1][2] = src[5];
+
+  dest[2][0] = src[6];
+  dest[2][1] = src[7];
+  dest[2][2] = src[8];
+}
+
 #endif /* cglm_mat3_h */

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) ;
@@ -43,6 +43,7 @@
    CGLM_INLINE void  glm_mat4_swap_col(mat4 mat, int col1, int col2);
    CGLM_INLINE void  glm_mat4_swap_row(mat4 mat, int row1, int row2);
    CGLM_INLINE float glm_mat4_rmc(vec4 r, mat4 m, vec4 c);
+   CGLM_INLINE void  glm_mat4_make(float * restrict src, mat4 dest);
  */
 
 #ifndef cglm_mat_h
@@ -64,6 +65,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 +126,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 +197,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 +314,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 +396,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 +518,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 +544,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 +585,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 +608,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 +708,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);
@@ -751,4 +782,24 @@ glm_mat4_rmc(vec4 r, mat4 m, vec4 c) {
   return glm_vec4_dot(r, tmp);
 }
 
+/*!
+ * @brief Create mat4 matrix from pointer
+ *
+ * @param[in]  src  pointer to an array of floats
+ * @param[out] dest matrix
+ */
+CGLM_INLINE
+void
+glm_mat4_make(float * __restrict src, mat4 dest) {
+  dest[0][0] = src[0];   dest[1][0] = src[4];
+  dest[0][1] = src[1];   dest[1][1] = src[5];
+  dest[0][2] = src[2];   dest[1][2] = src[6];
+  dest[0][3] = src[3];   dest[1][3] = src[7];
+
+  dest[2][0] = src[8];   dest[3][0] = src[12];
+  dest[2][1] = src[9];   dest[3][1] = src[13];
+  dest[2][2] = src[10];  dest[3][2] = src[14];
+  dest[2][3] = src[11];  dest[3][3] = src[15];
+}
+
 #endif /* cglm_mat_h */

include/cglm/quat.h

@@ -49,6 +49,7 @@
                                   versor dest);
    CGLM_INLINE void glm_quat_rotatev(versor q, vec3 v, vec3 dest);
    CGLM_INLINE void glm_quat_rotate(mat4 m, versor q, mat4 dest);
+   CGLM_INLINE void glm_quat_make(float * restrict src, versor dest);
  */
 
 #ifndef cglm_quat_h
@@ -70,6 +71,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 +243,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 +458,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);
@@ -864,4 +886,17 @@ glm_quat_rotate_atm(mat4 m, versor q, vec3 pivot) {
   glm_translate(m, pivotInv);
 }
 
+/*!
+ * @brief Create quaternion from pointer
+ *
+ * @param[in]  src  pointer to an array of floats
+ * @param[out] dest quaternion
+ */
+CGLM_INLINE
+void
+glm_quat_make(float * __restrict src, versor dest) {
+  dest[0] = src[0]; dest[1] = src[1];
+  dest[2] = src[2]; dest[3] = src[3];
+}
+
 #endif /* cglm_quat_h */

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)
+#if defined(_WIN32)
-#  include <arm_neon.h>
+/* TODO: non-ARM stuff already inported, will this be better option */
-#  if defined(__ARM_NEON_FP)
+/* #  include <intrin.h> */
-#    define CGLM_NEON_FP 1
+
+#  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"

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,24 @@
 #  endif
 #endif
 
+/* Note that `0x80000000` corresponds to `INT_MIN` for a 32-bit int. */
+#define GLMM_NEGZEROf ((int)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(GLMM_NEGZEROf)) /* _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 +270,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 +313,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-mat.h

@@ -0,0 +1,90 @@
+/*
+ * 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_mul(mat4 m1, mat4 m2);
+   CGLM_INLINE mat4s glms_mul_rot(mat4 m1, mat4 m2);
+   CGLM_INLINE mat4s glms_inv_tr();
+ */
+
+#ifndef cglms_affine_mat_h
+#define cglms_affine_mat_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../affine-mat.h"
+#include "vec3.h"
+#include "vec4.h"
+#include "mat4.h"
+
+/*!
+ * @brief this is similar to glms_mat4_mul but specialized to affine transform
+ *
+ * Matrix format should be:
+ *   R  R  R  X
+ *   R  R  R  Y
+ *   R  R  R  Z
+ *   0  0  0  W
+ *
+ * this reduces some multiplications. It should be faster than mat4_mul.
+ * if you are not sure about matrix format then DON'T use this! use mat4_mul
+ *
+ * @param[in]   m1    affine matrix 1
+ * @param[in]   m2    affine matrix 2
+ * @returns         destination matrix
+ */
+CGLM_INLINE
+mat4s
+glms_mul(mat4s m1, mat4s m2){
+  mat4s r;
+  glm_mul(m1.raw, m2.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief this is similar to glm_mat4_mul but specialized to affine transform
+ *
+ * Right Matrix format should be:
+ *   R  R  R  0
+ *   R  R  R  0
+ *   R  R  R  0
+ *   0  0  0  1
+ *
+ * this reduces some multiplications. It should be faster than mat4_mul.
+ * if you are not sure about matrix format then DON'T use this! use mat4_mul
+ *
+ * @param[in]   m1    affine matrix 1
+ * @param[in]   m2    affine matrix 2
+ * @returns         destination matrix
+ */
+CGLM_INLINE
+mat4s
+glms_mul_rot(mat4s m1, mat4s m2){
+  mat4s r;
+  glm_mul_rot(m1.raw, m2.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief inverse orthonormal rotation + translation matrix (ridig-body)
+ *
+ * @code
+ * X = | R  T |   X' = | R' -R'T |
+ *     | 0  1 |        | 0     1 |
+ * @endcode
+ *
+ * @param[in]  m  matrix
+ * @returns      destination matrix
+ */
+CGLM_INLINE
+mat4s
+glms_inv_tr(mat4s m){
+  glm_inv_tr(m.raw);
+  return m;
+}
+#endif /* cglms_affine_mat_h */

include/cglm/struct/affine.h

@@ -39,6 +39,7 @@
 #include "vec3.h"
 #include "vec4.h"
 #include "mat4.h"
+#include "affine-mat.h"
 
 /*!
  * @brief creates NEW translate transform matrix by v vector

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,13 +27,13 @@
  */
 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);
+  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)(rawBox1, box1, 2);
-  glms_vec3_unpack(rawBox2, box2, 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)(rawBox, box, 2);
-  glms_vec3_unpack(rawCropBox, cropBox, 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],
+glms_aabb_(crop_until)(vec3s box[2],
-                     vec3s cropBox[2],
+                       vec3s cropBox[2],
-                     vec3s clampBox[2],
+                       vec3s clampBox[2],
-                     vec3s dest[2]) {
+                       vec3s dest[2]) {
-  glms_aabb_crop(box, cropBox, dest);
+  glms_aabb_(crop)(box, cropBox, dest);
-  glms_aabb_merge(clampBox, dest, 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_vec3_(unpack)(rawBox, box, 2);
-  glms_vec4_unpack(rawPlanes, planes, 6);
+  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]) {
+glms_aabb_(invalidate)(vec3s box[2]) {
-  box[0] = glms_vec3_broadcast(FLT_MAX);
+  box[0] = glms_vec3_(broadcast)(FLT_MAX);
-  box[1] = 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]) {
+glms_aabb_(radius)(vec3s box[2]) {
-  return glms_aabb_size(box) * 0.5f;
+  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]) {
+glms_aabb_(center)(vec3s box[2]) {
-  return glms_vec3_center(box[0], box[1]);
+  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)(rawBox, box, 2);
-  glms_vec3_unpack(rawOther, other, 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)(rawBox, box, 2);
-  glms_vec3_unpack(rawOther, other, 2);
+  glms_vec3_(unpack)(rawOther, other, 2);
   return glm_aabb_contains(rawBox, rawOther);
 }
 

include/cglm/struct/clipspace/ortho_lh_no.h

@@ -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

@@ -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

@@ -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

@@ -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/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

@@ -27,6 +27,7 @@
    CGLM_INLINE void  glms_mat2_swap_col(mat2 mat, int col1, int col2)
    CGLM_INLINE void  glms_mat2_swap_row(mat2 mat, int row1, int row2)
    CGLM_INLINE float glms_mat2_rmc(vec2 r, mat2 m, vec2 c)
+   CGLM_INLINE float glms_mat42_make(float * __restrict src);
  */
 
 #ifndef cglms_mat2_h
@@ -36,6 +37,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 +63,7 @@
  */
 CGLM_INLINE
 mat2s
-glms_mat2_identity(void) {
+glms_mat2_(identity)(void) {
   mat2s r;
   glm_mat2_identity(r.raw);
   return r;
@@ -75,7 +79,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 +95,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 +118,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 +133,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 +147,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 +162,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 +177,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 +191,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 +203,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 +219,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 +234,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,8 +255,22 @@ 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);
 }
 
+/*!
+ * @brief Create mat2 matrix from pointer
+ *
+ * @param[in]  src  pointer to an array of floats
+ * @return constructed matrix from raw pointer
+ */
+CGLM_INLINE
+mat2s
+glms_mat2_(make)(float * __restrict src) {
+  mat2s r;
+  glm_mat2_make(src, r.raw);
+  return r;
+}
+
 #endif /* cglms_mat2_h */

include/cglm/struct/mat3.h

@@ -28,6 +28,7 @@
    CGLM_INLINE mat3s  glms_mat3_swap_col(mat3s mat, int col1, int col2);
    CGLM_INLINE mat3s  glms_mat3_swap_row(mat3s mat, int row1, int row2);
    CGLM_INLINE float  glms_mat3_rmc(vec3s r, mat3s m, vec3s c);
+   CGLM_INLINE float  glms_mat3_make(float * __restrict src);
  */
 
 #ifndef cglms_mat3s_h
@@ -38,6 +39,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 +57,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 +79,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 +95,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 +111,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 +133,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 +146,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 +160,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 +175,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 +187,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 +204,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 +218,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 +230,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 +246,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 +261,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,8 +282,22 @@ 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);
 }
 
+/*!
+ * @brief Create mat3 matrix from pointer
+ *
+ * @param[in]  src  pointer to an array of floats
+ * @return constructed matrix from raw pointer
+ */
+CGLM_INLINE
+mat3s
+glms_mat3_(make)(float * __restrict src) {
+  mat3s r;
+  glm_mat3_make(src, r.raw);
+  return r;
+}
+
 #endif /* cglms_mat3s_h */

include/cglm/struct/mat4.h

@@ -42,6 +42,7 @@
    CGLM_INLINE mat4s   glms_mat4_swap_col(mat4s mat, int col1, int col2);
    CGLM_INLINE mat4s   glms_mat4_swap_row(mat4s mat, int row1, int row2);
    CGLM_INLINE float   glms_mat4_rmc(vec4s r, mat4s m, vec4s c);
+   CGLM_INLINE float   glms_mat4_make(float * __restrict src);
  */
 
 #ifndef cglms_mat4s_h
@@ -53,6 +54,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 +75,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 +89,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 +111,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 +127,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 +143,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 +157,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 +173,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 +187,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 +209,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 +236,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 +256,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 +271,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 +284,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 +296,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 +312,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 +326,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 +342,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 +358,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 +372,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 +384,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 +404,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 +420,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 +435,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,8 +456,22 @@ 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);
 }
 
+/*!
+ * @brief Create mat4 matrix from pointer
+ *
+ * @param[in]  src  pointer to an array of floats
+ * @return constructed matrix from raw pointer
+ */
+CGLM_INLINE
+mat4s
+glms_mat4_(make)(float * __restrict src) {
+  mat4s r;
+  glm_mat4_make(src, r.raw);
+  return r;
+}
+
 #endif /* cglms_mat4s_h */

include/cglm/struct/quat.h

@@ -44,6 +44,7 @@
    CGLM_INLINE mat4s   glms_quat_rotate(mat4s m, versors q)
    CGLM_INLINE mat4s   glms_quat_rotate_at(mat4s m, versors q, vec3s pivot)
    CGLM_INLINE mat4s   glms_quat_rotate_atm(versors q, vec3s pivot)
+   CGLM_INLINE versors glms_quat_make(float * restrict src)
  */
 
 #ifndef cglms_quat_h
@@ -54,6 +55,9 @@
 #include "../plane.h"
 #include "../quat.h"
 
+/* api definition */
+#define glms_quat_(NAME) CGLM_STRUCTAPI(quat, NAME)
+
 /*
  * IMPORTANT:
  * ----------------------------------------------------------------------------
@@ -74,7 +78,7 @@
  */
 CGLM_INLINE
 versors
-glms_quat_identity(void) {
+glms_quat_(identity)(void) {
   versors dest;
   glm_quat_identity(dest.raw);
   return dest;
@@ -90,7 +94,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 +114,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 +161,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 +174,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 +186,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 +201,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 +213,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 +227,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 +242,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 +257,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 +270,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 +283,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 +294,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 +306,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 +326,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 +340,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 +354,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 +368,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 +382,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 +399,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 +416,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 +434,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 +451,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 +466,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 +481,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 +498,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 +513,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 +528,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 +542,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,10 +560,24 @@ 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;
 }
 
+/*!
+ * @brief Create CGLM quaternion from pointer
+ *
+ * @param[in]  src  pointer to an array of floats
+ * @returns constructed quaternion from raw pointer
+ */
+CGLM_INLINE
+versors
+glms_quat_(make)(float * __restrict src) {
+  versors dest;
+  glm_quat_make(src, dest.raw);
+  return dest;
+}
+
 #endif /* cglms_quat_h */

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,18 +71,18 @@ 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);
 }
 
 /*!
- * @brief check if vectors members are equal (without epsilon)
+ * @brief check if vector members are equal (without epsilon)
  *
  * @param[in] v   vector
  */
 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

@@ -46,6 +46,7 @@
    CGLM_INLINE vec2s glms_vec2_minv(vec2s a, vec2s b)
    CGLM_INLINE vec2s glms_vec2_clamp(vec2s v, float minVal, float maxVal)
    CGLM_INLINE vec2s glms_vec2_lerp(vec2s from, vec2s to, float t)
+   CGLM_INLINE vec2s glms_vec2_make(float * restrict src)
  */
 
 #ifndef cglms_vec2s_h
@@ -86,7 +87,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 +104,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 +119,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 +132,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 +148,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 +164,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 +181,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 +194,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 +207,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 +222,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 +237,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,22 +252,22 @@ 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;
 }
 
 /*!
- * @brief multiply two vector (component-wise multiplication)
+ * @brief multiply two vectors (component-wise multiplication)
  *
  * @param     a     vector1
  * @param     b     vector2
- * @returns         v3 = (a[0] * b[0], a[1] * b[1], a[2] * b[2])
+ * @returns         result = (a[0] * b[0], a[1] * b[1])
  */
 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 +282,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 +297,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;
@@ -307,11 +308,11 @@ glms_vec2_scale_as(vec2s v, float s) {
  *
  * @param[in]  a    vector 1
  * @param[in]  b    vector 2
- * @returns         result = (a[0]/b[0], a[1]/b[1], a[2]/b[2])
+ * @returns         result = (a[0]/b[0], a[1]/b[1])
  */
 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;
@@ -322,11 +323,11 @@ glms_vec2_div(vec2s a, vec2s b) {
  *
  * @param[in]  a    vector
  * @param[in]  s    scalar
- * @returns         result = (a[0]/s, a[1]/s, a[2]/s)
+ * @returns         result = (a[0]/s, a[1]/s)
  */
 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 +344,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 +360,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 +376,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,13 +392,13 @@ 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;
 }
 
 /*!
- * @brief add max of two vector to result/dest
+ * @brief add max of two vectors to result/dest
  *
  * it applies += operator so dest must be initialized
  *
@@ -407,13 +408,13 @@ 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;
 }
 
 /*!
- * @brief add min of two vector to result/dest
+ * @brief add min of two vectors to result/dest
  *
  * it applies += operator so dest must be initialized
  *
@@ -423,7 +424,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 +437,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 +450,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 +464,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 +479,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 +492,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 +505,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 +520,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 +536,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,10 +553,24 @@ 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;
 }
 
+/*!
+ * @brief Create two dimensional vector from pointer
+ *
+ * @param[in]  src  pointer to an array of floats
+ * @returns constructed 2D vector from raw pointer
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_(make)(float * __restrict src) {
+  vec2s dest;
+  glm_vec2_make(src, dest.raw);
+  return dest;
+}
+
 #endif /* cglms_vec2s_h */

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,18 +89,18 @@ 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);
 }
 
 /*!
- * @brief check if vectors members are equal (without epsilon)
+ * @brief check if vector members are equal (without epsilon)
  *
  * @param[in] v   vector
  */
 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

@@ -70,6 +70,7 @@
    CGLM_INLINE vec3s glms_vec3_smoothinterp(vec3s from, vec3s to, float t);
    CGLM_INLINE vec3s glms_vec3_smoothinterpc(vec3s from, vec3s to, float t);
    CGLM_INLINE vec3s glms_vec3_swizzle(vec3s v, int mask);
+   CGLM_INLINE vec3s glms_vec3_make(float * restrict src);
 
  Convenient:
    CGLM_INLINE vec3s glms_cross(vec3s a, vec3s b);
@@ -119,7 +120,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 +137,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 +152,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 +165,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 +181,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 +198,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 +211,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 +231,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 +250,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 +263,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 +278,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 +293,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,14 +308,14 @@ 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;
 }
 
 /*!
- * @brief multiply two vector (component-wise multiplication)
+ * @brief multiply two vectors (component-wise multiplication)
  *
  * @param     a     vector1
  * @param     b     vector2
@@ -322,7 +323,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 +338,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 +353,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 +368,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 +383,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 +400,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 +416,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 +432,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,13 +448,13 @@ 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;
 }
 
 /*!
- * @brief add max of two vector to result/dest
+ * @brief add max of two vectors to result/dest
  *
  * it applies += operator so dest must be initialized
  *
@@ -463,13 +464,13 @@ 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;
 }
 
 /*!
- * @brief add min of two vector to result/dest
+ * @brief add min of two vectors to result/dest
  *
  * it applies += operator so dest must be initialized
  *
@@ -479,7 +480,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 +493,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 +506,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 +519,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 +533,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 +548,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 +564,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 +578,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 +598,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 +613,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 +628,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 +643,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 +658,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 +671,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 +684,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 +699,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 +713,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 +729,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 +746,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 +764,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 +782,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 +800,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 +815,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 +830,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 +846,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 +862,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 +880,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 +898,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,10 +962,24 @@ 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;
 }
 
+/*!
+ * @brief Create three dimensional vector from pointer
+ *
+ * @param[in]  src  pointer to an array of floats
+ * @returns constructed 3D vector from raw pointer
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_(make)(float * __restrict src) {
+  vec3s dest;
+  glm_vec3_make(src, dest.raw);
+  return dest;
+}
+
 #endif /* cglms_vec3s_h */

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,18 +89,18 @@ 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);
 }
 
 /*!
- * @brief check if vectors members are equal (without epsilon)
+ * @brief check if vector members are equal (without epsilon)
  *
  * @param v   vector
  */
 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

@@ -61,6 +61,7 @@
    CGLM_INLINE vec4s glms_vec4_smoothinterpc(vec4s from, vec4s to, float t);
    CGLM_INLINE vec4s glms_vec4_cubic(float s);
    CGLM_INLINE vec4s glms_vec4_swizzle(vec4s v, int mask);
+   CGLM_INLINE vec4s glms_vec4_make(float * restrict src);
  */
 
 #ifndef cglms_vec4s_h
@@ -103,7 +104,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 +118,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 +134,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 +149,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 +166,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 +181,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 +194,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 +210,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 +227,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 +240,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 +260,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 +279,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 +292,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 +307,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 +322,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,14 +337,14 @@ 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;
 }
 
 /*!
- * @brief multiply two vector (component-wise multiplication)
+ * @brief multiply two vectors (component-wise multiplication)
  *
  * @param a    vector1
  * @param b    vector2
@@ -351,7 +352,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 +367,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 +382,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 +397,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 +412,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 +429,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 +445,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 +461,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,13 +477,13 @@ 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;
 }
 
 /*!
- * @brief add max of two vector to result/dest
+ * @brief add max of two vectors to result/dest
  *
  * it applies += operator so dest must be initialized
  *
@@ -492,13 +493,13 @@ 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;
 }
 
 /*!
- * @brief add min of two vector to result/dest
+ * @brief add min of two vectors to result/dest
  *
  * it applies += operator so dest must be initialized
  *
@@ -508,7 +509,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 +522,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 +535,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 +549,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 +562,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 +575,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 +590,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 +606,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 +623,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 +641,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 +659,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 +677,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 +692,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 +707,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 +723,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 +739,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 +757,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 +775,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 +789,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,10 +806,24 @@ 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;
 }
 
+/*!
+ * @brief Create four dimensional vector from pointer
+ *
+ * @param[in]  src  pointer to an array of floats
+ * @returns constructed 4D vector from raw pointer
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_(make)(float * __restrict src) {
+  vec4s dest;
+  glm_vec4_make(src, dest.raw);
+  return dest;
+}
+
 #endif /* cglms_vec4s_h */

include/cglm/types-struct.h

@@ -25,10 +25,17 @@
       * only #define governing the use of anonymous structs, so for backward
       * compatibility, we still honor that choice and disable them. */
 #    define CGLM_USE_ANONYMOUS_STRUCT 0
-#  elif __STDC_VERSION__ >= 20112L || defined(_MSVC_VER)
+#  elif (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || \
+        (defined(__cplusplus)      && __cplusplus >= 201103L)
      /* We're compiling for C11 or this is the MSVC compiler. In either
       * case, anonymous structs are available, so use them. */
 #    define CGLM_USE_ANONYMOUS_STRUCT 1
+#  elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+     /* GCC 4.6 and onwards support anonymous structs as an extension */
+#    define CGLM_USE_ANONYMOUS_STRUCT 1
+#  elif defined(__clang__) && __clang_major__ >= 3
+     /* Clang 3.0 and onwards support anonymous structs as an extension */
+#    define CGLM_USE_ANONYMOUS_STRUCT 1
 #  elif defined(_MSC_VER) && (_MSC_VER >= 1900) /*  Visual Studio 2015 */
      /* We can support anonymous structs
       * since Visual Studio 2015 or 2017 (1910) maybe? */

include/cglm/types.h

@@ -32,9 +32,13 @@
 #  define CGLM_ALIGN_MAT CGLM_ALIGN(16)
 #endif
 
-#ifdef __GNUC__
+#if defined(__has_builtin)
-#  define CGLM_ASSUME_ALIGNED(expr, alignment) \
+#  if __has_builtin(__builtin_assume_aligned)
-  __builtin_assume_aligned((expr), (alignment))
+#    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

include/cglm/vec2-ext.h

@@ -19,6 +19,7 @@
    CGLM_INLINE bool  glm_vec2_isinf(vec2 v);
    CGLM_INLINE bool  glm_vec2_isvalid(vec2 v);
    CGLM_INLINE void  glm_vec2_sign(vec2 v, vec2 dest);
+   CGLM_INLINE void  glm_vec2_abs(vec2 v, vec2 dest);
    CGLM_INLINE void  glm_vec2_sqrt(vec2 v, vec2 dest);
    CGLM_INLINE void  glm_vec2_complex_mul(vec2 a, vec2 b, vec2 dest)
    CGLM_INLINE void  glm_vec2_complex_div(vec2 a, vec2 b, vec2 dest)
@@ -69,7 +70,7 @@ glm_vec2_eq_eps(vec2 v, float val) {
 }
 
 /*!
- * @brief check if vectors members are equal (without epsilon)
+ * @brief check if vector members are equal (without epsilon)
  *
  * @param[in] v   vector
  */
@@ -176,6 +177,19 @@ glm_vec2_sign(vec2 v, vec2 dest) {
   dest[1] = glm_signf(v[1]);
 }
 
+/*!
+ * @brief absolute value of v
+ *
+ * @param[in]	v	vector
+ * @param[out]	dest	destination
+ */
+CGLM_INLINE
+void
+glm_vec2_abs(vec2 v, vec2 dest) {
+  dest[0] = fabsf(v[0]);
+  dest[1] = fabsf(v[1]);
+}
+
 /*!
  * @brief square root of each vector item
  *
@@ -237,5 +251,4 @@ glm_vec2_complex_conjugate(vec2 a, vec2 dest) {
   dest[1] = -a[1];
 }
 
-
 #endif /* cglm_vec2_ext_h */

include/cglm/vec2.h

@@ -47,6 +47,7 @@
    CGLM_INLINE void  glm_vec2_minv(vec2 v1, vec2 v2, vec2 dest)
    CGLM_INLINE void  glm_vec2_clamp(vec2 v, float minVal, float maxVal)
    CGLM_INLINE void  glm_vec2_lerp(vec2 from, vec2 to, float t, vec2 dest)
+   CGLM_INLINE void  glm_vec2_make(float * restrict src, vec2 dest)
 
  */
 
@@ -229,7 +230,7 @@ glm_vec2_subs(vec2 v, float s, vec2 dest) {
 }
 
 /*!
- * @brief multiply two vector (component-wise multiplication)
+ * @brief multiply two vectors (component-wise multiplication)
  *
  * @param a    v1
  * @param b    v2
@@ -370,7 +371,7 @@ glm_vec2_muladds(vec2 a, float s, vec2 dest) {
 }
 
 /*!
- * @brief add max of two vector to result/dest
+ * @brief add max of two vectors to result/dest
  *
  * it applies += operator so dest must be initialized
  *
@@ -386,7 +387,7 @@ glm_vec2_maxadd(vec2 a, vec2 b, vec2 dest) {
 }
 
 /*!
- * @brief add min of two vector to result/dest
+ * @brief add min of two vectors to result/dest
  *
  * it applies += operator so dest must be initialized
  *
@@ -582,4 +583,16 @@ glm_vec2_lerp(vec2 from, vec2 to, float t, vec2 dest) {
   glm_vec2_add(from, v, dest);
 }
 
+/*!
+ * @brief Create two dimensional vector from pointer
+ *
+ * @param[in]  src  pointer to an array of floats
+ * @param[out] dest destination vector
+ */
+CGLM_INLINE
+void
+glm_vec2_make(float * __restrict src, vec2 dest) {
+  dest[0] = src[0]; dest[1] = src[1];
+}
+
 #endif /* cglm_vec2_h */

include/cglm/vec3-ext.h

@@ -87,7 +87,7 @@ glm_vec3_eq_eps(vec3 v, float val) {
 }
 
 /*!
- * @brief check if vectors members are equal (without epsilon)
+ * @brief check if vector members are equal (without epsilon)
  *
  * @param[in] v   vector
  */

include/cglm/vec3.h

@@ -73,6 +73,7 @@
    CGLM_INLINE void  glm_vec3_smoothinterp(vec3 from, vec3 to, float t, vec3 dest);
    CGLM_INLINE void  glm_vec3_smoothinterpc(vec3 from, vec3 to, float t, vec3 dest);
    CGLM_INLINE void  glm_vec3_swizzle(vec3 v, int mask, vec3 dest);
+   CGLM_INLINE void  glm_vec3_make(float * restrict src, vec3 dest);
 
  Convenient:
    CGLM_INLINE void  glm_cross(vec3 a, vec3 b, vec3 d);
@@ -320,7 +321,7 @@ glm_vec3_subs(vec3 v, float s, vec3 dest) {
 }
 
 /*!
- * @brief multiply two vector (component-wise multiplication)
+ * @brief multiply two vectors (component-wise multiplication)
  *
  * @param a    vector1
  * @param b    vector2
@@ -469,7 +470,7 @@ glm_vec3_muladds(vec3 a, float s, vec3 dest) {
 }
 
 /*!
- * @brief add max of two vector to result/dest
+ * @brief add max of two vectors to result/dest
  *
  * it applies += operator so dest must be initialized
  *
@@ -486,7 +487,7 @@ glm_vec3_maxadd(vec3 a, vec3 b, vec3 dest) {
 }
 
 /*!
- * @brief add min of two vector to result/dest
+ * @brief add min of two vectors to result/dest
  *
  * it applies += operator so dest must be initialized
  *
@@ -1079,4 +1080,18 @@ glm_normalize_to(vec3 v, vec3 dest) {
   glm_vec3_normalize_to(v, dest);
 }
 
+/*!
+ * @brief Create three dimensional vector from pointer
+ *
+ * @param[in]  src  pointer to an array of floats
+ * @param[out] dest destination vector
+ */
+CGLM_INLINE
+void
+glm_vec3_make(float * __restrict src, vec3 dest) {
+  dest[0] = src[0];
+  dest[1] = src[1];
+  dest[2] = src[2];
+}
+
 #endif /* cglm_vec3_h */

include/cglm/vec4-ext.h

@@ -45,7 +45,9 @@
 CGLM_INLINE
 void
 glm_vec4_broadcast(float val, vec4 d) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glmm_store(d, wasm_f32x4_splat(val));
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(d, _mm_set1_ps(val));
 #else
   d[0] = d[1] = d[2] = d[3] = val;
@@ -61,7 +63,9 @@ glm_vec4_broadcast(float val, vec4 d) {
 CGLM_INLINE
 void
 glm_vec4_fill(vec4 v, float val) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glmm_store(v, wasm_f32x4_splat(val));
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(v, _mm_set1_ps(val));
 #else
   v[0] = v[1] = v[2] = v[3] = val;
@@ -99,7 +103,7 @@ glm_vec4_eq_eps(vec4 v, float val) {
 }
 
 /*!
- * @brief check if vectors members are equal (without epsilon)
+ * @brief check if vector members are equal (without epsilon)
  *
  * @param v   vector
  */
@@ -247,7 +251,9 @@ glm_vec4_sign(vec4 v, vec4 dest) {
 CGLM_INLINE
 void
 glm_vec4_abs(vec4 v, vec4 dest) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glmm_store(dest, glmm_abs(glmm_load(v)));
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, glmm_abs(glmm_load(v)));
 #elif defined(CGLM_NEON_FP)
   vst1q_f32(dest, vabsq_f32(vld1q_f32(v)));
@@ -284,7 +290,9 @@ glm_vec4_fract(vec4 v, vec4 dest) {
 CGLM_INLINE
 float
 glm_vec4_hadd(vec4 v) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  return glmm_hadd(glmm_load(v));
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   return glmm_hadd(glmm_load(v));
 #else
   return v[0] + v[1] + v[2] + v[3];
@@ -300,7 +308,9 @@ glm_vec4_hadd(vec4 v) {
 CGLM_INLINE
 void
 glm_vec4_sqrt(vec4 v, vec4 dest) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glmm_store(dest, wasm_f32x4_sqrt(glmm_load(v)));
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_sqrt_ps(glmm_load(v)));
 #else
   dest[0] = sqrtf(v[0]);

include/cglm/vec4.h

@@ -58,6 +58,7 @@
    CGLM_INLINE void  glm_vec4_smoothinterp(vec4 from, vec4 to, float t, vec4 dest);
    CGLM_INLINE void  glm_vec4_smoothinterpc(vec4 from, vec4 to, float t, vec4 dest);
    CGLM_INLINE void  glm_vec4_swizzle(vec4 v, int mask, vec4 dest);
+   CGLM_INLINE void  glm_vec4_make(float * restrict src, vec4 dest);
 
  DEPRECATED:
    glm_vec4_dup
@@ -137,7 +138,9 @@ glm_vec4_copy3(vec4 a, vec3 dest) {
 CGLM_INLINE
 void
 glm_vec4_copy(vec4 v, vec4 dest) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glmm_store(dest, glmm_load(v));
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, glmm_load(v));
 #elif defined(CGLM_NEON_FP)
   vst1q_f32(dest, vld1q_f32(v));
@@ -160,10 +163,15 @@ glm_vec4_copy(vec4 v, vec4 dest) {
 CGLM_INLINE
 void
 glm_vec4_ucopy(vec4 v, vec4 dest) {
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  /* note here wasm v128.load/v128.store support unaligned loads and stores */
+  wasm_v128_store(dest, wasm_v128_load(v));
+#else
   dest[0] = v[0];
   dest[1] = v[1];
   dest[2] = v[2];
   dest[3] = v[3];
+#endif
 }
 
 /*!
@@ -174,7 +182,9 @@ glm_vec4_ucopy(vec4 v, vec4 dest) {
 CGLM_INLINE
 void
 glm_vec4_zero(vec4 v) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glmm_store(v, wasm_f32x4_const_splat(0.f));
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(v, _mm_setzero_ps());
 #elif defined(CGLM_NEON_FP)
   vst1q_f32(v, vdupq_n_f32(0.0f));
@@ -194,7 +204,9 @@ glm_vec4_zero(vec4 v) {
 CGLM_INLINE
 void
 glm_vec4_one(vec4 v) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glmm_store(v, wasm_f32x4_const_splat(1.0f));
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(v, _mm_set1_ps(1.0f));
 #elif defined(CGLM_NEON_FP)
   vst1q_f32(v, vdupq_n_f32(1.0f));
@@ -320,7 +332,9 @@ glm_vec4_norm_inf(vec4 v) {
 CGLM_INLINE
 void
 glm_vec4_add(vec4 a, vec4 b, vec4 dest) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glmm_store(dest, wasm_f32x4_add(glmm_load(a), glmm_load(b)));
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_add_ps(glmm_load(a), glmm_load(b)));
 #elif defined(CGLM_NEON_FP)
   vst1q_f32(dest, vaddq_f32(vld1q_f32(a), vld1q_f32(b)));
@@ -342,7 +356,9 @@ glm_vec4_add(vec4 a, vec4 b, vec4 dest) {
 CGLM_INLINE
 void
 glm_vec4_adds(vec4 v, float s, vec4 dest) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glmm_store(dest, wasm_f32x4_add(glmm_load(v), wasm_f32x4_splat(s)));
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_add_ps(glmm_load(v), _mm_set1_ps(s)));
 #elif defined(CGLM_NEON_FP)
   vst1q_f32(dest, vaddq_f32(vld1q_f32(v), vdupq_n_f32(s)));
@@ -364,7 +380,9 @@ glm_vec4_adds(vec4 v, float s, vec4 dest) {
 CGLM_INLINE
 void
 glm_vec4_sub(vec4 a, vec4 b, vec4 dest) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glmm_store(dest, wasm_f32x4_sub(glmm_load(a), glmm_load(b)));
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_sub_ps(glmm_load(a), glmm_load(b)));
 #elif defined(CGLM_NEON_FP)
   vst1q_f32(dest, vsubq_f32(vld1q_f32(a), vld1q_f32(b)));
@@ -386,7 +404,9 @@ glm_vec4_sub(vec4 a, vec4 b, vec4 dest) {
 CGLM_INLINE
 void
 glm_vec4_subs(vec4 v, float s, vec4 dest) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glmm_store(dest, wasm_f32x4_sub(glmm_load(v), wasm_f32x4_splat(s)));
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_sub_ps(glmm_load(v), _mm_set1_ps(s)));
 #elif defined(CGLM_NEON_FP)
   vst1q_f32(dest, vsubq_f32(vld1q_f32(v), vdupq_n_f32(s)));
@@ -399,7 +419,7 @@ glm_vec4_subs(vec4 v, float s, vec4 dest) {
 }
 
 /*!
- * @brief multiply two vector (component-wise multiplication)
+ * @brief multiply two vectors (component-wise multiplication)
  *
  * @param a    vector1
  * @param b    vector2
@@ -408,7 +428,9 @@ glm_vec4_subs(vec4 v, float s, vec4 dest) {
 CGLM_INLINE
 void
 glm_vec4_mul(vec4 a, vec4 b, vec4 dest) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glmm_store(dest, wasm_f32x4_mul(glmm_load(a), glmm_load(b)));
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_mul_ps(glmm_load(a), glmm_load(b)));
 #elif defined(CGLM_NEON_FP)
   vst1q_f32(dest, vmulq_f32(vld1q_f32(a), vld1q_f32(b)));
@@ -430,7 +452,9 @@ glm_vec4_mul(vec4 a, vec4 b, vec4 dest) {
 CGLM_INLINE
 void
 glm_vec4_scale(vec4 v, float s, vec4 dest) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glmm_store(dest, wasm_f32x4_mul(glmm_load(v), wasm_f32x4_splat(s)));
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_mul_ps(glmm_load(v), _mm_set1_ps(s)));
 #elif defined(CGLM_NEON_FP)
   vst1q_f32(dest, vmulq_f32(vld1q_f32(v), vdupq_n_f32(s)));
@@ -493,7 +517,9 @@ glm_vec4_div(vec4 a, vec4 b, vec4 dest) {
 CGLM_INLINE
 void
 glm_vec4_divs(vec4 v, float s, vec4 dest) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glmm_store(dest, wasm_f32x4_div(glmm_load(v), wasm_f32x4_splat(s)));
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_div_ps(glmm_load(v), _mm_set1_ps(s)));
 #else
   glm_vec4_scale(v, 1.0f / s, dest);
@@ -512,7 +538,11 @@ glm_vec4_divs(vec4 v, float s, vec4 dest) {
 CGLM_INLINE
 void
 glm_vec4_addadd(vec4 a, vec4 b, vec4 dest) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glmm_store(dest, wasm_f32x4_add(
+          glmm_load(dest),
+          wasm_f32x4_add(glmm_load(a), glmm_load(b))));
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_add_ps(glmm_load(dest),
                               _mm_add_ps(glmm_load(a),
                                          glmm_load(b))));
@@ -540,7 +570,11 @@ glm_vec4_addadd(vec4 a, vec4 b, vec4 dest) {
 CGLM_INLINE
 void
 glm_vec4_subadd(vec4 a, vec4 b, vec4 dest) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glmm_store(dest, wasm_f32x4_add(
+          glmm_load(dest),
+          wasm_f32x4_sub(glmm_load(a), glmm_load(b))));
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_add_ps(glmm_load(dest),
                               _mm_sub_ps(glmm_load(a),
                                          glmm_load(b))));
@@ -601,7 +635,7 @@ glm_vec4_muladds(vec4 a, float s, vec4 dest) {
 }
 
 /*!
- * @brief add max of two vector to result/dest
+ * @brief add max of two vectors to result/dest
  *
  * it applies += operator so dest must be initialized
  *
@@ -612,7 +646,11 @@ glm_vec4_muladds(vec4 a, float s, vec4 dest) {
 CGLM_INLINE
 void
 glm_vec4_maxadd(vec4 a, vec4 b, vec4 dest) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glmm_store(dest, wasm_f32x4_add(
+          glmm_load(dest),
+          wasm_f32x4_max(glmm_load(a), glmm_load(b))));
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_add_ps(glmm_load(dest),
                               _mm_max_ps(glmm_load(a),
                                          glmm_load(b))));
@@ -629,7 +667,7 @@ glm_vec4_maxadd(vec4 a, vec4 b, vec4 dest) {
 }
 
 /*!
- * @brief add min of two vector to result/dest
+ * @brief add min of two vectors to result/dest
  *
  * it applies += operator so dest must be initialized
  *
@@ -640,7 +678,11 @@ glm_vec4_maxadd(vec4 a, vec4 b, vec4 dest) {
 CGLM_INLINE
 void
 glm_vec4_minadd(vec4 a, vec4 b, vec4 dest) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glmm_store(dest, wasm_f32x4_add(
+          glmm_load(dest),
+          wasm_f32x4_min(glmm_load(a), glmm_load(b))));
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_add_ps(glmm_load(dest),
                               _mm_min_ps(glmm_load(a),
                                          glmm_load(b))));
@@ -665,8 +707,10 @@ glm_vec4_minadd(vec4 a, vec4 b, vec4 dest) {
 CGLM_INLINE
 void
 glm_vec4_negate_to(vec4 v, vec4 dest) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
-  glmm_store(dest, _mm_xor_ps(glmm_load(v), _mm_set1_ps(-0.0f)));
+  glmm_store(dest, wasm_f32x4_neg(glmm_load(v)));
+#elif defined( __SSE__ ) || defined( __SSE2__ )
+  glmm_store(dest, _mm_xor_ps(glmm_load(v), glmm_float32x4_SIGNMASK_NEG));
 #elif defined(CGLM_NEON_FP)
   vst1q_f32(dest, vnegq_f32(vld1q_f32(v)));
 #else
@@ -697,7 +741,22 @@ glm_vec4_negate(vec4 v) {
 CGLM_INLINE
 void
 glm_vec4_normalize_to(vec4 v, vec4 dest) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glmm_128 xdot, x0;
+  float  dot;
+
+  x0   = glmm_load(v);
+  xdot = glmm_vdot(x0, x0);
+  /* dot  = _mm_cvtss_f32(xdot); */
+  dot  = wasm_f32x4_extract_lane(xdot, 0);
+
+  if (dot == 0.0f) {
+    glmm_store(dest, wasm_f32x4_const_splat(0.f));
+    return;
+  }
+
+  glmm_store(dest, wasm_f32x4_div(x0, wasm_f32x4_sqrt(xdot)));
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   __m128 xdot, x0;
   float  dot;
 
@@ -746,7 +805,9 @@ glm_vec4_normalize(vec4 v) {
 CGLM_INLINE
 float
 glm_vec4_distance(vec4 a, vec4 b) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  return glmm_norm(wasm_f32x4_sub(glmm_load(a), glmm_load(b)));
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   return glmm_norm(_mm_sub_ps(glmm_load(a), glmm_load(b)));
 #elif defined(CGLM_NEON_FP)
   return glmm_norm(vsubq_f32(glmm_load(a), glmm_load(b)));
@@ -768,7 +829,9 @@ glm_vec4_distance(vec4 a, vec4 b) {
 CGLM_INLINE
 float
 glm_vec4_distance2(vec4 a, vec4 b) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  return glmm_norm2(wasm_f32x4_sub(glmm_load(a), glmm_load(b)));
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   return glmm_norm2(_mm_sub_ps(glmm_load(a), glmm_load(b)));
 #elif defined(CGLM_NEON_FP)
   return glmm_norm2(vsubq_f32(glmm_load(a), glmm_load(b)));
@@ -790,7 +853,9 @@ glm_vec4_distance2(vec4 a, vec4 b) {
 CGLM_INLINE
 void
 glm_vec4_maxv(vec4 a, vec4 b, vec4 dest) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glmm_store(dest, wasm_f32x4_max(glmm_load(a), glmm_load(b)));
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_max_ps(glmm_load(a), glmm_load(b)));
 #elif defined(CGLM_NEON_FP)
   vst1q_f32(dest, vmaxq_f32(vld1q_f32(a), vld1q_f32(b)));
@@ -812,7 +877,9 @@ glm_vec4_maxv(vec4 a, vec4 b, vec4 dest) {
 CGLM_INLINE
 void
 glm_vec4_minv(vec4 a, vec4 b, vec4 dest) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glmm_store(dest, wasm_f32x4_min(glmm_load(a), glmm_load(b)));
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_min_ps(glmm_load(a), glmm_load(b)));
 #elif defined(CGLM_NEON_FP)
   vst1q_f32(dest, vminq_f32(vld1q_f32(a), vld1q_f32(b)));
@@ -834,7 +901,11 @@ glm_vec4_minv(vec4 a, vec4 b, vec4 dest) {
 CGLM_INLINE
 void
 glm_vec4_clamp(vec4 v, float minVal, float maxVal) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
+#if defined(__wasm__) && defined(__wasm_simd128__)
+  glmm_store(v, wasm_f32x4_min(
+          wasm_f32x4_max(glmm_load(v), wasm_f32x4_splat(minVal)),
+          wasm_f32x4_splat(maxVal)));
+#elif defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(v, _mm_min_ps(_mm_max_ps(glmm_load(v), _mm_set1_ps(minVal)),
                            _mm_set1_ps(maxVal)));
 #elif defined(CGLM_NEON_FP)
@@ -1063,4 +1134,17 @@ glm_vec4_swizzle(vec4 v, int mask, vec4 dest) {
   glm_vec4_copy(t, dest);
 }
 
+/*!
+ * @brief Create four dimensional vector from pointer
+ *
+ * @param[in]  src  pointer to an array of floats
+ * @param[out] dest destination vector
+ */
+CGLM_INLINE
+void
+glm_vec4_make(float * __restrict src, vec4 dest) {
+  dest[0] = src[0]; dest[1] = src[1];
+  dest[2] = src[2]; dest[3] = src[3];
+}
+
 #endif /* cglm_vec4_h */

include/cglm/version.h

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

meson.build

@@ -1,9 +1,8 @@
 project('cglm', 'c',
-    version : '0.8.7',
+    version : '0.9.1',
     license : 'mit',
     default_options : [
         'c_std=c11',
-        'werror=true',
         'warning_level=2',
         'buildtype=release'
     ]
@@ -108,11 +107,6 @@ if get_option('build_tests') == true
 test_src = files(
     'test/runner.c',
     'test/src/test_bezier.c',
-    'test/src/test_cam.c',
-    'test/src/test_cam_lh_no.c',
-    'test/src/test_cam_lh_zo.c',
-    'test/src/test_cam_rh_no.c',
-    'test/src/test_cam_rh_zo.c',
     'test/src/test_clamp.c',
     'test/src/test_common.c',
     'test/src/test_euler.c',

src/ivec2.c

@@ -97,3 +97,10 @@ void
 glmc_ivec2_clamp(ivec2 v, int minVal, int maxVal) {
   glm_ivec2_clamp(v, minVal, maxVal);
 }
+
+CGLM_EXPORT
+void
+glmc_ivec2_abs(ivec2 v, ivec2 dest) {
+  glm_ivec2_abs(v, dest);
+}
+

src/ivec3.c

@@ -97,3 +97,10 @@ void
 glmc_ivec3_clamp(ivec3 v, int minVal, int maxVal) {
   glm_ivec3_clamp(v, minVal, maxVal);
 }
+
+CGLM_EXPORT
+void
+glmc_ivec3_abs(ivec3 v, ivec3 dest) {
+  glm_ivec3_abs(v, dest);
+}
+

src/ivec4.c

@@ -97,3 +97,10 @@ void
 glmc_ivec4_clamp(ivec4 v, int minVal, int maxVal) {
   glm_ivec4_clamp(v, minVal, maxVal);
 }
+
+CGLM_EXPORT
+void
+glmc_ivec4_abs(ivec4 v, ivec4 dest) {
+  glm_ivec4_abs(v, dest);
+}
+