Merge branch 'master' into non-square-matrix

add docs and tests to non-square-matrix branch

.github/workflows/cmake-wasm.yml

@@ -66,7 +66,7 @@ jobs:
     steps:
     - uses: actions/checkout@v3
     - name: Setup emsdk
-      uses: mymindstorm/setup-emsdk@v11
+      uses: mymindstorm/setup-emsdk@v12
 
     - name: Verify emsdk
       run: emcc -v

CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.8.2)
 project(cglm
-  VERSION 0.9.0
+  VERSION 0.9.1
   HOMEPAGE_URL https://github.com/recp/cglm
   DESCRIPTION "OpenGL Mathematics (glm) for C"
   LANGUAGES C
@@ -43,7 +43,7 @@ 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()
 
 get_directory_property(hasParent PARENT_DIRECTORY)
@@ -79,8 +79,14 @@ add_library(${PROJECT_NAME}
   src/vec4.c
   src/ivec4.c
   src/mat2.c
+  src/mat2x3.c
+  src/mat2x4.c
   src/mat3.c
+  src/mat3x2.c
+  src/mat3x4.c
   src/mat4.c
+  src/mat4x2.c
+  src/mat4x3.c
   src/plane.c
   src/frustum.c
   src/box.c

Makefile.am

@@ -11,8 +11,7 @@ AM_CFLAGS = -Wall \
             -std=gnu11 \
             -O3 \
             -Wstrict-aliasing=2 \
-            -fstrict-aliasing \
-            -Werror=strict-prototypes
+            -fstrict-aliasing
 
 lib_LTLIBRARIES = libcglm.la
 libcglm_la_LDFLAGS = -no-undefined -version-info 0:1:0
@@ -43,8 +42,14 @@ cglm_HEADERS = include/cglm/version.h \
                include/cglm/cam.h \
                include/cglm/io.h \
                include/cglm/mat4.h \
+               include/cglm/mat4x2.h \
+               include/cglm/mat4x3.h \
                include/cglm/mat3.h \
+               include/cglm/mat3x2.h \
+               include/cglm/mat3x4.h \
                include/cglm/mat2.h \
+               include/cglm/mat2x3.h \
+               include/cglm/mat2x4.h \
                include/cglm/affine-pre.h \
                include/cglm/affine-post.h \
                include/cglm/affine.h \
@@ -95,8 +100,14 @@ cglm_clipspace_HEADERS = include/cglm/clipspace/persp.h \
 
 cglm_calldir=$(includedir)/cglm/call
 cglm_call_HEADERS = include/cglm/call/mat4.h \
+                    include/cglm/call/mat4x2.h \
+                    include/cglm/call/mat4x3.h \
                     include/cglm/call/mat3.h \
+                    include/cglm/call/mat3x2.h \
+                    include/cglm/call/mat3x4.h \
                     include/cglm/call/mat2.h \
+                    include/cglm/call/mat2x3.h \
+                    include/cglm/call/mat2x4.h \
                     include/cglm/call/vec2.h \
                     include/cglm/call/vec3.h \
                     include/cglm/call/vec4.h \
@@ -159,10 +170,17 @@ cglm_simd_neon_HEADERS = include/cglm/simd/neon/affine.h \
 
 cglm_structdir=$(includedir)/cglm/struct
 cglm_struct_HEADERS = include/cglm/struct/mat4.h \
+                      include/cglm/struct/mat4x2.h \
+                      include/cglm/struct/mat4x3.h \
                       include/cglm/struct/mat3.h \
+                      include/cglm/struct/mat3x2.h \
+                      include/cglm/struct/mat3x4.h \
                       include/cglm/struct/mat2.h \
+                      include/cglm/struct/mat2x3.h \
+                      include/cglm/struct/mat2x4.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 \
@@ -212,8 +230,14 @@ libcglm_la_SOURCES=\
     src/vec4.c \
     src/ivec4.c \
     src/mat2.c \
+    src/mat2x3.c \
+    src/mat2x4.c \
     src/mat3.c \
+    src/mat3x2.c \
+    src/mat3x4.c \
     src/mat4.c \
+    src/mat4x2.c \
+    src/mat4x3.c \
     src/plane.c \
     src/frustum.c \
     src/box.c \
@@ -243,11 +267,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.podspec

@@ -2,7 +2,7 @@ Pod::Spec.new do |s|
 
   # Description
   s.name         = "cglm"
-  s.version      = "0.8.9"
+  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.9.0], [info@recp.me])
-AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects serial-tests])
+AC_INIT([cglm], [0.9.1], [info@recp.me])
+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,
-once for their namespace and once for global namespace
-to make easier to write very common functions
+**cglm** provides a few APIs for similar 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...
+* 📦 **Inline API**: All functions are inline. You can include **cglm/cglm.h** header
+  to use this API. This is the default API. `glm_` is namespace/prefix for this API. 
+* 📦 **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
-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`
+And also there are also sub categories:
 
-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.
+* 📦 **Array API**: Types are raw arrays and functions takes array as argument. You can include **cglm/cglm.h** header
+  to use this API. This is the default API. `glm_` is namespace/prefix for this API. 
+* 📦 **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*
-version of functions. You need to build *cglm* and link it.
-Follow the :doc:`build` documentation for this
+📌 Since struct api and call api are built top of inline array api, follow inline array api docs for individual functions. 
 
 .. toctree::
    :maxdepth: 1
-   :caption: API categories:
+   :caption: API documentations:
 
-   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
+   api_inline_array
+   api_struct
+   api_call
+   api_simd

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,76 @@
+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
+   mat2x3
+   mat2x4
+   mat3
+   mat3x2
+   mat3x4
+   mat4
+   mat4x2
+   mat4x3
+   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/conf.py

@@ -62,16 +62,16 @@ author = u'Recep Aslantas'
 # built documents.
 #
 # The short X.Y version.
-version = u'0.9.0'
+version = u'0.9.1'
 # The full version, including alpha/beta/rc tags.
-release = u'0.9.0'
+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/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
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -64,11 +65,12 @@ Functions documentation
     make given matrix zero
 
     Parameters:
-      | *[in,out]* **mat**  matrix to
+      | *[in,out]* **mat**  matrix
 
 .. c:function:: void glm_mat2_mul(mat2 m1, mat2 m2, mat2 dest)
 
     multiply m1 and m2 to dest
+
     m1, m2 and dest matrices can be same matrix, it is possible to write this:
 
     .. code-block:: c
@@ -100,7 +102,7 @@ Functions documentation
 
 .. c:function:: void glm_mat2_mulv(mat2 m, vec2 v, vec2 dest)
 
-    multiply mat4 with vec4 (column vector) and store in dest vector
+    multiply mat2 with vec2 (column vector) and store in dest vector
 
     Parameters:
       | *[in]*  **mat**   mat2 (left)
@@ -112,8 +114,8 @@ Functions documentation
     multiply matrix with scalar
 
     Parameters:
-      | *[in, out]* **mat**   matrix
-      | *[in]*      **dest**  scalar
+      | *[in, out]* **m**  matrix
+      | *[in]*      **s**  scalar
 
 .. c:function:: float  glm_mat2_det(mat2 mat)
 
@@ -177,3 +179,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 at least 4 elements.
+
+    Parameters:
+      | *[in]*  **src**  pointer to an array of floats
+      | *[out]* **dest** destination matrix2x2

docs/source/mat2x3.rst

@@ -0,0 +1,92 @@
+.. default-domain:: C
+
+mat2x3
+======
+
+Header: cglm/mat2x3.h
+
+Table of contents (click to go):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Macros:
+
+1. GLM_MAT2X3_ZERO_INIT
+#. GLM_MAT2X3_ZERO
+
+Functions:
+
+1. :c:func:`glm_mat2x3_copy`
+#. :c:func:`glm_mat2x3_zero`
+#. :c:func:`glm_mat2x3_make`
+#. :c:func:`glm_mat2x3_mul`
+#. :c:func:`glm_mat2x3_mulv`
+#. :c:func:`glm_mat2x3_transpose`
+#. :c:func:`glm_mat2x3_scale`
+
+Functions documentation
+~~~~~~~~~~~~~~~~~~~~~~~
+
+.. c:function:: void glm_mat2x3_copy(mat2x3 mat, mat2x3 dest)
+
+    copy mat2x3 to another one (dest).
+
+    Parameters:
+      | *[in]*  **mat**   source
+      | *[out]* **dest**  destination
+
+.. c:function:: void glm_mat2x3_zero(mat2x3 mat)
+
+    make given matrix zero
+
+    Parameters:
+      | *[in,out]* **mat**  matrix
+
+.. c:function:: void glm_mat2x3_make(float * __restrict src, mat2x3 dest)
+
+    Create mat2x3 matrix from pointer
+
+    | NOTE: **@src** must contain at least 6 elements.
+
+    Parameters:
+      | *[in]*  **src**  pointer to an array of floats
+      | *[out]* **dest** destination matrix2x3
+
+.. c:function:: void glm_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat2 dest)
+
+    multiply m1 and m2 to dest
+
+    m1, m2 and dest matrices can be same matrix, it is possible to write this:
+
+    .. code-block:: c
+
+       glm_mat2x3_mul(m, m, m);
+
+    Parameters:
+      | *[in]*  **m1**    left matrix
+      | *[in]*  **m2**    right matrix
+      | *[out]* **dest**  destination matrix
+
+.. c:function:: void glm_mat2x3_mulv(mat2x3 m, vec3 v, vec2 dest)
+
+    multiply mat2x3 with vec3 (column vector) and store in dest vector
+
+    Parameters:
+      | *[in]*  **m**     mat2x3 (left)
+      | *[in]*  **v**     vec3 (right, column vector)
+      | *[out]* **dest**  destination (result, column vector)
+
+.. c:function:: void glm_mat2x3_transpose(mat2x3 m, mat3x2 dest)
+
+    transpose matrix and store in dest
+
+    Parameters:
+      | *[in]*  **m**     matrix
+      | *[out]* **dest**  destination
+
+.. c:function:: void  glm_mat2x3_scale(mat2x3 m, float s)
+
+    multiply matrix with scalar
+
+    Parameters:
+      | *[in, out]* **m** matrix
+      | *[in]*      **s** scalar

docs/source/mat2x4.rst

@@ -0,0 +1,92 @@
+.. default-domain:: C
+
+mat2x4
+======
+
+Header: cglm/mat2x4.h
+
+Table of contents (click to go):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Macros:
+
+1. GLM_MAT2X4_ZERO_INIT
+#. GLM_MAT2X4_ZERO
+
+Functions:
+
+1. :c:func:`glm_mat2x4_copy`
+#. :c:func:`glm_mat2x4_zero`
+#. :c:func:`glm_mat2x4_make`
+#. :c:func:`glm_mat2x4_mul`
+#. :c:func:`glm_mat2x4_mulv`
+#. :c:func:`glm_mat2x4_transpose`
+#. :c:func:`glm_mat2x4_scale`
+
+Functions documentation
+~~~~~~~~~~~~~~~~~~~~~~~
+
+.. c:function:: void glm_mat2x4_copy(mat2x4 mat, mat2x4 dest)
+
+    copy mat2x4 to another one (dest).
+
+    Parameters:
+      | *[in]*  **mat**   source
+      | *[out]* **dest**  destination
+
+.. c:function:: void glm_mat2x4_zero(mat2x4 mat)
+
+    make given matrix zero
+
+    Parameters:
+      | *[in,out]* **mat**  matrix
+
+.. c:function:: void glm_mat2x4_make(float * __restrict src, mat2x4 dest)
+
+    Create mat2x4 matrix from pointer
+
+    | NOTE: **@src** must contain at least 8 elements.
+
+    Parameters:
+      | *[in]*  **src**  pointer to an array of floats
+      | *[out]* **dest** destination matrix2x4
+
+.. c:function:: void glm_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat2 dest)
+
+    multiply m1 and m2 to dest
+
+    m1, m2 and dest matrices can be same matrix, it is possible to write this:
+
+    .. code-block:: c
+
+       glm_mat2x4_mul(m, m, m);
+
+    Parameters:
+      | *[in]*  **m1**    left matrix
+      | *[in]*  **m2**    right matrix
+      | *[out]* **dest**  destination matrix
+
+.. c:function:: void glm_mat2x4_mulv(mat2x4 m, vec4 v, vec2 dest)
+
+    multiply mat2x4 with vec4 (column vector) and store in dest vector
+
+    Parameters:
+      | *[in]*  **m**     mat2x4 (left)
+      | *[in]*  **v**     vec4 (right, column vector)
+      | *[out]* **dest**  destination (result, column vector)
+
+.. c:function:: void glm_mat2x4_transpose(mat2x4 m, mat4x2 dest)
+
+    transpose matrix and store in dest
+
+    Parameters:
+      | *[in]*  **m**     matrix
+      | *[out]* **dest**  destination
+
+.. c:function:: void  glm_mat2x4_scale(mat2x4 m, float s)
+
+    multiply matrix with scalar
+
+    Parameters:
+      | *[in, out]* **m** matrix
+      | *[in]*      **s** scalar

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
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -71,6 +72,7 @@ Functions documentation
 .. c:function:: void  glm_mat3_mul(mat3 m1, mat3 m2, mat3 dest)
 
     multiply m1 and m2 to dest
+
     m1, m2 and dest matrices can be same matrix, it is possible to write this:
 
     .. code-block:: c
@@ -102,10 +104,10 @@ Functions documentation
 
 .. c:function:: void  glm_mat3_mulv(mat3 m, vec3 v, vec3 dest)
 
-    multiply mat4 with vec4 (column vector) and store in dest vector
+    multiply mat3 with vec3 (column vector) and store in dest vector
 
     Parameters:
-      | *[in]*  **mat**   mat3 (left)
+      | *[in]*  **m**     mat3 (left)
       | *[in]*  **v**     vec3 (right, column vector)
       | *[out]* **dest**  destination (result, column vector)
 
@@ -122,8 +124,8 @@ Functions documentation
     multiply matrix with scalar
 
     Parameters:
-      | *[in, out]* **mat**   matrix
-      | *[in]*      **dest**  scalar
+      | *[in, out]* **m** matrix
+      | *[in]*      **s** scalar
 
 .. c:function:: float  glm_mat3_det(mat3 mat)
 
@@ -187,3 +189,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 at least 9 elements.
+
+    Parameters:
+      | *[in]*  **src**  pointer to an array of floats
+      | *[out]* **dest** destination matrix3x3

docs/source/mat3x2.rst

@@ -0,0 +1,91 @@
+.. default-domain:: C
+
+mat3x2
+======
+
+Header: cglm/mat3x2.h
+
+Table of contents (click to go):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Macros:
+
+1. GLM_MAT3X2_ZERO_INIT
+#. GLM_MAT3X2_ZERO
+
+Functions:
+
+1. :c:func:`glm_mat3x2_copy`
+#. :c:func:`glm_mat3x2_zero`
+#. :c:func:`glm_mat3x2_make`
+#. :c:func:`glm_mat3x2_mul`
+#. :c:func:`glm_mat3x2_mulv`
+#. :c:func:`glm_mat3x2_transpose`
+#. :c:func:`glm_mat3x2_scale`
+
+Functions documentation
+~~~~~~~~~~~~~~~~~~~~~~~
+
+.. c:function:: void glm_mat3x2_copy(mat3x2 mat, mat3x2 dest)
+
+    copy mat3x2 to another one (dest).
+
+    Parameters:
+      | *[in]*  **mat**   source
+      | *[out]* **dest**  destination
+
+.. c:function:: void glm_mat3x2_zero(mat3x2 mat)
+
+    make given matrix zero
+
+    Parameters:
+      | *[in,out]* **mat**  matrix
+
+.. c:function:: void glm_mat3x2_make(float * __restrict src, mat3x2 dest)
+
+    Create mat3x2 matrix from pointer
+
+    | NOTE: **@src** must contain at least 6 elements.
+    Parameters:
+      | *[in]*  **src**  pointer to an array of floats
+      | *[out]* **dest** destination matrix3x2
+
+.. c:function:: void glm_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat3 dest)
+
+    multiply m1 and m2 to dest
+
+    m1, m2 and dest matrices can be same matrix, it is possible to write this:
+
+    .. code-block:: c
+
+       glm_mat3x2_mul(m, m, m);
+
+    Parameters:
+      | *[in]*  **m1**    left matrix
+      | *[in]*  **m2**    right matrix
+      | *[out]* **dest**  destination matrix
+
+.. c:function:: void glm_mat3x2_mulv(mat3x2 m, vec2 v, vec3 dest)
+
+    multiply mat3x2 with vec2 (column vector) and store in dest vector
+
+    Parameters:
+      | *[in]*  **m**     mat3x2 (left)
+      | *[in]*  **v**     vec3 (right, column vector)
+      | *[out]* **dest**  destination (result, column vector)
+
+.. c:function:: void glm_mat3x2_transpose(mat3x2 m, mat2x3 dest)
+
+    transpose matrix and store in dest
+
+    Parameters:
+      | *[in]*  **m**     matrix
+      | *[out]* **dest**  destination
+
+.. c:function:: void  glm_mat3x2_scale(mat3x2 m, float s)
+
+    multiply matrix with scalar
+
+    Parameters:
+      | *[in, out]* **m** matrix
+      | *[in]*      **s** scalar

docs/source/mat3x4.rst

@@ -0,0 +1,91 @@
+.. default-domain:: C
+
+mat3x4
+======
+
+Header: cglm/mat3x4.h
+
+Table of contents (click to go):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Macros:
+
+1. GLM_MAT3X4_ZERO_INIT
+#. GLM_MAT3X4_ZERO
+
+Functions:
+
+1. :c:func:`glm_mat3x4_copy`
+#. :c:func:`glm_mat3x4_zero`
+#. :c:func:`glm_mat3x4_make`
+#. :c:func:`glm_mat3x4_mul`
+#. :c:func:`glm_mat3x4_mulv`
+#. :c:func:`glm_mat3x4_transpose`
+#. :c:func:`glm_mat3x4_scale`
+
+Functions documentation
+~~~~~~~~~~~~~~~~~~~~~~~
+
+.. c:function:: void glm_mat3x4_copy(mat3x4 mat, mat3x4 dest)
+
+    copy mat3x4 to another one (dest).
+
+    Parameters:
+      | *[in]*  **mat**   source
+      | *[out]* **dest**  destination
+
+.. c:function:: void glm_mat3x4_zero(mat3x4 mat)
+
+    make given matrix zero
+
+    Parameters:
+      | *[in,out]* **mat**  matrix
+
+.. c:function:: void glm_mat3x4_make(float * __restrict src, mat3x4 dest)
+
+    Create mat3x4 matrix from pointer
+
+    | NOTE: **@src** must contain at least 12 elements.
+    Parameters:
+      | *[in]*  **src**  pointer to an array of floats
+      | *[out]* **dest** destination matrix3x4
+
+.. c:function:: void glm_mat3x4_mul(mat3x4 m1, mat4x3 m2, mat3 dest)
+
+    multiply m1 and m2 to dest
+
+    m1, m2 and dest matrices can be same matrix, it is possible to write this:
+
+    .. code-block:: c
+
+       glm_mat3x4_mul(m, m, m);
+
+    Parameters:
+      | *[in]*  **m1**    left matrix
+      | *[in]*  **m2**    right matrix
+      | *[out]* **dest**  destination matrix
+
+.. c:function:: void glm_mat3x4_mulv(mat3x4 m, vec4 v, vec3 dest)
+
+    multiply mat3x4 with vec4 (column vector) and store in dest vector
+
+    Parameters:
+      | *[in]*  **m**     mat3x4 (left)
+      | *[in]*  **v**     vec4 (right, column vector)
+      | *[out]* **dest**  destination (result, column vector)
+
+.. c:function:: void glm_mat3x4_transpose(mat3x4 m, mat4x3 dest)
+
+    transpose matrix and store in dest
+
+    Parameters:
+      | *[in]*  **m**     matrix
+      | *[out]* **dest**  destination
+
+.. c:function:: void  glm_mat3x4_scale(mat3x4 m, float s)
+
+    multiply matrix with scalar
+
+    Parameters:
+      | *[in, out]* **m** matrix
+      | *[in]*      **s** scalar

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
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -118,6 +119,7 @@ Functions documentation
 .. c:function:: void  glm_mat4_mul(mat4 m1, mat4 m2, mat4 dest)
 
     multiply m1 and m2 to dest
+
     m1, m2 and dest matrices can be same matrix, it is possible to write this:
 
     .. code-block:: c
@@ -156,7 +158,6 @@ Functions documentation
     Parameters:
       | *[in]*  **m**     mat4 (left)
       | *[in]*  **v**     vec4 (right, column vector)
-      | *[in]*  **last**  4th item to make it vec4
       | *[out]* **dest**  vec4 (result, column vector)
 
 .. c:function:: void  glm_mat4_mulv3(mat4 m, vec3 v, float last, vec3 dest)
@@ -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 at least 16 elements.
+
+    Parameters:
+      | *[in]*  **src**  pointer to an array of floats
+      | *[out]* **dest** destination matrix4x4

docs/source/mat4x2.rst

@@ -0,0 +1,91 @@
+.. default-domain:: C
+
+mat4x2
+======
+
+Header: cglm/mat4x2.h
+
+Table of contents (click to go):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Macros:
+
+1. GLM_MAT4X2_ZERO_INIT
+#. GLM_MAT4X2_ZERO
+
+Functions:
+
+1. :c:func:`glm_mat4x2_copy`
+#. :c:func:`glm_mat4x2_zero`
+#. :c:func:`glm_mat4x2_make`
+#. :c:func:`glm_mat4x2_mul`
+#. :c:func:`glm_mat4x2_mulv`
+#. :c:func:`glm_mat4x2_transpose`
+#. :c:func:`glm_mat4x2_scale`
+
+Functions documentation
+~~~~~~~~~~~~~~~~~~~~~~~
+
+.. c:function:: void glm_mat4x2_copy(mat4x2 mat, mat4x2 dest)
+
+    copy mat4x2 to another one (dest).
+
+    Parameters:
+      | *[in]*  **mat**   source
+      | *[out]* **dest**  destination
+
+.. c:function:: void glm_mat4x2_zero(mat4x2 mat)
+
+    make given matrix zero
+
+    Parameters:
+      | *[in,out]* **mat**  matrix
+
+.. c:function:: void glm_mat4x2_make(float * __restrict src, mat4x2 dest)
+
+    Create mat4x2 matrix from pointer
+
+    | NOTE: **@src** must contain at least 8 elements.
+    Parameters:
+      | *[in]*  **src**  pointer to an array of floats
+      | *[out]* **dest** destination matrix4x2
+
+.. c:function:: void glm_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat4 dest)
+
+    multiply m1 and m2 to dest
+
+    m1, m2 and dest matrices can be same matrix, it is possible to write this:
+
+    .. code-block:: c
+
+       glm_mat4x2_mul(m, m, m);
+
+    Parameters:
+      | *[in]*  **m1**    left matrix
+      | *[in]*  **m2**    right matrix
+      | *[out]* **dest**  destination matrix
+
+.. c:function:: void glm_mat4x2_mulv(mat4x2 m, vec2 v, vec4 dest)
+
+    multiply mat4x2 with vec2 (column vector) and store in dest vector
+
+    Parameters:
+      | *[in]*  **m**     mat4x2 (left)
+      | *[in]*  **v**     vec2 (right, column vector)
+      | *[out]* **dest**  destination (result, column vector)
+
+.. c:function:: void glm_mat4x2_transpose(mat4x2 m, mat2x4 dest)
+
+    transpose matrix and store in dest
+
+    Parameters:
+      | *[in]*  **m**     matrix
+      | *[out]* **dest**  destination
+
+.. c:function:: void  glm_mat4x2_scale(mat4x2 m, float s)
+
+    multiply matrix with scalar
+
+    Parameters:
+      | *[in, out]* **m** matrix
+      | *[in]*      **s** scalar

docs/source/mat4x3.rst

@@ -0,0 +1,91 @@
+.. default-domain:: C
+
+mat4x3
+======
+
+Header: cglm/mat4x3.h
+
+Table of contents (click to go):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Macros:
+
+1. GLM_MAT4X3_ZERO_INIT
+#. GLM_MAT4X3_ZERO
+
+Functions:
+
+1. :c:func:`glm_mat4x3_copy`
+#. :c:func:`glm_mat4x3_zero`
+#. :c:func:`glm_mat4x3_make`
+#. :c:func:`glm_mat4x3_mul`
+#. :c:func:`glm_mat4x3_mulv`
+#. :c:func:`glm_mat4x3_transpose`
+#. :c:func:`glm_mat4x3_scale`
+
+Functions documentation
+~~~~~~~~~~~~~~~~~~~~~~~
+
+.. c:function:: void glm_mat4x3_copy(mat4x3 mat, mat4x3 dest)
+
+    copy mat4x3 to another one (dest).
+
+    Parameters:
+      | *[in]*  **mat**   source
+      | *[out]* **dest**  destination
+
+.. c:function:: void glm_mat4x3_zero(mat4x3 mat)
+
+    make given matrix zero
+
+    Parameters:
+      | *[in,out]* **mat**  matrix
+
+.. c:function:: void glm_mat4x3_make(float * __restrict src, mat4x3 dest)
+
+    Create mat4x3 matrix from pointer
+
+    | NOTE: **@src** must contain at least 12 elements.
+    Parameters:
+      | *[in]*  **src**  pointer to an array of floats
+      | *[out]* **dest** destination matrix4x3
+
+.. c:function:: void glm_mat4x3_mul(mat4x3 m1, mat3x4 m2, mat4 dest)
+
+    multiply m1 and m2 to dest
+
+    m1, m2 and dest matrices can be same matrix, it is possible to write this:
+
+    .. code-block:: c
+
+       glm_mat4x3_mul(m, m, m);
+
+    Parameters:
+      | *[in]*  **m1**    left matrix
+      | *[in]*  **m2**    right matrix
+      | *[out]* **dest**  destination matrix
+
+.. c:function:: void glm_mat4x3_mulv(mat4x3 m, vec3 v, vec4 dest)
+
+    multiply mat4x3 with vec3 (column vector) and store in dest vector
+
+    Parameters:
+      | *[in]*  **m**     mat4x3 (left)
+      | *[in]*  **v**     vec3 (right, column vector)
+      | *[out]* **dest**  destination (result, column vector)
+
+.. c:function:: void glm_mat4x3_transpose(mat4x3 m, mat3x4 dest)
+
+    transpose matrix and store in dest
+
+    Parameters:
+      | *[in]*  **m**     matrix
+      | *[out]* **dest**  destination
+
+.. c:function:: void  glm_mat4x3_scale(mat4x3 m, float s)
+
+    multiply matrix with scalar
+
+    Parameters:
+      | *[in, out]* **m** matrix
+      | *[in]*      **s** scalar

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.rst

@@ -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.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);
  */
 

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

@@ -19,8 +19,14 @@ extern "C" {
 #include "call/ivec3.h"
 #include "call/ivec4.h"
 #include "call/mat2.h"
+#include "call/mat2x3.h"
+#include "call/mat2x4.h"
 #include "call/mat3.h"
+#include "call/mat3x2.h"
+#include "call/mat3x4.h"
 #include "call/mat4.h"
+#include "call/mat4x2.h"
+#include "call/mat4x3.h"
 #include "call/affine.h"
 #include "call/cam.h"
 #include "call/quat.h"

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

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_mat2x3_h
+#define cglmc_mat2x3_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_mat2x3_copy(mat2x3 mat, mat2x3 dest);
+
+CGLM_EXPORT
+void
+glmc_mat2x3_zero(mat2x3 mat);
+
+CGLM_EXPORT
+void
+glmc_mat2x3_make(float * __restrict src, mat2x3 dest);
+
+CGLM_EXPORT
+void
+glmc_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat2 dest);
+
+CGLM_EXPORT
+void
+glmc_mat2x3_mulv(mat2x3 m, vec3 v, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_mat2x3_transpose(mat2x3 m, mat3x2 dest);
+
+CGLM_EXPORT
+void
+glmc_mat2x3_scale(mat2x3 m, float s);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_mat2x3_h */

include/cglm/call/mat2x4.h

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_mat2x4_h
+#define cglmc_mat2x4_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_mat2x4_copy(mat2x4 mat, mat2x4 dest);
+
+CGLM_EXPORT
+void
+glmc_mat2x4_zero(mat2x4 mat);
+
+CGLM_EXPORT
+void
+glmc_mat2x4_make(float * __restrict src, mat2x4 dest);
+
+CGLM_EXPORT
+void
+glmc_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat2 dest);
+
+CGLM_EXPORT
+void
+glmc_mat2x4_mulv(mat2x4 m, vec4 v, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_mat2x4_transpose(mat2x4 m, mat4x2 dest);
+
+CGLM_EXPORT
+void
+glmc_mat2x4_scale(mat2x4 m, float s);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_mat2x4_h */

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

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_mat3x2_h
+#define cglmc_mat3x2_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_mat3x2_copy(mat3x2 mat, mat3x2 dest);
+
+CGLM_EXPORT
+void
+glmc_mat3x2_zero(mat3x2 mat);
+
+CGLM_EXPORT
+void
+glmc_mat3x2_make(float * __restrict src, mat3x2 dest);
+
+CGLM_EXPORT
+void
+glmc_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat3 dest);
+
+CGLM_EXPORT
+void
+glmc_mat3x2_mulv(mat3x2 m, vec2 v, vec3 dest);
+
+CGLM_EXPORT
+void
+glmc_mat3x2_transpose(mat3x2 m, mat2x3 dest);
+
+CGLM_EXPORT
+void
+glmc_mat3x2_scale(mat3x2 m, float s);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_mat3x2_h */

include/cglm/call/mat3x4.h

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_mat3x4_h
+#define cglmc_mat3x4_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_mat3x4_copy(mat3x4 mat, mat3x4 dest);
+
+CGLM_EXPORT
+void
+glmc_mat3x4_zero(mat3x4 mat);
+
+CGLM_EXPORT
+void
+glmc_mat3x4_make(float * __restrict src, mat3x4 dest);
+
+CGLM_EXPORT
+void
+glmc_mat3x4_mul(mat3x4 m1, mat4x3 m2, mat3 dest);
+
+CGLM_EXPORT
+void
+glmc_mat3x4_mulv(mat3x4 m, vec4 v, vec3 dest);
+
+CGLM_EXPORT
+void
+glmc_mat3x4_transpose(mat3x4 m, mat4x3 dest);
+
+CGLM_EXPORT
+void
+glmc_mat3x4_scale(mat3x4 m, float s);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_mat3x4_h */

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

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_mat4x2_h
+#define cglmc_mat4x2_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_mat4x2_copy(mat4x2 mat, mat4x2 dest);
+
+CGLM_EXPORT
+void
+glmc_mat4x2_zero(mat4x2 mat);
+
+CGLM_EXPORT
+void
+glmc_mat4x2_make(float * __restrict src, mat4x2 dest);
+
+CGLM_EXPORT
+void
+glmc_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_mat4x2_mulv(mat4x2 m, vec2 v, vec4 dest);
+
+CGLM_EXPORT
+void
+glmc_mat4x2_transpose(mat4x2 m, mat2x4 dest);
+
+CGLM_EXPORT
+void
+glmc_mat4x2_scale(mat4x2 m, float s);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_mat4x2_h */

include/cglm/call/mat4x3.h

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_mat4x3_h
+#define cglmc_mat4x3_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_mat4x3_copy(mat4x3 mat, mat4x3 dest);
+
+CGLM_EXPORT
+void
+glmc_mat4x3_zero(mat4x3 mat);
+
+CGLM_EXPORT
+void
+glmc_mat4x3_make(float * __restrict src, mat4x3 dest);
+
+CGLM_EXPORT
+void
+glmc_mat4x3_mul(mat4x3 m1, mat3x4 m2, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_mat4x3_mulv(mat4x3 m, vec3 v, vec4 dest);
+
+CGLM_EXPORT
+void
+glmc_mat4x3_transpose(mat4x3 m, mat3x4 dest);
+
+CGLM_EXPORT
+void
+glmc_mat4x3_scale(mat4x3 m, float s);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_mat4x3_h */

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

@@ -165,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/cglm.h

@@ -16,8 +16,14 @@
 #include "ivec3.h"
 #include "ivec4.h"
 #include "mat4.h"
+#include "mat4x2.h"
+#include "mat4x3.h"
 #include "mat3.h"
+#include "mat3x2.h"
+#include "mat3x4.h"
 #include "mat2.h"
+#include "mat2x3.h"
+#include "mat2x4.h"
 #include "affine.h"
 #include "cam.h"
 #include "frustum.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);
  */
 
 /*
@@ -52,12 +53,20 @@
 #  define CGLM_PRINT_MAX_TO_SHORT 1e5f
 #endif
 
-#ifndef CGLM_PRINT_COLOR
-#  define CGLM_PRINT_COLOR        "\033[36m"
-#endif
-
-#ifndef CGLM_PRINT_COLOR_RESET
-#  define CGLM_PRINT_COLOR_RESET  "\033[0m"
+#ifndef GLM_TESTS_NO_COLORFUL_OUTPUT
+#  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
 
 /*!
@@ -67,26 +76,40 @@
  */
 CGLM_INLINE
 void
-glm_arch_print_name(FILE* __restrict ostream) {
+glm_arch_print(FILE* __restrict ostream) {
+  fprintf(ostream, CGLM_PRINT_COLOR "arch: "
 #if defined(CGLM_SIMD_WASM)
-  fprintf(ostream, CGLM_PRINT_COLOR "\ncglm arch: wasm SIMD128"
-    "\n\n" CGLM_PRINT_COLOR_RESET);
+  "wasm SIMD128"
 #elif defined(CGLM_SIMD_x86)
-  fprintf(ostream, CGLM_PRINT_COLOR "\ncglm arch: x86 SSE*" 
-#ifdef __AVX__
-    " AVX"
-#endif
-    "\n\n" CGLM_PRINT_COLOR_RESET);
+  "x86 SSE* "
+#  ifdef __AVX__
+  " AVX"
+#  endif
 #elif defined(CGLM_SIMD_ARM)
-  fprintf(ostream, CGLM_PRINT_COLOR "\ncglm arch: arm"
-#ifndef __ARM_NEON_FP
+  "arm"
+#  ifndef __ARM_NEON_FP
     " NEON_FP"
-#endif
-#ifdef CGLM_ARM64
+#  endif
+#  ifdef CGLM_ARM64
     " ARM64"
+#  endif
+#else
+  "uncommon"
 #endif
-    "\n\n" CGLM_PRINT_COLOR_RESET);
-#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
@@ -369,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/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
@@ -345,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/mat2x3.h

@@ -0,0 +1,156 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   GLM_MAT2X3_ZERO_INIT
+   GLM_MAT2X3_ZERO
+
+ Functions:
+   CGLM_INLINE void glm_mat2x3_copy(mat2x3 mat, mat2x3 dest);
+   CGLM_INLINE void glm_mat2x3_zero(mat2x3 mat);
+   CGLM_INLINE void glm_mat2x3_make(float * __restrict src, mat2x3 dest);
+   CGLM_INLINE void glm_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat2 dest);
+   CGLM_INLINE void glm_mat2x3_mulv(mat2x3 m, vec3 v, vec2 dest);
+   CGLM_INLINE void glm_mat2x3_transpose(mat2x3 m, mat3x2 dest);
+   CGLM_INLINE void glm_mat2x3_scale(mat2x3 m, float s);
+ */
+
+#ifndef cglm_mat2x3_h
+#define cglm_mat2x3_h
+
+#include "common.h"
+
+#define GLM_MAT2X3_ZERO_INIT {{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}}
+
+/* for C only */
+#define GLM_MAT2X3_ZERO GLM_MAT2X3_ZERO_INIT
+
+/*!
+ * @brief copy all members of [mat] to [dest]
+ *
+ * @param[in]  mat  source
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_mat2x3_copy(mat2x3 mat, mat2x3 dest) {
+  dest[0][0] = mat[0][0];
+  dest[0][1] = mat[0][1];
+  dest[0][2] = mat[0][2];
+
+  dest[1][0] = mat[1][0];
+  dest[1][1] = mat[1][1];
+  dest[1][2] = mat[1][2];
+}
+
+/*!
+ * @brief make given matrix zero.
+ *
+ * @param[in, out]  mat  matrix
+ */
+CGLM_INLINE
+void
+glm_mat2x3_zero(mat2x3 mat) {
+  CGLM_ALIGN_MAT mat2x3 t = GLM_MAT2X3_ZERO_INIT;
+  glm_mat2x3_copy(t, mat);
+}
+
+/*!
+ * @brief Create mat2x3 matrix from pointer
+ *
+ * @param[in]  src  pointer to an array of floats
+ * @param[out] dest matrix
+ */
+CGLM_INLINE
+void
+glm_mat2x3_make(float * __restrict src, mat2x3 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];
+}
+
+/*!
+ * @brief multiply m1 and m2 to dest
+ *
+ * m1, m2 and dest matrices can be same matrix, it is possible to write this:
+ *
+ * @code
+ * glm_mat2x3_mul(m, m, m);
+ * @endcode
+ *
+ * @param[in]  m1   left matrix
+ * @param[in]  m2   right matrix
+ * @param[out] dest destination matrix
+ */
+CGLM_INLINE
+void
+glm_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat2 dest) {
+  float a00 = m1[0][0], a01 = m1[0][1], a02 = m1[0][2],
+        a10 = m1[1][0], a11 = m1[1][1], a12 = m1[1][2],
+
+        b00 = m2[0][0], b01 = m2[0][1],
+        b10 = m2[1][0], b11 = m2[1][1],
+        b20 = m2[2][0], b21 = m2[2][1];
+
+  dest[0][0] = a00 * b00 + a01 * b10 + a02 * b20;
+  dest[0][1] = a00 * b01 + a01 * b11 + a02 * b21;
+
+  dest[1][0] = a10 * b00 + a11 * b10 + a12 * b20;
+  dest[1][1] = a10 * b01 + a11 * b11 + a12 * b21;
+}
+
+/*!
+ * @brief multiply matrix with column vector and store in dest vector
+ *
+ * @param[in]  m    matrix (left)
+ * @param[in]  v    vector (right, column vector)
+ * @param[out] dest result vector
+ */
+CGLM_INLINE
+void
+glm_mat2x3_mulv(mat2x3 m, vec3 v, vec2 dest) {
+  float v0 = v[0], v1 = v[1], v2 = v[2];
+
+  dest[0] = m[0][0] * v0 + m[0][1] * v1 + m[0][2] * v2;
+  dest[1] = m[1][0] * v0 + m[1][1] * v1 + m[1][2] * v2;
+}
+
+/*!
+ * @brief transpose matrix and store in dest
+ *
+ * @param[in]  m     matrix
+ * @param[out] dest  result
+ */
+CGLM_INLINE
+void
+glm_mat2x3_transpose(mat2x3 m, mat3x2 dest) {
+  dest[0][0] = m[0][0];  dest[0][1] = m[1][0];
+  dest[1][0] = m[0][1];  dest[1][1] = m[1][1];
+  dest[2][0] = m[0][2];  dest[2][1] = m[1][2];
+}
+
+/*!
+ * @brief scale (multiply with scalar) matrix
+ *
+ * multiply matrix with scalar
+ *
+ * @param[in, out] m matrix
+ * @param[in]    s scalar
+ */
+CGLM_INLINE
+void
+glm_mat2x3_scale(mat2x3 m, float s) {
+  m[0][0] *= s;  m[0][1] *= s;  m[0][2] *= s;
+  m[1][0] *= s;  m[1][1] *= s;  m[1][2] *= s;
+}
+
+#endif

include/cglm/mat2x4.h

@@ -0,0 +1,156 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   GLM_MAT2X4_ZERO_INIT
+   GLM_MAT2X4_ZERO
+
+ Functions:
+   CGLM_INLINE void glm_mat2x4_copy(mat2x4 mat, mat2x4 dest);
+   CGLM_INLINE void glm_mat2x4_zero(mat2x4 mat);
+   CGLM_INLINE void glm_mat2x4_make(float * __restrict src, mat2x4 dest);
+   CGLM_INLINE void glm_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat2 dest);
+   CGLM_INLINE void glm_mat2x4_mulv(mat2x4 m, vec4 v, vec2 dest);
+   CGLM_INLINE void glm_mat2x4_transpose(mat2x4 m, mat4x2 dest);
+   CGLM_INLINE void glm_mat2x4_scale(mat2x4 m, float s);
+ */
+
+#ifndef cglm_mat2x4_h
+#define cglm_mat2x4_h
+
+#include "common.h"
+#include "vec4.h"
+
+#define GLM_MAT2X4_ZERO_INIT {{0.0f, 0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f, 0.0f}}
+
+/* for C only */
+#define GLM_MAT2X4_ZERO GLM_MAT2X4_ZERO_INIT
+
+/*!
+ * @brief copy all members of [mat] to [dest]
+ *
+ * @param[in]  mat  source
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_mat2x4_copy(mat2x4 mat, mat2x4 dest) {
+  glm_vec4_ucopy(mat[0], dest[0]);
+  glm_vec4_ucopy(mat[1], dest[1]);
+}
+
+/*!
+ * @brief make given matrix zero.
+ *
+ * @param[in, out]  mat  matrix
+ */
+CGLM_INLINE
+void
+glm_mat2x4_zero(mat2x4 mat) {
+  CGLM_ALIGN_MAT mat2x4 t = GLM_MAT2X4_ZERO_INIT;
+  glm_mat2x4_copy(t, mat);
+}
+
+/*!
+ * @brief Create mat2x4 matrix from pointer
+ *
+ * @param[in]  src  pointer to an array of floats
+ * @param[out] dest matrix
+ */
+CGLM_INLINE
+void
+glm_mat2x4_make(float * __restrict src, mat2x4 dest) {
+  dest[0][0] = src[0];
+  dest[0][1] = src[1];
+  dest[0][2] = src[2];
+  dest[0][3] = src[3];
+
+  dest[1][0] = src[4];
+  dest[1][1] = src[5];
+  dest[1][2] = src[6];
+  dest[1][3] = src[7];
+}
+
+/*!
+ * @brief multiply m1 and m2 to dest
+ *
+ * m1, m2 and dest matrices can be same matrix, it is possible to write this:
+ *
+ * @code
+ * glm_mat2x4_mul(m, m, m);
+ * @endcode
+ *
+ * @param[in]  m1   left matrix
+ * @param[in]  m2   right matrix
+ * @param[out] dest destination matrix
+ */
+CGLM_INLINE
+void
+glm_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat2 dest) {
+  float a00 = m1[0][0], a01 = m1[0][1], a02 = m1[0][2], a03 = m1[0][3],
+        a10 = m1[1][0], a11 = m1[1][1], a12 = m1[1][2], a13 = m1[1][3],
+
+        b00 = m2[0][0], b01 = m2[0][1],
+        b10 = m2[1][0], b11 = m2[1][1],
+        b20 = m2[2][0], b21 = m2[2][1],
+        b30 = m2[3][0], b31 = m2[3][1];
+
+  dest[0][0] = a00 * b00 + a01 * b10 + a02 * b20 + a03 * b30;
+  dest[0][1] = a00 * b01 + a01 * b11 + a02 * b21 + a03 * b31;
+
+  dest[1][0] = a10 * b00 + a11 * b10 + a12 * b20 + a13 * b30;
+  dest[1][1] = a10 * b01 + a11 * b11 + a12 * b21 + a13 * b31;
+}
+
+/*!
+ * @brief multiply matrix with column vector and store in dest vector
+ *
+ * @param[in]  m    matrix (left)
+ * @param[in]  v    vector (right, column vector)
+ * @param[out] dest result vector
+ */
+CGLM_INLINE
+void
+glm_mat2x4_mulv(mat2x4 m, vec4 v, vec2 dest) {
+  float v0 = v[0], v1 = v[1], v2 = v[2], v3 = v[3];
+
+  dest[0] = m[0][0] * v0 + m[0][1] * v1 + m[0][2] * v2 + m[0][3] * v3;
+  dest[1] = m[1][0] * v0 + m[1][1] * v1 + m[1][2] * v2 + m[1][3] * v3;
+}
+
+/*!
+ * @brief transpose matrix and store in dest
+ *
+ * @param[in]  m     matrix
+ * @param[out] dest  result
+ */
+CGLM_INLINE
+void
+glm_mat2x4_transpose(mat2x4 m, mat4x2 dest) {
+  dest[0][0] = m[0][0];  dest[0][1] = m[1][0];
+  dest[1][0] = m[0][1];  dest[1][1] = m[1][1];
+  dest[2][0] = m[0][2];  dest[2][1] = m[1][2];
+  dest[3][0] = m[0][3];  dest[3][1] = m[1][3];
+}
+
+/*!
+ * @brief scale (multiply with scalar) matrix
+ *
+ * multiply matrix with scalar
+ *
+ * @param[in, out] m matrix
+ * @param[in]    s scalar
+ */
+CGLM_INLINE
+void
+glm_mat2x4_scale(mat2x4 m, float s) {
+  m[0][0] *= s;  m[0][1] *= s;  m[0][2] *= s;  m[0][3] *= s;
+  m[1][0] *= s;  m[1][1] *= s;  m[1][2] *= s;  m[1][3] *= s;
+}
+
+#endif

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
@@ -427,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/mat3x2.h

@@ -0,0 +1,164 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   GLM_MAT3X2_ZERO_INIT
+   GLM_MAT3X2_ZERO
+
+ Functions:
+   CGLM_INLINE void glm_mat3x2_copy(mat3x2 mat, mat3x2 dest);
+   CGLM_INLINE void glm_mat3x2_zero(mat3x2 mat);
+   CGLM_INLINE void glm_mat3x2_make(float * __restrict src, mat3x2 dest);
+   CGLM_INLINE void glm_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat3 dest);
+   CGLM_INLINE void glm_mat3x2_mulv(mat3x2 m, vec2 v, vec3 dest);
+   CGLM_INLINE void glm_mat3x2_transpose(mat3x2 m, mat2x3 dest);
+   CGLM_INLINE void glm_mat3x2_scale(mat3x2 m, float s);
+ */
+
+#ifndef cglm_mat3x2_h
+#define cglm_mat3x2_h
+
+#include "common.h"
+
+#define GLM_MAT3X2_ZERO_INIT {{0.0f, 0.0f}, {0.0f, 0.0f}, {0.0f, 0.0f}}
+
+/* for C only */
+#define GLM_MAT3X2_ZERO GLM_MAT3X2_ZERO_INIT
+
+/*!
+ * @brief copy all members of [mat] to [dest]
+ *
+ * @param[in]  mat  source
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_mat3x2_copy(mat3x2 mat, mat3x2 dest) {
+  dest[0][0] = mat[0][0];
+  dest[0][1] = mat[0][1];
+
+  dest[1][0] = mat[1][0];
+  dest[1][1] = mat[1][1];
+
+  dest[2][0] = mat[2][0];
+  dest[2][1] = mat[2][1];
+}
+
+/*!
+ * @brief make given matrix zero.
+ *
+ * @param[in, out]  mat  matrix
+ */
+CGLM_INLINE
+void
+glm_mat3x2_zero(mat3x2 mat) {
+  CGLM_ALIGN_MAT mat3x2 t = GLM_MAT3X2_ZERO_INIT;
+  glm_mat3x2_copy(t, mat);
+}
+
+/*!
+ * @brief Create mat3x2 matrix from pointer
+ *
+ * @param[in]  src  pointer to an array of floats
+ * @param[out] dest matrix
+ */
+CGLM_INLINE
+void
+glm_mat3x2_make(float * __restrict src, mat3x2 dest) {
+  dest[0][0] = src[0];
+  dest[0][1] = src[1];
+
+  dest[1][0] = src[2];
+  dest[1][1] = src[3];
+
+  dest[2][0] = src[4];
+  dest[2][1] = src[5];
+}
+
+/*!
+ * @brief multiply m1 and m2 to dest
+ *
+ * m1, m2 and dest matrices can be same matrix, it is possible to write this:
+ *
+ * @code
+ * glm_mat3x2_mul(m, m, m);
+ * @endcode
+ *
+ * @param[in]  m1   left matrix
+ * @param[in]  m2   right matrix
+ * @param[out] dest destination matrix
+ */
+CGLM_INLINE
+void
+glm_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat3 dest) {
+  float a00 = m1[0][0], a01 = m1[0][1],
+        a10 = m1[1][0], a11 = m1[1][1],
+        a20 = m1[2][0], a21 = m1[2][1],
+
+        b00 = m2[0][0], b01 = m2[0][1], b02 = m2[0][2],
+        b10 = m2[1][0], b11 = m2[1][1], b12 = m2[1][2];
+
+  dest[0][0] = a00 * b00 + a01 * b10;
+  dest[0][1] = a00 * b01 + a01 * b11;
+  dest[0][2] = a00 * b02 + a01 * b12;
+
+  dest[1][0] = a10 * b00 + a11 * b10;
+  dest[1][1] = a10 * b01 + a11 * b11;
+  dest[1][2] = a10 * b02 + a11 * b12;
+
+  dest[2][0] = a20 * b00 + a21 * b10;
+  dest[2][1] = a20 * b01 + a21 * b11;
+  dest[2][2] = a20 * b02 + a21 * b12;
+}
+
+/*!
+ * @brief multiply matrix with column vector and store in dest vector
+ *
+ * @param[in]  m    matrix (left)
+ * @param[in]  v    vector (right, column vector)
+ * @param[out] dest result vector
+ */
+CGLM_INLINE
+void
+glm_mat3x2_mulv(mat3x2 m, vec2 v, vec3 dest) {
+  float v0 = v[0], v1 = v[1];
+
+  dest[0] = m[0][0] * v0 + m[0][1] * v1;
+  dest[1] = m[1][0] * v0 + m[1][1] * v1;
+  dest[2] = m[2][0] * v0 + m[2][1] * v1;
+}
+
+/*!
+ * @brief transpose matrix and store in dest
+ *
+ * @param[in]  m     matrix
+ * @param[out] dest  result
+ */
+CGLM_INLINE
+void
+glm_mat3x2_transpose(mat3x2 m, mat2x3 dest) {
+  dest[0][0] = m[0][0];  dest[0][1] = m[1][0];  dest[0][2] = m[2][0];
+  dest[1][0] = m[0][1];  dest[1][1] = m[1][1];  dest[1][2] = m[2][1];
+}
+
+/*!
+ * @brief scale (multiply with scalar) matrix
+ *
+ * multiply matrix with scalar
+ *
+ * @param[in, out] m matrix
+ * @param[in]    s scalar
+ */
+CGLM_INLINE
+void
+glm_mat3x2_scale(mat3x2 m, float s) {
+  m[0][0] *= s;  m[0][1] *= s;  m[1][0] *= s;
+  m[1][1] *= s;  m[2][0] *= s;  m[2][1] *= s;
+}
+
+#endif

include/cglm/mat3x4.h

@@ -0,0 +1,173 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   GLM_MAT3X4_ZERO_INIT
+   GLM_MAT3X4_ZERO
+
+ Functions:
+   CGLM_INLINE void glm_mat3x4_copy(mat3x4 mat, mat3x4 dest);
+   CGLM_INLINE void glm_mat3x4_zero(mat3x4 mat);
+   CGLM_INLINE void glm_mat3x4_make(float * __restrict src, mat3x4 dest);
+   CGLM_INLINE void glm_mat3x4_mul(mat3x4 m1, mat4x3 m2, mat3 dest);
+   CGLM_INLINE void glm_mat3x4_mulv(mat3x4 m, vec4 v, vec3 dest);
+   CGLM_INLINE void glm_mat3x4_transpose(mat3x4 m, mat4x3 dest);
+   CGLM_INLINE void glm_mat3x4_scale(mat3x4 m, float s);
+ */
+
+#ifndef cglm_mat3x4_h
+#define cglm_mat3x4_h
+
+#include "common.h"
+
+#define GLM_MAT3X4_ZERO_INIT {{0.0f, 0.0f, 0.0f, 0.0f}, \
+                              {0.0f, 0.0f, 0.0f, 0.0f}, \
+                              {0.0f, 0.0f, 0.0f, 0.0f}}
+
+/* for C only */
+#define GLM_MAT3X4_ZERO GLM_MAT3X4_ZERO_INIT
+
+/*!
+ * @brief copy all members of [mat] to [dest]
+ *
+ * @param[in]  mat  source
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_mat3x4_copy(mat3x4 mat, mat3x4 dest) {
+  glm_vec4_ucopy(mat[0], dest[0]);
+  glm_vec4_ucopy(mat[1], dest[1]);
+  glm_vec4_ucopy(mat[2], dest[2]);
+}
+
+/*!
+ * @brief make given matrix zero.
+ *
+ * @param[in, out]  mat  matrix
+ */
+CGLM_INLINE
+void
+glm_mat3x4_zero(mat3x4 mat) {
+  CGLM_ALIGN_MAT mat3x4 t = GLM_MAT3X4_ZERO_INIT;
+  glm_mat3x4_copy(t, mat);
+}
+
+/*!
+ * @brief Create mat3x4 matrix from pointer
+ *
+ * @param[in]  src  pointer to an array of floats
+ * @param[out] dest matrix
+ */
+CGLM_INLINE
+void
+glm_mat3x4_make(float * __restrict src, mat3x4 dest) {
+  dest[0][0] = src[0];
+  dest[0][1] = src[1];
+  dest[0][2] = src[2];
+  dest[0][3] = src[3];
+
+  dest[1][0] = src[4];
+  dest[1][1] = src[5];
+  dest[1][2] = src[6];
+  dest[1][3] = src[7];
+
+  dest[2][0] = src[8];
+  dest[2][1] = src[9];
+  dest[2][2] = src[10];
+  dest[2][3] = src[11];
+}
+
+/*!
+ * @brief multiply m1 and m2 to dest
+ *
+ * m1, m2 and dest matrices can be same matrix, it is possible to write this:
+ *
+ * @code
+ * glm_mat3x4_mul(m, m, m);
+ * @endcode
+ *
+ * @param[in]  m1   left matrix
+ * @param[in]  m2   right matrix
+ * @param[out] dest destination matrix
+ */
+CGLM_INLINE
+void
+glm_mat3x4_mul(mat3x4 m1, mat4x3 m2, mat3 dest) {
+  float a00 = m1[0][0], a01 = m1[0][1], a02 = m1[0][2], a03 = m1[0][3],
+        a10 = m1[1][0], a11 = m1[1][1], a12 = m1[1][2], a13 = m1[1][3],
+        a20 = m1[2][0], a21 = m1[2][1], a22 = m1[2][2], a23 = m1[2][3],
+
+        b00 = m2[0][0], b01 = m2[0][1], b02 = m2[0][2],
+        b10 = m2[1][0], b11 = m2[1][1], b12 = m2[1][2],
+        b20 = m2[2][0], b21 = m2[2][1], b22 = m2[2][2],
+        b30 = m2[3][0], b31 = m2[3][1], b32 = m2[3][2];
+
+  dest[0][0] = a00 * b00 + a01 * b10 + a02 * b20 + a03 * b30;
+  dest[0][1] = a00 * b01 + a01 * b11 + a02 * b21 + a03 * b31;
+  dest[0][2] = a00 * b02 + a01 * b12 + a02 * b22 + a03 * b32;
+
+  dest[1][0] = a10 * b00 + a11 * b10 + a12 * b20 + a13 * b30;
+  dest[1][1] = a10 * b01 + a11 * b11 + a12 * b21 + a13 * b31;
+  dest[1][2] = a10 * b02 + a11 * b12 + a12 * b22 + a13 * b32;
+
+  dest[2][0] = a20 * b00 + a21 * b10 + a22 * b20 + a23 * b30;
+  dest[2][1] = a20 * b01 + a21 * b11 + a22 * b21 + a23 * b31;
+  dest[2][2] = a20 * b02 + a21 * b12 + a22 * b22 + a23 * b32;
+}
+
+/*!
+ * @brief multiply matrix with column vector and store in dest vector
+ *
+ * @param[in]  m    matrix (left)
+ * @param[in]  v    vector (right, column vector)
+ * @param[out] dest result vector
+ */
+CGLM_INLINE
+void
+glm_mat3x4_mulv(mat3x4 m, vec4 v, vec3 dest) {
+  float v0 = v[0], v1 = v[1], v2 = v[2], v3 = v[3];
+
+  dest[0] = m[0][0] * v0 + m[0][1] * v1 + m[0][2] * v2 + m[0][3] * v3;
+  dest[1] = m[1][0] * v0 + m[1][1] * v1 + m[1][2] * v2 + m[1][3] * v3;
+  dest[2] = m[2][0] * v0 + m[2][1] * v1 + m[2][2] * v2 + m[2][3] * v3;
+}
+
+/*!
+ * @brief transpose matrix and store in dest
+ *
+ * @param[in]  m     matrix
+ * @param[out] dest  result
+ */
+CGLM_INLINE
+void
+glm_mat3x4_transpose(mat3x4 m, mat4x3 dest) {
+  dest[0][0] = m[0][0];  dest[0][1] = m[1][0];  dest[0][2] = m[2][0];
+  dest[1][0] = m[0][1];  dest[1][1] = m[1][1];  dest[1][2] = m[2][1];
+  dest[2][0] = m[0][2];  dest[2][1] = m[1][2];  dest[2][2] = m[2][2];
+  dest[3][0] = m[0][3];  dest[3][1] = m[1][3];  dest[3][2] = m[2][3];
+}
+
+/*!
+ * @brief scale (multiply with scalar) matrix
+ *
+ * multiply matrix with scalar
+ *
+ * @param[in, out] m matrix
+ * @param[in]    s scalar
+ */
+CGLM_INLINE
+void
+glm_mat3x4_scale(mat3x4 m, float s) {
+  m[0][0] *= s;  m[1][0] *= s;   m[2][0] *= s;
+  m[0][1] *= s;  m[1][1] *= s;   m[2][1] *= s;
+  m[0][2] *= s;  m[1][2] *= s;   m[2][2] *= s;
+  m[0][3] *= s;  m[1][3] *= s;   m[2][3] *= s;
+}
+
+#endif

include/cglm/mat4.h

@@ -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
@@ -781,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/mat4x2.h

@@ -0,0 +1,186 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   GLM_MAT4X2_ZERO_INIT
+   GLM_MAT4X2_ZERO
+
+ Functions:
+   CGLM_INLINE void glm_mat4x2_copy(mat4x2 mat, mat4x2 dest);
+   CGLM_INLINE void glm_mat4x2_zero(mat4x2 mat);
+   CGLM_INLINE void glm_mat4x2_make(float * __restrict src, mat4x2 dest);
+   CGLM_INLINE void glm_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat4 dest);
+   CGLM_INLINE void glm_mat4x2_mulv(mat4x2 m, vec2 v, vec4 dest);
+   CGLM_INLINE void glm_mat4x2_transpose(mat4x2 m, mat2x4 dest);
+   CGLM_INLINE void glm_mat4x2_scale(mat4x2 m, float s);
+ */
+
+#ifndef cglm_mat4x2_h
+#define cglm_mat4x2_h
+
+#include "common.h"
+
+#define GLM_MAT4X2_ZERO_INIT {{0.0f, 0.0f}, {0.0f, 0.0f}, {0.0f, 0.0f}, {0.0f, 0.0f}}
+
+/* for C only */
+#define GLM_MAT4X2_ZERO GLM_MAT4X2_ZERO_INIT
+
+/*!
+ * @brief copy all members of [mat] to [dest]
+ *
+ * @param[in]  mat  source
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_mat4x2_copy(mat4x2 mat, mat4x2 dest) {
+  dest[0][0] = mat[0][0];
+  dest[0][1] = mat[0][1];
+
+  dest[1][0] = mat[1][0];
+  dest[1][1] = mat[1][1];
+
+  dest[2][0] = mat[2][0];
+  dest[2][1] = mat[2][1];
+
+  dest[3][0] = mat[3][0];
+  dest[3][1] = mat[3][1];
+}
+
+/*!
+ * @brief make given matrix zero.
+ *
+ * @param[in, out]  mat  matrix
+ */
+CGLM_INLINE
+void
+glm_mat4x2_zero(mat4x2 mat) {
+  CGLM_ALIGN_MAT mat4x2 t = GLM_MAT4X2_ZERO_INIT;
+  glm_mat4x2_copy(t, mat);
+}
+
+/*!
+ * @brief Create mat4x2 matrix from pointer
+ *
+ * @param[in]  src  pointer to an array of floats
+ * @param[out] dest matrix
+ */
+CGLM_INLINE
+void
+glm_mat4x2_make(float * __restrict src, mat4x2 dest) {
+  dest[0][0] = src[0];
+  dest[0][1] = src[1];
+
+  dest[1][0] = src[2];
+  dest[1][1] = src[3];
+
+  dest[2][0] = src[4];
+  dest[2][1] = src[5];
+
+  dest[3][0] = src[6];
+  dest[3][1] = src[7];
+}
+
+/*!
+ * @brief multiply m1 and m2 to dest
+ *
+ * m1, m2 and dest matrices can be same matrix, it is possible to write this:
+ *
+ * @code
+ * glm_mat4x2_mul(m, m, m);
+ * @endcode
+ *
+ * @param[in]  m1   left matrix
+ * @param[in]  m2   right matrix
+ * @param[out] dest destination matrix
+ */
+CGLM_INLINE
+void
+glm_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat4 dest) {
+  float a00 = m1[0][0], a01 = m1[0][1],
+        a10 = m1[1][0], a11 = m1[1][1],
+        a20 = m1[2][0], a21 = m1[2][1],
+        a30 = m1[3][0], a31 = m1[3][1],
+
+        b00 = m2[0][0], b01 = m2[0][1], b02 = m2[0][2], b03 = m2[0][3],
+        b10 = m2[1][0], b11 = m2[1][1], b12 = m2[1][2], b13 = m2[1][3];
+
+  dest[0][0] = a00 * b00 + a01 * b10;
+  dest[0][1] = a00 * b01 + a01 * b11;
+  dest[0][2] = a00 * b02 + a01 * b12;
+  dest[0][3] = a00 * b03 + a01 * b13;
+
+  dest[1][0] = a10 * b00 + a11 * b10;
+  dest[1][1] = a10 * b01 + a11 * b11;
+  dest[1][2] = a10 * b02 + a11 * b12;
+  dest[1][3] = a10 * b03 + a11 * b13;
+
+  dest[2][0] = a20 * b00 + a21 * b10;
+  dest[2][1] = a20 * b01 + a21 * b11;
+  dest[2][2] = a20 * b02 + a21 * b12;
+  dest[2][3] = a20 * b03 + a21 * b13;
+
+  dest[3][0] = a30 * b00 + a31 * b10;
+  dest[3][1] = a30 * b01 + a31 * b11;
+  dest[3][2] = a30 * b02 + a31 * b12;
+  dest[3][3] = a30 * b03 + a31 * b13;
+}
+
+/*!
+ * @brief multiply matrix with column vector and store in dest vector
+ *
+ * @param[in]  m    matrix (left)
+ * @param[in]  v    vector (right, column vector)
+ * @param[out] dest result vector
+ */
+CGLM_INLINE
+void
+glm_mat4x2_mulv(mat4x2 m, vec2 v, vec4 dest) {
+  float v0 = v[0], v1 = v[1];
+
+  dest[0] = m[0][0] * v0 + m[0][1] * v1;
+  dest[1] = m[1][0] * v0 + m[1][1] * v1;
+  dest[2] = m[2][0] * v0 + m[2][1] * v1;
+  dest[3] = m[3][0] * v0 + m[3][1] * v1;
+}
+
+/*!
+ * @brief transpose matrix and store in dest
+ *
+ * @param[in]  m     matrix
+ * @param[out] dest  result
+ */
+CGLM_INLINE
+void
+glm_mat4x2_transpose(mat4x2 m, mat2x4 dest) {
+  dest[0][0] = m[0][0];
+  dest[0][1] = m[1][0];
+  dest[0][2] = m[2][0];
+  dest[0][3] = m[3][0];
+  dest[1][0] = m[0][1];
+  dest[1][1] = m[1][1];
+  dest[1][2] = m[2][1];
+  dest[1][3] = m[3][1];
+}
+
+/*!
+ * @brief scale (multiply with scalar) matrix
+ *
+ * multiply matrix with scalar
+ *
+ * @param[in, out] m matrix
+ * @param[in]    s scalar
+ */
+CGLM_INLINE
+void
+glm_mat4x2_scale(mat4x2 m, float s) {
+  m[0][0] *= s;  m[0][1] *= s;  m[1][0] *= s;  m[1][1] *= s;
+  m[2][0] *= s;  m[2][1] *= s;  m[3][0] *= s;  m[3][1] *= s;
+}
+
+#endif

include/cglm/mat4x3.h

@@ -0,0 +1,203 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   GLM_MAT4X3_ZERO_INIT
+   GLM_MAT4X3_ZERO
+
+ Functions:
+   CGLM_INLINE void glm_mat4x3_copy(mat4x3 mat, mat4x3 dest);
+   CGLM_INLINE void glm_mat4x3_zero(mat4x3 mat);
+   CGLM_INLINE void glm_mat4x3_make(float * __restrict src, mat4x3 dest);
+   CGLM_INLINE void glm_mat4x3_mul(mat4x3 m1, mat3x4 m2, mat4 dest);
+   CGLM_INLINE void glm_mat4x3_mulv(mat4x3 m, vec3 v, vec4 dest);
+   CGLM_INLINE void glm_mat4x3_transpose(mat4x3 m, mat3x4 dest);
+   CGLM_INLINE void glm_mat4x3_scale(mat4x3 m, float s);
+ */
+
+#ifndef cglm_mat4x3_h
+#define cglm_mat4x3_h
+
+#include "common.h"
+
+#define GLM_MAT4X3_ZERO_INIT {{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}, \
+                              {0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}}
+
+/* for C only */
+#define GLM_MAT4X3_ZERO GLM_MAT4X3_ZERO_INIT
+
+/*!
+ * @brief copy all members of [mat] to [dest]
+ *
+ * @param[in]  mat  source
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_mat4x3_copy(mat4x3 mat, mat4x3 dest) {
+  dest[0][0] = mat[0][0];
+  dest[0][1] = mat[0][1];
+  dest[0][2] = mat[0][2];
+
+  dest[1][0] = mat[1][0];
+  dest[1][1] = mat[1][1];
+  dest[1][2] = mat[1][2];
+
+  dest[2][0] = mat[2][0];
+  dest[2][1] = mat[2][1];
+  dest[2][2] = mat[2][2];
+
+  dest[3][0] = mat[3][0];
+  dest[3][1] = mat[3][1];
+  dest[3][2] = mat[3][2];
+}
+
+/*!
+ * @brief make given matrix zero.
+ *
+ * @param[in, out]  mat  matrix
+ */
+CGLM_INLINE
+void
+glm_mat4x3_zero(mat4x3 mat) {
+  CGLM_ALIGN_MAT mat4x3 t = GLM_MAT4X3_ZERO_INIT;
+  glm_mat4x3_copy(t, mat);
+}
+
+/*!
+ * @brief Create mat4x3 matrix from pointer
+ *
+ * @param[in]  src  pointer to an array of floats
+ * @param[out] dest matrix
+ */
+CGLM_INLINE
+void
+glm_mat4x3_make(float * __restrict src, mat4x3 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];
+
+  dest[3][0] = src[9];
+  dest[3][1] = src[10];
+  dest[3][2] = src[11];
+}
+
+/*!
+ * @brief multiply m1 and m2 to dest
+ *
+ * m1, m2 and dest matrices can be same matrix, it is possible to write this:
+ *
+ * @code
+ * glm_mat4x3_mul(m, m, m);
+ * @endcode
+ *
+ * @param[in]  m1   left matrix
+ * @param[in]  m2   right matrix
+ * @param[out] dest destination matrix
+ */
+CGLM_INLINE
+void
+glm_mat4x3_mul(mat4x3 m1, mat3x4 m2, mat4 dest) {
+  float a00 = m1[0][0], a01 = m1[0][1], a02 = m1[0][2],
+        a10 = m1[1][0], a11 = m1[1][1], a12 = m1[1][2],
+        a20 = m1[2][0], a21 = m1[2][1], a22 = m1[2][2],
+        a30 = m1[3][0], a31 = m1[3][1], a32 = m1[3][2],
+
+        b00 = m2[0][0], b01 = m2[0][1], b02 = m2[0][2], b03 = m2[0][3],
+        b10 = m2[1][0], b11 = m2[1][1], b12 = m2[1][2], b13 = m2[1][3],
+        b20 = m2[2][0], b21 = m2[2][1], b22 = m2[2][2], b23 = m2[2][3];
+
+  dest[0][0] = a00 * b00 + a01 * b10 + a02 * b20;
+  dest[0][1] = a00 * b01 + a01 * b11 + a02 * b21;
+  dest[0][2] = a00 * b02 + a01 * b12 + a02 * b22;
+  dest[0][3] = a00 * b03 + a01 * b13 + a02 * b23;
+
+  dest[1][0] = a10 * b00 + a11 * b10 + a12 * b20;
+  dest[1][1] = a10 * b01 + a11 * b11 + a12 * b21;
+  dest[1][2] = a10 * b02 + a11 * b12 + a12 * b22;
+  dest[1][3] = a10 * b03 + a11 * b13 + a12 * b23;
+
+  dest[2][0] = a20 * b00 + a21 * b10 + a22 * b20;
+  dest[2][1] = a20 * b01 + a21 * b11 + a22 * b21;
+  dest[2][2] = a20 * b02 + a21 * b12 + a22 * b22;
+  dest[2][3] = a20 * b03 + a21 * b13 + a22 * b23;
+
+  dest[3][0] = a30 * b00 + a31 * b10 + a32 * b20;
+  dest[3][1] = a30 * b01 + a31 * b11 + a32 * b21;
+  dest[3][2] = a30 * b02 + a31 * b12 + a32 * b22;
+  dest[3][3] = a30 * b03 + a31 * b13 + a32 * b23;
+}
+
+/*!
+ * @brief multiply matrix with column vector and store in dest vector
+ *
+ * @param[in]  m    matrix (left)
+ * @param[in]  v    vector (right, column vector)
+ * @param[out] dest result vector
+ */
+CGLM_INLINE
+void
+glm_mat4x3_mulv(mat4x3 m, vec3 v, vec4 dest) {
+  float v0 = v[0], v1 = v[1], v2 = v[2];
+
+  dest[0] = m[0][0] * v0 + m[0][1] * v1 + m[0][2] * v2;
+  dest[1] = m[1][0] * v0 + m[1][1] * v1 + m[1][2] * v2;
+  dest[2] = m[2][0] * v0 + m[2][1] * v1 + m[2][2] * v2;
+  dest[3] = m[3][0] * v0 + m[3][1] * v1 + m[3][2] * v2;
+}
+
+/*!
+ * @brief transpose matrix and store in dest
+ *
+ * @param[in]  m     matrix
+ * @param[out] dest  result
+ */
+CGLM_INLINE
+void
+glm_mat4x3_transpose(mat4x3 m, mat3x4 dest) {
+  dest[0][0] = m[0][0];
+  dest[0][1] = m[1][0];
+  dest[0][2] = m[2][0];
+  dest[0][3] = m[3][0];
+
+  dest[1][0] = m[0][1];
+  dest[1][1] = m[1][1];
+  dest[1][2] = m[2][1];
+  dest[1][3] = m[3][1];
+
+  dest[2][0] = m[0][2];
+  dest[2][1] = m[1][2];
+  dest[2][2] = m[2][2];
+  dest[2][3] = m[3][2];
+}
+
+/*!
+ * @brief scale (multiply with scalar) matrix
+ *
+ * multiply matrix with scalar
+ *
+ * @param[in, out] m matrix
+ * @param[in]    s scalar
+ */
+CGLM_INLINE
+void
+glm_mat4x3_scale(mat4x3 m, float s) {
+  m[0][0] *= s;  m[0][1] *= s;  m[0][2] *= s;  m[1][0] *= s;
+  m[1][1] *= s;  m[1][2] *= s;  m[2][0] *= s;  m[2][1] *= s;
+  m[2][2] *= s;  m[3][0] *= s;  m[3][1] *= s;  m[3][2] *= s;
+}
+
+#endif

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

@@ -52,6 +52,10 @@ glmm_float32x4_init(float x, float y, float z, float w) {
 #  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

@@ -99,7 +99,6 @@
 #  endif
 #endif
 
-
 /* WebAssembly */
 #if defined(__wasm__) && defined(__wasm_simd128__)
 #  ifndef CGLM_SIMD_WASM

include/cglm/simd/neon/mat4.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 = glmm_float32x4_init(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 = glmm_float32x4_init(-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

@@ -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 = glmm_float32x4_init(-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,7 +26,7 @@ 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);

include/cglm/simd/wasm.h

@@ -26,6 +26,16 @@
 #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) {

include/cglm/simd/wasm/mat4.h

@@ -164,8 +164,8 @@ glm_mat4_det_wasm(mat4 mat) {
   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, 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));
 }
@@ -178,7 +178,8 @@ glm_mat4_inv_fast_wasm(mat4 mat, mat4 dest) {
          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 = 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 */
@@ -318,7 +319,8 @@ glm_mat4_inv_wasm(mat4 mat, mat4 dest) {
          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 = 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 */

include/cglm/simd/wasm/quat.h

@@ -26,7 +26,8 @@ glm_quat_mul_wasm(versor p, versor q, versor dest) {
 
   xp = glmm_load(p); /* 3 2 1 0 */
   xq = glmm_load(q);
-  x1 = wasm_f32x4_const(0.f, -0.f, 0.f, -0.f); /* TODO: _mm_set1_ss() + shuff ? */
+  /* 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);

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

@@ -17,8 +17,14 @@ extern "C" {
 #include "struct/vec3.h"
 #include "struct/vec4.h"
 #include "struct/mat2.h"
+#include "struct/mat2x3.h"
+#include "struct/mat2x4.h"
 #include "struct/mat3.h"
+#include "struct/mat3x2.h"
+#include "struct/mat3x4.h"
 #include "struct/mat4.h"
+#include "struct/mat4x2.h"
+#include "struct/mat4x3.h"
 #include "struct/affine.h"
 #include "struct/frustum.h"
 #include "struct/plane.h"

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

@@ -31,9 +31,9 @@ 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);
 }
 
 /*!
@@ -53,10 +53,10 @@ glms_aabb_(merge)(vec3s box1[2], vec3s box2[2], vec3s dest[2]) {
   vec3 rawBox2[2];
   vec3 rawDest[2];
 
-  glms_vec3_unpack(rawBox1, box1, 2);
-  glms_vec3_unpack(rawBox2, box2, 2);
+  glms_vec3_(unpack)(rawBox1, box1, 2);
+  glms_vec3_(unpack)(rawBox2, box2, 2);
   glm_aabb_merge(rawBox1, rawBox2, rawDest);
-  glms_vec3_pack(dest, rawDest, 2);
+  glms_vec3_(pack)(dest, rawDest, 2);
 }
 
 /*!
@@ -77,10 +77,10 @@ glms_aabb_(crop)(vec3s box[2], vec3s cropBox[2], vec3s dest[2]) {
   vec3 rawCropBox[2];
   vec3 rawDest[2];
 
-  glms_vec3_unpack(rawBox, box, 2);
-  glms_vec3_unpack(rawCropBox, cropBox, 2);
+  glms_vec3_(unpack)(rawBox, box, 2);
+  glms_vec3_(unpack)(rawCropBox, cropBox, 2);
   glm_aabb_crop(rawBox, rawCropBox, rawDest);
-  glms_vec3_pack(dest, rawDest, 2);
+  glms_vec3_(pack)(dest, rawDest, 2);
 }
 
 /*!
@@ -101,8 +101,8 @@ glms_aabb_(crop_until)(vec3s box[2],
                        vec3s cropBox[2],
                        vec3s clampBox[2],
                        vec3s dest[2]) {
-  glms_aabb_crop(box, cropBox, dest);
-  glms_aabb_merge(clampBox, dest, dest);
+  glms_aabb_(crop)(box, cropBox, dest);
+  glms_aabb_(merge)(clampBox, dest, dest);
 }
 
 /*!
@@ -125,8 +125,8 @@ glms_aabb_(frustum)(vec3s box[2], vec4s planes[6]) {
   vec3 rawBox[2];
   vec4 rawPlanes[6];
 
-  glms_vec3_unpack(rawBox, box, 2);
-  glms_vec4_unpack(rawPlanes, planes, 6);
+  glms_vec3_(unpack)(rawBox, box, 2);
+  glms_vec4_(unpack)(rawPlanes, planes, 6);
   return glm_aabb_frustum(rawBox, rawPlanes);
 }
 
@@ -138,8 +138,8 @@ glms_aabb_(frustum)(vec3s box[2], vec4s planes[6]) {
 CGLM_INLINE
 void
 glms_aabb_(invalidate)(vec3s box[2]) {
-  box[0] = glms_vec3_broadcast(FLT_MAX);
-  box[1] = glms_vec3_broadcast(-FLT_MAX);
+  box[0] = glms_vec3_(broadcast)(FLT_MAX);
+  box[1] = glms_vec3_(broadcast)(-FLT_MAX);
 }
 
 /*!
@@ -151,7 +151,7 @@ CGLM_INLINE
 bool
 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);
 }
 
@@ -174,7 +174,7 @@ glms_aabb_(size)(vec3s box[2]) {
 CGLM_INLINE
 float
 glms_aabb_(radius)(vec3s box[2]) {
-  return glms_aabb_size(box) * 0.5f;
+  return glms_aabb_(size)(box) * 0.5f;
 }
 
 /*!
@@ -186,7 +186,7 @@ glms_aabb_(radius)(vec3s box[2]) {
 CGLM_INLINE
 vec3s
 glms_aabb_(center)(vec3s box[2]) {
-  return glms_vec3_center(box[0], box[1]);
+  return glms_vec3_(center)(box[0], box[1]);
 }
 
 /*!
@@ -201,8 +201,8 @@ glms_aabb_(aabb)(vec3s box[2], vec3s other[2]) {
   vec3 rawBox[2];
   vec3 rawOther[2];
 
-  glms_vec3_unpack(rawBox, box, 2);
-  glms_vec3_unpack(rawOther, other, 2);
+  glms_vec3_(unpack)(rawBox, box, 2);
+  glms_vec3_(unpack)(rawOther, other, 2);
   return glm_aabb_aabb(rawBox, rawOther);
 }
 
@@ -220,7 +220,7 @@ bool
 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);
 }
 
@@ -235,7 +235,7 @@ bool
 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);
 }
 
@@ -251,8 +251,8 @@ glms_aabb_(contains)(vec3s box[2], vec3s other[2]) {
   vec3 rawBox[2];
   vec3 rawOther[2];
 
-  glms_vec3_unpack(rawBox, box, 2);
-  glms_vec3_unpack(rawOther, other, 2);
+  glms_vec3_(unpack)(rawBox, box, 2);
+  glms_vec3_(unpack)(rawOther, other, 2);
   return glm_aabb_contains(rawBox, rawOther);
 }
 

include/cglm/struct/clipspace/ortho_lh_no.h

@@ -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 mat2s glms_mat2_make(float * __restrict src);
  */
 
 #ifndef cglms_mat2_h
@@ -43,8 +44,8 @@
 #define GLMS_MAT2_ZERO_INIT     {GLM_MAT2_ZERO_INIT}
 
 /* for C only */
-#define GLMS_MAT2_IDENTITY ((mat3s)GLMS_MAT2_IDENTITY_INIT)
-#define GLMS_MAT2_ZERO     ((mat3s)GLMS_MAT2_ZERO_INIT)
+#define GLMS_MAT2_IDENTITY ((mat2s)GLMS_MAT2_IDENTITY_INIT)
+#define GLMS_MAT2_ZERO     ((mat2s)GLMS_MAT2_ZERO_INIT)
 
 /*!
  * @brief make given matrix identity. It is identical with below,
@@ -258,4 +259,18 @@ 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/mat2x3.h

@@ -0,0 +1,129 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   GLMS_MAT2X3_ZERO_INIT
+   GLMS_MAT2X3_ZERO
+
+ Functions:
+   CGLM_INLINE mat2x3s glms_mat2x3_zero(void);
+   CGLM_INLINE mat2x3s glms_mat2x3_make(float * __restrict src);
+   CGLM_INLINE mat2s   glms_mat2x3_mul(mat2x3s m1, mat3x2s m2);
+   CGLM_INLINE vec2s   glms_mat2x3_mulv(mat2x3s m, vec3s v);
+   CGLM_INLINE mat3x2s glms_mat2x3_transpose(mat2x3s m);
+   CGLM_INLINE mat2x3s glms_mat2x3_scale(mat2x3s m, float s);
+ */
+
+#ifndef cglms_mat2x3_h
+#define cglms_mat2x3_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../mat2x3.h"
+
+/* api definition */
+#define glms_mat2x3_(NAME) CGLM_STRUCTAPI(mat2x3, NAME)
+
+#define GLMS_MAT2X3_ZERO_INIT {GLM_MAT2X3_ZERO_INIT}
+
+/* for C only */
+#define GLMS_MAT2X3_ZERO ((mat2x3s)GLMS_MAT2X3_ZERO_INIT)
+
+/*!
+ * @brief make given matrix zero.
+ *
+ * @param[in, out]  mat  matrix
+ */
+CGLM_INLINE
+mat2x3s
+glms_mat2x3_(zero)(void) {
+  mat2x3s r;
+  glm_mat2x3_zero(r.raw);
+  return r;
+}
+
+/*!
+ * @brief Create mat2x3 matrix from pointer
+ *
+ * @param[in]  src  pointer to an array of floats
+ * @return constructed matrix from raw pointer
+ */
+CGLM_INLINE
+mat2x3s
+glms_mat2x3_(make)(float * __restrict src) {
+  mat2x3s r;
+  glm_mat2x3_make(src, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply m1 and m2 to dest
+ *
+ * m1, m2 and dest matrices can be same matrix, it is possible to write this:
+ *
+ * @code
+ * glm_mat2x3_mul(m, m, m);
+ * @endcode
+ *
+ * @param[in]  m1   left matrix
+ * @param[in]  m2   right matrix
+ * @param[out] dest destination matrix
+ */
+CGLM_INLINE
+mat2s
+glms_mat2x3_(mul)(mat2x3s m1, mat3x2s m2) {
+  mat2s r;
+  glm_mat2x3_mul(m1.raw, m2.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply matrix with column vector and store in dest vector
+ *
+ * @param[in]  m    matrix (left)
+ * @param[in]  v    vector (right, column vector)
+ * @param[out] dest result vector
+ */
+CGLM_INLINE
+vec2s
+glms_mat2x3_(mulv)(mat2x3s m, vec3s v) {
+  vec2s r;
+  glm_mat2x3_mulv(m.raw, v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief transpose matrix and store in dest
+ *
+ * @param[in]  m     matrix
+ * @param[out] dest  result
+ */
+CGLM_INLINE
+mat3x2s
+glms_mat2x3_(transpose)(mat2x3s m) {
+  mat3x2s r;
+  glm_mat2x3_transpose(m.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief scale (multiply with scalar) matrix
+ *
+ * multiply matrix with scalar
+ *
+ * @param[in, out] m matrix
+ * @param[in]    s scalar
+ */
+CGLM_INLINE
+mat2x3s
+glms_mat2x3_(scale)(mat2x3s m, float s) {
+  glm_mat2x3_scale(m.raw, s);
+  return m;
+}
+
+#endif /* cglms_mat2x3_h */

include/cglm/struct/mat2x4.h

@@ -0,0 +1,129 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   GLMS_MAT2X4_ZERO_INIT
+   GLMS_MAT2X4_ZERO
+
+ Functions:
+   CGLM_INLINE mat2x4s glms_mat2x4_zero(void);
+   CGLM_INLINE mat2x4s glms_mat2x4_make(float * __restrict src);
+   CGLM_INLINE mat2s   glms_mat2x4_mul(mat2x4s m1, mat4x2s m2);
+   CGLM_INLINE vec2s   glms_mat2x4_mulv(mat2x4s m, vec4s v);
+   CGLM_INLINE mat4x2s glms_mat2x4_transpose(mat2x4s m);
+   CGLM_INLINE mat2x4s glms_mat2x4_scale(mat2x4s m, float s);
+ */
+
+#ifndef cglms_mat2x4_h
+#define cglms_mat2x4_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../mat2x4.h"
+
+/* api definition */
+#define glms_mat2x4_(NAME) CGLM_STRUCTAPI(mat2x4, NAME)
+
+#define GLMS_MAT2X4_ZERO_INIT {GLM_MAT2X4_ZERO_INIT}
+
+/* for C only */
+#define GLMS_MAT2X4_ZERO ((mat2x4s)GLMS_MAT2X4_ZERO_INIT)
+
+/*!
+ * @brief make given matrix zero.
+ *
+ * @param[in, out]  mat  matrix
+ */
+CGLM_INLINE
+mat2x4s
+glms_mat2x4_(zero)(void) {
+  mat2x4s r;
+  glm_mat2x4_zero(r.raw);
+  return r;
+}
+
+/*!
+ * @brief Create mat2x4 matrix from pointer
+ *
+ * @param[in]  src  pointer to an array of floats
+ * @return constructed matrix from raw pointer
+ */
+CGLM_INLINE
+mat2x4s
+glms_mat2x4_(make)(float * __restrict src) {
+  mat2x4s r;
+  glm_mat2x4_make(src, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply m1 and m2 to dest
+ *
+ * m1, m2 and dest matrices can be same matrix, it is possible to write this:
+ *
+ * @code
+ * glm_mat2x4_mul(m, m, m);
+ * @endcode
+ *
+ * @param[in]  m1   left matrix
+ * @param[in]  m2   right matrix
+ * @param[out] dest destination matrix
+ */
+CGLM_INLINE
+mat2s
+glms_mat2x4_(mul)(mat2x4s m1, mat4x2s m2) {
+  mat2s r;
+  glm_mat2x4_mul(m1.raw, m2.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply matrix with column vector and store in dest vector
+ *
+ * @param[in]  m    matrix (left)
+ * @param[in]  v    vector (right, column vector)
+ * @param[out] dest result vector
+ */
+CGLM_INLINE
+vec2s
+glms_mat2x4_(mulv)(mat2x4s m, vec4s v) {
+  vec2s r;
+  glm_mat2x4_mulv(m.raw, v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief transpose matrix and store in dest
+ *
+ * @param[in]  m     matrix
+ * @param[out] dest  result
+ */
+CGLM_INLINE
+mat4x2s
+glms_mat2x4_(transpose)(mat2x4s m) {
+  mat4x2s r;
+  glm_mat2x4_transpose(m.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief scale (multiply with scalar) matrix
+ *
+ * multiply matrix with scalar
+ *
+ * @param[in, out] m matrix
+ * @param[in]    s scalar
+ */
+CGLM_INLINE
+mat2x4s
+glms_mat2x4_(scale)(mat2x4s m, float s) {
+  glm_mat2x4_scale(m.raw, s);
+  return m;
+}
+
+#endif /* cglms_mat2x4_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 mat3s  glms_mat3_make(float * __restrict src);
  */
 
 #ifndef cglms_mat3s_h
@@ -285,4 +286,18 @@ 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/mat3x2.h

@@ -0,0 +1,129 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   GLMS_MAT3X2_ZERO_INIT
+   GLMS_MAT3X2_ZERO
+
+ Functions:
+   CGLM_INLINE mat3x2s glms_mat3x2_zero(void);
+   CGLM_INLINE mat3x2s glms_mat3x2_make(float * __restrict src);
+   CGLM_INLINE mat3s   glms_mat3x2_mul(mat3x2s m1, mat2x3s m2);
+   CGLM_INLINE vec3s   glms_mat3x2_mulv(mat3x2s m, vec2s v);
+   CGLM_INLINE mat2x3s glms_mat3x2_transpose(mat3x2s m);
+   CGLM_INLINE mat3x2s glms_mat3x2_scale(mat3x2s m, float s);
+ */
+
+#ifndef cglms_mat3x2_h
+#define cglms_mat3x2_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../mat3x2.h"
+
+/* api definition */
+#define glms_mat3x2_(NAME) CGLM_STRUCTAPI(mat3x2, NAME)
+
+#define GLMS_MAT3X2_ZERO_INIT {GLM_MAT3X2_ZERO_INIT}
+
+/* for C only */
+#define GLMS_MAT3X2_ZERO ((mat3x2s)GLMS_MAT3X2_ZERO_INIT)
+
+/*!
+ * @brief make given matrix zero.
+ *
+ * @param[in, out]  mat  matrix
+ */
+CGLM_INLINE
+mat3x2s
+glms_mat3x2_(zero)(void) {
+  mat3x2s r;
+  glm_mat3x2_zero(r.raw);
+  return r;
+}
+
+/*!
+ * @brief Create mat3x2 matrix from pointer
+ *
+ * @param[in]  src  pointer to an array of floats
+ * @return constructed matrix from raw pointer
+ */
+CGLM_INLINE
+mat3x2s
+glms_mat3x2_(make)(float * __restrict src) {
+  mat3x2s r;
+  glm_mat3x2_make(src, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply m1 and m2 to dest
+ *
+ * m1, m2 and dest matrices can be same matrix, it is possible to write this:
+ *
+ * @code
+ * glm_mat3x2_mul(m, m, m);
+ * @endcode
+ *
+ * @param[in]  m1   left matrix
+ * @param[in]  m2   right matrix
+ * @param[out] dest destination matrix
+ */
+CGLM_INLINE
+mat3s
+glms_mat3x2_(mul)(mat3x2s m1, mat2x3s m2) {
+  mat3s r;
+  glm_mat3x2_mul(m1.raw, m2.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply matrix with column vector and store in dest vector
+ *
+ * @param[in]  m    matrix (left)
+ * @param[in]  v    vector (right, column vector)
+ * @param[out] dest result vector
+ */
+CGLM_INLINE
+vec3s
+glms_mat3x2_(mulv)(mat3x2s m, vec2s v) {
+  vec3s r;
+  glm_mat3x2_mulv(m.raw, v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief transpose matrix and store in dest
+ *
+ * @param[in]  m     matrix
+ * @param[out] dest  result
+ */
+CGLM_INLINE
+mat2x3s
+glms_mat3x2_(transpose)(mat3x2s m) {
+  mat2x3s r;
+  glm_mat3x2_transpose(m.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief scale (multiply with scalar) matrix
+ *
+ * multiply matrix with scalar
+ *
+ * @param[in, out] m matrix
+ * @param[in]    s scalar
+ */
+CGLM_INLINE
+mat3x2s
+glms_mat3x2_(scale)(mat3x2s m, float s) {
+  glm_mat3x2_scale(m.raw, s);
+  return m;
+}
+
+#endif /* cglms_mat3x2_h */

include/cglm/struct/mat3x4.h

@@ -0,0 +1,129 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   GLMS_MAT3X4_ZERO_INIT
+   GLMS_MAT3X4_ZERO
+
+ Functions:
+   CGLM_INLINE mat3x4s glms_mat3x4_zero(void);
+   CGLM_INLINE mat3x4s glms_mat3x4_make(float * __restrict src);
+   CGLM_INLINE mat3s   glms_mat3x4_mul(mat3x4s m1, mat4x3s m2);
+   CGLM_INLINE vec3s   glms_mat3x4_mulv(mat3x4s m, vec4s v);
+   CGLM_INLINE mat4x3s glms_mat3x4_transpose(mat3x4s m);
+   CGLM_INLINE mat3x4s glms_mat3x4_scale(mat3x4s m, float s);
+ */
+
+#ifndef cglms_mat3x4_h
+#define cglms_mat3x4_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../mat3x4.h"
+
+/* api definition */
+#define glms_mat3x4_(NAME) CGLM_STRUCTAPI(mat3x4, NAME)
+
+#define GLMS_MAT3X4_ZERO_INIT {GLM_MAT3X4_ZERO_INIT}
+
+/* for C only */
+#define GLMS_MAT3X4_ZERO ((mat3x4s)GLMS_MAT3X4_ZERO_INIT)
+
+/*!
+ * @brief make given matrix zero.
+ *
+ * @param[in, out]  mat  matrix
+ */
+CGLM_INLINE
+mat3x4s
+glms_mat3x4_(zero)(void) {
+  mat3x4s r;
+  glm_mat3x4_zero(r.raw);
+  return r;
+}
+
+/*!
+ * @brief Create mat3x4 matrix from pointer
+ *
+ * @param[in]  src  pointer to an array of floats
+ * @return constructed matrix from raw pointer
+ */
+CGLM_INLINE
+mat3x4s
+glms_mat3x4_(make)(float * __restrict src) {
+  mat3x4s r;
+  glm_mat3x4_make(src, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply m1 and m2 to dest
+ *
+ * m1, m2 and dest matrices can be same matrix, it is possible to write this:
+ *
+ * @code
+ * glm_mat3x4_mul(m, m, m);
+ * @endcode
+ *
+ * @param[in]  m1   left matrix
+ * @param[in]  m2   right matrix
+ * @param[out] dest destination matrix
+ */
+CGLM_INLINE
+mat3s
+glms_mat3x4_(mul)(mat3x4s m1, mat4x3s m2) {
+  mat3s r;
+  glm_mat3x4_mul(m1.raw, m2.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply matrix with column vector and store in dest vector
+ *
+ * @param[in]  m    matrix (left)
+ * @param[in]  v    vector (right, column vector)
+ * @param[out] dest result vector
+ */
+CGLM_INLINE
+vec3s
+glms_mat3x4_(mulv)(mat3x4s m, vec4s v) {
+  vec3s r;
+  glm_mat3x4_mulv(m.raw, v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief transpose matrix and store in dest
+ *
+ * @param[in]  m     matrix
+ * @param[out] dest  result
+ */
+CGLM_INLINE
+mat4x3s
+glms_mat3x4_(transpose)(mat3x4s m) {
+  mat4x3s r;
+  glm_mat3x4_transpose(m.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief scale (multiply with scalar) matrix
+ *
+ * multiply matrix with scalar
+ *
+ * @param[in, out] m matrix
+ * @param[in]    s scalar
+ */
+CGLM_INLINE
+mat3x4s
+glms_mat3x4_(scale)(mat3x4s m, float s) {
+  glm_mat3x4_scale(m.raw, s);
+  return m;
+}
+
+#endif /* cglms_mat3x4_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 mat4s   glms_mat4_make(float * __restrict src);
  */
 
 #ifndef cglms_mat4s_h
@@ -240,7 +241,7 @@ glms_mat4_(mulN)(mat4s * __restrict matrices[], uint32_t len) {
   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;
@@ -459,4 +460,18 @@ 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/mat4x2.h

@@ -0,0 +1,130 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   GLMS_MAT4X2_ZERO_INIT
+   GLMS_MAT4X2_ZERO
+
+ Functions:
+   CGLM_INLINE mat4x2s glms_mat4x2_zero(void);
+   CGLM_INLINE mat4x2s glms_mat4x2_make(float * __restrict src);
+   CGLM_INLINE mat4s   glms_mat4x2_mul(mat4x2s m1, mat2x4s m2);
+   CGLM_INLINE vec4s   glms_mat4x2_mulv(mat4x2s m, vec2s v);
+   CGLM_INLINE mat2x4s glms_mat4x2_transpose(mat4x2s m);
+   CGLM_INLINE mat4x2s glms_mat4x2_scale(mat4x2s m, float s);
+ */
+
+#ifndef cglms_mat4x2_h
+#define cglms_mat4x2_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../mat4x2.h"
+
+/* api definition */
+#define glms_mat4x2_(NAME) CGLM_STRUCTAPI(mat4x2, NAME)
+
+#define GLMS_MAT4X2_ZERO_INIT {GLM_MAT4X2_ZERO_INIT}
+
+/* for C only */
+#define GLMS_MAT4X2_ZERO ((mat4x2s)GLMS_MAT4X2_ZERO_INIT)
+
+
+/*!
+ * @brief make given matrix zero.
+ *
+ * @param[in, out]  mat  matrix
+ */
+CGLM_INLINE
+mat4x2s
+glms_mat4x2_(zero)(void) {
+  mat4x2s r;
+  glm_mat4x2_zero(r.raw);
+  return r;
+}
+
+/*!
+ * @brief Create mat4x2 matrix from pointer
+ *
+ * @param[in]  src  pointer to an array of floats
+ * @return constructed matrix from raw pointer
+ */
+CGLM_INLINE
+mat4x2s
+glms_mat4x2_(make)(float * __restrict src) {
+  mat4x2s r;
+  glm_mat4x2_make(src, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply m1 and m2 to dest
+ *
+ * m1, m2 and dest matrices can be same matrix, it is possible to write this:
+ *
+ * @code
+ * glm_mat4x2_mul(m, m, m);
+ * @endcode
+ *
+ * @param[in]  m1   left matrix
+ * @param[in]  m2   right matrix
+ * @param[out] dest destination matrix
+ */
+CGLM_INLINE
+mat4s
+glms_mat4x2_(mul)(mat4x2s m1, mat2x4s m2) {
+  mat4s r;
+  glm_mat4x2_mul(m1.raw, m2.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply matrix with column vector and store in dest vector
+ *
+ * @param[in]  m    matrix (left)
+ * @param[in]  v    vector (right, column vector)
+ * @param[out] dest result vector
+ */
+CGLM_INLINE
+vec4s
+glms_mat4x2_(mulv)(mat4x2s m, vec2s v) {
+  vec4s r;
+  glm_mat4x2_mulv(m.raw, v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief transpose matrix and store in dest
+ *
+ * @param[in]  m     matrix
+ * @param[out] dest  result
+ */
+CGLM_INLINE
+mat2x4s
+glms_mat4x2_(transpose)(mat4x2s m) {
+  mat2x4s r;
+  glm_mat4x2_transpose(m.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief scale (multiply with scalar) matrix
+ *
+ * multiply matrix with scalar
+ *
+ * @param[in, out] m matrix
+ * @param[in]    s scalar
+ */
+CGLM_INLINE
+mat4x2s
+glms_mat4x2_(scale)(mat4x2s m, float s) {
+  glm_mat4x2_scale(m.raw, s);
+  return m;
+}
+
+#endif /* cglms_mat4x2_h */

include/cglm/struct/mat4x3.h

@@ -0,0 +1,129 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   GLMS_MAT4X3_ZERO_INIT
+   GLMS_MAT4X3_ZERO
+
+ Functions:
+   CGLM_INLINE mat4x3s glms_mat4x3_zero(void);
+   CGLM_INLINE mat4x3s glms_mat4x3_make(float * __restrict src);
+   CGLM_INLINE mat4s   glms_mat4x3_mul(mat4x3s m1, mat3x4s m2);
+   CGLM_INLINE vec4s   glms_mat4x3_mulv(mat4x3s m, vec3s v);
+   CGLM_INLINE mat3x4s glms_mat4x3_transpose(mat4x3s m);
+   CGLM_INLINE mat4x3s glms_mat4x3_scale(mat4x3s m, float s);
+ */
+
+#ifndef cglms_mat4x3_h
+#define cglms_mat4x3_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../mat4x3.h"
+
+/* api definition */
+#define glms_mat4x3_(NAME) CGLM_STRUCTAPI(mat4x3, NAME)
+
+#define GLMS_MAT4X3_ZERO_INIT {GLM_MAT4X3_ZERO_INIT}
+
+/* for C only */
+#define GLMS_MAT4X3_ZERO ((mat4x3s)GLMS_MAT4X3_ZERO_INIT)
+
+/*!
+ * @brief make given matrix zero.
+ *
+ * @param[in, out]  mat  matrix
+ */
+CGLM_INLINE
+mat4x3s
+glms_mat4x3_(zero)(void) {
+  mat4x3s r;
+  glm_mat4x3_zero(r.raw);
+  return r;
+}
+
+/*!
+ * @brief Create mat4x3 matrix from pointer
+ *
+ * @param[in]  src  pointer to an array of floats
+ * @return constructed matrix from raw pointer
+ */
+CGLM_INLINE
+mat4x3s
+glms_mat4x3_(make)(float * __restrict src) {
+  mat4x3s r;
+  glm_mat4x3_make(src, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply m1 and m2 to dest
+ *
+ * m1, m2 and dest matrices can be same matrix, it is possible to write this:
+ *
+ * @code
+ * glm_mat4x3_mul(m, m, m);
+ * @endcode
+ *
+ * @param[in]  m1   left matrix
+ * @param[in]  m2   right matrix
+ * @param[out] dest destination matrix
+ */
+CGLM_INLINE
+mat4s
+glms_mat4x3_(mul)(mat4x3s m1, mat3x4s m2) {
+  mat4s r;
+  glm_mat4x3_mul(m1.raw, m2.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply matrix with column vector and store in dest vector
+ *
+ * @param[in]  m    matrix (left)
+ * @param[in]  v    vector (right, column vector)
+ * @param[out] dest result vector
+ */
+CGLM_INLINE
+vec4s
+glms_mat4x3_(mulv)(mat4x3s m, vec3s v) {
+  vec4s r;
+  glm_mat4x3_mulv(m.raw, v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief transpose matrix and store in dest
+ *
+ * @param[in]  m     matrix
+ * @param[out] dest  result
+ */
+CGLM_INLINE
+mat3x4s
+glms_mat4x3_(transpose)(mat4x3s m) {
+  mat3x4s r;
+  glm_mat4x3_transpose(m.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief scale (multiply with scalar) matrix
+ *
+ * multiply matrix with scalar
+ *
+ * @param[in, out] m matrix
+ * @param[in]    s scalar
+ */
+CGLM_INLINE
+mat4x3s
+glms_mat4x3_(scale)(mat4x3s m, float s) {
+  glm_mat4x3_scale(m.raw, s);
+  return m;
+}
+
+#endif /* cglms_mat4x3_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
@@ -565,4 +566,18 @@ glms_quat_(rotate_atm)(versors q, vec3s pivot) {
   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

@@ -76,7 +76,7 @@ glms_vec2_(eq_eps)(vec2s 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/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
@@ -258,11 +259,11 @@ glms_vec2_(subs)(vec2s a, float s) {
 }
 
 /*!
- * @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
@@ -307,7 +308,7 @@ 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
@@ -322,7 +323,7 @@ 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
@@ -397,7 +398,7 @@ glms_vec2_(muladds)(vec2s a, float s, vec2s 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
  *
@@ -413,7 +414,7 @@ glms_vec2_(maxadd)(vec2s a, vec2s b, vec2s 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
  *
@@ -558,4 +559,18 @@ glms_vec2_(lerp)(vec2s from, vec2s to, float t) {
   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

@@ -94,7 +94,7 @@ glms_vec3_(eq_eps)(vec3s 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/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);
@@ -314,7 +315,7 @@ glms_vec3_(subs)(vec3s a, float s) {
 }
 
 /*!
- * @brief multiply two vector (component-wise multiplication)
+ * @brief multiply two vectors (component-wise multiplication)
  *
  * @param     a     vector1
  * @param     b     vector2
@@ -453,7 +454,7 @@ glms_vec3_(muladds)(vec3s a, float s, vec3s 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
  *
@@ -469,7 +470,7 @@ glms_vec3_(maxadd)(vec3s a, vec3s b, vec3s 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
  *
@@ -967,4 +968,18 @@ glms_vec3_(swizzle)(vec3s v, int mask) {
   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

@@ -94,7 +94,7 @@ glms_vec4_(eq_eps)(vec4s v, float val) {
 }
 
 /*!
- * @brief check if vectors members are equal (without epsilon)
+ * @brief check if vector members are equal (without epsilon)
  *
  * @param v   vector
  */

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
@@ -343,7 +344,7 @@ glms_vec4_(subs)(vec4s v, float s) {
 }
 
 /*!
- * @brief multiply two vector (component-wise multiplication)
+ * @brief multiply two vectors (component-wise multiplication)
  *
  * @param a    vector1
  * @param b    vector2
@@ -482,7 +483,7 @@ glms_vec4_(muladds)(vec4s a, float s, vec4s 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
  *
@@ -498,7 +499,7 @@ glms_vec4_(maxadd)(vec4s a, vec4s b, vec4s 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
  *
@@ -811,4 +812,18 @@ glms_vec4_(swizzle)(vec4s v, int mask) {
   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? */
@@ -190,6 +197,28 @@ typedef union mat2s {
 #endif
 } mat2s;
 
+typedef union mat2x3s {
+  mat2x3 raw;
+  vec3s  col[2]; /* [col (2), row (3)] */
+#if CGLM_USE_ANONYMOUS_STRUCT
+  struct {
+    float m00, m01, m02;
+    float m10, m11, m12;
+  };
+#endif
+} mat2x3s;
+
+typedef union mat2x4s {
+  mat2x4 raw;
+  vec4s  col[2]; /* [col (2), row (4)] */
+#if CGLM_USE_ANONYMOUS_STRUCT
+  struct {
+    float m00, m01, m02, m03;
+    float m10, m11, m12, m13;
+  };
+#endif
+} mat2x4s;
+
 typedef union mat3s {
   mat3  raw;
   vec3s col[3];
@@ -202,6 +231,30 @@ typedef union mat3s {
 #endif
 } mat3s;
 
+typedef union mat3x2s {
+  mat3x2 raw;
+  vec2s  col[3]; /* [col (3), row (2)] */
+#if CGLM_USE_ANONYMOUS_STRUCT
+  struct {
+    float m00, m01;
+    float m10, m11;
+    float m20, m21;
+  };
+#endif
+} mat3x2s;
+
+typedef union mat3x4s {
+  mat3x4 raw;
+  vec4s  col[3]; /* [col (3), row (4)] */
+#if CGLM_USE_ANONYMOUS_STRUCT
+  struct {
+    float m00, m01, m02, m03;
+    float m10, m11, m12, m13;
+    float m20, m21, m22, m23;
+  };
+#endif
+} mat3x4s;
+
 typedef union CGLM_ALIGN_MAT mat4s {
   mat4  raw;
   vec4s col[4];
@@ -215,4 +268,30 @@ typedef union CGLM_ALIGN_MAT mat4s {
 #endif
 } mat4s;
 
+typedef union mat4x2s {
+  mat4x2 raw;
+  vec2s  col[4]; /* [col (4), row (2)] */
+#if CGLM_USE_ANONYMOUS_STRUCT
+  struct {
+    float m00, m01;
+    float m10, m11;
+    float m20, m21;
+    float m30, m31;
+  };
+#endif
+} mat4x2s;
+
+typedef union mat4x3s {
+  mat4x3 raw;
+  vec3s  col[4]; /* [col (4), row (3)] */
+#if CGLM_USE_ANONYMOUS_STRUCT
+  struct {
+    float m00, m01, m02;
+    float m10, m11, m12;
+    float m20, m21, m22;
+    float m30, m31, m32;
+  };
+#endif
+} mat4x3s;
+
 #endif /* cglm_types_struct_h */

include/cglm/types.h

@@ -32,13 +32,27 @@
 #  define CGLM_ALIGN_MAT CGLM_ALIGN(16)
 #endif
 
-#if defined(__has_builtin)
-#  if __has_builtin(__builtin_assume_aligned)
-#    define CGLM_ASSUME_ALIGNED(expr, alignment) \
-    __builtin_assume_aligned((expr), (alignment))
-#  else
-#    define CGLM_ASSUME_ALIGNED(expr, alignment) (expr)
+#ifndef CGLM_HAVE_BUILTIN_ASSUME_ALIGNED
+
+#  if defined(__has_builtin)
+#    if __has_builtin(__builtin_assume_aligned)
+#      define CGLM_HAVE_BUILTIN_ASSUME_ALIGNED 1
+#    endif
+#  elif defined(__GNUC__) && defined(__GNUC_MINOR__)
+#    if __GNUC__ >= 4 && __GNUC_MINOR__ >= 7
+#      define CGLM_HAVE_BUILTIN_ASSUME_ALIGNED 1
+#    endif
 #  endif
+
+#  ifndef CGLM_HAVE_BUILTIN_ASSUME_ALIGNED
+#    define CGLM_HAVE_BUILTIN_ASSUME_ALIGNED 0
+#  endif
+
+#endif
+
+#if CGLM_HAVE_BUILTIN_ASSUME_ALIGNED
+#  define CGLM_ASSUME_ALIGNED(expr, alignment) \
+     __builtin_assume_aligned((expr), (alignment))
 #else
 #  define CGLM_ASSUME_ALIGNED(expr, alignment) (expr)
 #endif
@@ -46,17 +60,23 @@
 #define CGLM_CASTPTR_ASSUME_ALIGNED(expr, type) \
   ((type*)CGLM_ASSUME_ALIGNED((expr), __alignof__(type)))
 
-typedef int                    ivec2[2];
-typedef int                    ivec3[3];
-typedef int                    ivec4[4];
+typedef int                     ivec2[2];
+typedef int                     ivec3[3];
+typedef int                     ivec4[4];
 
 typedef float                   vec2[2];
 typedef float                   vec3[3];
 typedef CGLM_ALIGN_IF(16) float vec4[4];
 typedef vec4                    versor;     /* |x, y, z, w| -> w is the last */
 typedef vec3                    mat3[3];
+typedef vec2                    mat3x2[3];  /* [col (3), row (2)] */
+typedef vec4                    mat3x4[3];  /* [col (3), row (4)] */
 typedef CGLM_ALIGN_IF(16) vec2  mat2[2];
+typedef vec3                    mat2x3[2];  /* [col (2), row (3)] */
+typedef vec4                    mat2x4[2];  /* [col (2), row (4)] */
 typedef CGLM_ALIGN_MAT    vec4  mat4[4];
+typedef vec2                    mat4x2[4];  /* [col (4), row (2)] */
+typedef vec3                    mat4x3[4];  /* [col (4), row (3)] */
 
 /*
   Important: cglm stores quaternion as [x, y, z, w] in memory since v0.4.0 

include/cglm/vec2-ext.h

@@ -70,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
  */

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

@@ -103,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
  */