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

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

configure.ac

@@ -8,7 +8,7 @@
 
 AC_PREREQ([2.69])
 AC_INIT([cglm], [0.9.1], [info@recp.me])
-AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects serial-tests])
+AM_INIT_AUTOMAKE([-Wall foreign subdir-objects serial-tests])
 
 # Don't use the default cflags (-O2 -g), we set ours manually in Makefile.am.
 : ${CFLAGS=""}

docs/source/api_inline_array.rst

@@ -46,8 +46,14 @@ Follow the :doc:`build` documentation for this
    quat
    euler
    mat2
+   mat2x3
+   mat2x4
    mat3
+   mat3x2
+   mat3x4
    mat4
+   mat4x2
+   mat4x3
    vec2
    vec2-ext
    vec3

docs/source/mat2.rst

@@ -65,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
@@ -101,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)
@@ -113,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)
 
@@ -183,7 +184,7 @@ Functions documentation
 
     Create mat2 matrix from pointer
 
-    | NOTE: **@src** must contain 4 elements.
+    | NOTE: **@src** must contain at least 4 elements.
 
     Parameters:
       | *[in]*  **src**  pointer to an array of floats

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

@@ -72,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
@@ -103,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)
 
@@ -123,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)
 
@@ -193,7 +194,7 @@ Functions documentation
 
     Create mat3 matrix from pointer
 
-    | NOTE: **@src** must contain 9 elements.
+    | NOTE: **@src** must contain at least 9 elements.
 
     Parameters:
       | *[in]*  **src**  pointer to an array of floats

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

@@ -119,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
@@ -157,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)
@@ -308,7 +308,7 @@ Functions documentation
 
     Create mat4 matrix from pointer
 
-    | NOTE: **@src** must contain 16 elements.
+    | NOTE: **@src** must contain at least 16 elements.
 
     Parameters:
       | *[in]*  **src**  pointer to an array of floats

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

@@ -33,7 +33,7 @@ glms_aabb_(transform)(vec3s box[2], mat4s m, vec3s dest[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);
 }
 
 /*!

include/cglm/struct/mat2.h

@@ -27,7 +27,7 @@
    CGLM_INLINE void  glms_mat2_swap_col(mat2 mat, int col1, int col2)
    CGLM_INLINE void  glms_mat2_swap_row(mat2 mat, int row1, int row2)
    CGLM_INLINE float glms_mat2_rmc(vec2 r, mat2 m, vec2 c)
-   CGLM_INLINE float glms_mat42_make(float * __restrict src);
+   CGLM_INLINE mat2s glms_mat2_make(float * __restrict src);
  */
 
 #ifndef cglms_mat2_h
@@ -44,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,

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,7 +28,7 @@
    CGLM_INLINE mat3s  glms_mat3_swap_col(mat3s mat, int col1, int col2);
    CGLM_INLINE mat3s  glms_mat3_swap_row(mat3s mat, int row1, int row2);
    CGLM_INLINE float  glms_mat3_rmc(vec3s r, mat3s m, vec3s c);
-   CGLM_INLINE float  glms_mat3_make(float * __restrict src);
+   CGLM_INLINE mat3s  glms_mat3_make(float * __restrict src);
  */
 
 #ifndef 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,7 +42,7 @@
    CGLM_INLINE mat4s   glms_mat4_swap_col(mat4s mat, int col1, int col2);
    CGLM_INLINE mat4s   glms_mat4_swap_row(mat4s mat, int row1, int row2);
    CGLM_INLINE float   glms_mat4_rmc(vec4s r, mat4s m, vec4s c);
-   CGLM_INLINE float   glms_mat4_make(float * __restrict src);
+   CGLM_INLINE mat4s   glms_mat4_make(float * __restrict src);
  */
 
 #ifndef 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

@@ -197,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];
@@ -209,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];
@@ -222,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
  */

include/cglm/vec4.h

@@ -58,6 +58,7 @@
    CGLM_INLINE void  glm_vec4_smoothinterp(vec4 from, vec4 to, float t, vec4 dest);
    CGLM_INLINE void  glm_vec4_smoothinterpc(vec4 from, vec4 to, float t, vec4 dest);
    CGLM_INLINE void  glm_vec4_swizzle(vec4 v, int mask, vec4 dest);
+   CGLM_INLINE void  glm_vec4_make(float * restrict src, vec4 dest);
 
  DEPRECATED:
    glm_vec4_dup
@@ -418,7 +419,7 @@ glm_vec4_subs(vec4 v, float s, vec4 dest) {
 }
 
 /*!
- * @brief multiply two vector (component-wise multiplication)
+ * @brief multiply two vectors (component-wise multiplication)
  *
  * @param a    vector1
  * @param b    vector2
@@ -634,7 +635,7 @@ glm_vec4_muladds(vec4 a, float s, vec4 dest) {
 }
 
 /*!
- * @brief add max of two vector to result/dest
+ * @brief add max of two vectors to result/dest
  *
  * it applies += operator so dest must be initialized
  *
@@ -666,7 +667,7 @@ glm_vec4_maxadd(vec4 a, vec4 b, vec4 dest) {
 }
 
 /*!
- * @brief add min of two vector to result/dest
+ * @brief add min of two vectors to result/dest
  *
  * it applies += operator so dest must be initialized
  *
@@ -1133,4 +1134,17 @@ glm_vec4_swizzle(vec4 v, int mask, vec4 dest) {
   glm_vec4_copy(t, dest);
 }
 
+/*!
+ * @brief Create four dimensional vector from pointer
+ *
+ * @param[in]  src  pointer to an array of floats
+ * @param[out] dest destination vector
+ */
+CGLM_INLINE
+void
+glm_vec4_make(float * __restrict src, vec4 dest) {
+  dest[0] = src[0]; dest[1] = src[1];
+  dest[2] = src[2]; dest[3] = src[3];
+}
+
 #endif /* cglm_vec4_h */

meson.build

@@ -3,7 +3,6 @@ project('cglm', 'c',
     license : 'mit',
     default_options : [
         'c_std=c11',
-        'werror=true',
         'warning_level=2',
         'buildtype=release'
     ]
@@ -18,11 +17,19 @@ cglm_args = []
 build_args = []
 
 if get_option('default_library') == 'static'
-    cglm_args = '-DCGLM_STATIC'
+    cglm_args += '-DCGLM_STATIC'
+endif
+
+if cc.compiles(
+    'int *test(char *p) { return (int*)__builtin_assume_aligned(p, 4); }',
+    name : '__builtin_assume_aligned test')
+    cglm_args += '-DCGLM_HAVE_BUILTIN_ASSUME_ALIGNED=1'
+else
+    cglm_args += '-DCGLM_HAVE_BUILTIN_ASSUME_ALIGNED=0'
 endif
 
 if host_machine.system() == 'windows'
-    build_args = '-DCGLM_EXPORTS'
+    build_args += '-DCGLM_EXPORTS'
 endif
 
 cglm_inc = include_directories('include')
@@ -40,8 +47,14 @@ cglm_src = files(
     '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',

src/mat2x3.c

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "../include/cglm/cglm.h"
+#include "../include/cglm/call.h"
+
+CGLM_EXPORT
+void
+glmc_mat2x3_copy(mat2x3 mat, mat2x3 dest) {
+  glm_mat2x3_copy(mat, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2x3_zero(mat2x3 mat) {
+  glm_mat2x3_zero(mat);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2x3_make(float * __restrict src, mat2x3 dest) {
+  glm_mat2x3_make(src, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat2 dest) {
+  glm_mat2x3_mul(m1, m2, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2x3_mulv(mat2x3 m, vec3 v, vec2 dest) {
+  glm_mat2x3_mulv(m, v, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2x3_transpose(mat2x3 m, mat3x2 dest) {
+  glm_mat2x3_transpose(m, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2x3_scale(mat2x3 m, float s) {
+  glm_mat2x3_scale(m, s);
+}

src/mat2x4.c

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "../include/cglm/cglm.h"
+#include "../include/cglm/call.h"
+
+CGLM_EXPORT
+void
+glmc_mat2x4_copy(mat2x4 mat, mat2x4 dest) {
+  glm_mat2x4_copy(mat, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2x4_zero(mat2x4 mat) {
+  glm_mat2x4_zero(mat);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2x4_make(float * __restrict src, mat2x4 dest) {
+  glm_mat2x4_make(src, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat2 dest) {
+  glm_mat2x4_mul(m1, m2, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2x4_mulv(mat2x4 m, vec4 v, vec2 dest) {
+  glm_mat2x4_mulv(m, v, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2x4_transpose(mat2x4 m, mat4x2 dest) {
+  glm_mat2x4_transpose(m, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2x4_scale(mat2x4 m, float s) {
+  glm_mat2x4_scale(m, s);
+}

src/mat3x2.c

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "../include/cglm/cglm.h"
+#include "../include/cglm/call.h"
+
+CGLM_EXPORT
+void
+glmc_mat3x2_copy(mat3x2 mat, mat3x2 dest) {
+  glm_mat3x2_copy(mat, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat3x2_zero(mat3x2 mat) {
+  glm_mat3x2_zero(mat);
+}
+
+CGLM_EXPORT
+void
+glmc_mat3x2_make(float * __restrict src, mat3x2 dest) {
+  glm_mat3x2_make(src, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat3 dest) {
+  glm_mat3x2_mul(m1, m2, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat3x2_mulv(mat3x2 m, vec2 v, vec3 dest) {
+  glm_mat3x2_mulv(m, v, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat3x2_transpose(mat3x2 m, mat2x3 dest) {
+  glm_mat3x2_transpose(m, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat3x2_scale(mat3x2 m, float s) {
+  glm_mat3x2_scale(m, s);
+}

src/mat3x4.c

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "../include/cglm/cglm.h"
+#include "../include/cglm/call.h"
+
+CGLM_EXPORT
+void
+glmc_mat3x4_copy(mat3x4 mat, mat3x4 dest) {
+  glm_mat3x4_copy(mat, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat3x4_zero(mat3x4 mat) {
+  glm_mat3x4_zero(mat);
+}
+
+CGLM_EXPORT
+void
+glmc_mat3x4_make(float * __restrict src, mat3x4 dest) {
+  glm_mat3x4_make(src, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat3x4_mul(mat3x4 m1, mat4x3 m2, mat3 dest) {
+  glm_mat3x4_mul(m1, m2, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat3x4_mulv(mat3x4 m, vec4 v, vec3 dest) {
+  glm_mat3x4_mulv(m, v, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat3x4_transpose(mat3x4 m, mat4x3 dest) {
+  glm_mat3x4_transpose(m, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat3x4_scale(mat3x4 m, float s) {
+  glm_mat3x4_scale(m, s);
+}

src/mat4x2.c

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "../include/cglm/cglm.h"
+#include "../include/cglm/call.h"
+
+CGLM_EXPORT
+void
+glmc_mat4x2_copy(mat4x2 mat, mat4x2 dest) {
+  glm_mat4x2_copy(mat, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat4x2_zero(mat4x2 mat) {
+  glm_mat4x2_zero(mat);
+}
+
+CGLM_EXPORT
+void
+glmc_mat4x2_make(float * __restrict src, mat4x2 dest) {
+  glm_mat4x2_make(src, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat4 dest) {
+  glm_mat4x2_mul(m1, m2, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat4x2_mulv(mat4x2 m, vec2 v, vec4 dest) {
+  glm_mat4x2_mulv(m, v, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat4x2_transpose(mat4x2 m, mat2x4 dest) {
+  glm_mat4x2_transpose(m, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat4x2_scale(mat4x2 m, float s) {
+  glm_mat4x2_scale(m, s);
+}

src/mat4x3.c

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "../include/cglm/cglm.h"
+#include "../include/cglm/call.h"
+
+CGLM_EXPORT
+void
+glmc_mat4x3_copy(mat4x3 mat, mat4x3 dest) {
+  glm_mat4x3_copy(mat, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat4x3_zero(mat4x3 mat) {
+  glm_mat4x3_zero(mat);
+}
+
+CGLM_EXPORT
+void
+glmc_mat4x3_make(float * __restrict src, mat4x3 dest) {
+  glm_mat4x3_make(src, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat4x3_mul(mat4x3 m1, mat3x4 m2, mat4 dest) {
+  glm_mat4x3_mul(m1, m2, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat4x3_mulv(mat4x3 m, vec3 v, vec4 dest) {
+  glm_mat4x3_mulv(m, v, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat4x3_transpose(mat4x3 m, mat3x4 dest) {
+  glm_mat4x3_transpose(m, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat4x3_scale(mat4x3 m, float s) {
+  glm_mat4x3_scale(m, s);
+}

src/quat.c

@@ -229,3 +229,9 @@ void
 glmc_quat_rotate_atm(mat4 m, versor q, vec3 pivot) {
   glm_quat_rotate_atm(m, q, pivot);
 }
+
+CGLM_EXPORT
+void
+glmc_quat_make(float * __restrict src, versor dest) {
+  glm_quat_make(src, dest);
+}

src/vec2.c

@@ -235,3 +235,9 @@ void
 glmc_vec2_complex_conjugate(vec2 a, vec2 dest) {
   glm_vec2_complex_conjugate(a, dest);
 }
+
+CGLM_EXPORT
+void
+glmc_vec2_make(float * __restrict src, vec2 dest) {
+  glm_vec2_make(src, dest);
+}

src/vec3.c

@@ -417,3 +417,9 @@ void
 glmc_vec3_sqrt(vec3 v, vec3 dest) {
   glm_vec3_sqrt(v, dest);
 }
+
+CGLM_EXPORT
+void
+glmc_vec3_make(float * __restrict src, vec3 dest) {
+  glm_vec3_make(src, dest);
+}

src/vec4.c

@@ -381,3 +381,9 @@ void
 glmc_vec4_sqrt(vec4 v, vec4 dest) {
   glm_vec4_sqrt(v, dest);
 }
+
+CGLM_EXPORT
+void
+glmc_vec4_make(float * __restrict src, vec4 dest) {
+  glm_vec4_make(src, dest);
+}

test/src/test_common.c

@@ -22,6 +22,40 @@ test_rand_mat4(mat4 dest) {
   /* glm_scale(dest, (vec3){drand48(), drand48(), drand48()}); */
 }
 
+void
+test_rand_mat4x2(mat4x2 dest) {
+  dest[0][0] = drand48();
+  dest[0][1] = drand48();
+
+  dest[1][0] = drand48();
+  dest[1][1] = drand48();
+
+  dest[2][0] = drand48();
+  dest[2][1] = drand48();
+
+  dest[3][0] = drand48();
+  dest[3][1] = drand48();
+}
+
+void
+test_rand_mat4x3(mat4x3 dest) {
+  dest[0][0] = drand48();
+  dest[0][1] = drand48();
+  dest[0][2] = drand48();
+
+  dest[1][0] = drand48();
+  dest[1][1] = drand48();
+  dest[1][2] = drand48();
+
+  dest[2][0] = drand48();
+  dest[2][1] = drand48();
+  dest[2][2] = drand48();
+
+  dest[3][0] = drand48();
+  dest[3][1] = drand48();
+  dest[3][2] = drand48();
+}
+
 void
 test_rand_mat3(mat3 dest) {
   mat4 m4;
@@ -31,6 +65,34 @@ test_rand_mat3(mat3 dest) {
   glm_mat4_pick3(m4, dest);
 }
 
+void
+test_rand_mat3x2(mat3x2 dest) {
+  dest[0][0] = drand48();
+  dest[0][1] = drand48();
+  dest[1][0] = drand48();
+  dest[1][1] = drand48();
+  dest[2][0] = drand48();
+  dest[2][1] = drand48();
+}
+
+void
+test_rand_mat3x4(mat3x4 dest) {
+  dest[0][0] = drand48();
+  dest[0][1] = drand48();
+  dest[0][2] = drand48();
+  dest[0][3] = drand48();
+
+  dest[1][0] = drand48();
+  dest[1][1] = drand48();
+  dest[1][2] = drand48();
+  dest[1][3] = drand48();
+
+  dest[2][0] = drand48();
+  dest[2][1] = drand48();
+  dest[2][2] = drand48();
+  dest[2][3] = drand48();
+}
+
 void
 test_rand_mat2(mat2 dest) {
   dest[0][0] = drand48();
@@ -39,6 +101,28 @@ test_rand_mat2(mat2 dest) {
   dest[1][1] = drand48();
 }
 
+void
+test_rand_mat2x3(mat2x3 dest) {
+  dest[0][0] = drand48();
+  dest[0][1] = drand48();
+  dest[0][2] = drand48();
+  dest[1][0] = drand48();
+  dest[1][1] = drand48();
+  dest[1][2] = drand48();
+}
+
+void
+test_rand_mat2x4(mat2x4 dest) {
+  dest[0][0] = drand48();
+  dest[0][1] = drand48();
+  dest[0][2] = drand48();
+  dest[0][3] = drand48();
+  dest[1][0] = drand48();
+  dest[1][1] = drand48();
+  dest[1][2] = drand48();
+  dest[1][3] = drand48();
+}
+
 void
 test_rand_vec3(vec3 dest) {
   dest[0] = drand48();
@@ -174,6 +258,58 @@ test_assert_mat2_eq_zero(mat2 m2) {
   TEST_SUCCESS
 }
 
+test_status_t
+test_assert_mat2x3_eq_zero(mat2x3 m2x3) {
+  int i, j;
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 3; j++) {
+      ASSERT(test_eq(m2x3[i][j], 0.0f))
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat2x3_eq(mat2x3 m1, mat2x3 m2) {
+  int i, j;
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 3; j++) {
+      ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009)
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat2x4_eq_zero(mat2x4 m2x4) {
+  int i, j;
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 4; j++) {
+      ASSERT(test_eq(m2x4[i][j], 0.0f))
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat2x4_eq(mat2x4 m1, mat2x4 m2) {
+  int i, j;
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 4; j++) {
+      ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009)
+    }
+  }
+
+  TEST_SUCCESS
+}
+
 test_status_t
 test_assert_mat3_eq(mat3 m1, mat3 m2) {
   int i, j;
@@ -230,6 +366,58 @@ test_assert_mat3_eq_zero(mat3 m3) {
   TEST_SUCCESS
 }
 
+test_status_t
+test_assert_mat3x2_eq_zero(mat3x2 m3x2) {
+  int i, j;
+
+  for (i = 0; i < 3; i++) {
+    for (j = 0; j < 2; j++) {
+      ASSERT(test_eq(m3x2[i][j], 0.0f))
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat3x2_eq(mat3x2 m1, mat3x2 m2) {
+  int i, j;
+
+  for (i = 0; i < 3; i++) {
+    for (j = 0; j < 2; j++) {
+      ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009)
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat3x4_eq_zero(mat3x4 m3x4) {
+  int i, j;
+
+  for (i = 0; i < 3; i++) {
+    for (j = 0; j < 4; j++) {
+      ASSERT(test_eq(m3x4[i][j], 0.0f))
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat3x4_eq(mat3x4 m1, mat3x4 m2) {
+  int i, j;
+
+  for (i = 0; i < 3; i++) {
+    for (j = 0; j < 4; j++) {
+      ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009)
+    }
+  }
+
+  TEST_SUCCESS
+}
+
 test_status_t
 test_assert_mat4_eq_identity(mat4 m4) {
   int i, j;
@@ -260,6 +448,58 @@ test_assert_mat4_eq_zero(mat4 m4) {
   TEST_SUCCESS
 }
 
+test_status_t
+test_assert_mat4x2_eq_zero(mat4x2 m4x2) {
+  int i, j;
+
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 2; j++) {
+      ASSERT(test_eq(m4x2[i][j], 0.0f))
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat4x2_eq(mat4x2 m1, mat4x2 m2) {
+  int i, j;
+
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 2; j++) {
+      ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009)
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat4x3_eq_zero(mat4x3 m4x3) {
+  int i, j;
+
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 3; j++) {
+      ASSERT(test_eq(m4x3[i][j], 0.0f))
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat4x3_eq(mat4x3 m1, mat4x3 m2) {
+  int i, j;
+
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 3; j++) {
+      ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009)
+    }
+  }
+
+  TEST_SUCCESS
+}
+
 test_status_t
 test_assert_eqf(float a, float b) {
   ASSERT(fabsf(a - b) <= 0.000009); /* rounding errors */

test/src/test_common.h

@@ -17,12 +17,30 @@
 void
 test_rand_mat4(mat4 dest);
 
+void
+test_rand_mat4x2(mat4x2 dest);
+
+void
+test_rand_mat4x3(mat4x3 dest);
+
 void
 test_rand_mat3(mat3 dest);
 
+void
+test_rand_mat3x2(mat3x2 dest);
+
+void
+test_rand_mat3x4(mat3x4 dest);
+
 void
 test_rand_mat2(mat2 dest);
 
+void
+test_rand_mat2x3(mat2x3 dest);
+
+void
+test_rand_mat2x4(mat2x4 dest);
+
 test_status_t
 test_assert_eqf(float a, float b);
 
@@ -41,6 +59,18 @@ test_assert_mat4_eq_identity(mat4 m4);
 test_status_t
 test_assert_mat4_eq_zero(mat4 m4);
 
+test_status_t
+test_assert_mat4x2_eq_zero(mat4x2 m4x2);
+
+test_status_t
+test_assert_mat4x2_eq(mat4x2 m1, mat4x2 m2);
+
+test_status_t
+test_assert_mat4x3_eq_zero(mat4x3 m4x3);
+
+test_status_t
+test_assert_mat4x3_eq(mat4x3 m1, mat4x3 m2);
+
 test_status_t
 test_assert_mat2_eqt(mat2 m1, mat2 m2);
 
@@ -53,6 +83,18 @@ test_assert_mat2_eq_identity(mat2 m2);
 test_status_t
 test_assert_mat2_eq_zero(mat2 m2);
 
+test_status_t
+test_assert_mat2x3_eq_zero(mat2x3 m2x3);
+
+test_status_t
+test_assert_mat2x3_eq(mat2x3 m1, mat2x3 m2);
+
+test_status_t
+test_assert_mat2x4_eq_zero(mat2x4 m2x4);
+
+test_status_t
+test_assert_mat2x4_eq(mat2x4 m1, mat2x4 m2);
+
 test_status_t
 test_assert_mat3_eq(mat3 m1, mat3 m2);
 
@@ -68,6 +110,18 @@ test_assert_mat3_eq_identity(mat3 m3);
 test_status_t
 test_assert_mat3_eq_zero(mat3 m3);
 
+test_status_t
+test_assert_mat3x2_eq_zero(mat3x2 m3x2);
+
+test_status_t
+test_assert_mat3x2_eq(mat3x2 m1, mat3x2 m2);
+
+test_status_t
+test_assert_mat3x4_eq_zero(mat3x4 m3x4);
+
+test_status_t
+test_assert_mat3x4_eq(mat3x4 m1, mat3x4 m2);
+
 test_status_t
 test_assert_vec3_eq(vec3 v1, vec3 v2);
 

test/src/test_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
+ */
+
+#include "test_common.h"
+
+#define A_MATRIX2X3 {{1,2,3},{5,6,7}}
+#define A_MATRIX2X3_TRANSPOSE {{1,5}, {2,6}, {3,7}}
+
+#ifndef CGLM_TEST_MAT2X3_ONCE
+#define CGLM_TEST_MAT2X3_ONCE
+
+TEST_IMPL(MACRO_GLM_MAT2X3_ZERO_INIT) {
+  mat2x3 mat2x3_zero   = GLM_MAT2X3_ZERO_INIT;
+  test_assert_mat2x3_eq_zero(mat2x3_zero);
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_MAT2X3_ZERO) {
+  mat2x3 mat2x3_zero   = GLM_MAT2X3_ZERO;
+  test_assert_mat2x3_eq_zero(mat2x3_zero);
+  TEST_SUCCESS
+}
+
+#endif /* CGLM_TEST_MAT2X3_ONCE */
+
+TEST_IMPL(GLM_PREFIX, mat2x3_copy) {
+  mat2x3 m1 = A_MATRIX2X3;
+  mat2x3 m2 = GLM_MAT2X3_ZERO_INIT;
+
+  GLM(mat2x3_copy)(m1, m2);
+
+  test_assert_mat2x3_eq(m1, m2);
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2x3_zero) {
+  mat2x3 m1 = GLM_MAT2X3_ZERO_INIT;
+  mat2x3 m2 = GLM_MAT2X3_ZERO_INIT;
+  mat2x3 m3;
+
+  GLM(mat2x3_zero)(m3);
+
+  ASSERTIFY(test_assert_mat2x3_eq_zero(m1))
+  ASSERTIFY(test_assert_mat2x3_eq_zero(m2))
+  ASSERTIFY(test_assert_mat2x3_eq_zero(m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2x3_make) {
+  float src[18] = {
+    0.5f, 1.7f, 10.3f, 4.2f, 8.9f, 1.1f,
+    2.3f, 4.2f, 66.5f, 23.7f, 6.6f, 8.9f,
+    5.3f, 4.8f, 96.3f, 13.7f, 4.7f, 5.5f
+  };
+
+  mat2x3 dest[3];
+
+  float *srcp = src;
+  unsigned int i, j, k;
+
+  for (i = 0, j = 0, k = 0; i < sizeof(src) / sizeof(float); i+=6,j++) {
+    GLM(mat2x3_make)(srcp + i, dest[j]);
+
+    ASSERT(test_eq(src[ i ], dest[j][k][0]));
+    ASSERT(test_eq(src[i+1], dest[j][k][1]));
+    ASSERT(test_eq(src[i+2], dest[j][k][2]));
+
+    ASSERT(test_eq(src[i+3], dest[j][k+1][0]));
+    ASSERT(test_eq(src[i+4], dest[j][k+1][1]));
+    ASSERT(test_eq(src[i+5], dest[j][k+1][2]));
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2x3_mul) {
+  mat2x3 m1 = GLM_MAT2X3_ZERO_INIT;
+  mat3x2 m2 = GLM_MAT3X2_ZERO_INIT;
+
+  mat2 m3 = GLM_MAT2_ZERO_INIT;
+  mat2 m4 = GLM_MAT2_ZERO_INIT;
+
+  int i, j, k;
+
+  /* test random matrices */
+  /* random matrices */
+  test_rand_mat2x3(m1);
+  test_rand_mat3x2(m2);
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 2; j++) {
+      for (k = 0; k < 3; k++) {
+        m4[i][j] += m1[i][k] * m2[k][j];
+      }
+    }
+  }
+
+  GLM(mat2x3_mul)(m1, m2, m3);
+  ASSERTIFY(test_assert_mat2_eq(m3, m4))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2x3_mulv) {
+  mat2x3 mat = A_MATRIX2X3;
+  vec3 v = {11.0f, 21.0f, 31.0f};
+
+  int  i;
+  vec2 dest;
+  float res = 0.0;
+
+  GLM(mat2x3_mulv)(mat, v, dest);
+
+  for (i = 0; i < 2; i++) {
+    res = mat[i][0] * v[0] + mat[i][1] * v[1] + mat[i][2] * v[2];
+    ASSERT(test_eq(dest[i], res))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2x3_transpose) {
+  mat2x3 m1 = A_MATRIX2X3;
+
+  mat3x2 m2;
+  mat3x2 m3 = A_MATRIX2X3_TRANSPOSE;
+  GLM(mat2x3_transpose)(m1, m2);
+
+  ASSERTIFY(test_assert_mat3x2_eq(m2, m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2x3_scale) {
+  mat2x3 m1 = A_MATRIX2X3;
+  mat2x3 m2 = A_MATRIX2X3;
+  int i, j, scale;
+
+  scale = rand() % 100;
+
+  GLM(mat2x3_scale)(m1, (float) scale);
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 3; j++) {
+      ASSERT(test_eq(m1[i][j], m2[i][j] * scale))
+    }
+  }
+
+  TEST_SUCCESS
+}

test/src/test_mat2x4.h

@@ -0,0 +1,159 @@
+
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "test_common.h"
+
+#define A_MATRIX2X4 {{1,2,3,4},{5,6,7,8}}
+#define A_MATRIX2X4_TRANSPOSE {{1,5}, {2,6}, {3,7}, {4,8}}
+
+#ifndef CGLM_TEST_MAT2X4_ONCE
+#define CGLM_TEST_MAT2X4_ONCE
+
+TEST_IMPL(MACRO_GLM_MAT2X4_ZERO_INIT) {
+  mat2x4 mat2x4_zero = GLM_MAT2X4_ZERO_INIT;
+  test_assert_mat2x4_eq_zero(mat2x4_zero);
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_MAT2X4_ZERO) {
+  mat2x4 mat2x4_zero = GLM_MAT2X4_ZERO;
+  test_assert_mat2x4_eq_zero(mat2x4_zero);
+  TEST_SUCCESS
+}
+
+#endif /* CGLM_TEST_MAT2X4_ONCE */
+
+TEST_IMPL(GLM_PREFIX, mat2x4_copy) {
+  mat2x4 m1 = A_MATRIX2X4;
+  mat2x4 m2 = GLM_MAT2X4_ZERO_INIT;
+
+  GLM(mat2x4_copy)(m1, m2);
+
+  test_assert_mat2x4_eq(m1, m2);
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2x4_zero) {
+  mat2x4 m1 = GLM_MAT2X4_ZERO_INIT;
+  mat2x4 m2 = GLM_MAT2X4_ZERO_INIT;
+  mat2x4 m3;
+
+  GLM(mat2x4_zero)(m3);
+
+  ASSERTIFY(test_assert_mat2x4_eq_zero(m1))
+  ASSERTIFY(test_assert_mat2x4_eq_zero(m2))
+  ASSERTIFY(test_assert_mat2x4_eq_zero(m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2x4_make) {
+  float src[24] = {
+    0.5f, 1.7f, 10.3f, 4.2f, 8.9f, 1.1f, 77.3f, 88.4f,
+    2.3f, 4.2f, 66.5f, 23.7f, 6.6f, 8.9f, 90.3f, 34.2f,
+    5.3f, 4.8f, 96.3f, 13.7f, 4.7f, 5.5f, 22.9f, 5.5f
+  };
+
+  mat2x4 dest[3];
+
+  float *srcp = src;
+  unsigned int i, j, k;
+
+  for (i = 0, j = 0, k = 0; i < sizeof(src) / sizeof(float); i+=8,j++) {
+    GLM(mat2x4_make)(srcp + i, dest[j]);
+
+    ASSERT(test_eq(src[ i ], dest[j][k][0]));
+    ASSERT(test_eq(src[i+1], dest[j][k][1]));
+    ASSERT(test_eq(src[i+2], dest[j][k][2]));
+    ASSERT(test_eq(src[i+3], dest[j][k][3]));
+
+    ASSERT(test_eq(src[i+4], dest[j][k+1][0]));
+    ASSERT(test_eq(src[i+5], dest[j][k+1][1]));
+    ASSERT(test_eq(src[i+6], dest[j][k+1][2]));
+    ASSERT(test_eq(src[i+7], dest[j][k+1][3]));
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2x4_mul) {
+  mat2x4 m1 = GLM_MAT2X4_ZERO_INIT;
+  mat4x2 m2 = GLM_MAT4X2_ZERO_INIT;
+
+  mat2 m3 = GLM_MAT2_ZERO_INIT;
+  mat2 m4 = GLM_MAT2_ZERO_INIT;
+
+  int i, j, k;
+
+  /* test random matrices */
+  /* random matrices */
+  test_rand_mat2x4(m1);
+  test_rand_mat4x2(m2);
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 2; j++) {
+      for (k = 0; k < 4; k++) {
+        m4[i][j] += m1[i][k] * m2[k][j];
+      }
+    }
+  }
+
+  GLM(mat2x4_mul)(m1, m2, m3);
+  ASSERTIFY(test_assert_mat2_eq(m3, m4))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2x4_mulv) {
+  mat2x4 mat = A_MATRIX2X4;
+  vec4 v = {11.0f, 21.0f, 31.0f, 41.0f};
+
+  int  i;
+  vec2 dest;
+  float res = 0.0;
+
+  GLM(mat2x4_mulv)(mat, v, dest);
+
+  for (i = 0; i < 2; i++) {
+    res = mat[i][0] * v[0] + mat[i][1] * v[1] + mat[i][2] * v[2] + mat[i][3] * v[3];
+    ASSERT(test_eq(dest[i], res))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2x4_transpose) {
+  mat2x4 m1 = A_MATRIX2X4;
+
+  mat4x2 m2;
+  mat4x2 m3 = A_MATRIX2X4_TRANSPOSE;
+  GLM(mat2x4_transpose)(m1, m2);
+
+  ASSERTIFY(test_assert_mat4x2_eq(m2, m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2x4_scale) {
+  mat2x4 m1 = A_MATRIX2X4;
+  mat2x4 m2 = A_MATRIX2X4;
+  int i, j, scale;
+
+  scale = rand() % 100;
+
+  GLM(mat2x4_scale)(m1, (float) scale);
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 4; j++) {
+      ASSERT(test_eq(m1[i][j], m2[i][j] * scale))
+    }
+  }
+
+  TEST_SUCCESS
+}

test/src/test_mat3x2.h

@@ -0,0 +1,155 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "test_common.h"
+
+#define A_MATRIX3X2 {{1,2},{5,6},{3,7}}
+#define A_MATRIX3X2_TRANSPOSE {{1,5,3}, {2,6,7}}
+
+#ifndef CGLM_TEST_MAT3X2_ONCE
+#define CGLM_TEST_MAT3X2_ONCE
+
+TEST_IMPL(MACRO_GLM_MAT3X2_ZERO_INIT) {
+  mat3x2 mat3x2_zero = GLM_MAT3X2_ZERO_INIT;
+  test_assert_mat3x2_eq_zero(mat3x2_zero);
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_MAT3X2_ZERO) {
+  mat3x2 mat3x2_zero = GLM_MAT3X2_ZERO;
+  test_assert_mat3x2_eq_zero(mat3x2_zero);
+  TEST_SUCCESS
+}
+
+#endif /* CGLM_TEST_MAT3X2_ONCE */
+
+TEST_IMPL(GLM_PREFIX, mat3x2_copy) {
+  mat3x2 m1 = A_MATRIX3X2;
+  mat3x2 m2 = GLM_MAT3X2_ZERO_INIT;
+
+  GLM(mat3x2_copy)(m1, m2);
+
+  test_assert_mat3x2_eq(m1, m2);
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3x2_zero) {
+  mat3x2 m1 = GLM_MAT3X2_ZERO_INIT;
+  mat3x2 m2 = GLM_MAT3X2_ZERO_INIT;
+  mat3x2 m3;
+
+  GLM(mat3x2_zero)(m3);
+
+  ASSERTIFY(test_assert_mat3x2_eq_zero(m1))
+  ASSERTIFY(test_assert_mat3x2_eq_zero(m2))
+  ASSERTIFY(test_assert_mat3x2_eq_zero(m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3x2_make) {
+  float src[18] = {
+    0.5f, 1.7f, 10.3f, 4.2f, 8.9f, 1.1f,
+    2.3f, 4.2f, 66.5f, 23.7f, 6.6f, 8.9f,
+    5.3f, 4.8f, 96.3f, 13.7f, 4.7f, 5.5f
+  };
+
+  mat3x2 dest[3];
+
+  float *srcp = src;
+  unsigned int i, j, k;
+
+  for (i = 0, j = 0, k = 0; i < sizeof(src) / sizeof(float); i+=6,j++) {
+    GLM(mat3x2_make)(srcp + i, dest[j]);
+
+    ASSERT(test_eq(src[ i ], dest[j][k][0]));
+    ASSERT(test_eq(src[i+1], dest[j][k][1]));
+
+    ASSERT(test_eq(src[i+2], dest[j][k+1][0]));
+    ASSERT(test_eq(src[i+3], dest[j][k+1][1]));
+
+    ASSERT(test_eq(src[i+4], dest[j][k+2][0]));
+    ASSERT(test_eq(src[i+5], dest[j][k+2][1]));
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3x2_mul) {
+  mat3x2 m1 = GLM_MAT3X2_ZERO_INIT;
+  mat2x3 m2 = GLM_MAT2X3_ZERO_INIT;
+
+  mat3 m3 = GLM_MAT3_ZERO_INIT;
+  mat3 m4 = GLM_MAT3_ZERO_INIT;
+
+  int i, j, k;
+
+  test_rand_mat3x2(m1);
+  test_rand_mat2x3(m2);
+
+  for (i = 0; i < 3; i++) {
+    for (j = 0; j < 3; j++) {
+      for (k = 0; k < 2; k++) {
+        m4[i][j] += m1[i][k] * m2[k][j];
+      }
+    }
+  }
+
+  GLM(mat3x2_mul)(m1, m2, m3);
+  ASSERTIFY(test_assert_mat3_eq(m3, m4))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3x2_mulv) {
+  mat3x2 mat = A_MATRIX3X2;
+  vec2 v = {11.0f, 21.0f};
+
+  int  i;
+  vec3 dest;
+  float res = 0.0;
+
+  GLM(mat3x2_mulv)(mat, v, dest);
+
+  for (i = 0; i < 3; i++) {
+    res = mat[i][0] * v[0] + mat[i][1] * v[1];
+    ASSERT(test_eq(dest[i], res))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3x2_transpose) {
+  mat3x2 m1 = A_MATRIX3X2;
+
+  mat2x3 m2;
+  mat2x3 m3 = A_MATRIX3X2_TRANSPOSE;
+  GLM(mat3x2_transpose)(m1, m2);
+
+  ASSERTIFY(test_assert_mat2x3_eq(m2, m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3x2_scale) {
+  mat3x2 m1 = A_MATRIX3X2;
+  mat3x2 m2 = A_MATRIX3X2;
+  int i, j, scale;
+
+  scale = rand() % 100;
+
+  GLM(mat3x2_scale)(m1, (float) scale);
+
+  for (i = 0; i < 3; i++) {
+    for (j = 0; j < 2; j++) {
+      ASSERT(test_eq(m1[i][j], m2[i][j] * scale))
+    }
+  }
+
+  TEST_SUCCESS
+}

test/src/test_mat3x4.h

@@ -0,0 +1,161 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "test_common.h"
+
+#define A_MATRIX3X4 {{1,2,4,5},{6,7,8,9},{10,11,12,13}}
+#define A_MATRIX3X4_TRANSPOSE {{1,6,10}, {2,7,1}, {4,8,12}, {5,9,13}}
+
+#ifndef CGLM_TEST_MAT3X4_ONCE
+#define CGLM_TEST_MAT3X4_ONCE
+
+TEST_IMPL(MACRO_GLM_MAT3X4_ZERO_INIT) {
+  mat3x4 mat3x4_zero = GLM_MAT3X4_ZERO_INIT;
+  test_assert_mat3x4_eq_zero(mat3x4_zero);
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_MAT3X4_ZERO) {
+  mat3x4 mat3x4_zero = GLM_MAT3X4_ZERO;
+  test_assert_mat3x4_eq_zero(mat3x4_zero);
+  TEST_SUCCESS
+}
+
+#endif /* CGLM_TEST_MAT3X4_ONCE */
+
+TEST_IMPL(GLM_PREFIX, mat3x4_copy) {
+  mat3x4 m1 = A_MATRIX3X4;
+  mat3x4 m2 = GLM_MAT3X4_ZERO_INIT;
+
+  GLM(mat3x4_copy)(m1, m2);
+
+  test_assert_mat3x4_eq(m1, m2);
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3x4_zero) {
+  mat3x4 m1 = GLM_MAT3X4_ZERO_INIT;
+  mat3x4 m2 = GLM_MAT3X4_ZERO_INIT;
+  mat3x4 m3;
+
+  GLM(mat3x4_zero)(m3);
+
+  ASSERTIFY(test_assert_mat3x4_eq_zero(m1))
+  ASSERTIFY(test_assert_mat3x4_eq_zero(m2))
+  ASSERTIFY(test_assert_mat3x4_eq_zero(m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3x4_make) {
+  float src[36] = {
+    0.5f, 1.7f, 10.3f, 4.2f, 8.9f, 1.1f, 2.3f, 4.2f, 66.5f, 23.7f, 6.6f, 8.9f,
+    2.3f, 4.2f, 66.5f, 23.7f, 6.6f, 8.9f, 0.5f, 1.7f, 10.3f, 4.2f, 8.9f, 1.1f,
+    5.3f, 4.8f, 96.3f, 13.7f, 4.7f, 5.5f, 2.3f, 4.2f, 66.5f, 23.7f, 6.6f, 8.9f
+  };
+
+  mat3x4 dest[3];
+
+  float *srcp = src;
+  unsigned int i, j, k;
+
+  for (i = 0, j = 0, k = 0; i < sizeof(src) / sizeof(float); i+=12,j++) {
+    GLM(mat3x4_make)(srcp + i, dest[j]);
+
+    ASSERT(test_eq(src[ i ], dest[j][k][0]));
+    ASSERT(test_eq(src[i+1], dest[j][k][1]));
+    ASSERT(test_eq(src[i+2], dest[j][k][2]));
+    ASSERT(test_eq(src[i+3], dest[j][k][3]));
+
+    ASSERT(test_eq(src[i+4], dest[j][k+1][0]));
+    ASSERT(test_eq(src[i+5], dest[j][k+1][1]));
+    ASSERT(test_eq(src[i+6], dest[j][k+1][2]));
+    ASSERT(test_eq(src[i+7], dest[j][k+1][3]));
+
+    ASSERT(test_eq(src[i+8], dest[j][k+2][0]));
+    ASSERT(test_eq(src[i+9], dest[j][k+2][1]));
+    ASSERT(test_eq(src[i+10], dest[j][k+2][2]));
+    ASSERT(test_eq(src[i+11], dest[j][k+2][3]));
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3x4_mul) {
+  mat3x4 m1 = GLM_MAT3X4_ZERO_INIT;
+  mat4x3 m2 = GLM_MAT4X3_ZERO_INIT;
+
+  mat3 m3 = GLM_MAT3_ZERO_INIT;
+  mat3 m4 = GLM_MAT3_ZERO_INIT;
+
+  int i, j, k;
+
+  test_rand_mat3x4(m1);
+  test_rand_mat4x3(m2);
+
+  for (i = 0; i < 3; i++) {
+    for (j = 0; j < 3; j++) {
+      for (k = 0; k < 4; k++) {
+        m4[i][j] += m1[i][k] * m2[k][j];
+      }
+    }
+  }
+
+  GLM(mat3x4_mul)(m1, m2, m3);
+  ASSERTIFY(test_assert_mat3_eq(m3, m4))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3x4_mulv) {
+  mat3x4 mat = A_MATRIX3X4;
+  vec4 v = {11.0f, 21.0f, 31.0f, 41.0f};
+
+  int  i;
+  vec3 dest;
+  float res = 0.0;
+
+  GLM(mat3x4_mulv)(mat, v, dest);
+
+  for (i = 0; i < 3; i++) {
+    res = mat[i][0] * v[0] + mat[i][1] * v[1] + mat[i][2] * v[2];
+    ASSERT(test_eq(dest[i], res))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3x4_transpose) {
+  mat3x4 m1 = A_MATRIX3X4;
+
+  mat4x3 m2;
+  mat4x3 m3 = A_MATRIX3X2_TRANSPOSE;
+  GLM(mat3x4_transpose)(m1, m2);
+
+  ASSERTIFY(test_assert_mat4x3_eq(m2, m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3x4_scale) {
+  mat3x4 m1 = A_MATRIX3X4;
+  mat3x4 m2 = A_MATRIX3X4;
+  int i, j, scale;
+
+  scale = rand() % 100;
+
+  GLM(mat3x4_scale)(m1, (float) scale);
+
+  for (i = 0; i < 3; i++) {
+    for (j = 0; j < 4; j++) {
+      ASSERT(test_eq(m1[i][j], m2[i][j] * scale))
+    }
+  }
+
+  TEST_SUCCESS
+}

test/src/test_mat4x2.h

@@ -0,0 +1,158 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "test_common.h"
+
+#define A_MATRIX4X2 {{1,2},{3,4},{5,6},{7,8}}
+#define A_MATRIX4X2_TRANSPOSE {{1,3,5,7}, {2,4,6,8}}
+
+#ifndef CGLM_TEST_MAT4X2_ONCE
+#define CGLM_TEST_MAT4X2_ONCE
+
+TEST_IMPL(MACRO_GLM_MAT4X2_ZERO_INIT) {
+  mat4x2 mat4x2_zero = GLM_MAT4X2_ZERO_INIT;
+  test_assert_mat4x2_eq_zero(mat4x2_zero);
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_MAT4X2_ZERO) {
+  mat4x2 mat4x2_zero = GLM_MAT4X2_ZERO;
+  test_assert_mat4x2_eq_zero(mat4x2_zero);
+  TEST_SUCCESS
+}
+
+#endif /* CGLM_TEST_MAT4X2_ONCE */
+
+TEST_IMPL(GLM_PREFIX, mat4x2_copy) {
+  mat4x2 m1 = A_MATRIX4X2;
+  mat4x2 m2 = GLM_MAT4X2_ZERO_INIT;
+
+  GLM(mat4x2_copy)(m1, m2);
+
+  test_assert_mat4x2_eq(m1, m2);
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4x2_zero) {
+  mat4x2 m1 = GLM_MAT4X2_ZERO_INIT;
+  mat4x2 m2 = GLM_MAT4X2_ZERO_INIT;
+  mat4x2 m3;
+
+  GLM(mat4x2_zero)(m3);
+
+  ASSERTIFY(test_assert_mat4x2_eq_zero(m1))
+  ASSERTIFY(test_assert_mat4x2_eq_zero(m2))
+  ASSERTIFY(test_assert_mat4x2_eq_zero(m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4x2_make) {
+  float src[24] = {
+    0.5f, 1.7f, 10.3f, 4.2f, 8.9f, 1.1f, 2.3f, 4.2f,
+    2.3f, 4.2f, 66.5f, 23.7f, 6.6f, 8.9f, 0.5f, 1.7f,
+    5.3f, 4.8f, 96.3f, 13.7f, 4.7f, 5.5f, 2.3f, 4.2f
+  };
+
+  mat4x2 dest[3];
+
+  float *srcp = src;
+  unsigned int i, j, k;
+
+  for (i = 0, j = 0, k = 0; i < sizeof(src) / sizeof(float); i+=8,j++) {
+    GLM(mat4x2_make)(srcp + i, dest[j]);
+
+    ASSERT(test_eq(src[ i ], dest[j][k][0]));
+    ASSERT(test_eq(src[i+1], dest[j][k][1]));
+
+    ASSERT(test_eq(src[i+2], dest[j][k+1][0]));
+    ASSERT(test_eq(src[i+3], dest[j][k+1][1]));
+
+    ASSERT(test_eq(src[i+4], dest[j][k+2][0]));
+    ASSERT(test_eq(src[i+5], dest[j][k+2][1]));
+
+    ASSERT(test_eq(src[i+6], dest[j][k+3][0]));
+    ASSERT(test_eq(src[i+7], dest[j][k+3][1]));
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4x2_mul) {
+  mat4x2 m1 = GLM_MAT4X2_ZERO_INIT;
+  mat2x4 m2 = GLM_MAT2X4_ZERO_INIT;
+
+  mat4 m3 = GLM_MAT4_ZERO_INIT;
+  mat4 m4 = GLM_MAT4_ZERO_INIT;
+
+  int i, j, k;
+
+  test_rand_mat4x2(m1);
+  test_rand_mat2x4(m2);
+
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 4; j++) {
+      for (k = 0; k < 2; k++) {
+        m4[i][j] += m1[i][k] * m2[k][j];
+      }
+    }
+  }
+
+  GLM(mat4x2_mul)(m1, m2, m3);
+  ASSERTIFY(test_assert_mat4_eq(m3, m4))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4x2_mulv) {
+  mat4x2 mat = A_MATRIX4X2;
+  vec2 v = {11.0f, 21.0f};
+
+  int  i;
+  vec4 dest;
+  float res = 0.0;
+
+  GLM(mat4x2_mulv)(mat, v, dest);
+
+  for (i = 0; i < 4; i++) {
+    res = mat[i][0] * v[0] + mat[i][1] * v[1];
+    ASSERT(test_eq(dest[i], res))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4x2_transpose) {
+  mat4x2 m1 = A_MATRIX4X2;
+
+  mat2x4 m2;
+  mat2x4 m3 = A_MATRIX4X2_TRANSPOSE;
+  GLM(mat4x2_transpose)(m1, m2);
+
+  ASSERTIFY(test_assert_mat2x4_eq(m2, m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4x2_scale) {
+  mat4x2 m1 = A_MATRIX4X2;
+  mat4x2 m2 = A_MATRIX4X2;
+  int i, j, scale;
+
+  scale = rand() % 100;
+
+  GLM(mat4x2_scale)(m1, (float) scale);
+
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 2; j++) {
+      ASSERT(test_eq(m1[i][j], m2[i][j] * scale))
+    }
+  }
+
+  TEST_SUCCESS
+}

test/src/test_mat4x3.h

@@ -0,0 +1,162 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "test_common.h"
+
+#define A_MATRIX4X3 {{1,2,3},{4,5,6},{7,8,9},{10,11,12}}
+#define A_MATRIX4X3_TRANSPOSE {{1,4,7,10},{2,5,8,11},{3,6,9,12}}
+
+#ifndef CGLM_TEST_MAT4X3_ONCE
+#define CGLM_TEST_MAT4X3_ONCE
+
+TEST_IMPL(MACRO_GLM_MAT4X3_ZERO_INIT) {
+  mat4x3 mat4x3_zero = GLM_MAT4X3_ZERO_INIT;
+  test_assert_mat4x3_eq_zero(mat4x3_zero);
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_MAT4X3_ZERO) {
+  mat4x3 mat4x3_zero = GLM_MAT4X3_ZERO;
+  test_assert_mat4x3_eq_zero(mat4x3_zero);
+  TEST_SUCCESS
+}
+
+#endif /* CGLM_TEST_MAT4X3_ONCE */
+
+TEST_IMPL(GLM_PREFIX, mat4x3_copy) {
+  mat4x3 m1 = A_MATRIX4X3;
+  mat4x3 m2 = GLM_MAT4X3_ZERO_INIT;
+
+  GLM(mat4x3_copy)(m1, m2);
+
+  test_assert_mat4x3_eq(m1, m2);
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4x3_zero) {
+  mat4x3 m1 = GLM_MAT4X3_ZERO_INIT;
+  mat4x3 m2 = GLM_MAT4X3_ZERO_INIT;
+  mat4x3 m3;
+
+  GLM(mat4x3_zero)(m3);
+
+  ASSERTIFY(test_assert_mat4x3_eq_zero(m1))
+  ASSERTIFY(test_assert_mat4x3_eq_zero(m2))
+  ASSERTIFY(test_assert_mat4x3_eq_zero(m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4x3_make) {
+  float src[36] = {
+    0.5f, 1.7f, 10.3f, 4.2f, 8.9f, 1.1f, 2.3f, 4.2f, 5.3f, 4.8f, 96.3f, 13.7f,
+    4.7f, 5.5f, 2.3f, 4.2f, 2.3f, 4.2f, 66.5f, 23.7f, 6.6f, 8.9f, 0.5f, 1.7f,
+    5.3f, 4.8f, 96.3f, 13.7f, 4.7f, 5.5f, 2.3f, 4.2f, 0.5f, 1.7f, 10.3f, 4.2f
+  };
+
+  mat4x3 dest[3];
+
+  float *srcp = src;
+  unsigned int i, j, k;
+
+  for (i = 0, j = 0, k = 0; i < sizeof(src) / sizeof(float); i+=12,j++) {
+    GLM(mat4x3_make)(srcp + i, dest[j]);
+
+    ASSERT(test_eq(src[ i ], dest[j][k][0]));
+    ASSERT(test_eq(src[i+1], dest[j][k][1]));
+    ASSERT(test_eq(src[i+2], dest[j][k][2]));
+
+    ASSERT(test_eq(src[i+3], dest[j][k+1][0]));
+    ASSERT(test_eq(src[i+4], dest[j][k+1][1]));
+    ASSERT(test_eq(src[i+5], dest[j][k+1][2]));
+
+    ASSERT(test_eq(src[i+6], dest[j][k+2][0]));
+    ASSERT(test_eq(src[i+7], dest[j][k+2][1]));
+    ASSERT(test_eq(src[i+8], dest[j][k+2][2]));
+
+    ASSERT(test_eq(src[i+9], dest[j][k+3][0]));
+    ASSERT(test_eq(src[i+10], dest[j][k+3][1]));
+    ASSERT(test_eq(src[i+11], dest[j][k+3][2]));
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4x3_mul) {
+  mat4x3 m1 = GLM_MAT4X3_ZERO_INIT;
+  mat3x4 m2 = GLM_MAT3X4_ZERO_INIT;
+
+  mat4 m3 = GLM_MAT4_ZERO_INIT;
+  mat4 m4 = GLM_MAT4_ZERO_INIT;
+
+  int i, j, k;
+
+  test_rand_mat4x3(m1);
+  test_rand_mat3x4(m2);
+
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 4; j++) {
+      for (k = 0; k < 3; k++) {
+        m4[i][j] += m1[i][k] * m2[k][j];
+      }
+    }
+  }
+
+  GLM(mat4x3_mul)(m1, m2, m3);
+  ASSERTIFY(test_assert_mat4_eq(m3, m4))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4x3_mulv) {
+  mat4x3 mat = A_MATRIX4X3;
+  vec3 v = {11.0f, 21.0f, 31.0f};
+
+  int  i;
+  vec4 dest;
+  float res = 0.0;
+
+  GLM(mat4x3_mulv)(mat, v, dest);
+
+  for (i = 0; i < 4; i++) {
+    res = mat[i][0] * v[0] + mat[i][1] * v[1] + mat[i][2] * v[2];
+    ASSERT(test_eq(dest[i], res))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4x3_transpose) {
+  mat4x3 m1 = A_MATRIX4X3;
+
+  mat3x4 m2;
+  mat3x4 m3 = A_MATRIX4X3_TRANSPOSE;
+  GLM(mat4x3_transpose)(m1, m2);
+
+  ASSERTIFY(test_assert_mat3x4_eq(m2, m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4x3_scale) {
+  mat4x3 m1 = A_MATRIX4X3;
+  mat4x3 m2 = A_MATRIX4X3;
+  int i, j, scale;
+
+  scale = rand() % 100;
+
+  GLM(mat4x3_scale)(m1, (float) scale);
+
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 3; j++) {
+      ASSERT(test_eq(m1[i][j], m2[i][j] * scale))
+    }
+  }
+
+  TEST_SUCCESS
+}

test/src/test_quat.h

@@ -1084,3 +1084,25 @@ TEST_IMPL(GLM_PREFIX, quat_rotate_atm) {
 
   TEST_SUCCESS
 }
+
+TEST_IMPL(GLM_PREFIX, quat_make) {
+  versor dest[3];
+  float src[12] = {
+    7.2f, 1.0f, 2.5f, 6.1f,
+    0.2f, 2.8f, 17.3f, 5.1f,
+    4.2f, 7.3f, 6.6f, 8.8f
+  };
+
+  float *srcp = src;
+  unsigned int i, j;
+
+  for (i = 0, j = 0; i < sizeof(src) / sizeof(float); i+=4,j++) {
+    GLM(quat_make)(srcp + i, dest[j]);
+    ASSERT(test_eq(src[ i ], dest[j][0]));
+    ASSERT(test_eq(src[i+1], dest[j][1]));
+    ASSERT(test_eq(src[i+2], dest[j][2]));
+    ASSERT(test_eq(src[i+3], dest[j][3]));
+  }
+
+  TEST_SUCCESS
+}

test/src/test_struct.c

@@ -7,6 +7,30 @@
 
 #include "test_common.h"
 
+TEST_IMPL(mat2x3s_zero_init) {
+  mat2x3s mat2x3_zero   = GLMS_MAT2X3_ZERO_INIT;
+  test_assert_mat2x3_eq_zero(mat2x3_zero.raw);
+  TEST_SUCCESS
+}
+
+TEST_IMPL(mat2x3s_zero) {
+  mat2x3s mat2x3_zero   = GLMS_MAT2X3_ZERO;
+  test_assert_mat2x3_eq_zero(mat2x3_zero.raw);
+  TEST_SUCCESS
+}
+
+TEST_IMPL(mat2x4s_zero_init) {
+  mat2x4s mat2x4_zero   = GLMS_MAT2X4_ZERO_INIT;
+  test_assert_mat2x4_eq_zero(mat2x4_zero.raw);
+  TEST_SUCCESS
+}
+
+TEST_IMPL(mat2x4s_zero) {
+  mat2x4s mat2x4_zero   = GLMS_MAT2X4_ZERO;
+  test_assert_mat2x4_eq_zero(mat2x4_zero.raw);
+  TEST_SUCCESS
+}
+
 TEST_IMPL(mat3s_identity_init) {
   mat3s mat3_identity   = GLMS_MAT3_IDENTITY_INIT;
   mat3  mat3_identity_a =  GLM_MAT3_IDENTITY_INIT;
@@ -21,6 +45,30 @@ TEST_IMPL(mat3s_zero_init) {
   TEST_SUCCESS
 }
 
+TEST_IMPL(mat3x2s_zero_init) {
+  mat3x2s mat3x2_zero   = GLMS_MAT3X2_ZERO_INIT;
+  test_assert_mat3x2_eq_zero(mat3x2_zero.raw);
+  TEST_SUCCESS
+}
+
+TEST_IMPL(mat3x2s_zero) {
+  mat3x2s mat3x2_zero   = GLMS_MAT3X2_ZERO;
+  test_assert_mat3x2_eq_zero(mat3x2_zero.raw);
+  TEST_SUCCESS
+}
+
+TEST_IMPL(mat3x4s_zero_init) {
+  mat3x4s mat3x4_zero   = GLMS_MAT3X4_ZERO_INIT;
+  test_assert_mat3x4_eq_zero(mat3x4_zero.raw);
+  TEST_SUCCESS
+}
+
+TEST_IMPL(mat3x4s_zero) {
+  mat3x4s mat3x4_zero   = GLMS_MAT3X4_ZERO;
+  test_assert_mat3x4_eq_zero(mat3x4_zero.raw);
+  TEST_SUCCESS
+}
+
 TEST_IMPL(mat4s_identity_init) {
   mat4s mat4_identity   = GLMS_MAT4_IDENTITY_INIT;
   mat4  mat4_identity_a =  GLM_MAT4_IDENTITY_INIT;
@@ -35,6 +83,30 @@ TEST_IMPL(mat4s_zero_init) {
   TEST_SUCCESS
 }
 
+TEST_IMPL(mat4x2s_zero_init) {
+  mat4x2s mat4x2_zero   = GLMS_MAT4X2_ZERO_INIT;
+  test_assert_mat4x2_eq_zero(mat4x2_zero.raw);
+  TEST_SUCCESS
+}
+
+TEST_IMPL(mat4x2s_zero) {
+  mat4x2s mat4x2_zero   = GLMS_MAT4X2_ZERO;
+  test_assert_mat4x2_eq_zero(mat4x2_zero.raw);
+  TEST_SUCCESS
+}
+
+TEST_IMPL(mat4x3s_zero_init) {
+  mat4x3s mat4x3_zero   = GLMS_MAT4X3_ZERO_INIT;
+  test_assert_mat4x3_eq_zero(mat4x3_zero.raw);
+  TEST_SUCCESS
+}
+
+TEST_IMPL(mat4x3s_zero) {
+  mat4x3s mat4x3_zero   = GLMS_MAT4X3_ZERO;
+  test_assert_mat4x3_eq_zero(mat4x3_zero.raw);
+  TEST_SUCCESS
+}
+
 TEST_IMPL(quats_zero_init) {
   versors quat_zero   = GLMS_QUAT_IDENTITY_INIT;
   versor  quat_zero_a =  GLM_QUAT_IDENTITY_INIT;

test/src/test_vec2.h

@@ -637,3 +637,23 @@ TEST_IMPL(GLM_PREFIX, vec2_complex_div) {
 
   TEST_SUCCESS
 }
+
+TEST_IMPL(GLM_PREFIX, vec2_make) {
+  float src[6] = {
+    7.2f, 1.0f,
+    2.5f, 6.1f,
+    17.7f, 4.3f
+  };
+  vec2 dest[3];
+
+  float *srcp = src;
+  unsigned int i, j;
+
+  for (i = 0, j = 0; i < sizeof(src) / sizeof(float); i+=2,j++) {
+    GLM(vec2_make)(srcp + i, dest[j]);
+    ASSERT(test_eq(src[ i ], dest[j][0]));
+    ASSERT(test_eq(src[i+1], dest[j][1]));
+  }
+
+  TEST_SUCCESS
+}

test/src/test_vec3.h

@@ -1729,3 +1729,24 @@ TEST_IMPL(GLM_PREFIX, vec3_sqrt) {
 
   TEST_SUCCESS
 }
+
+TEST_IMPL(GLM_PREFIX, vec3_make) {
+  float src[9] = {
+    7.2f, 1.0f, 5.8f,
+    2.5f, 6.1f, 9.9f,
+    17.7f, 4.3f, 3.2f
+  };
+  vec3 dest[3];
+
+  float *srcp = src;
+  unsigned int i, j;
+
+  for (i = 0, j = 0; i < sizeof(src) / sizeof(float); i+=3,j++) {
+    GLM(vec3_make)(srcp + i, dest[j]);
+    ASSERT(test_eq(src[ i ], dest[j][0]));
+    ASSERT(test_eq(src[i+1], dest[j][1]));
+    ASSERT(test_eq(src[i+2], dest[j][2]));
+  }
+
+  TEST_SUCCESS
+}

test/src/test_vec4.h

@@ -1418,3 +1418,25 @@ TEST_IMPL(GLM_PREFIX, vec4_sqrt) {
 
   TEST_SUCCESS
 }
+
+TEST_IMPL(GLM_PREFIX, vec4_make) {
+  float src[12] = {
+    7.2f, 1.0f, 5.8f, 0.0f,
+    2.5f, 6.1f, 9.9f, 1.0f,
+    17.7f, 4.3f, 3.2f, 1.0f
+  };
+  vec4 dest[3];
+
+  float *srcp = src;
+  unsigned int i, j;
+
+  for (i = 0, j = 0; i < sizeof(src) / sizeof(float); i+=4,j++) {
+    GLM(vec4_make)(srcp + i, dest[j]);
+    ASSERT(test_eq(src[ i ], dest[j][0]));
+    ASSERT(test_eq(src[i+1], dest[j][1]));
+    ASSERT(test_eq(src[i+2], dest[j][2]));
+    ASSERT(test_eq(src[i+3], dest[j][3]));
+  }
+
+  TEST_SUCCESS
+}

test/src/tests.c

@@ -19,8 +19,14 @@
 #include "test_ivec3.h"
 #include "test_ivec4.h"
 #include "test_mat2.h"
+#include "test_mat2x3.h"
+#include "test_mat2x4.h"
 #include "test_mat3.h"
+#include "test_mat3x2.h"
+#include "test_mat3x4.h"
 #include "test_mat4.h"
+#include "test_mat4x2.h"
+#include "test_mat4x3.h"
 #include "test_quat.h"
 #include "test_project.h"
 #include "test_plane.h"
@@ -50,8 +56,14 @@
 #include "test_ivec3.h"
 #include "test_ivec4.h"
 #include "test_mat2.h"
+#include "test_mat2x3.h"
+#include "test_mat2x4.h"
 #include "test_mat3.h"
+#include "test_mat3x2.h"
+#include "test_mat3x4.h"
 #include "test_mat4.h"
+#include "test_mat4x2.h"
+#include "test_mat4x3.h"
 #include "test_quat.h"
 #include "test_project.h"
 #include "test_plane.h"

test/tests.h

@@ -153,6 +153,42 @@ TEST_DECLARE(glmc_mat4_swap_row)
 TEST_DECLARE(glmc_mat4_rmc)
 TEST_DECLARE(glmc_mat4_make)
 
+TEST_DECLARE(MACRO_GLM_MAT4X2_ZERO_INIT)
+TEST_DECLARE(MACRO_GLM_MAT4X2_ZERO)
+TEST_DECLARE(glm_mat4x2_copy)
+TEST_DECLARE(glm_mat4x2_zero)
+TEST_DECLARE(glm_mat4x2_make)
+TEST_DECLARE(glm_mat4x2_mul)
+TEST_DECLARE(glm_mat4x2_mulv)
+TEST_DECLARE(glm_mat4x2_transpose)
+TEST_DECLARE(glm_mat4x2_scale)
+
+TEST_DECLARE(glmc_mat4x2_copy)
+TEST_DECLARE(glmc_mat4x2_zero)
+TEST_DECLARE(glmc_mat4x2_make)
+TEST_DECLARE(glmc_mat4x2_mul)
+TEST_DECLARE(glmc_mat4x2_mulv)
+TEST_DECLARE(glmc_mat4x2_transpose)
+TEST_DECLARE(glmc_mat4x2_scale)
+
+TEST_DECLARE(MACRO_GLM_MAT4X3_ZERO_INIT)
+TEST_DECLARE(MACRO_GLM_MAT4X3_ZERO)
+TEST_DECLARE(glm_mat4x3_copy)
+TEST_DECLARE(glm_mat4x3_zero)
+TEST_DECLARE(glm_mat4x3_make)
+TEST_DECLARE(glm_mat4x3_mul)
+TEST_DECLARE(glm_mat4x3_mulv)
+TEST_DECLARE(glm_mat4x3_transpose)
+TEST_DECLARE(glm_mat4x3_scale)
+
+TEST_DECLARE(glmc_mat4x3_copy)
+TEST_DECLARE(glmc_mat4x3_zero)
+TEST_DECLARE(glmc_mat4x3_make)
+TEST_DECLARE(glmc_mat4x3_mul)
+TEST_DECLARE(glmc_mat4x3_mulv)
+TEST_DECLARE(glmc_mat4x3_transpose)
+TEST_DECLARE(glmc_mat4x3_scale)
+
 /* mat3 */
 TEST_DECLARE(glm_mat3_copy)
 TEST_DECLARE(glm_mat3_identity)
@@ -190,6 +226,30 @@ TEST_DECLARE(glmc_mat3_swap_row)
 TEST_DECLARE(glmc_mat3_rmc)
 TEST_DECLARE(glmc_mat3_make)
 
+TEST_DECLARE(MACRO_GLM_MAT3X2_ZERO_INIT)
+TEST_DECLARE(MACRO_GLM_MAT3X2_ZERO)
+TEST_DECLARE(glm_mat3x2_copy)
+TEST_DECLARE(glm_mat3x2_zero)
+TEST_DECLARE(glm_mat3x2_make)
+TEST_DECLARE(glm_mat3x2_mul)
+TEST_DECLARE(glm_mat3x2_mulv)
+TEST_DECLARE(glm_mat3x2_transpose)
+TEST_DECLARE(glm_mat3x2_scale)
+
+TEST_DECLARE(glmc_mat3x2_copy)
+TEST_DECLARE(glmc_mat3x2_zero)
+TEST_DECLARE(glmc_mat3x2_make)
+TEST_DECLARE(glmc_mat3x2_mul)
+TEST_DECLARE(glmc_mat3x2_mulv)
+TEST_DECLARE(glmc_mat3x2_transpose)
+TEST_DECLARE(glmc_mat3x2_scale)
+
+TEST_DECLARE(MACRO_GLM_MAT3X4_ZERO_INIT)
+TEST_DECLARE(MACRO_GLM_MAT3X4_ZERO)
+TEST_DECLARE(glm_mat3x4_make)
+
+TEST_DECLARE(glmc_mat3x4_make)
+
 TEST_DECLARE(MACRO_GLM_MAT2_IDENTITY_INIT)
 TEST_DECLARE(MACRO_GLM_MAT2_ZERO_INIT)
 TEST_DECLARE(MACRO_GLM_MAT2_IDENTITY)
@@ -228,6 +288,42 @@ TEST_DECLARE(glmc_mat2_swap_row)
 TEST_DECLARE(glmc_mat2_rmc)
 TEST_DECLARE(glmc_mat2_make)
 
+TEST_DECLARE(MACRO_GLM_MAT2X3_ZERO_INIT)
+TEST_DECLARE(MACRO_GLM_MAT2X3_ZERO)
+TEST_DECLARE(glm_mat2x3_copy)
+TEST_DECLARE(glm_mat2x3_zero)
+TEST_DECLARE(glm_mat2x3_make)
+TEST_DECLARE(glm_mat2x3_mul)
+TEST_DECLARE(glm_mat2x3_mulv)
+TEST_DECLARE(glm_mat2x3_transpose)
+TEST_DECLARE(glm_mat2x3_scale)
+
+TEST_DECLARE(glmc_mat2x3_copy)
+TEST_DECLARE(glmc_mat2x3_zero)
+TEST_DECLARE(glmc_mat2x3_make)
+TEST_DECLARE(glmc_mat2x3_mul)
+TEST_DECLARE(glmc_mat2x3_mulv)
+TEST_DECLARE(glmc_mat2x3_transpose)
+TEST_DECLARE(glmc_mat2x3_scale)
+
+TEST_DECLARE(MACRO_GLM_MAT2X4_ZERO_INIT)
+TEST_DECLARE(MACRO_GLM_MAT2X4_ZERO)
+TEST_DECLARE(glm_mat2x4_copy)
+TEST_DECLARE(glm_mat2x4_zero)
+TEST_DECLARE(glm_mat2x4_make)
+TEST_DECLARE(glm_mat2x4_mul)
+TEST_DECLARE(glm_mat2x4_mulv)
+TEST_DECLARE(glm_mat2x4_transpose)
+TEST_DECLARE(glm_mat2x4_scale)
+
+TEST_DECLARE(glmc_mat2x4_copy)
+TEST_DECLARE(glmc_mat2x4_zero)
+TEST_DECLARE(glmc_mat2x4_make)
+TEST_DECLARE(glmc_mat2x4_mul)
+TEST_DECLARE(glmc_mat2x4_mulv)
+TEST_DECLARE(glmc_mat2x4_transpose)
+TEST_DECLARE(glmc_mat2x4_scale)
+
 /* camera (incl [LR]H cross [NZ]O) */
 TEST_DECLARE(glm_perspective_lh_zo)
 TEST_DECLARE(glm_perspective_rh_zo)
@@ -311,6 +407,7 @@ TEST_DECLARE(glm_quat_rotate)
 TEST_DECLARE(glm_quat_rotate_at)
 TEST_DECLARE(glm_quat_rotate_atm)
 TEST_DECLARE(glm_quat_from_vecs)
+TEST_DECLARE(glm_quat_make)
 
 TEST_DECLARE(glmc_quat_identity)
 TEST_DECLARE(glmc_quat_identity_array)
@@ -349,6 +446,7 @@ TEST_DECLARE(glmc_quat_rotate)
 TEST_DECLARE(glmc_quat_rotate_at)
 TEST_DECLARE(glmc_quat_rotate_atm)
 TEST_DECLARE(glmc_quat_from_vecs)
+TEST_DECLARE(glmc_quat_make)
 
 /* bezier */
 TEST_DECLARE(bezier)
@@ -396,6 +494,7 @@ TEST_DECLARE(glm_vec2_abs)
 TEST_DECLARE(glm_vec2_lerp)
 TEST_DECLARE(glm_vec2_complex_mul)
 TEST_DECLARE(glm_vec2_complex_div)
+TEST_DECLARE(glm_vec2_make)
 
 TEST_DECLARE(glmc_vec2)
 TEST_DECLARE(glmc_vec2_copy)
@@ -434,6 +533,7 @@ TEST_DECLARE(glmc_vec2_abs)
 TEST_DECLARE(glmc_vec2_lerp)
 TEST_DECLARE(glmc_vec2_complex_mul)
 TEST_DECLARE(glmc_vec2_complex_div)
+TEST_DECLARE(glmc_vec2_make)
 
 /* vec3 */
 TEST_DECLARE(MACRO_GLM_VEC3_ONE_INIT)
@@ -529,6 +629,7 @@ TEST_DECLARE(glm_vec3_abs)
 TEST_DECLARE(glm_vec3_fract)
 TEST_DECLARE(glm_vec3_hadd)
 TEST_DECLARE(glm_vec3_sqrt)
+TEST_DECLARE(glm_vec3_make)
 
 TEST_DECLARE(glmc_vec3)
 TEST_DECLARE(glmc_vec3_copy)
@@ -598,6 +699,7 @@ TEST_DECLARE(glmc_vec3_abs)
 TEST_DECLARE(glmc_vec3_fract)
 TEST_DECLARE(glmc_vec3_hadd)
 TEST_DECLARE(glmc_vec3_sqrt)
+TEST_DECLARE(glmc_vec3_make)
 
 /* vec4 */
 TEST_DECLARE(MACRO_GLM_VEC4_ONE_INIT)
@@ -679,6 +781,7 @@ TEST_DECLARE(glm_vec4_abs)
 TEST_DECLARE(glm_vec4_fract)
 TEST_DECLARE(glm_vec4_hadd)
 TEST_DECLARE(glm_vec4_sqrt)
+TEST_DECLARE(glm_vec4_make)
 
 TEST_DECLARE(glmc_vec4)
 TEST_DECLARE(glmc_vec4_copy3)
@@ -744,6 +847,7 @@ TEST_DECLARE(glmc_vec4_abs)
 TEST_DECLARE(glmc_vec4_fract)
 TEST_DECLARE(glmc_vec4_hadd)
 TEST_DECLARE(glmc_vec4_sqrt)
+TEST_DECLARE(glmc_vec4_make)
 
 /* ivec2 */
 TEST_DECLARE(glm_ivec2)
@@ -849,10 +953,22 @@ TEST_DECLARE(glmc_ivec4_clamp)
 TEST_DECLARE(glmc_ivec4_abs)
 
 /* structs */
+TEST_DECLARE(mat2x3s_zero_init)
+TEST_DECLARE(mat2x3s_zero)
+TEST_DECLARE(mat2x4s_zero_init)
+TEST_DECLARE(mat2x4s_zero)
 TEST_DECLARE(mat3s_identity_init)
 TEST_DECLARE(mat3s_zero_init)
+TEST_DECLARE(mat3x2s_zero_init)
+TEST_DECLARE(mat3x2s_zero)
+TEST_DECLARE(mat3x4s_zero_init)
+TEST_DECLARE(mat3x4s_zero)
 TEST_DECLARE(mat4s_identity_init)
 TEST_DECLARE(mat4s_zero_init)
+TEST_DECLARE(mat4x2s_zero_init)
+TEST_DECLARE(mat4x2s_zero)
+TEST_DECLARE(mat4x3s_zero_init)
+TEST_DECLARE(mat4x3s_zero)
 TEST_DECLARE(quats_zero_init)
 TEST_DECLARE(vec3s_one_init)
 TEST_DECLARE(vec3s_zero_init)
@@ -999,7 +1115,43 @@ TEST_LIST {
   TEST_ENTRY(glmc_mat4_swap_row)
   TEST_ENTRY(glmc_mat4_rmc)
   TEST_ENTRY(glmc_mat4_make)
-  
+
+  TEST_ENTRY(MACRO_GLM_MAT4X2_ZERO_INIT)
+  TEST_ENTRY(MACRO_GLM_MAT4X2_ZERO)
+  TEST_ENTRY(glm_mat4x2_copy)
+  TEST_ENTRY(glm_mat4x2_zero)
+  TEST_ENTRY(glm_mat4x2_make)
+  TEST_ENTRY(glm_mat4x2_mul)
+  TEST_ENTRY(glm_mat4x2_mulv)
+  TEST_ENTRY(glm_mat4x2_transpose)
+  TEST_ENTRY(glm_mat4x2_scale)
+
+  TEST_ENTRY(glmc_mat4x2_copy)
+  TEST_ENTRY(glmc_mat4x2_zero)
+  TEST_ENTRY(glmc_mat4x2_make)
+  TEST_ENTRY(glmc_mat4x2_mul)
+  TEST_ENTRY(glmc_mat4x2_mulv)
+  TEST_ENTRY(glmc_mat4x2_transpose)
+  TEST_ENTRY(glmc_mat4x2_scale)
+
+  TEST_ENTRY(MACRO_GLM_MAT4X3_ZERO_INIT)
+  TEST_ENTRY(MACRO_GLM_MAT4X3_ZERO)
+  TEST_ENTRY(glm_mat4x3_copy)
+  TEST_ENTRY(glm_mat4x3_zero)
+  TEST_ENTRY(glm_mat4x3_make)
+  TEST_ENTRY(glm_mat4x3_mul)
+  TEST_ENTRY(glm_mat4x3_mulv)
+  TEST_ENTRY(glm_mat4x3_transpose)
+  TEST_ENTRY(glm_mat4x3_scale)
+
+  TEST_ENTRY(glmc_mat4x3_copy)
+  TEST_ENTRY(glmc_mat4x3_zero)
+  TEST_ENTRY(glmc_mat4x3_make)
+  TEST_ENTRY(glmc_mat4x3_mul)
+  TEST_ENTRY(glmc_mat4x3_mulv)
+  TEST_ENTRY(glmc_mat4x3_transpose)
+  TEST_ENTRY(glmc_mat4x3_scale)
+
   /* mat3 */
   TEST_ENTRY(glm_mat3_copy)
   TEST_ENTRY(glm_mat3_identity)
@@ -1036,7 +1188,31 @@ TEST_LIST {
   TEST_ENTRY(glmc_mat3_swap_row)
   TEST_ENTRY(glmc_mat3_rmc)
   TEST_ENTRY(glmc_mat3_make)
-  
+
+  TEST_ENTRY(MACRO_GLM_MAT3X2_ZERO_INIT)
+  TEST_ENTRY(MACRO_GLM_MAT3X2_ZERO)
+  TEST_ENTRY(glm_mat3x2_copy)
+  TEST_ENTRY(glm_mat3x2_zero)
+  TEST_ENTRY(glm_mat3x2_make)
+  TEST_ENTRY(glm_mat3x2_mul)
+  TEST_ENTRY(glm_mat3x2_mulv)
+  TEST_ENTRY(glm_mat3x2_transpose)
+  TEST_ENTRY(glm_mat3x2_scale)
+
+  TEST_ENTRY(glmc_mat3x2_copy)
+  TEST_ENTRY(glmc_mat3x2_zero)
+  TEST_ENTRY(glmc_mat3x2_make)
+  TEST_ENTRY(glmc_mat3x2_mul)
+  TEST_ENTRY(glmc_mat3x2_mulv)
+  TEST_ENTRY(glmc_mat3x2_transpose)
+  TEST_ENTRY(glmc_mat3x2_scale)
+
+  TEST_ENTRY(MACRO_GLM_MAT3X4_ZERO_INIT)
+  TEST_ENTRY(MACRO_GLM_MAT3X4_ZERO)
+  TEST_ENTRY(glm_mat3x4_make)
+
+  TEST_ENTRY(glmc_mat3x4_make)
+
   TEST_ENTRY(MACRO_GLM_MAT2_IDENTITY_INIT)
   TEST_ENTRY(MACRO_GLM_MAT2_ZERO_INIT)
   TEST_ENTRY(MACRO_GLM_MAT2_IDENTITY)
@@ -1075,6 +1251,42 @@ TEST_LIST {
   TEST_ENTRY(glmc_mat2_rmc)
   TEST_ENTRY(glmc_mat2_make)
 
+  TEST_ENTRY(MACRO_GLM_MAT2X3_ZERO_INIT)
+  TEST_ENTRY(MACRO_GLM_MAT2X3_ZERO)
+  TEST_ENTRY(glm_mat2x3_copy)
+  TEST_ENTRY(glm_mat2x3_zero)
+  TEST_ENTRY(glm_mat2x3_make)
+  TEST_ENTRY(glm_mat2x3_mul)
+  TEST_ENTRY(glm_mat2x3_mulv)
+  TEST_ENTRY(glm_mat2x3_transpose)
+  TEST_ENTRY(glm_mat2x3_scale)
+
+  TEST_ENTRY(glmc_mat2x3_copy)
+  TEST_ENTRY(glmc_mat2x3_zero)
+  TEST_ENTRY(glmc_mat2x3_make)
+  TEST_ENTRY(glmc_mat2x3_mul)
+  TEST_ENTRY(glmc_mat2x3_mulv)
+  TEST_ENTRY(glmc_mat2x3_transpose)
+  TEST_ENTRY(glmc_mat2x3_scale)
+
+  TEST_ENTRY(MACRO_GLM_MAT2X4_ZERO_INIT)
+  TEST_ENTRY(MACRO_GLM_MAT2X4_ZERO)
+  TEST_ENTRY(glm_mat2x4_copy)
+  TEST_ENTRY(glm_mat2x4_zero)
+  TEST_ENTRY(glm_mat2x4_make)
+  TEST_ENTRY(glm_mat2x4_mul)
+  TEST_ENTRY(glm_mat2x4_mulv)
+  TEST_ENTRY(glm_mat2x4_transpose)
+  TEST_ENTRY(glm_mat2x4_scale)
+
+  TEST_ENTRY(glm_mat2x4_copy)
+  TEST_ENTRY(glm_mat2x4_zero)
+  TEST_ENTRY(glm_mat2x4_make)
+  TEST_ENTRY(glm_mat2x4_mul)
+  TEST_ENTRY(glm_mat2x4_mulv)
+  TEST_ENTRY(glm_mat2x4_transpose)
+  TEST_ENTRY(glm_mat2x4_scale)
+
   /* camera (incl [LR]H cross [NZ]O) */
   TEST_ENTRY(glm_perspective_lh_zo)
   TEST_ENTRY(glm_perspective_rh_zo)
@@ -1158,6 +1370,7 @@ TEST_LIST {
   TEST_ENTRY(glm_quat_rotate_at)
   TEST_ENTRY(glm_quat_rotate_atm)
   TEST_ENTRY(glm_quat_from_vecs)
+  TEST_ENTRY(glm_quat_make)
 
   TEST_ENTRY(glmc_quat_identity)
   TEST_ENTRY(glmc_quat_identity_array)
@@ -1196,6 +1409,7 @@ TEST_LIST {
   TEST_ENTRY(glmc_quat_rotate_at)
   TEST_ENTRY(glmc_quat_rotate_atm)
   TEST_ENTRY(glmc_quat_from_vecs)
+  TEST_ENTRY(glmc_quat_make)
 
   /* bezier */
   TEST_ENTRY(bezier)
@@ -1242,6 +1456,7 @@ TEST_LIST {
   TEST_ENTRY(glm_vec2_lerp)
   TEST_ENTRY(glm_vec2_complex_mul)
   TEST_ENTRY(glm_vec2_complex_div)
+  TEST_ENTRY(glm_vec2_make)
 
   TEST_ENTRY(glmc_vec2)
   TEST_ENTRY(glmc_vec2_copy)
@@ -1280,6 +1495,7 @@ TEST_LIST {
   TEST_ENTRY(glmc_vec2_lerp)
   TEST_ENTRY(glmc_vec2_complex_mul)
   TEST_ENTRY(glmc_vec2_complex_div)
+  TEST_ENTRY(glmc_vec2_make)
 
   /* vec3 */
   TEST_ENTRY(MACRO_GLM_VEC3_ONE_INIT)
@@ -1374,6 +1590,7 @@ TEST_LIST {
   TEST_ENTRY(glm_vec3_fract)
   TEST_ENTRY(glm_vec3_hadd)
   TEST_ENTRY(glm_vec3_sqrt)
+  TEST_ENTRY(glm_vec3_make)
 
   TEST_ENTRY(glmc_vec3)
   TEST_ENTRY(glmc_vec3_copy)
@@ -1443,6 +1660,7 @@ TEST_LIST {
   TEST_ENTRY(glmc_vec3_fract)
   TEST_ENTRY(glmc_vec3_hadd)
   TEST_ENTRY(glmc_vec3_sqrt)
+  TEST_ENTRY(glmc_vec3_make)
 
   /* vec4 */
   TEST_ENTRY(MACRO_GLM_VEC4_ONE_INIT)
@@ -1524,6 +1742,7 @@ TEST_LIST {
   TEST_ENTRY(glm_vec4_fract)
   TEST_ENTRY(glm_vec4_hadd)
   TEST_ENTRY(glm_vec4_sqrt)
+  TEST_ENTRY(glm_vec4_make)
 
   TEST_ENTRY(glmc_vec4)
   TEST_ENTRY(glmc_vec4_copy3)
@@ -1589,6 +1808,7 @@ TEST_LIST {
   TEST_ENTRY(glmc_vec4_fract)
   TEST_ENTRY(glmc_vec4_hadd)
   TEST_ENTRY(glmc_vec4_sqrt)
+  TEST_ENTRY(glmc_vec4_make)
 
   /* ivec2 */
   TEST_ENTRY(glm_ivec2)
@@ -1693,10 +1913,22 @@ TEST_LIST {
   TEST_ENTRY(glmc_ivec4_abs)
 
   /* structs */
+  TEST_ENTRY(mat2x3s_zero_init)
+  TEST_ENTRY(mat2x3s_zero)
+  TEST_ENTRY(mat2x4s_zero_init)
+  TEST_ENTRY(mat2x4s_zero)
   TEST_ENTRY(mat3s_identity_init)
   TEST_ENTRY(mat3s_zero_init)
+  TEST_ENTRY(mat3x2s_zero_init)
+  TEST_ENTRY(mat3x2s_zero)
+  TEST_ENTRY(mat3x4s_zero_init)
+  TEST_ENTRY(mat3x4s_zero)
   TEST_ENTRY(mat4s_identity_init)
   TEST_ENTRY(mat4s_zero_init)
+  TEST_ENTRY(mat4x2s_zero_init)
+  TEST_ENTRY(mat4x2s_zero)
+  TEST_ENTRY(mat4x3s_zero_init)
+  TEST_ENTRY(mat4x3s_zero)
   TEST_ENTRY(quats_zero_init)
   TEST_ENTRY(vec3s_one_init)
   TEST_ENTRY(vec3s_zero_init)

win/cglm-test.vcxproj

@@ -66,8 +66,14 @@
     <ClInclude Include="..\test\src\test_ivec3.h" />
     <ClInclude Include="..\test\src\test_ivec4.h" />
     <ClInclude Include="..\test\src\test_mat2.h" />
+    <ClInclude Include="..\test\src\test_mat2x3.h" />
+    <ClInclude Include="..\test\src\test_mat2x4.h" />
     <ClInclude Include="..\test\src\test_mat3.h" />
+    <ClInclude Include="..\test\src\test_mat3x2.h" />
+    <ClInclude Include="..\test\src\test_mat3x4.h" />
     <ClInclude Include="..\test\src\test_mat4.h" />
+    <ClInclude Include="..\test\src\test_mat4x2.h" />
+    <ClInclude Include="..\test\src\test_mat4x3.h" />
     <ClInclude Include="..\test\src\test_plane.h" />
     <ClInclude Include="..\test\src\test_project.h" />
     <ClInclude Include="..\test\src\test_quat.h" />
@@ -419,4 +425,4 @@
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>
-</Project>
+</Project>

win/cglm-test.vcxproj.filters

@@ -79,12 +79,30 @@
     <ClInclude Include="..\test\src\test_mat2.h">
       <Filter>src</Filter>
     </ClInclude>
+    <ClInclude Include="..\test\src\test_mat2x3.h">
+      <Filter>src</Filter>
+    </ClInclude>
+    <ClInclude Include="..\test\src\test_mat2x4.h">
+      <Filter>src</Filter>
+    </ClInclude>
     <ClInclude Include="..\test\src\test_mat3.h">
       <Filter>src</Filter>
     </ClInclude>
+    <ClInclude Include="..\test\src\test_mat3x2.h">
+      <Filter>src</Filter>
+    </ClInclude>
+    <ClInclude Include="..\test\src\test_mat3x4.h">
+      <Filter>src</Filter>
+    </ClInclude>
     <ClInclude Include="..\test\src\test_mat4.h">
       <Filter>src</Filter>
     </ClInclude>
+    <ClInclude Include="..\test\src\test_mat4x2.h">
+      <Filter>src</Filter>
+    </ClInclude>
+    <ClInclude Include="..\test\src\test_mat4x3.h">
+      <Filter>src</Filter>
+    </ClInclude>
     <ClInclude Include="..\test\src\test_plane.h">
       <Filter>src</Filter>
     </ClInclude>
@@ -107,4 +125,4 @@
       <Filter>src</Filter>
     </ClInclude>
   </ItemGroup>
-</Project>
+</Project>

win/cglm.vcxproj

@@ -71,8 +71,14 @@
     <ClCompile Include="..\src\ivec3.c" />
     <ClCompile Include="..\src\ivec4.c" />
     <ClCompile Include="..\src\mat2.c" />
+    <ClCompile Include="..\src\mat2x3.c" />
+    <ClCompile Include="..\src\mat2x4.c" />
     <ClCompile Include="..\src\mat3.c" />
+    <ClCompile Include="..\src\mat3x2.c" />
+    <ClCompile Include="..\src\mat3x4.c" />
     <ClCompile Include="..\src\mat4.c" />
+    <ClCompile Include="..\src\mat4x2.c" />
+    <ClCompile Include="..\src\mat4x3.c" />
     <ClCompile Include="..\src\plane.c" />
     <ClCompile Include="..\src\project.c" />
     <ClCompile Include="..\src\quat.c" />
@@ -120,8 +126,14 @@
     <ClInclude Include="..\include\cglm\call\ivec3.h" />
     <ClInclude Include="..\include\cglm\call\ivec4.h" />
     <ClInclude Include="..\include\cglm\call\mat2.h" />
+    <ClInclude Include="..\include\cglm\call\mat2x3.h" />
+    <ClInclude Include="..\include\cglm\call\mat2x4.h" />
     <ClInclude Include="..\include\cglm\call\mat3.h" />
+    <ClInclude Include="..\include\cglm\call\mat3x2.h" />
+    <ClInclude Include="..\include\cglm\call\mat3x4.h" />
     <ClInclude Include="..\include\cglm\call\mat4.h" />
+    <ClInclude Include="..\include\cglm\call\mat4x2.h" />
+    <ClInclude Include="..\include\cglm\call\mat4x3.h" />
     <ClInclude Include="..\include\cglm\call\plane.h" />
     <ClInclude Include="..\include\cglm\call\project.h" />
     <ClInclude Include="..\include\cglm\call\quat.h" />
@@ -160,8 +172,14 @@
     <ClInclude Include="..\include\cglm\ivec3.h" />
     <ClInclude Include="..\include\cglm\ivec4.h" />
     <ClInclude Include="..\include\cglm\mat2.h" />
+    <ClInclude Include="..\include\cglm\mat2x3.h" />
+    <ClInclude Include="..\include\cglm\mat2x4.h" />
     <ClInclude Include="..\include\cglm\mat3.h" />
+    <ClInclude Include="..\include\cglm\mat3x2.h" />
+    <ClInclude Include="..\include\cglm\mat3x4.h" />
     <ClInclude Include="..\include\cglm\mat4.h" />
+    <ClInclude Include="..\include\cglm\mat4x2.h" />
+    <ClInclude Include="..\include\cglm\mat4x3.h" />
     <ClInclude Include="..\include\cglm\plane.h" />
     <ClInclude Include="..\include\cglm\project.h" />
     <ClInclude Include="..\include\cglm\quat.h" />
@@ -184,6 +202,7 @@
     <ClInclude Include="..\include\cglm\struct.h" />
     <ClInclude Include="..\include\cglm\struct\affine-post.h" />
     <ClInclude Include="..\include\cglm\struct\affine-pre.h" />
+    <ClInclude Include="..\include\cglm\struct\affine-mat.h" />
     <ClInclude Include="..\include\cglm\struct\affine.h" />
     <ClInclude Include="..\include\cglm\struct\affine2d.h" />
     <ClInclude Include="..\include\cglm\struct\box.h" />
@@ -208,8 +227,14 @@
     <ClInclude Include="..\include\cglm\struct\frustum.h" />
     <ClInclude Include="..\include\cglm\struct\io.h" />
     <ClInclude Include="..\include\cglm\struct\mat2.h" />
+    <ClInclude Include="..\include\cglm\struct\mat2x3.h" />
+    <ClInclude Include="..\include\cglm\struct\mat2x4.h" />
     <ClInclude Include="..\include\cglm\struct\mat3.h" />
+    <ClInclude Include="..\include\cglm\struct\mat3x2.h" />
+    <ClInclude Include="..\include\cglm\struct\mat3x4.h" />
     <ClInclude Include="..\include\cglm\struct\mat4.h" />
+    <ClInclude Include="..\include\cglm\struct\mat4x2.h" />
+    <ClInclude Include="..\include\cglm\struct\mat4x3.h" />
     <ClInclude Include="..\include\cglm\struct\plane.h" />
     <ClInclude Include="..\include\cglm\struct\project.h" />
     <ClInclude Include="..\include\cglm\struct\quat.h" />

win/cglm.vcxproj.filters

@@ -58,9 +58,21 @@
     <ClCompile Include="..\src\mat3.c">
       <Filter>src</Filter>
     </ClCompile>
+    <ClCompile Include="..\src\mat3x2.c">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\mat3x4.c">
+      <Filter>src</Filter>
+    </ClCompile>
     <ClCompile Include="..\src\mat4.c">
       <Filter>src</Filter>
     </ClCompile>
+    <ClCompile Include="..\src\mat4x2.c">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\mat4x3.c">
+      <Filter>src</Filter>
+    </ClCompile>
     <ClCompile Include="..\src\quat.c">
       <Filter>src</Filter>
     </ClCompile>
@@ -97,6 +109,12 @@
     <ClCompile Include="..\src\mat2.c">
       <Filter>src</Filter>
     </ClCompile>
+    <ClCompile Include="..\src\mat2x3.c">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\mat2x4.c">
+      <Filter>src</Filter>
+    </ClCompile>
     <ClCompile Include="..\src\vec2.c">
       <Filter>src</Filter>
     </ClCompile>
@@ -177,9 +195,21 @@
     <ClInclude Include="..\include\cglm\call\mat3.h">
       <Filter>include\cglm\call</Filter>
     </ClInclude>
+    <ClInclude Include="..\include\cglm\call\mat3x2.h">
+      <Filter>include\cglm\call</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\call\mat3x4.h">
+      <Filter>include\cglm\call</Filter>
+    </ClInclude>
     <ClInclude Include="..\include\cglm\call\mat4.h">
       <Filter>include\cglm\call</Filter>
     </ClInclude>
+    <ClInclude Include="..\include\cglm\call\mat4x2.h">
+      <Filter>include\cglm\call</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\call\mat4x3.h">
+      <Filter>include\cglm\call</Filter>
+    </ClInclude>
     <ClInclude Include="..\include\cglm\call\quat.h">
       <Filter>include\cglm\call</Filter>
     </ClInclude>
@@ -243,9 +273,21 @@
     <ClInclude Include="..\include\cglm\mat3.h">
       <Filter>include\cglm</Filter>
     </ClInclude>
+    <ClInclude Include="..\include\cglm\mat3x2.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\mat3x4.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
     <ClInclude Include="..\include\cglm\mat4.h">
       <Filter>include\cglm</Filter>
     </ClInclude>
+    <ClInclude Include="..\include\cglm\mat4x2.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\mat4x3.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
     <ClInclude Include="..\include\cglm\quat.h">
       <Filter>include\cglm</Filter>
     </ClInclude>
@@ -360,9 +402,21 @@
     <ClInclude Include="..\include\cglm\struct\mat3.h">
       <Filter>include\cglm\struct</Filter>
     </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\mat3x2.h">
+      <Filter>include\cglm\struct</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\mat3x4.h">
+      <Filter>include\cglm\struct</Filter>
+    </ClInclude>
     <ClInclude Include="..\include\cglm\struct\mat4.h">
       <Filter>include\cglm\struct</Filter>
     </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\mat4x2.h">
+      <Filter>include\cglm\struct</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\mat4x3.h">
+      <Filter>include\cglm\struct</Filter>
+    </ClInclude>
     <ClInclude Include="..\include\cglm\struct\plane.h">
       <Filter>include\cglm\struct</Filter>
     </ClInclude>
@@ -396,18 +450,36 @@
     <ClInclude Include="..\include\cglm\call\mat2.h">
       <Filter>include\cglm\call</Filter>
     </ClInclude>
+    <ClInclude Include="..\include\cglm\call\mat2x3.h">
+      <Filter>include\cglm\call</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\call\mat2x4.h">
+      <Filter>include\cglm\call</Filter>
+    </ClInclude>
     <ClInclude Include="..\include\cglm\call\vec2.h">
       <Filter>include\cglm\call</Filter>
     </ClInclude>
     <ClInclude Include="..\include\cglm\struct\mat2.h">
       <Filter>include\cglm\struct</Filter>
     </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\mat2x3.h">
+      <Filter>include\cglm\struct</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\mat2x4.h">
+      <Filter>include\cglm\struct</Filter>
+    </ClInclude>
     <ClInclude Include="..\include\cglm\applesimd.h">
       <Filter>include\cglm</Filter>
     </ClInclude>
     <ClInclude Include="..\include\cglm\mat2.h">
       <Filter>include\cglm</Filter>
     </ClInclude>
+    <ClInclude Include="..\include\cglm\mat2x3.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\mat2x4.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
     <ClInclude Include="..\include\cglm\vec2-ext.h">
       <Filter>include\cglm</Filter>
     </ClInclude>
@@ -603,5 +675,8 @@
     <ClInclude Include="..\include\cglm\struct\affine-pre.h">
       <Filter>include\cglm\struct</Filter>
     </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\affine-mat.h">
+      <Filter>include\cglm\struct</Filter>
+    </ClInclude>
   </ItemGroup>
-</Project>
+</Project>