mat4_mul_mvp

docs/source/mat4.rst

@@ -32,6 +32,7 @@ Functions:
 #. :c:func:`glm_mat4_ins3`
 #. :c:func:`glm_mat4_mul`
 #. :c:func:`glm_mat4_mulN`
+#. :c:func:`glm_mat4_mul3`
 #. :c:func:`glm_mat4_mulv`
 #. :c:func:`glm_mat4_mulv3`
 #. :c:func:`glm_mat4_trace`
@@ -151,6 +152,24 @@ Functions documentation
       | *[in]*  **len**      matrices count
       | *[out]* **dest**     destination matrix
 
+.. c:function:: void glm_mat4_mul3(mat4 m1, mat4 m2, mat4 m3, mat4 dest)
+
+    multiply 3 mat4 matrices and store result in dest 
+    this function does not wrap glm_mat4_mulN
+    it multiplies m, v, and p matricies in reverse order
+    example:
+
+    .. code-block:: c
+
+       mat4 m1, m2, m3, dest;
+       glm_mat4_mul3(m1, m2, m3, dest);
+
+    Parameters:
+        | *[in]*  **m1**     right matrix
+        | *[in]*  **m2**     center matrix
+        | *[in]*  **m3**     left matrix
+        | *[out]* **dest**   result
+
 .. c:function:: void  glm_mat4_mulv(mat4 m, vec4 v, vec4 dest)
 
     multiply mat4 with vec4 (column vector) and store in dest vector

include/cglm/call/mat4.h

@@ -57,6 +57,10 @@ CGLM_EXPORT
 void
 glmc_mat4_mulN(mat4 * __restrict matrices[], uint32_t len, mat4 dest);
 
+CGLM_EXPORT
+void
+glmc_mat4_mul3(mat4 m1, mat4 m2, mat4 m3, mat4 dest);
+
 CGLM_EXPORT
 void
 glmc_mat4_mulv(mat4 m, vec4 v, vec4 dest);

include/cglm/mat4.h

@@ -28,6 +28,7 @@
    CGLM_INLINE void  glm_mat4_ins3(mat3 mat, mat4 dest);
    CGLM_INLINE void  glm_mat4_mul(mat4 m1, mat4 m2, mat4 dest);
    CGLM_INLINE void  glm_mat4_mulN(mat4 *matrices[], int len, mat4 dest);
+   CGLM_INLINE void  glm_mat4_mul3(mat4 m1, mat4 m2, mat4 m3, mat4 dest);
    CGLM_INLINE void  glm_mat4_mulv(mat4 m, vec4 v, vec4 dest);
    CGLM_INLINE void  glm_mat4_mulv3(mat4 m, vec3 v, float last, vec3 dest);
    CGLM_INLINE float glm_mat4_trace(mat4 m);
@@ -353,7 +354,7 @@ glm_mat4_mul(mat4 m1, mat4 m2, mat4 dest) {
 }
 
 /*!
- * @brief mupliply N mat4 matrices and store result in dest
+ * @brief multiply N mat4 matrices and store result in dest
  *
  * this function lets you multiply multiple (more than two or more...) matrices
  * <br><br>multiplication will be done in loop, this may reduce instructions
@@ -386,6 +387,37 @@ glm_mat4_mulN(mat4 * __restrict matrices[], uint32_t len, mat4 dest) {
     glm_mat4_mul(dest, *matrices[i], dest);
 }
 
+/*!
+ * @brief multiply 3 mat4 matrices and store result in dest 
+ *
+ * this function does not wrap glm_mat4_mulN
+ * <br></br>it multiplies m1, m2, and m3 matricies in reverse order
+ * 
+ * example:
+ * @code
+ * mat4 m1, m2, m3, dest;
+ *
+ * glm_mat4_mul3(m1, m2, m3, dest);
+ * @endcode
+ *
+ * to construct a ModelViewProjection matrix, you would do so like this:
+ * @code
+ * mat4 m, v, p, dest;
+ * // . . .
+ * glm_mat4_mul3(m1, m2, m3, dest);
+ *
+ * @param[in]  m1        right matrix
+ * @param[in]  m2        center matrix
+ * @param[in]  m3        left matrix
+ * @param[out] dest      result
+ */
+CGLM_INLINE
+void
+glm_mat4_mul3(mat4 m1, mat4 m2, mat4 m3, mat4 dest) {
+    glm_mat4_mul(m2, m1, dest);
+    glm_mat4_mul(m3, dest, dest);
+}
+
 /*!
  * @brief multiply mat4 with vec4 (column vector) and store in dest vector
  *

include/cglm/struct/mat4.h

@@ -247,6 +247,22 @@ glms_mat4_(mulN)(mat4s * __restrict matrices[], uint32_t len) {
   return r;
 }
 
+/*!
+ * @brief multiply 3 mat4 matrices and store result in mvp
+ *
+ * @param[in]  m    mat4 (left)
+ * @param[in]  v    mat4 (middle)
+ * @param[in]  p    mat4 (right)
+ * @returns         mat4 (result)
+ */
+CGLM_INLINE
+mat4s
+glms_mat4_(mul_mvp)(mat4s m, mat4s v, mat4s p) {
+  mat4s dest;
+  glm_mat4_mul3(m.raw, v.raw, p.raw, dest.raw);
+  return dest;
+}
+
 /*!
  * @brief multiply mat4 with vec4 (column vector) and store in dest vector
  *

src/mat4.c

@@ -68,6 +68,12 @@ glmc_mat4_mulN(mat4 * __restrict matrices[], uint32_t len, mat4 dest) {
   glm_mat4_mulN(matrices, len, dest);
 }
 
+CGLM_EXPORT
+void
+glmc_mat4_mul3(mat4 m1, mat4 m2, mat4 m3, mat4 dest) {
+    glm_mat4_mul3(m1, m2, m3, dest);
+}
+
 CGLM_EXPORT
 void
 glmc_mat4_mulv(mat4 m, vec4 v, vec4 dest) {

test/src/test_mat4.h

@@ -176,6 +176,31 @@ TEST_IMPL(GLM_PREFIX, mat4_mulN) {
   TEST_SUCCESS
 }
 
+TEST_IMPL(GLM_PREFIX, mat4_mul3) {
+    mat4 m1;
+    GLM(mat4_identity)(m1);
+
+    mat4 m2;
+    GLM(mat4_identity)(m2);
+    GLM(mat4_scale)(m2, 2);
+
+    mat4 m3;
+    GLM(mat4_identity)(m3);
+    GLM(mat4_scale)(m3, 3);
+
+    mat4 dest = {0};
+
+    mat4 _6i;
+    GLM(mat4_identity)(_6i);
+    GLM(mat4_scale)(_6i, 6);
+
+    GLM(mat4_mul3)(m1, m2, m3, dest);
+
+    ASSERTIFY(test_assert_mat4_eq(dest, _6i))
+
+    TEST_SUCCESS
+}
+
 TEST_IMPL(GLM_PREFIX, mat4_mulv) {
   vec4 res;
   mat4 mat = A_MATRIX;

test/tests.h

@@ -111,6 +111,7 @@ TEST_DECLARE(glm_mat4_pick3t)
 TEST_DECLARE(glm_mat4_ins3)
 TEST_DECLARE(glm_mat4_mul)
 TEST_DECLARE(glm_mat4_mulN)
+TEST_DECLARE(glm_mat4_mul3)
 TEST_DECLARE(glm_mat4_mulv)
 TEST_DECLARE(glm_mat4_mulv3)
 TEST_DECLARE(glm_mat4_trace)
@@ -139,6 +140,7 @@ TEST_DECLARE(glmc_mat4_pick3t)
 TEST_DECLARE(glmc_mat4_ins3)
 TEST_DECLARE(glmc_mat4_mul)
 TEST_DECLARE(glmc_mat4_mulN)
+TEST_DECLARE(glmc_mat4_mul3)
 TEST_DECLARE(glmc_mat4_mulv)
 TEST_DECLARE(glmc_mat4_mulv3)
 TEST_DECLARE(glmc_mat4_trace)
@@ -1322,6 +1324,7 @@ TEST_LIST {
   TEST_ENTRY(glm_mat4_ins3)
   TEST_ENTRY(glm_mat4_mul)
   TEST_ENTRY(glm_mat4_mulN)
+  TEST_ENTRY(glm_mat4_mul3)
   TEST_ENTRY(glm_mat4_mulv)
   TEST_ENTRY(glm_mat4_mulv3)
   TEST_ENTRY(glm_mat4_trace)
@@ -1350,6 +1353,7 @@ TEST_LIST {
   TEST_ENTRY(glmc_mat4_ins3)
   TEST_ENTRY(glmc_mat4_mul)
   TEST_ENTRY(glmc_mat4_mulN)
+  TEST_ENTRY(glmc_mat4_mul3)
   TEST_ENTRY(glmc_mat4_mulv)
   TEST_ENTRY(glmc_mat4_mulv3)
   TEST_ENTRY(glmc_mat4_trace)