From 1e077fd125d890d968624425593a2ccb3a0c2650 Mon Sep 17 00:00:00 2001
From: Recep Aslantas <info@recp.me>
Date: Sat, 22 Jul 2023 01:21:14 +0300
Subject: [PATCH 01/12] add some missing non-square matrix funcs

---
 include/cglm/call/mat2x3.h |  8 ++++++++
 include/cglm/call/mat2x4.h |  8 ++++++++
 include/cglm/call/mat3x2.h |  8 ++++++++
 include/cglm/call/mat3x4.h |  8 ++++++++
 include/cglm/call/mat4x2.h |  8 ++++++++
 include/cglm/call/mat4x3.h |  8 ++++++++
 include/cglm/mat2x3.h      | 30 ++++++++++++++++++++++++++++++
 include/cglm/mat2x4.h      | 26 ++++++++++++++++++++++++++
 include/cglm/mat3x2.h      | 31 +++++++++++++++++++++++++++++++
 include/cglm/mat3x4.h      | 26 ++++++++++++++++++++++++++
 include/cglm/mat4x2.h      | 34 ++++++++++++++++++++++++++++++++++
 include/cglm/mat4x3.h      | 34 ++++++++++++++++++++++++++++++++++
 include/cglm/types.h       |  6 +++---
 src/mat2x3.c               | 12 ++++++++++++
 src/mat2x4.c               | 12 ++++++++++++
 src/mat3x2.c               | 12 ++++++++++++
 src/mat3x4.c               | 12 ++++++++++++
 src/mat4x2.c               | 12 ++++++++++++
 src/mat4x3.c               | 12 ++++++++++++
 19 files changed, 304 insertions(+), 3 deletions(-)

diff --git a/include/cglm/call/mat2x3.h b/include/cglm/call/mat2x3.h
index 3ca44afc8..c7f0946db 100644
--- a/include/cglm/call/mat2x3.h
+++ b/include/cglm/call/mat2x3.h
@@ -13,6 +13,14 @@ extern "C" {
 
 #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);
diff --git a/include/cglm/call/mat2x4.h b/include/cglm/call/mat2x4.h
index 63c5cbee0..c2b649567 100644
--- a/include/cglm/call/mat2x4.h
+++ b/include/cglm/call/mat2x4.h
@@ -13,6 +13,14 @@ extern "C" {
 
 #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);
diff --git a/include/cglm/call/mat3x2.h b/include/cglm/call/mat3x2.h
index f2d04405e..491151bc9 100644
--- a/include/cglm/call/mat3x2.h
+++ b/include/cglm/call/mat3x2.h
@@ -13,6 +13,14 @@ extern "C" {
 
 #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);
diff --git a/include/cglm/call/mat3x4.h b/include/cglm/call/mat3x4.h
index 9f7b3c2a7..714d744cb 100644
--- a/include/cglm/call/mat3x4.h
+++ b/include/cglm/call/mat3x4.h
@@ -13,6 +13,14 @@ extern "C" {
 
 #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);
diff --git a/include/cglm/call/mat4x2.h b/include/cglm/call/mat4x2.h
index f36c7319c..3710745cd 100644
--- a/include/cglm/call/mat4x2.h
+++ b/include/cglm/call/mat4x2.h
@@ -13,6 +13,14 @@ extern "C" {
 
 #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);
diff --git a/include/cglm/call/mat4x3.h b/include/cglm/call/mat4x3.h
index a6b1cd388..7790aa856 100644
--- a/include/cglm/call/mat4x3.h
+++ b/include/cglm/call/mat4x3.h
@@ -13,6 +13,14 @@ extern "C" {
 
 #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);
diff --git a/include/cglm/mat2x3.h b/include/cglm/mat2x3.h
index 81d682dd3..8ae65eaa7 100644
--- a/include/cglm/mat2x3.h
+++ b/include/cglm/mat2x3.h
@@ -24,6 +24,36 @@
 /* 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
  *
diff --git a/include/cglm/mat2x4.h b/include/cglm/mat2x4.h
index a77976b64..4b6faa1ed 100644
--- a/include/cglm/mat2x4.h
+++ b/include/cglm/mat2x4.h
@@ -18,12 +18,38 @@
 #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
  *
diff --git a/include/cglm/mat3x2.h b/include/cglm/mat3x2.h
index 52f330cae..0b102861d 100644
--- a/include/cglm/mat3x2.h
+++ b/include/cglm/mat3x2.h
@@ -24,6 +24,37 @@
 /* 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
  *
diff --git a/include/cglm/mat3x4.h b/include/cglm/mat3x4.h
index a2cbdfd22..a22ca4ce8 100644
--- a/include/cglm/mat3x4.h
+++ b/include/cglm/mat3x4.h
@@ -26,6 +26,32 @@
 /* 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
  *
diff --git a/include/cglm/mat4x2.h b/include/cglm/mat4x2.h
index 1320763d6..b5074d372 100644
--- a/include/cglm/mat4x2.h
+++ b/include/cglm/mat4x2.h
@@ -24,6 +24,40 @@
 /* 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
  *
diff --git a/include/cglm/mat4x3.h b/include/cglm/mat4x3.h
index bc694303d..b185d750b 100644
--- a/include/cglm/mat4x3.h
+++ b/include/cglm/mat4x3.h
@@ -25,6 +25,40 @@
 /* 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[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_mat4x3_zero(mat4x3 mat) {
+  CGLM_ALIGN_MAT mat4x3 t = GLM_MAT4X3_ZERO_INIT;
+  glm_mat4x3_copy(t, mat);
+}
+
 /*!
  * @brief Create mat4x3 matrix from pointer
  *
diff --git a/include/cglm/types.h b/include/cglm/types.h
index 67d41a141..02b30cee2 100644
--- a/include/cglm/types.h
+++ b/include/cglm/types.h
@@ -46,9 +46,9 @@
 #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];
diff --git a/src/mat2x3.c b/src/mat2x3.c
index b3645b590..ab3287057 100644
--- a/src/mat2x3.c
+++ b/src/mat2x3.c
@@ -8,6 +8,18 @@
 #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) {
diff --git a/src/mat2x4.c b/src/mat2x4.c
index 5fb2d53e6..ad3ec0daf 100644
--- a/src/mat2x4.c
+++ b/src/mat2x4.c
@@ -8,6 +8,18 @@
 #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) {
diff --git a/src/mat3x2.c b/src/mat3x2.c
index fd6546c16..ac59ebf3a 100644
--- a/src/mat3x2.c
+++ b/src/mat3x2.c
@@ -8,6 +8,18 @@
 #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) {
diff --git a/src/mat3x4.c b/src/mat3x4.c
index 2f90a7fae..64be1619a 100644
--- a/src/mat3x4.c
+++ b/src/mat3x4.c
@@ -8,6 +8,18 @@
 #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) {
diff --git a/src/mat4x2.c b/src/mat4x2.c
index 4e137c662..622d1e2ed 100644
--- a/src/mat4x2.c
+++ b/src/mat4x2.c
@@ -8,6 +8,18 @@
 #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) {
diff --git a/src/mat4x3.c b/src/mat4x3.c
index 6617b47ac..60a14fe2e 100644
--- a/src/mat4x3.c
+++ b/src/mat4x3.c
@@ -8,6 +8,18 @@
 #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) {

From 6e9e91be051b507e95912664825cb1a1b203d1ff Mon Sep 17 00:00:00 2001
From: Recep Aslantas <info@recp.me>
Date: Sat, 22 Jul 2023 12:00:23 +0300
Subject: [PATCH 02/12] add _mul for non-square matrices

---
 include/cglm/call/mat2x3.h |  4 ++++
 include/cglm/call/mat2x4.h |  4 ++++
 include/cglm/call/mat3x2.h |  4 ++++
 include/cglm/call/mat3x4.h |  4 ++++
 include/cglm/call/mat4x2.h |  4 ++++
 include/cglm/call/mat4x3.h |  4 ++++
 include/cglm/mat2x3.h      | 30 +++++++++++++++++++++++++
 include/cglm/mat2x4.h      | 32 +++++++++++++++++++++++++++
 include/cglm/mat3x2.h      | 36 ++++++++++++++++++++++++++++++
 include/cglm/mat3x4.h      | 38 ++++++++++++++++++++++++++++++++
 include/cglm/mat4x2.h      | 45 ++++++++++++++++++++++++++++++++++++++
 include/cglm/mat4x3.h      | 45 ++++++++++++++++++++++++++++++++++++++
 src/mat2x3.c               |  6 +++++
 src/mat2x4.c               |  6 +++++
 src/mat3x2.c               |  6 +++++
 src/mat3x4.c               |  6 +++++
 src/mat4x2.c               |  6 +++++
 src/mat4x3.c               |  6 +++++
 18 files changed, 286 insertions(+)

diff --git a/include/cglm/call/mat2x3.h b/include/cglm/call/mat2x3.h
index c7f0946db..4e106e297 100644
--- a/include/cglm/call/mat2x3.h
+++ b/include/cglm/call/mat2x3.h
@@ -25,6 +25,10 @@ CGLM_EXPORT
 void
 glmc_mat2x3_make(float * __restrict src, mat2x3 dest);
 
+CGLM_EXPORT
+void
+glmc_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat2 dest);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/cglm/call/mat2x4.h b/include/cglm/call/mat2x4.h
index c2b649567..ead2b9cb2 100644
--- a/include/cglm/call/mat2x4.h
+++ b/include/cglm/call/mat2x4.h
@@ -25,6 +25,10 @@ CGLM_EXPORT
 void
 glmc_mat2x4_make(float * __restrict src, mat2x4 dest);
 
+CGLM_EXPORT
+void
+glmc_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat2 dest);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/cglm/call/mat3x2.h b/include/cglm/call/mat3x2.h
index 491151bc9..78dcab439 100644
--- a/include/cglm/call/mat3x2.h
+++ b/include/cglm/call/mat3x2.h
@@ -25,6 +25,10 @@ CGLM_EXPORT
 void
 glmc_mat3x2_make(float * __restrict src, mat3x2 dest);
 
+CGLM_EXPORT
+void
+glmc_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat3 dest);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/cglm/call/mat3x4.h b/include/cglm/call/mat3x4.h
index 714d744cb..bb4c20bf0 100644
--- a/include/cglm/call/mat3x4.h
+++ b/include/cglm/call/mat3x4.h
@@ -25,6 +25,10 @@ CGLM_EXPORT
 void
 glmc_mat3x4_make(float * __restrict src, mat3x4 dest);
 
+CGLM_EXPORT
+void
+glmc_mat3x4_mul(mat3x4 m1, mat4x3 m2, mat3 dest);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/cglm/call/mat4x2.h b/include/cglm/call/mat4x2.h
index 3710745cd..05875b56a 100644
--- a/include/cglm/call/mat4x2.h
+++ b/include/cglm/call/mat4x2.h
@@ -25,6 +25,10 @@ CGLM_EXPORT
 void
 glmc_mat4x2_make(float * __restrict src, mat4x2 dest);
 
+CGLM_EXPORT
+void
+glmc_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat4 dest);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/cglm/call/mat4x3.h b/include/cglm/call/mat4x3.h
index 7790aa856..a0b1af6e1 100644
--- a/include/cglm/call/mat4x3.h
+++ b/include/cglm/call/mat4x3.h
@@ -25,6 +25,10 @@ CGLM_EXPORT
 void
 glmc_mat4x3_make(float * __restrict src, mat4x3 dest);
 
+CGLM_EXPORT
+void
+glmc_mat4x3_mul(mat4x3 m1, mat3x4 m2, mat4 dest);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/cglm/mat2x3.h b/include/cglm/mat2x3.h
index 8ae65eaa7..fa507f95a 100644
--- a/include/cglm/mat2x3.h
+++ b/include/cglm/mat2x3.h
@@ -72,4 +72,34 @@ glm_mat2x3_make(float * __restrict src, mat2x3 dest) {
   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],
+        a10 = m1[1][0], a11 = m1[1][1],
+        a20 = m1[2][0], a21 = m1[2][1],
+
+        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 + a10 * b01 + a20 * b20;
+  dest[0][1] = a00 * b10 + a10 * b11 + a20 * b21;
+  dest[1][0] = a01 * b00 + a11 * b01 + a21 * b20;
+  dest[1][1] = a01 * b10 + a11 * b11 + a21 * b21;
+}
+
 #endif
diff --git a/include/cglm/mat2x4.h b/include/cglm/mat2x4.h
index 4b6faa1ed..b8a1e6269 100644
--- a/include/cglm/mat2x4.h
+++ b/include/cglm/mat2x4.h
@@ -70,4 +70,36 @@ glm_mat2x4_make(float * __restrict src, mat2x4 dest) {
   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],
+        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],
+        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 + a10 * b01 + a20 * b20 + a30 * b30;
+  dest[0][1] = a00 * b10 + a10 * b11 + a20 * b21 + a30 * b31;
+  dest[1][0] = a01 * b00 + a11 * b01 + a21 * b20 + a31 * b30;
+  dest[1][1] = a01 * b10 + a11 * b11 + a21 * b21 + a31 * b31;
+}
+
 #endif
diff --git a/include/cglm/mat3x2.h b/include/cglm/mat3x2.h
index 0b102861d..1ef742d54 100644
--- a/include/cglm/mat3x2.h
+++ b/include/cglm/mat3x2.h
@@ -74,4 +74,40 @@ glm_mat3x2_make(float * __restrict src, mat3x2 dest) {
   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 + a10 * b10;
+  dest[0][1] = a00 * b01 + a10 * b11;
+  dest[0][2] = a00 * b02 + a10 * b12;
+
+  dest[1][0] = a01 * b00 + a11 * b10;
+  dest[1][1] = a01 * b01 + a11 * b11;
+  dest[1][2] = a01 * b02 + a11 * b12;
+
+  dest[2][0] = a20 * b00 + a21 * b10;
+  dest[2][1] = a20 * b01 + a21 * b11;
+  dest[2][2] = a20 * b02 + a21 * b12;
+}
+
 #endif
diff --git a/include/cglm/mat3x4.h b/include/cglm/mat3x4.h
index a22ca4ce8..ff963e741 100644
--- a/include/cglm/mat3x4.h
+++ b/include/cglm/mat3x4.h
@@ -77,4 +77,42 @@ glm_mat3x4_make(float * __restrict src, mat3x4 dest) {
   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;
+}
+
 #endif
diff --git a/include/cglm/mat4x2.h b/include/cglm/mat4x2.h
index b5074d372..5a5aca1b4 100644
--- a/include/cglm/mat4x2.h
+++ b/include/cglm/mat4x2.h
@@ -80,4 +80,49 @@ glm_mat4x2_make(float * __restrict src, mat4x2 dest) {
   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 + a10 * b10;
+  dest[0][1] = a00 * b01 + a10 * b11;
+  dest[0][2] = a00 * b02 + a10 * b12;
+  dest[0][3] = a00 * b03 + a10 * b13;
+
+  dest[1][0] = a01 * b00 + a11 * b10;
+  dest[1][1] = a01 * b01 + a11 * b11;
+  dest[1][2] = a01 * b02 + a11 * b12;
+  dest[1][3] = a01 * 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;
+}
+
 #endif
diff --git a/include/cglm/mat4x3.h b/include/cglm/mat4x3.h
index b185d750b..7dc0e190e 100644
--- a/include/cglm/mat4x3.h
+++ b/include/cglm/mat4x3.h
@@ -85,4 +85,49 @@ glm_mat4x3_make(float * __restrict src, mat4x3 dest) {
   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;
+}
 #endif
diff --git a/src/mat2x3.c b/src/mat2x3.c
index ab3287057..8dff83f81 100644
--- a/src/mat2x3.c
+++ b/src/mat2x3.c
@@ -25,3 +25,9 @@ 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);
+}
diff --git a/src/mat2x4.c b/src/mat2x4.c
index ad3ec0daf..1b93520ec 100644
--- a/src/mat2x4.c
+++ b/src/mat2x4.c
@@ -25,3 +25,9 @@ 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);
+}
diff --git a/src/mat3x2.c b/src/mat3x2.c
index ac59ebf3a..377b4116f 100644
--- a/src/mat3x2.c
+++ b/src/mat3x2.c
@@ -25,3 +25,9 @@ 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);
+}
diff --git a/src/mat3x4.c b/src/mat3x4.c
index 64be1619a..f5f5f2337 100644
--- a/src/mat3x4.c
+++ b/src/mat3x4.c
@@ -25,3 +25,9 @@ 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);
+}
diff --git a/src/mat4x2.c b/src/mat4x2.c
index 622d1e2ed..0c0bbb76f 100644
--- a/src/mat4x2.c
+++ b/src/mat4x2.c
@@ -25,3 +25,9 @@ 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);
+}
diff --git a/src/mat4x3.c b/src/mat4x3.c
index 60a14fe2e..4d94b07f1 100644
--- a/src/mat4x3.c
+++ b/src/mat4x3.c
@@ -25,3 +25,9 @@ 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);
+}

From dbb85f24c85364cb903e9960bcd7c23e2c3ef210 Mon Sep 17 00:00:00 2001
From: Recep Aslantas <info@recp.me>
Date: Sat, 22 Jul 2023 13:37:36 +0300
Subject: [PATCH 03/12] add some missing non-square matrix funcs

---
 include/cglm/call/mat2x3.h | 12 +++++++
 include/cglm/call/mat2x4.h | 12 +++++++
 include/cglm/call/mat3x2.h | 12 +++++++
 include/cglm/call/mat3x4.h | 12 +++++++
 include/cglm/call/mat4x2.h | 12 +++++++
 include/cglm/call/mat4x3.h | 12 +++++++
 include/cglm/mat2x3.h      | 53 ++++++++++++++++++++++++++++-
 include/cglm/mat2x4.h      | 54 +++++++++++++++++++++++++++++-
 include/cglm/mat3x2.h      | 53 ++++++++++++++++++++++++++++-
 include/cglm/mat3x4.h      | 57 +++++++++++++++++++++++++++++++-
 include/cglm/mat4x2.h      | 60 ++++++++++++++++++++++++++++++++-
 include/cglm/mat4x3.h      | 68 +++++++++++++++++++++++++++++++++++++-
 src/mat2x3.c               | 18 ++++++++++
 src/mat2x4.c               | 18 ++++++++++
 src/mat3x2.c               | 18 ++++++++++
 src/mat3x4.c               | 18 ++++++++++
 src/mat4x2.c               | 18 ++++++++++
 src/mat4x3.c               | 18 ++++++++++
 18 files changed, 519 insertions(+), 6 deletions(-)

diff --git a/include/cglm/call/mat2x3.h b/include/cglm/call/mat2x3.h
index 4e106e297..c70bbf63a 100644
--- a/include/cglm/call/mat2x3.h
+++ b/include/cglm/call/mat2x3.h
@@ -29,6 +29,18 @@ 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
diff --git a/include/cglm/call/mat2x4.h b/include/cglm/call/mat2x4.h
index ead2b9cb2..2c7fa5266 100644
--- a/include/cglm/call/mat2x4.h
+++ b/include/cglm/call/mat2x4.h
@@ -29,6 +29,18 @@ 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
diff --git a/include/cglm/call/mat3x2.h b/include/cglm/call/mat3x2.h
index 78dcab439..4d7871291 100644
--- a/include/cglm/call/mat3x2.h
+++ b/include/cglm/call/mat3x2.h
@@ -29,6 +29,18 @@ 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
diff --git a/include/cglm/call/mat3x4.h b/include/cglm/call/mat3x4.h
index bb4c20bf0..60fe94961 100644
--- a/include/cglm/call/mat3x4.h
+++ b/include/cglm/call/mat3x4.h
@@ -29,6 +29,18 @@ 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
diff --git a/include/cglm/call/mat4x2.h b/include/cglm/call/mat4x2.h
index 05875b56a..ba60fce48 100644
--- a/include/cglm/call/mat4x2.h
+++ b/include/cglm/call/mat4x2.h
@@ -29,6 +29,18 @@ 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
diff --git a/include/cglm/call/mat4x3.h b/include/cglm/call/mat4x3.h
index a0b1af6e1..411ea118d 100644
--- a/include/cglm/call/mat4x3.h
+++ b/include/cglm/call/mat4x3.h
@@ -29,6 +29,18 @@ 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
diff --git a/include/cglm/mat2x3.h b/include/cglm/mat2x3.h
index fa507f95a..aab0dc133 100644
--- a/include/cglm/mat2x3.h
+++ b/include/cglm/mat2x3.h
@@ -11,7 +11,13 @@
    GLM_MAT2X3_ZERO
 
  Functions:
-   CGLM_INLINE void  glm_mat2x3_make(float * restrict src, mat2x3 dest)
+   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
@@ -102,4 +108,49 @@ glm_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat2 dest) {
   dest[1][1] = a01 * b10 + a11 * b11 + a21 * 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
diff --git a/include/cglm/mat2x4.h b/include/cglm/mat2x4.h
index b8a1e6269..42f66738b 100644
--- a/include/cglm/mat2x4.h
+++ b/include/cglm/mat2x4.h
@@ -11,7 +11,13 @@
    GLM_MAT2X4_ZERO
 
  Functions:
-   CGLM_INLINE void  glm_mat2x4_make(float * restrict src, mat2x4 dest)
+   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
@@ -102,4 +108,50 @@ glm_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat2 dest) {
   dest[1][1] = a01 * b10 + a11 * b11 + a21 * b21 + a31 * 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[2][2] *= s;  m[3][3] *= s;
+}
+
 #endif
diff --git a/include/cglm/mat3x2.h b/include/cglm/mat3x2.h
index 1ef742d54..f3801ed45 100644
--- a/include/cglm/mat3x2.h
+++ b/include/cglm/mat3x2.h
@@ -11,7 +11,13 @@
    GLM_MAT3X2_ZERO
 
  Functions:
-   CGLM_INLINE void  glm_mat3x2_make(float * restrict src, mat3x2 dest)
+   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
@@ -110,4 +116,49 @@ glm_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat3 dest) {
   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
diff --git a/include/cglm/mat3x4.h b/include/cglm/mat3x4.h
index ff963e741..86fb938d5 100644
--- a/include/cglm/mat3x4.h
+++ b/include/cglm/mat3x4.h
@@ -11,7 +11,13 @@
    GLM_MAT3X4_ZERO
 
  Functions:
-   CGLM_INLINE void  glm_mat3x4_make(float * restrict src, mat3x4 dest)
+   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
@@ -115,4 +121,53 @@ glm_mat3x4_mul(mat3x4 m1, mat4x3 m2, mat3 dest) {
   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
diff --git a/include/cglm/mat4x2.h b/include/cglm/mat4x2.h
index 5a5aca1b4..183b38a3a 100644
--- a/include/cglm/mat4x2.h
+++ b/include/cglm/mat4x2.h
@@ -11,7 +11,13 @@
    GLM_MAT4X2_ZERO
 
  Functions:
-   CGLM_INLINE void  glm_mat4x2_make(float * restrict src, mat4x2 dest)
+   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
@@ -125,4 +131,56 @@ glm_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat4 dest) {
   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
diff --git a/include/cglm/mat4x3.h b/include/cglm/mat4x3.h
index 7dc0e190e..de96d84f5 100644
--- a/include/cglm/mat4x3.h
+++ b/include/cglm/mat4x3.h
@@ -11,7 +11,13 @@
    GLM_MAT4X3_ZERO
 
  Functions:
-   CGLM_INLINE void  glm_mat4x3_make(float * restrict src, mat4x3 dest)
+   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
@@ -130,4 +136,64 @@ glm_mat4x3_mul(mat4x3 m1, mat3x4 m2, mat4 dest) {
   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
diff --git a/src/mat2x3.c b/src/mat2x3.c
index 8dff83f81..da508e8de 100644
--- a/src/mat2x3.c
+++ b/src/mat2x3.c
@@ -31,3 +31,21 @@ 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);
+}
diff --git a/src/mat2x4.c b/src/mat2x4.c
index 1b93520ec..b941d63f7 100644
--- a/src/mat2x4.c
+++ b/src/mat2x4.c
@@ -31,3 +31,21 @@ 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);
+}
diff --git a/src/mat3x2.c b/src/mat3x2.c
index 377b4116f..3b0067e3f 100644
--- a/src/mat3x2.c
+++ b/src/mat3x2.c
@@ -31,3 +31,21 @@ 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);
+}
diff --git a/src/mat3x4.c b/src/mat3x4.c
index f5f5f2337..9232e5154 100644
--- a/src/mat3x4.c
+++ b/src/mat3x4.c
@@ -31,3 +31,21 @@ 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);
+}
diff --git a/src/mat4x2.c b/src/mat4x2.c
index 0c0bbb76f..f46255795 100644
--- a/src/mat4x2.c
+++ b/src/mat4x2.c
@@ -31,3 +31,21 @@ 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);
+}
diff --git a/src/mat4x3.c b/src/mat4x3.c
index 4d94b07f1..969ee90ef 100644
--- a/src/mat4x3.c
+++ b/src/mat4x3.c
@@ -31,3 +31,21 @@ 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);
+}

From 4d5653b1f658272c869552c23ff35472cc35f051 Mon Sep 17 00:00:00 2001
From: Recep Aslantas <info@recp.me>
Date: Sat, 22 Jul 2023 14:17:26 +0300
Subject: [PATCH 04/12] add some missing non-square matrix funcs in struct api

---
 include/cglm/struct/mat2x3.h | 83 +++++++++++++++++++++++++++++++++++
 include/cglm/struct/mat2x4.h | 83 +++++++++++++++++++++++++++++++++++
 include/cglm/struct/mat3x2.h | 83 +++++++++++++++++++++++++++++++++++
 include/cglm/struct/mat3x4.h | 83 +++++++++++++++++++++++++++++++++++
 include/cglm/struct/mat4x2.h | 84 ++++++++++++++++++++++++++++++++++++
 include/cglm/struct/mat4x3.h | 83 +++++++++++++++++++++++++++++++++++
 6 files changed, 499 insertions(+)

diff --git a/include/cglm/struct/mat2x3.h b/include/cglm/struct/mat2x3.h
index 483aea0d1..d0aacb02c 100644
--- a/include/cglm/struct/mat2x3.h
+++ b/include/cglm/struct/mat2x3.h
@@ -11,7 +11,12 @@
    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
@@ -29,6 +34,19 @@
 /* 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
  *
@@ -43,4 +61,69 @@ glms_mat2x3_(make)(float * __restrict src) {
   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 */
diff --git a/include/cglm/struct/mat2x4.h b/include/cglm/struct/mat2x4.h
index be76854d0..4b31dd2d6 100644
--- a/include/cglm/struct/mat2x4.h
+++ b/include/cglm/struct/mat2x4.h
@@ -11,7 +11,12 @@
    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
@@ -29,6 +34,19 @@
 /* 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
  *
@@ -43,4 +61,69 @@ glms_mat2x4_(make)(float * __restrict src) {
   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 */
diff --git a/include/cglm/struct/mat3x2.h b/include/cglm/struct/mat3x2.h
index 4c3529118..7f3c13481 100644
--- a/include/cglm/struct/mat3x2.h
+++ b/include/cglm/struct/mat3x2.h
@@ -11,7 +11,12 @@
    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
@@ -29,6 +34,19 @@
 /* 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
  *
@@ -43,4 +61,69 @@ glms_mat3x2_(make)(float * __restrict src) {
   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 */
diff --git a/include/cglm/struct/mat3x4.h b/include/cglm/struct/mat3x4.h
index 2bc024190..c273b2dfd 100644
--- a/include/cglm/struct/mat3x4.h
+++ b/include/cglm/struct/mat3x4.h
@@ -11,7 +11,12 @@
    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
@@ -29,6 +34,19 @@
 /* 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
  *
@@ -43,4 +61,69 @@ glms_mat3x4_(make)(float * __restrict src) {
   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 */
diff --git a/include/cglm/struct/mat4x2.h b/include/cglm/struct/mat4x2.h
index a367afb93..33449bbfd 100644
--- a/include/cglm/struct/mat4x2.h
+++ b/include/cglm/struct/mat4x2.h
@@ -11,7 +11,12 @@
    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
@@ -29,6 +34,20 @@
 /* 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
  *
@@ -43,4 +62,69 @@ glms_mat4x2_(make)(float * __restrict src) {
   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 */
diff --git a/include/cglm/struct/mat4x3.h b/include/cglm/struct/mat4x3.h
index 97a7c325c..30aea81ac 100644
--- a/include/cglm/struct/mat4x3.h
+++ b/include/cglm/struct/mat4x3.h
@@ -11,7 +11,12 @@
    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
@@ -29,6 +34,19 @@
 /* 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
  *
@@ -43,4 +61,69 @@ glms_mat4x3_(make)(float * __restrict src) {
   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 */

From 0fb9e73ec169c7131d9e31f8341ab50305127e5b Mon Sep 17 00:00:00 2001
From: Vincent Davis Jr <vince@underview.tech>
Date: Sat, 5 Aug 2023 20:48:13 -0400
Subject: [PATCH 05/12] docs: add missing non-square matrix funcs

Functions include:
	* glm_mat#x#_copy
	* glm_mat#x#_zero
	* glm_mat#x#_mul
	* glm_mat#x#_mulv
	* glm_mat#x#_transpose
	* glm_mat#x#_scale

Commit also includes some minor changes to
	* mat2
	* mat3
	* mat4

Signed-off-by: Vincent Davis Jr <vince@underview.tech>
---
 docs/source/mat2.rst   |  9 +++---
 docs/source/mat2x3.rst | 63 +++++++++++++++++++++++++++++++++++++++++-
 docs/source/mat2x4.rst | 63 +++++++++++++++++++++++++++++++++++++++++-
 docs/source/mat3.rst   |  9 +++---
 docs/source/mat3x2.rst | 63 +++++++++++++++++++++++++++++++++++++++++-
 docs/source/mat3x4.rst | 63 +++++++++++++++++++++++++++++++++++++++++-
 docs/source/mat4.rst   |  2 +-
 docs/source/mat4x2.rst | 63 +++++++++++++++++++++++++++++++++++++++++-
 docs/source/mat4x3.rst | 63 +++++++++++++++++++++++++++++++++++++++++-
 9 files changed, 383 insertions(+), 15 deletions(-)

diff --git a/docs/source/mat2.rst b/docs/source/mat2.rst
index 119049d82..268d09843 100644
--- a/docs/source/mat2.rst
+++ b/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)
 
diff --git a/docs/source/mat2x3.rst b/docs/source/mat2x3.rst
index 6f7f8bb3e..99ab6d51c 100644
--- a/docs/source/mat2x3.rst
+++ b/docs/source/mat2x3.rst
@@ -15,11 +15,32 @@ Macros:
 
 Functions:
 
-1. :c:func:`glm_mat2x3_make`
+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
@@ -29,3 +50,43 @@ Functions documentation
     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
diff --git a/docs/source/mat2x4.rst b/docs/source/mat2x4.rst
index 499bc950f..efb79ded4 100644
--- a/docs/source/mat2x4.rst
+++ b/docs/source/mat2x4.rst
@@ -15,11 +15,32 @@ Macros:
 
 Functions:
 
-1. :c:func:`glm_mat2x4_make`
+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
@@ -29,3 +50,43 @@ Functions documentation
     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
diff --git a/docs/source/mat3.rst b/docs/source/mat3.rst
index 58863a28e..a14e773e9 100644
--- a/docs/source/mat3.rst
+++ b/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)
 
diff --git a/docs/source/mat3x2.rst b/docs/source/mat3x2.rst
index d89643146..0a9cb87fb 100644
--- a/docs/source/mat3x2.rst
+++ b/docs/source/mat3x2.rst
@@ -15,11 +15,32 @@ Macros:
 
 Functions:
 
-1. :c:func:`glm_mat3x2_make`
+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
@@ -28,3 +49,43 @@ Functions documentation
     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
diff --git a/docs/source/mat3x4.rst b/docs/source/mat3x4.rst
index 15a7d08d7..8afaff052 100644
--- a/docs/source/mat3x4.rst
+++ b/docs/source/mat3x4.rst
@@ -15,11 +15,32 @@ Macros:
 
 Functions:
 
-1. :c:func:`glm_mat3x4_make`
+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
@@ -28,3 +49,43 @@ Functions documentation
     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
diff --git a/docs/source/mat4.rst b/docs/source/mat4.rst
index 6fb8a38b7..34c39be8a 100644
--- a/docs/source/mat4.rst
+++ b/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)
diff --git a/docs/source/mat4x2.rst b/docs/source/mat4x2.rst
index 99f03bacd..ccda3acf3 100644
--- a/docs/source/mat4x2.rst
+++ b/docs/source/mat4x2.rst
@@ -15,11 +15,32 @@ Macros:
 
 Functions:
 
-1. :c:func:`glm_mat4x2_make`
+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
@@ -28,3 +49,43 @@ Functions documentation
     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
diff --git a/docs/source/mat4x3.rst b/docs/source/mat4x3.rst
index 4e1cd5c8d..7284045f5 100644
--- a/docs/source/mat4x3.rst
+++ b/docs/source/mat4x3.rst
@@ -15,11 +15,32 @@ Macros:
 
 Functions:
 
-1. :c:func:`glm_mat4x3_make`
+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
@@ -28,3 +49,43 @@ Functions documentation
     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

From aa37c1aa749a2791b4d0ad33a71d83a37f123e87 Mon Sep 17 00:00:00 2001
From: Vincent Davis Jr <vince@underview.tech>
Date: Sun, 6 Aug 2023 00:29:06 -0400
Subject: [PATCH 06/12] fix array subscript is outside array bounds
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

warning: array subscript # is outside array bounds
of ‘float[#]’ [-Warray-bounds]

Commit also fixes variable order when calculating
multiplication between two matrices.

Signed-off-by: Vincent Davis Jr <vince@underview.tech>
---
 include/cglm/mat2x3.h | 14 +++++++-------
 include/cglm/mat2x4.h | 17 ++++++++---------
 include/cglm/mat3x2.h | 12 ++++++------
 include/cglm/mat4x2.h | 18 +++++++++---------
 include/cglm/mat4x3.h |  4 ++++
 5 files changed, 34 insertions(+), 31 deletions(-)

diff --git a/include/cglm/mat2x3.h b/include/cglm/mat2x3.h
index aab0dc133..e7ca209ca 100644
--- a/include/cglm/mat2x3.h
+++ b/include/cglm/mat2x3.h
@@ -94,18 +94,18 @@ glm_mat2x3_make(float * __restrict src, mat2x3 dest) {
 CGLM_INLINE
 void
 glm_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat2 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],
+  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 + a10 * b01 + a20 * b20;
-  dest[0][1] = a00 * b10 + a10 * b11 + a20 * b21;
-  dest[1][0] = a01 * b00 + a11 * b01 + a21 * b20;
-  dest[1][1] = a01 * b10 + a11 * b11 + a21 * b21;
+  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;
 }
 
 /*!
diff --git a/include/cglm/mat2x4.h b/include/cglm/mat2x4.h
index 42f66738b..28156cd2a 100644
--- a/include/cglm/mat2x4.h
+++ b/include/cglm/mat2x4.h
@@ -92,20 +92,19 @@ glm_mat2x4_make(float * __restrict src, mat2x4 dest) {
 CGLM_INLINE
 void
 glm_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat2 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],
+  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 + a10 * b01 + a20 * b20 + a30 * b30;
-  dest[0][1] = a00 * b10 + a10 * b11 + a20 * b21 + a30 * b31;
-  dest[1][0] = a01 * b00 + a11 * b01 + a21 * b20 + a31 * b30;
-  dest[1][1] = a01 * b10 + a11 * b11 + a21 * b21 + a31 * b31;
+  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;
 }
 
 /*!
@@ -151,7 +150,7 @@ 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[2][2] *= s;  m[3][3] *= s;
+  m[1][0] *= s;  m[1][1] *= s;  m[1][2] *= s;  m[1][3] *= s;
 }
 
 #endif
diff --git a/include/cglm/mat3x2.h b/include/cglm/mat3x2.h
index f3801ed45..f7c8a72bd 100644
--- a/include/cglm/mat3x2.h
+++ b/include/cglm/mat3x2.h
@@ -103,13 +103,13 @@ glm_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat3 dest) {
         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 + a10 * b10;
-  dest[0][1] = a00 * b01 + a10 * b11;
-  dest[0][2] = a00 * b02 + a10 * b12;
+  dest[0][0] = a00 * b00 + a01 * b10;
+  dest[0][1] = a00 * b01 + a01 * b11;
+  dest[0][2] = a00 * b02 + a01 * b12;
 
-  dest[1][0] = a01 * b00 + a11 * b10;
-  dest[1][1] = a01 * b01 + a11 * b11;
-  dest[1][2] = a01 * b02 + a11 * 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;
diff --git a/include/cglm/mat4x2.h b/include/cglm/mat4x2.h
index 183b38a3a..4c647a28c 100644
--- a/include/cglm/mat4x2.h
+++ b/include/cglm/mat4x2.h
@@ -110,15 +110,15 @@ glm_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat4 dest) {
         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 + a10 * b10;
-  dest[0][1] = a00 * b01 + a10 * b11;
-  dest[0][2] = a00 * b02 + a10 * b12;
-  dest[0][3] = a00 * b03 + a10 * b13;
-
-  dest[1][0] = a01 * b00 + a11 * b10;
-  dest[1][1] = a01 * b01 + a11 * b11;
-  dest[1][2] = a01 * b02 + a11 * b12;
-  dest[1][3] = a01 * b03 + a11 * b13;
+  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;
diff --git a/include/cglm/mat4x3.h b/include/cglm/mat4x3.h
index de96d84f5..1066dfc97 100644
--- a/include/cglm/mat4x3.h
+++ b/include/cglm/mat4x3.h
@@ -42,15 +42,19 @@ 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];
 }
 
 /*!

From 006e4ffbdf7b05373c5f7200c266eebee7588d74 Mon Sep 17 00:00:00 2001
From: Vincent Davis Jr <vince@underview.tech>
Date: Sun, 6 Aug 2023 02:40:58 -0400
Subject: [PATCH 07/12] test: add missing mat2x3 tests

Signed-off-by: Vincent Davis Jr <vince@underview.tech>
---
 test/src/test_common.c |  46 ++++++++++++++++++
 test/src/test_common.h |  12 +++++
 test/src/test_mat2x3.h | 104 +++++++++++++++++++++++++++++++++++++++++
 test/tests.h           |  24 ++++++++++
 4 files changed, 186 insertions(+)

diff --git a/test/src/test_common.c b/test/src/test_common.c
index d11ff6f5a..f499e1ce5 100644
--- a/test/src/test_common.c
+++ b/test/src/test_common.c
@@ -31,6 +31,16 @@ 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_mat2(mat2 dest) {
   dest[0][0] = drand48();
@@ -39,6 +49,16 @@ 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_vec3(vec3 dest) {
   dest[0] = drand48();
@@ -187,6 +207,19 @@ test_assert_mat2x3_eq_zero(mat2x3 m2x3) {
   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;
@@ -269,6 +302,19 @@ test_assert_mat3x2_eq_zero(mat3x2 m3x2) {
   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;
diff --git a/test/src/test_common.h b/test/src/test_common.h
index 0338d15b0..5598322f8 100644
--- a/test/src/test_common.h
+++ b/test/src/test_common.h
@@ -20,9 +20,15 @@ test_rand_mat4(mat4 dest);
 void
 test_rand_mat3(mat3 dest);
 
+void
+test_rand_mat3x2(mat3x2 dest);
+
 void
 test_rand_mat2(mat2 dest);
 
+void
+test_rand_mat2x3(mat2x3 dest);
+
 test_status_t
 test_assert_eqf(float a, float b);
 
@@ -62,6 +68,9 @@ 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);
 
@@ -83,6 +92,9 @@ 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);
 
diff --git a/test/src/test_mat2x3.h b/test/src/test_mat2x3.h
index 566230c4b..7d615e43d 100644
--- a/test/src/test_mat2x3.h
+++ b/test/src/test_mat2x3.h
@@ -7,6 +7,9 @@
 
 #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
 
@@ -24,6 +27,31 @@ TEST_IMPL(MACRO_GLM_MAT2X3_ZERO) {
 
 #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,
@@ -50,3 +78,79 @@ TEST_IMPL(GLM_PREFIX, mat2x3_make) {
 
   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
+}
diff --git a/test/tests.h b/test/tests.h
index aab760f75..101a2682b 100644
--- a/test/tests.h
+++ b/test/tests.h
@@ -254,9 +254,21 @@ 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)
@@ -1157,9 +1169,21 @@ TEST_LIST {
 
   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)

From 37d20f7da8e09dfc83fa08734937f744e5102224 Mon Sep 17 00:00:00 2001
From: Vincent Davis Jr <vince@underview.tech>
Date: Sun, 6 Aug 2023 10:18:41 -0400
Subject: [PATCH 08/12] test: add missing mat2x4 tests

Signed-off-by: Vincent Davis Jr <vince@underview.tech>
---
 test/src/test_common.c |  53 +++++++++++++++++++++
 test/src/test_common.h |  12 +++++
 test/src/test_mat2x4.h | 104 +++++++++++++++++++++++++++++++++++++++++
 test/tests.h           |  26 ++++++++++-
 4 files changed, 194 insertions(+), 1 deletion(-)

diff --git a/test/src/test_common.c b/test/src/test_common.c
index f499e1ce5..63b6fd91d 100644
--- a/test/src/test_common.c
+++ b/test/src/test_common.c
@@ -22,6 +22,21 @@ 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_mat3(mat3 dest) {
   mat4 m4;
@@ -59,6 +74,18 @@ test_rand_mat2x3(mat2x3 dest) {
   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();
@@ -233,6 +260,19 @@ test_assert_mat2x4_eq_zero(mat2x4 m2x4) {
   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;
@@ -371,6 +411,19 @@ test_assert_mat4x2_eq_zero(mat4x2 m4x2) {
   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;
diff --git a/test/src/test_common.h b/test/src/test_common.h
index 5598322f8..bd4ecd9a6 100644
--- a/test/src/test_common.h
+++ b/test/src/test_common.h
@@ -17,6 +17,9 @@
 void
 test_rand_mat4(mat4 dest);
 
+void
+test_rand_mat4x2(mat4x2 dest);
+
 void
 test_rand_mat3(mat3 dest);
 
@@ -29,6 +32,9 @@ 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);
 
@@ -50,6 +56,9 @@ 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);
 
@@ -74,6 +83,9 @@ 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);
 
diff --git a/test/src/test_mat2x4.h b/test/src/test_mat2x4.h
index 7348965aa..ea594d160 100644
--- a/test/src/test_mat2x4.h
+++ b/test/src/test_mat2x4.h
@@ -8,6 +8,9 @@
 
 #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
 
@@ -25,6 +28,31 @@ TEST_IMPL(MACRO_GLM_MAT2X4_ZERO) {
 
 #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,
@@ -53,3 +81,79 @@ TEST_IMPL(GLM_PREFIX, mat2x4_make) {
 
   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
+}
diff --git a/test/tests.h b/test/tests.h
index 101a2682b..600188619 100644
--- a/test/tests.h
+++ b/test/tests.h
@@ -272,9 +272,21 @@ 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)
@@ -1187,9 +1199,21 @@ TEST_LIST {
 
   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(glmc_mat2x4_make)
+  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)

From eece0b7bc9bb3ff67bbede06b8e31c0df0b2baba Mon Sep 17 00:00:00 2001
From: Vincent Davis Jr <vince@underview.tech>
Date: Sun, 6 Aug 2023 11:02:55 -0400
Subject: [PATCH 09/12] test: add missing mat3x2 tests

Signed-off-by: Vincent Davis Jr <vince@underview.tech>
---
 test/src/test_mat3x2.h | 102 +++++++++++++++++++++++++++++++++++++++++
 test/tests.h           |  24 ++++++++++
 2 files changed, 126 insertions(+)

diff --git a/test/src/test_mat3x2.h b/test/src/test_mat3x2.h
index cbf3be2e4..a825a2be3 100644
--- a/test/src/test_mat3x2.h
+++ b/test/src/test_mat3x2.h
@@ -7,6 +7,9 @@
 
 #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
 
@@ -24,6 +27,31 @@ TEST_IMPL(MACRO_GLM_MAT3X2_ZERO) {
 
 #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,
@@ -51,3 +79,77 @@ TEST_IMPL(GLM_PREFIX, mat3x2_make) {
 
   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
+}
diff --git a/test/tests.h b/test/tests.h
index 600188619..7b25124e4 100644
--- a/test/tests.h
+++ b/test/tests.h
@@ -204,9 +204,21 @@ 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)
@@ -1131,9 +1143,21 @@ TEST_LIST {
 
   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)

From f0f7b67ef4a5bb67d569b493929fa7580e1c1126 Mon Sep 17 00:00:00 2001
From: Vincent Davis Jr <vince@underview.tech>
Date: Sun, 6 Aug 2023 13:23:31 -0400
Subject: [PATCH 10/12] test: add missing mat3x4 tests

Signed-off-by: Vincent Davis Jr <vince@underview.tech>
---
 test/src/test_common.c |  63 +++++++++++++++++++++++++
 test/src/test_common.h |  12 +++++
 test/src/test_mat3x4.h | 102 +++++++++++++++++++++++++++++++++++++++++
 3 files changed, 177 insertions(+)

diff --git a/test/src/test_common.c b/test/src/test_common.c
index 63b6fd91d..a6c31c6c5 100644
--- a/test/src/test_common.c
+++ b/test/src/test_common.c
@@ -37,6 +37,25 @@ test_rand_mat4x2(mat4x2 dest) {
   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;
@@ -56,6 +75,24 @@ test_rand_mat3x2(mat3x2 dest) {
   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();
@@ -368,6 +405,19 @@ test_assert_mat3x4_eq_zero(mat3x4 m3x4) {
   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;
@@ -437,6 +487,19 @@ test_assert_mat4x3_eq_zero(mat4x3 m4x3) {
   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 */
diff --git a/test/src/test_common.h b/test/src/test_common.h
index bd4ecd9a6..4fff04085 100644
--- a/test/src/test_common.h
+++ b/test/src/test_common.h
@@ -20,12 +20,18 @@ 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);
 
@@ -62,6 +68,9 @@ 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);
 
@@ -110,6 +119,9 @@ 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);
 
diff --git a/test/src/test_mat3x4.h b/test/src/test_mat3x4.h
index 83dd011a9..c7d704c52 100644
--- a/test/src/test_mat3x4.h
+++ b/test/src/test_mat3x4.h
@@ -7,6 +7,9 @@
 
 #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
 
@@ -24,6 +27,31 @@ TEST_IMPL(MACRO_GLM_MAT3X4_ZERO) {
 
 #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,
@@ -57,3 +85,77 @@ TEST_IMPL(GLM_PREFIX, mat3x4_make) {
 
   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
+}

From a5d8e61c2ba0b44838cf2da50ab1a779c0ebae0b Mon Sep 17 00:00:00 2001
From: Vincent Davis Jr <vince@underview.tech>
Date: Sun, 6 Aug 2023 13:45:17 -0400
Subject: [PATCH 11/12] test: add missing mat4x2 tests

Signed-off-by: Vincent Davis Jr <vince@underview.tech>
---
 test/src/test_mat4x2.h | 102 +++++++++++++++++++++++++++++++++++++++++
 test/tests.h           |  24 ++++++++++
 2 files changed, 126 insertions(+)

diff --git a/test/src/test_mat4x2.h b/test/src/test_mat4x2.h
index ea745071c..fd1ac488c 100644
--- a/test/src/test_mat4x2.h
+++ b/test/src/test_mat4x2.h
@@ -7,6 +7,9 @@
 
 #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
 
@@ -24,6 +27,31 @@ TEST_IMPL(MACRO_GLM_MAT4X2_ZERO) {
 
 #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,
@@ -54,3 +82,77 @@ TEST_IMPL(GLM_PREFIX, mat4x2_make) {
 
   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
+}
diff --git a/test/tests.h b/test/tests.h
index 7b25124e4..b27751ba1 100644
--- a/test/tests.h
+++ b/test/tests.h
@@ -155,9 +155,21 @@ 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)
@@ -1094,9 +1106,21 @@ TEST_LIST {
 
   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)

From da51741c503be915091cf07c10489187bbda5675 Mon Sep 17 00:00:00 2001
From: Vincent Davis Jr <vince@underview.tech>
Date: Sun, 6 Aug 2023 14:12:46 -0400
Subject: [PATCH 12/12] test: add missing mat4x3 tests

Signed-off-by: Vincent Davis Jr <vince@underview.tech>
---
 test/src/test_mat4x3.h | 102 +++++++++++++++++++++++++++++++++++++++++
 test/tests.h           |  24 ++++++++++
 2 files changed, 126 insertions(+)

diff --git a/test/src/test_mat4x3.h b/test/src/test_mat4x3.h
index 27b8795c4..b760405be 100644
--- a/test/src/test_mat4x3.h
+++ b/test/src/test_mat4x3.h
@@ -7,6 +7,9 @@
 
 #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
 
@@ -24,6 +27,31 @@ TEST_IMPL(MACRO_GLM_MAT4X3_ZERO) {
 
 #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,
@@ -58,3 +86,77 @@ TEST_IMPL(GLM_PREFIX, mat4x3_make) {
 
   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
+}
diff --git a/test/tests.h b/test/tests.h
index b27751ba1..9c9334594 100644
--- a/test/tests.h
+++ b/test/tests.h
@@ -173,9 +173,21 @@ 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)
@@ -1124,9 +1136,21 @@ TEST_LIST {
 
   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)