From dde053a29566477b48ab61603fa7436a09d94d09 Mon Sep 17 00:00:00 2001 From: Vincent Davis Jr Date: Sat, 5 Apr 2025 09:58:49 -0400 Subject: [PATCH 1/3] mat2x3[docs]: fix glm_mat2x3_zero parameters Signed-off-by: Vincent Davis Jr --- docs/source/mat2x3.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/mat2x3.rst b/docs/source/mat2x3.rst index 33298a0..5a250f2 100644 --- a/docs/source/mat2x3.rst +++ b/docs/source/mat2x3.rst @@ -63,7 +63,7 @@ Functions documentation Zero out the mat2x3 (m). Parameters: - | *[in, out]* **mat** mat2x3 (src, dest) + | *[in, out]* **m** mat2x3 (src, dest) .. csv-table:: mat2x3 **(m)** :header: "", "column 1", "column 2" From 5d530cd8e0e568ccf71a08ed6239f013c375f1d3 Mon Sep 17 00:00:00 2001 From: Vincent Davis Jr Date: Sat, 5 Apr 2025 10:00:05 -0400 Subject: [PATCH 2/3] mat2: add tables to docs & fix comments Signed-off-by: Vincent Davis Jr --- docs/source/mat2.rst | 830 +++++++++++++++++++++++++++++++++---- include/cglm/call/mat2.h | 38 +- include/cglm/mat2.h | 247 ++++++----- include/cglm/struct/mat2.h | 226 +++++----- src/mat2.c | 62 +-- 5 files changed, 1033 insertions(+), 370 deletions(-) diff --git a/docs/source/mat2.rst b/docs/source/mat2.rst index 60b2360..e6739ae 100644 --- a/docs/source/mat2.rst +++ b/docs/source/mat2.rst @@ -10,182 +10,848 @@ Table of contents (click to go): Macros: -1. GLM_mat2_IDENTITY_INIT -#. GLM_mat2_ZERO_INIT -#. GLM_mat2_IDENTITY -#. GLM_mat2_ZERO +1. GLM_MAT2_IDENTITY_INIT +#. GLM_MAT2_ZERO_INIT +#. GLM_MAT2_IDENTITY +#. GLM_MAT2_ZERO Functions: -1. :c:func:`glm_mat2_copy` +1. :c:func:`glm_mat2_make` +#. :c:func:`glm_mat2_copy` #. :c:func:`glm_mat2_identity` #. :c:func:`glm_mat2_identity_array` #. :c:func:`glm_mat2_zero` #. :c:func:`glm_mat2_mul` +#. :c:func:`glm_mat2_mulv` #. :c:func:`glm_mat2_transpose_to` #. :c:func:`glm_mat2_transpose` -#. :c:func:`glm_mat2_mulv` #. :c:func:`glm_mat2_scale` -#. :c:func:`glm_mat2_det` #. :c:func:`glm_mat2_inv` -#. :c:func:`glm_mat2_trace` #. :c:func:`glm_mat2_swap_col` #. :c:func:`glm_mat2_swap_row` +#. :c:func:`glm_mat2_det` +#. :c:func:`glm_mat2_trace` #. :c:func:`glm_mat2_rmc` -#. :c:func:`glm_mat2_make` + +Represented +~~~~~~~~~~~ + +.. csv-table:: mat2x2 + :header: "", "column 1", "column 2" + + "row 1", "m00", "m10" + "row 2", "m01", "m11" Functions documentation ~~~~~~~~~~~~~~~~~~~~~~~ +.. c:function:: void glm_mat2_make(const float * __restrict src, mat2 dest) + + Create mat2 (dest) from pointer (src). + + .. note:: **@src** must contain at least 4 elements. + + Parameters: + | *[in]* **src** pointer to an array of floats (left) + | *[out]* **dest** destination (result, mat2) + + .. note:: Mathematical explanation + + .. csv-table:: float array (1x4) **(src)** + :header: "", "column 1" + + "row 1", "v0" + "row 2", "v1" + "row 3", "v2" + "row 4", "v3" + + .. csv-table:: mat2 **(dest)** + :header: "", "column 1", "column 2" + + "row 1", "v0", "v2" + "row 2", "v1", "v3" + + .. note:: Example + + .. code-block:: c + + mat2 dest = GLM_MAT2_ZERO_INIT; + float src[4] = { 1.00, 5.00, 8.00, 11.00 }; + glm_mat2_make(src, dest); + + .. csv-table:: float array (1x4) **(src)** + :header: "", "column 1" + + "row 1", "1.00" + "row 2", "5.00" + "row 3", "8.00" + "row 4", "11.00" + + .. csv-table:: mat2 **(dest)** Before + :header: "", "column 1", "column 2" + + "row 1", "0.00", "0.00" + "row 2", "0.00", "0.00" + + .. csv-table:: mat2 **(dest)** After + :header: "", "column 1", "column 2" + + "row 1", "1.00", "8.00" + "row 2", "5.00", "11.00" + .. c:function:: void glm_mat2_copy(mat2 mat, mat2 dest) - copy mat2 to another one (dest). + Copy mat2 (mat) to mat2 (dest). Parameters: - | *[in]* **mat** source - | *[out]* **dest** destination + | *[in]* **mat** mat2 (left) + | *[out]* **dest** destination (result, mat2) -.. c:function:: void glm_mat2_identity(mat2 mat) + .. note:: Mathematical explanation - copy identity mat2 to mat, or makes mat to identity + .. csv-table:: mat2 **(mat)** + :header: "", "column 1", "column 2" + + "row 1", "m00", "m10" + "row 2", "m01", "m11" + + .. csv-table:: mat2 **(dest)** + :header: "", "column 1", "column 2" + + "row 1", "m00", "m10" + "row 2", "m01", "m11" + + .. note:: Example + + .. code-block:: c + + mat2 mat = {{3.00,4.00},{7.00,8.00}}; + mat2 dest = GLM_MAT2_ZERO_INIT; + glm_mat2_copy(mat, dest); + + .. csv-table:: mat2 **(mat)** + :header: "", "column 1", "column 2" + + "row 1", "3.00", "7.00" + "row 2", "4.00", "8.00" + + .. csv-table:: mat2 **(dest)** Before + :header: "", "column 1", "column 2" + + "row 1", "0.00", "0.00" + "row 2", "0.00", "0.00" + + .. csv-table:: mat2 **(dest)** After + :header: "", "column 1", "column 2" + + "row 1", "3.00", "7.00" + "row 2", "4.00", "8.00" + +.. c:function:: void glm_mat2_identity(mat2 m) + + Copy a mat2 identity to mat2 **(m)**, or makes mat2 **(m)** an identity. + + The same thing may be achieved with either of bellow methods, + but it is more easy to do that with this func especially for members + e.g. ``glm_mat2_identity(aStruct->aMatrix);``. + + .. code-block:: c + + glm_mat2_copy(GLM_MAT2_IDENTITY, m); + + // or + mat2 mat = GLM_MAT2_IDENTITY_INIT; Parameters: - | *[out]* **mat** matrix + | *[in, out]* **m** mat2 (src, dest) -.. c:function:: void glm_mat2_identity_array(mat2 * __restrict mat, size_t count) + .. note:: Mathematical explanation - make given matrix array's each element identity matrix + .. csv-table:: mat2 **(m)** + :header: "", "column 1", "column 2" + + "row 1", "m00", "m10" + "row 2", "m01", "m11" + + .. csv-table:: mat2 **(m)** + :header: "", "column 1", "column 2" + + "row 1", "1.00", "0.00" + "row 2", "0.00", "1.00" + + .. note:: Example + + .. code-block:: c + + mat2 m = {{3.00,4.00},{7.00,8.00}}; + glm_mat2_identity(m); + + .. csv-table:: mat2 **(m)** + :header: "", "column 1", "column 2" + + "row 1", "3.00", "7.00" + "row 2", "4.00", "8.00" + + .. csv-table:: mat2 **(m)** + :header: "", "column 1", "column 2" + + "row 1", "1.00", "0.00" + "row 2", "0.00", "1.00" + +.. c:function:: void glm_mat2_identity_array(mat2 * __restrict mats, size_t count) + + Given an array of mat2's **(mats)** make each matrix an identity matrix. Parameters: - | *[in,out]* **mat** matrix array (must be aligned (16/32) if alignment is not disabled) - | *[in]* **count** count of matrices + | *[in, out]* **mats** Array of mat2's (must be aligned (16/32) if alignment is not disabled) + | *[in]* **count** Array size of ``mats`` or number of matrices -.. c:function:: void glm_mat2_zero(mat2 mat) + .. note:: Mathematical explanation - make given matrix zero + .. csv-table:: mat2 **(mats[index])** + :header: "", "column 1", "column 2" + + "row 1", "m00", "m10" + "row 2", "m01", "m11" + + .. csv-table:: mat2 **(mats[index])** + :header: "", "column 1", "column 2" + + "row 1", "1.00", "0.00" + "row 2", "0.00", "1.00" + + .. note:: Example + + .. code-block:: c + + size_t count = 3; + + mat2 matrices[count] = { + {{1.00,2.00},{5.00,6.00}}, + {{3.00,4.00},{7.00,8.00}}, + {{5.00,6.00},{9.00,10.00}}, + }; + + glm_mat2_identity_array(matrices, count); + + .. csv-table:: mat2 **(mats[0])** Before + :header: "", "column 1", "column 2" + + "row 1", "1.00", "5.00" + "row 2", "2.00", "6.00" + + .. csv-table:: mat2 **(mats[0])** After + :header: "", "column 1", "column 2" + + "row 1", "1.00", "0.00" + "row 2", "0.00", "1.00" + + .. csv-table:: mat2 **(mats[1])** Before + :header: "", "column 1", "column 2" + + "row 1", "3.00", "7.00" + "row 2", "4.00", "8.00" + + .. csv-table:: mat2 **(mats[1])** After + :header: "", "column 1", "column 2" + + "row 1", "1.00", "0.00" + "row 2", "0.00", "1.00" + + .. csv-table:: mat2 **(mats[2])** Before + :header: "", "column 1", "column 2" + + "row 1", "5.00", "9.00" + "row 2", "6.00", "10.00" + + .. csv-table:: mat2 **(mats[2])** After + :header: "", "column 1", "column 2" + + "row 1", "1.00", "0.00" + "row 2", "0.00", "1.00" + +.. c:function:: void glm_mat2_zero(mat2 m) + + Zero out the mat2 (m). Parameters: - | *[in,out]* **mat** matrix + | *[in, out]* **m** mat2 (src, dest) + + .. note:: Mathematical explanation + + .. csv-table:: mat2 **(m)** + :header: "", "column 1", "column 2" + + "row 1", "m00", "m10" + "row 2", "m01", "m11" + + .. csv-table:: mat2 **(m)** + :header: "", "column 1", "column 2" + + "row 1", "0.00", "0.00" + "row 2", "0.00", "0.00" + + .. note:: Example + + .. code-block:: c + + mat2 m = {{19.00,5.00},{2.00,4.00}}; + glm_mat2_zero(m); + + .. csv-table:: mat2 **(m)** Before + :header: "", "column 1", "column 2" + + "row 1", "19.00", "2.00" + "row 2", "5.00", "4.00" + + .. csv-table:: mat2 **(m)** After + :header: "", "column 1", "column 2" + + "row 1", "0.00", "0.00" + "row 2", "0.00", "0.00" .. c:function:: void glm_mat2_mul(mat2 m1, mat2 m2, mat2 dest) - multiply m1 and m2 to dest + Multiply mat2 (m1) by mat2 (m2) and store in mat2 (dest). m1, m2 and dest matrices can be same matrix, it is possible to write this: .. code-block:: c - mat2 m = GLM_mat2_IDENTITY_INIT; + mat2 m = GLM_MAT2_IDENTITY_INIT; glm_mat2_mul(m, m, m); Parameters: - | *[in]* **m1** left matrix - | *[in]* **m2** right matrix - | *[out]* **dest** destination matrix + | *[in]* **m1** mat2 (left) + | *[in]* **m2** mat2 (right) + | *[out]* **dest** destination (result, mat2) -.. c:function:: void glm_mat2_transpose_to(mat2 m, mat2 dest) + .. note:: Mathematical explanation - transpose mat4 and store in dest - source matrix will not be transposed unless dest is m + .. csv-table:: mat2 **(m1)** + :header: "", "column 1", "column 2" - Parameters: - | *[in]* **mat** source - | *[out]* **dest** destination + "row 1", "a00", "a10" + "row 2", "a01", "a11" -.. c:function:: void glm_mat2_transpose(mat2 m) + .. csv-table:: mat2 **(m2)** + :header: "", "column 1", "column 2" - transpose mat2 and store result in same matrix + "row 1", "b00", "b10" + "row 2", "b01", "b11" - Parameters: - | *[in]* **mat** source - | *[out]* **dest** destination + .. csv-table:: mat2 **(dest)** + :header: "", "column 1", "column 2" + + "row 1", "a00 * b00 + a10 * b01", "a00 * b10 + a10 * b11" + "row 2", "a01 * b00 + a11 * b01", "a01 * b10 + a11 * b11" + + .. note:: Example + + .. code-block:: c + + mat2 m = {{19.00,5.00},{2.00,4.00}}; + glm_mat2_mul(m, m, m); + + .. csv-table:: mat2 **(m1)** + :header: "", "column 1", "column 2" + + "row 1", "19.00", "2.00" + "row 2", "5.00", "4.00" + + .. csv-table:: mat2 **(m2)** + :header: "", "column 1", "column 2" + + "row 1", "19.00", "2.00" + "row 2", "5.00", "4.00" + + .. csv-table:: mat2 **(dest)** + :header: "", "column 1", "column 2" + + "row 1", "**371.00** = 19.00 * 19.00 + 2.00 * 5.00", "**46.00** = 19.00 * 2.00 + 2.00 * 4.00" + "row 2", "**115.00** = 5.00 * 19.00 + 4.00 * 5.00", "**18.00** = 5.00 * 2.00 + 4.00 * 4.00" .. c:function:: void glm_mat2_mulv(mat2 m, vec2 v, vec2 dest) - multiply mat2 with vec2 (column vector) and store in dest vector + Multiply mat2 (m) by vec2 (v) and store in vec2 (dest). Parameters: - | *[in]* **mat** mat2 (left) - | *[in]* **v** vec2 (right, column vector) - | *[out]* **dest** destination (result, column vector) + | *[in]* **m** mat2 (left) + | *[in]* **v** vec2 (right, column vector) + | *[out]* **dest** destination (result, column vector) -.. c:function:: void glm_mat2_scale(mat2 m, float s) + .. note:: Mathematical explanation - multiply matrix with scalar + .. csv-table:: mat2 **(m)** + :header: "", "column 1", "column 2" + + "row 1", "m00", "m10" + "row 2", "m01", "m11" + + .. csv-table:: column vec2 (1x2) **(v)** + :header: "", "column 1" + + "row 1", "v0" + "row 2", "v1" + + .. csv-table:: column vec2 (1x2) **(dest)** + :header: "", "column 1" + + "row 1", "m00 * v0 + m10 * v1" + "row 2", "m01 * v0 + m11 * v1" + + .. note:: Example + + .. code-block:: c + + vec2 dest; + vec2 v = {33.00,55.00}; + mat2 m = {{1.00,2.00},{3.00,4.00}}; + glm_mat2_mulv(m, v, dest); + + .. csv-table:: mat2 **(m)** + :header: "", "column 1", "column 2" + + "row 1", "1.00", "3.00" + "row 2", "2.00", "4.00" + + .. csv-table:: column vec2 **(v)** + :header: "", "column 1" + + "row 1", "33.00" + "row 2", "55.00" + + .. csv-table:: vec2 **(dest)** Result + :header: "", "column 1" + + "row 1", "**143.00** = 1.00 * 33.00 + 2.00 * 55.00" + "row 2", "**286.00** = 2.00 * 33.00 + 4.00 * 5.00" + +.. c:function:: void glm_mat2_transpose_to(mat2 mat, mat2 dest) + + Transpose mat2 (mat) and store in mat2 (dest). Parameters: - | *[in, out]* **m** matrix - | *[in]* **s** scalar + | *[in]* **mat** mat2 (left) + | *[out]* **dest** destination (result, mat2) -.. c:function:: float glm_mat2_det(mat2 mat) + .. note:: Mathematical explanation - returns mat2 determinant + .. csv-table:: mat2 **(mat)** + :header: "", "column 1", "column 2" + + "row 1", "m00", "m10" + "row 2", "m01", "m11" + + .. csv-table:: mat2 **(dest)** + :header: "", "column 1", "column 2" + + "row 1", "m00", "m01" + "row 2", "m10", "m11" + + .. note:: Example + + .. code-block:: c + + mat2 mat = {{1.00,2.00},{3.00,4.00}}; + mat2 dest = GLM_MAT2_ZERO_INIT; + glm_mat2_transpose_to(mat, dest); + + .. csv-table:: mat2 **(mat)** + :header: "", "column 1", "column 2" + + "row 1", "1.00", "3.00" + "row 2", "2.00", "4.00" + + .. csv-table:: mat2 **(dest)** Before + :header: "", "column 1", "column 2" + + "row 1", "0.00", "0.00" + "row 2", "0.00", "0.00" + + .. csv-table:: mat2 **(dest)** After + :header: "", "column 1", "column 2" + + "row 1", "1.00", "2.00" + "row 2", "3.00", "4.00" + +.. c:function:: void glm_mat2_transpose(mat2 m) + + Transpose mat2 (m) and store result in the same matrix. Parameters: - | *[in]* **mat** matrix + | *[in, out]* **m** mat2 (src, dest) - Returns: - mat2 determinant + .. note:: Mathematical explanation + + .. csv-table:: mat2 **(m)** src + :header: "", "column 1", "column 2" + + "row 1", "m00", "m10" + "row 2", "m01", "m11" + + .. csv-table:: mat2 **(m)** dest + :header: "", "column 1", "column 2" + + "row 1", "m00", "m01" + "row 2", "m10", "m11" + + .. note:: Example + + .. code-block:: c + + mat2 m = {{1.00,2.00},{3.00,4.00}}; + glm_mat2_transpose(m); + + .. csv-table:: mat2 **(m)** Before + :header: "", "column 1", "column 2" + + "row 1", "1.00", "3.00" + "row 2", "2.00", "4.00" + + .. csv-table:: mat2 **(m)** After + :header: "", "column 1", "column 2" + + "row 1", "1.00", "2.00" + "row 2", "3.00", "4.00" + +.. c:function:: void glm_mat2_scale(mat2 m, float s) + + Multiply mat2 (m) by scalar constant (s). + + Parameters: + | *[in, out]* **m** mat2 (src, dest) + | *[in]* **s** float (scalar) + + .. note:: Mathematical explanation + + .. csv-table:: mat2 **(m)** + :header: "", "column 1", "column 2" + + "row 1", "m00 * s", "m10 * s" + "row 2", "m01 * s", "m11 * s" + + .. note:: Example + + .. code-block:: c + + float s = 3.00f; + mat2 m = {{1.00,2.00},{3.00,4.00}}; + glm_mat2_scale(m, s); + + .. csv-table:: mat2 **(src)** Before + :header: "", "column 1", "column 2" + + "row 1", "1.00", "3.00" + "row 2", "2.00", "4.00" + + .. csv-table:: mat2 **(dest)** After + :header: "", "column 1", "column 2" + + "row 1", "**3.00** = 1.00 * 3.00", "**9.00** = 3.00 * 3.00" + "row 2", "**6.00** = 2.00 * 3.00", "**12.00** = 4.00 * 3.00" .. c:function:: void glm_mat2_inv(mat2 mat, mat2 dest) - inverse mat2 and store in dest + Inverse mat2 (mat) and store in mat2 (dest). Parameters: - | *[in]* **mat** matrix - | *[out]* **dest** destination (inverse matrix) + | *[in]* **mat** mat2 (left) + | *[out]* **dest** destination (result, inverse mat2) -.. c:function:: void glm_mat2_trace(mat2 m) + .. note:: Mathematical explanation - | sum of the elements on the main diagonal from upper left to the lower right + .. csv-table:: mat2 **(mat)** + :header: "", "column 1", "column 2" - Parameters: - | *[in]* **m** matrix + "row 1", "m00", "m10" + "row 2", "m01", "m11" - Returns: - trace of matrix + .. csv-table:: mat2 **(dest)** + :header: "", "column 1", "column 2" + + "row 1", "m11 * (1.0f / (m00 * m11 - m01 * m10))", "-m10 * (1.0f / (m00 * m11 - m01 * m10))" + "row 2", "-m01 * (1.0f / (m00 * m11 - m01 * m10))", "m00 * (1.0f / (m00 * m11 - m01 * m10))" + + .. note:: Example + + .. code-block:: c + + mat2 dest = GLM_MAT2_ZERO_INIT; + mat2 mat = {{1.00,2.00},{3.00,4.00}}; + glm_mat2_inv(mat, dest); + + .. csv-table:: mat2 **(mat)** Before + :header: "", "column 1", "column 2" + + "row 1", "1.00", "3.00" + "row 2", "2.00", "4.00" + + .. csv-table:: mat2 **(dest)** After + :header: "", "column 1", "column 2" + + "row 1", "**-2.00** = 4.00 * (1.00 / (1.00 * 4.00 - 2.00 * 3.00))", "**1.50** = -3.00 * (1.00 / (1.00 * 4.00 - 2.00 * 3.00))" + "row 2", "**1.00** = -2.00 * (1.00 / (1.00 * 4.00 - 2.00 * 3.00))", "**-0.50** = 1.00 * (1.00 / (1.00 * 4.00 - 2.00 * 3.00))" .. c:function:: void glm_mat2_swap_col(mat2 mat, int col1, int col2) - swap two matrix columns + Swap two columns in mat2 (mat) and store in same matrix. Parameters: - | *[in, out]* **mat** matrix - | *[in]* **col1** col1 - | *[in]* **col2** col2 + | *[in, out]* **mat** mat2 (src, dest) + | *[in]* **col1** Column 1 array index + | *[in]* **col2** Column 2 array index + + .. note:: Mathematical explanation + + .. csv-table:: mat2 **(mat)** Before + :header: "", "column 1", "column 2" + + "row 1", "m00", "m10" + "row 2", "m01", "m11" + + .. code-block:: c + + glm_mat2_swap_col(mat, 0, 1); + + .. csv-table:: mat2 **(mat)** After + :header: "", "column 1", "column 2" + + "row 1", "m10", "m00" + "row 2", "m11", "m01" + + .. note:: Example + + .. code-block:: c + + mat2 mat = {{76.00,5.00},{3.00,6.00}}; + glm_mat2_swap_col(mat, 0, 1); + + .. csv-table:: mat2 **(mat)** Before + :header: "", "column 1", "column 2" + + "row 1", "76.00", "3.00" + "row 2", "5.00", "6.00" + + .. csv-table:: mat2 **(mat)** After + :header: "", "column 1", "column 2" + + "row 1", "3.00", "76.00" + "row 2", "6.00", "5.00" .. c:function:: void glm_mat2_swap_row(mat2 mat, int row1, int row2) - swap two matrix rows + Swap two rows in mat2 (mat) and store in same matrix. Parameters: - | *[in, out]* **mat** matrix - | *[in]* **row1** row1 - | *[in]* **row2** row2 + | *[in, out]* **mat** mat2 (src, dest) + | *[in]* **row1** Row 1 array index + | *[in]* **row2** Row 2 array index + + .. note:: Mathematical explanation + + .. csv-table:: mat2 **(mat)** Before + :header: "", "column 1", "column 2" + + "row 1", "m00", "m10" + "row 2", "m01", "m11" + + .. code-block:: c + + glm_mat2_swap_row(mat, 0, 1); + + .. csv-table:: mat2 **(mat)** After + :header: "", "column 1", "column 2" + + "row 1", "m01", "m11" + "row 2", "m00", "m10" + + .. note:: Example + + .. code-block:: c + + mat2 mat = {{76.00,5.00},{3.00,6.00}}; + glm_mat2_swap_row(mat, 0, 1); + + .. csv-table:: mat2 **(mat)** Before + :header: "", "column 1", "column 2" + + "row 1", "76.00", "3.00" + "row 2", "5.00", "6.00" + + .. csv-table:: mat2 **(mat)** After + :header: "", "column 1", "column 2" + + "row 1", "5.00", "6.00" + "row 2", "76.00", "3.00" + +.. c:function:: float glm_mat2_det(mat2 m) + + Returns mat2 determinant. + + Parameters: + | *[in]* **m** mat2 (src) + + Returns: + | mat2 determinant (float) + + .. note:: Mathematical explanation + + .. csv-table:: mat2 **(m)** + :header: "", "column 1", "column 2" + + "row 1", "m00", "m10" + "row 2", "m01", "m11" + + .. code-block:: c + + m00 * m11 - m10 * m01; + + .. note:: Example + + .. code-block:: c + + mat2 m = {{76.00,5.00},{3.00,6.00}}; + glm_mat2_det(m); + + .. csv-table:: mat2 **(m)** + :header: "", "column 1", "column 2" + + "row 1", "76.00", "3.00" + "row 2", "5.00", "6.00" + + .. code-block:: c + + 441.00 = 76.00 * 6.00 - 3.00 * 5.00; + +.. c:function:: void glm_mat2_trace(mat2 m) + + | Returns trace of matrix. Which is: + | + | The sum of the elements on the main diagonal from + | upper left corner to the bottom right corner. + + Parameters: + | *[in]* **m** mat2 (src) + + Returns: + | mat2 trace (float) + + .. note:: Mathematical explanation + + .. csv-table:: mat2 **(m)** + :header: "", "column 1", "column 2" + + "row 1", "m00", "m10" + "row 2", "m01", "m11" + + .. code-block:: c + + m00 + m11; + + .. note:: Example + + .. code-block:: c + + mat2 m = {{76.00,5.00},{3.00,6.00}}; + glm_mat2_trace(m); + + .. csv-table:: mat2 **(m)** + :header: "", "column 1", "column 2" + + "row 1", "76.00", "3.00" + "row 2", "5.00", "6.00" + + .. code-block:: c + + 82.00 = 76.00 + 6.00; .. c:function:: float glm_mat2_rmc(vec2 r, mat2 m, vec2 c) + | Helper for R (row vector) * M (matrix) * C (column vector) + | **rmc** stands for **Row** * **Matrix** * **Column** - | helper for R (row vector) * M (matrix) * C (column vector) - - | the result is scalar because R * M = Matrix1x2 (row vector), - | then Matrix1x2 * Vec2 (column vector) = Matrix1x1 (Scalar) + | the result is scalar because M * C = ResC (1x2, column vector), + | then if you take the dot_product(R (2x1), ResC (1x2)) = scalar value. Parameters: - | *[in]* **r** row vector or matrix1x2 - | *[in]* **m** matrix2x2 - | *[in]* **c** column vector or matrix2x1 + | *[in]* **r** vec2 (2x1, row vector) + | *[in]* **m** mat2 (2x2, matrix) + | *[in]* **c** vec2 (1x2, column vector) Returns: - scalar value e.g. Matrix1x1 + | Scalar value (float, 1x1) -.. c:function:: void glm_mat2_make(const float * __restrict src, mat2 dest) + .. note:: Mathematical explanation - Create mat2 matrix from pointer + .. csv-table:: row vec2 (2x1) **(r)** + :header: "", "column 1", "column 2" - .. note:: **@src** must contain at least 4 elements. + "row 1", "a00", "a10" - Parameters: - | *[in]* **src** pointer to an array of floats - | *[out]* **dest** destination matrix2x2 + .. csv-table:: mat2 **(m)** + :header: "", "column 1", "column 2" + + "row 1", "b00", "b10" + "row 2", "b01", "b11" + + .. csv-table:: column vec2 (1x2) **(c)** + :header: "", "column 1" + + "row 1", "c00" + "row 2", "c01" + + .. code-block:: c + + M * C = C (column vector) + dot_product(R, C) + + .. csv-table:: column vec2 (1x2) **(C)** + :header: "", "column 1" + + "row 1", "b00 * c00 + b10 * c01" + "row 2", "b01 * c00 + b11 * c01" + + .. csv-table:: float **(scalar)** + :header: "", "column 1" + + "row 1", "a00 * (b00 * c00 + b10 * c01) + a10 * (b01 * c00 + b11 * c01)" + + .. note:: Example + + .. code-block:: c + + vec2 r = {8.00,4.00}; + vec2 c = {7.00,2.00}; + mat2 m = {{5.00,9.00},{3.00,6.00}}; + glm_mat2_rmc(r, m, c); + + .. csv-table:: row vec2 (2x1) **(r)** + :header: "", "column 1", "column 2" + + "row 1", "8.00", "4.00" + + .. csv-table:: mat2 **(m)** + :header: "", "column 1", "column 2" + + "row 1", "5.00", "3.00" + "row 2", "9.00", "6.00" + + .. csv-table:: column vec2 (1x2) **(c)** + :header: "", "column 1" + + "row 1", "7.00" + "row 2", "2.00" + + .. csv-table:: column vec2 (1x2) **(C)** + :header: "", "column 1" + + "row 1", "**41.00** = 5.00 * 7.00 + 3.00 * 2.00" + "row 2", "**75.00** = 9.00 * 7.00 + 6.00 * 2.00" + + .. csv-table:: float (1x1) **(scalar)** + :header: "", "column 1" + + "row 1", "**628.00** = 8.00 * 41.00 + 4.00 * 75.00" diff --git a/include/cglm/call/mat2.h b/include/cglm/call/mat2.h index 598b5c8..c268938 100644 --- a/include/cglm/call/mat2.h +++ b/include/cglm/call/mat2.h @@ -13,21 +13,25 @@ extern "C" { #include "../cglm.h" +CGLM_EXPORT +void +glmc_mat2_make(const float * __restrict src, mat2 dest); + CGLM_EXPORT void glmc_mat2_copy(mat2 mat, mat2 dest); CGLM_EXPORT void -glmc_mat2_identity(mat2 mat); +glmc_mat2_identity(mat2 m); CGLM_EXPORT void -glmc_mat2_identity_array(mat2 * __restrict mat, size_t count); +glmc_mat2_identity_array(mat2 * __restrict mats, size_t count); CGLM_EXPORT void -glmc_mat2_zero(mat2 mat); +glmc_mat2_zero(mat2 m); CGLM_EXPORT void @@ -35,28 +39,20 @@ glmc_mat2_mul(mat2 m1, mat2 m2, mat2 dest); CGLM_EXPORT void -glmc_mat2_transpose_to(mat2 m, mat2 dest); +glmc_mat2_mulv(mat2 m, vec2 v, vec2 dest); + +CGLM_EXPORT +void +glmc_mat2_transpose_to(mat2 mat, mat2 dest); CGLM_EXPORT void glmc_mat2_transpose(mat2 m); -CGLM_EXPORT -void -glmc_mat2_mulv(mat2 m, vec2 v, vec2 dest); - -CGLM_EXPORT -float -glmc_mat2_trace(mat2 m); - CGLM_EXPORT void glmc_mat2_scale(mat2 m, float s); -CGLM_EXPORT -float -glmc_mat2_det(mat2 mat); - CGLM_EXPORT void glmc_mat2_inv(mat2 mat, mat2 dest); @@ -71,11 +67,15 @@ glmc_mat2_swap_row(mat2 mat, int row1, int row2); CGLM_EXPORT float -glmc_mat2_rmc(vec2 r, mat2 m, vec2 c); +glmc_mat2_trace(mat2 m); CGLM_EXPORT -void -glmc_mat2_make(const float * __restrict src, mat2 dest); +float +glmc_mat2_det(mat2 m); + +CGLM_EXPORT +float +glmc_mat2_rmc(vec2 r, mat2 m, vec2 c); #ifdef __cplusplus } diff --git a/include/cglm/mat2.h b/include/cglm/mat2.h index 1da0cd4..5bec482 100644 --- a/include/cglm/mat2.h +++ b/include/cglm/mat2.h @@ -13,22 +13,22 @@ GLM_MAT2_ZERO Functions: + CGLM_INLINE void glm_mat2_make(float * restrict src, mat2 dest) CGLM_INLINE void glm_mat2_copy(mat2 mat, mat2 dest) - CGLM_INLINE void glm_mat2_identity(mat2 mat) - CGLM_INLINE void glm_mat2_identity_array(mat2 * restrict mat, size_t count) - CGLM_INLINE void glm_mat2_zero(mat2 mat) + CGLM_INLINE void glm_mat2_identity(mat2 m) + CGLM_INLINE void glm_mat2_identity_array(mat2 * restrict mats, size_t count) + CGLM_INLINE void glm_mat2_zero(mat2 m) CGLM_INLINE void glm_mat2_mul(mat2 m1, mat2 m2, mat2 dest) - CGLM_INLINE void glm_mat2_transpose_to(mat2 m, mat2 dest) - CGLM_INLINE void glm_mat2_transpose(mat2 m) CGLM_INLINE void glm_mat2_mulv(mat2 m, vec2 v, vec2 dest) - CGLM_INLINE float glm_mat2_trace(mat2 m) + CGLM_INLINE void glm_mat2_transpose_to(mat2 mat, mat2 dest) + CGLM_INLINE void glm_mat2_transpose(mat2 m) CGLM_INLINE void glm_mat2_scale(mat2 m, float s) - CGLM_INLINE float glm_mat2_det(mat2 mat) CGLM_INLINE void glm_mat2_inv(mat2 mat, mat2 dest) CGLM_INLINE void glm_mat2_swap_col(mat2 mat, int col1, int col2) CGLM_INLINE void glm_mat2_swap_row(mat2 mat, int row1, int row2) + CGLM_INLINE float glm_mat2_det(mat2 m) + CGLM_INLINE float glm_mat2_trace(mat2 m) CGLM_INLINE float glm_mat2_rmc(vec2 r, mat2 m, vec2 c) - CGLM_INLINE void glm_mat2_make(float * restrict src, mat2 dest) */ #ifndef cglm_mat2_h @@ -57,10 +57,25 @@ #define GLM_MAT2_ZERO ((mat2)GLM_MAT2_ZERO_INIT) /*! - * @brief copy all members of [mat] to [dest] + * @brief Create mat2 (dest) from pointer (src). * - * @param[in] mat source - * @param[out] dest destination + * @param[in] src pointer to an array of floats (left) + * @param[out] dest destination (result, mat2) + */ +CGLM_INLINE +void +glm_mat2_make(const float * __restrict src, mat2 dest) { + dest[0][0] = src[0]; + dest[0][1] = src[1]; + dest[1][0] = src[2]; + dest[1][1] = src[3]; +} + +/*! + * @brief Copy mat2 (mat) to mat2 (dest). + * + * @param[in] mat mat2 (left) + * @param[out] dest destination (result, mat2) */ CGLM_INLINE void @@ -69,7 +84,9 @@ glm_mat2_copy(mat2 mat, mat2 dest) { } /*! - * @brief make given matrix identity. It is identical with below, + * @brief Copy a mat2 identity to mat2 (m), or makes mat2 (m) an identity. + * + * The same thing may be achieved with either of bellow methods, * but it is more easy to do that with this func especially for members * e.g. glm_mat2_identity(aStruct->aMatrix); * @@ -80,59 +97,57 @@ glm_mat2_copy(mat2 mat, mat2 dest) { * mat2 mat = GLM_MAT2_IDENTITY_INIT; * @endcode * - * @param[in, out] mat destination + * @param[in, out] m mat2 (src, dest) */ CGLM_INLINE void -glm_mat2_identity(mat2 mat) { +glm_mat2_identity(mat2 m) { CGLM_ALIGN_MAT mat2 t = GLM_MAT2_IDENTITY_INIT; - glm_mat2_copy(t, mat); + glm_mat2_copy(t, m); } /*! - * @brief make given matrix array's each element identity matrix + * @brief Given an array of mat2’s (mats) make each matrix an identity matrix. * - * @param[in, out] mat matrix array (must be aligned (16) - * if alignment is not disabled) - * - * @param[in] count count of matrices + * @param[in, out] mats Array of mat2’s (must be aligned (16/32) if alignment is not disabled) + * @param[in] count Array size of mats or number of matrices */ CGLM_INLINE void -glm_mat2_identity_array(mat2 * __restrict mat, size_t count) { +glm_mat2_identity_array(mat2 * __restrict mats, size_t count) { CGLM_ALIGN_MAT mat2 t = GLM_MAT2_IDENTITY_INIT; size_t i; for (i = 0; i < count; i++) { - glm_mat2_copy(t, mat[i]); + glm_mat2_copy(t, mats[i]); } } /*! - * @brief make given matrix zero. + * @brief Zero out the mat2 (m). * - * @param[in, out] mat matrix + * @param[in, out] m mat2 (src, dest) */ CGLM_INLINE void -glm_mat2_zero(mat2 mat) { +glm_mat2_zero(mat2 m) { CGLM_ALIGN_MAT mat2 t = GLM_MAT2_ZERO_INIT; - glm_mat2_copy(t, mat); + glm_mat2_copy(t, m); } /*! - * @brief multiply m1 and m2 to dest + * @brief Multiply mat2 (m1) by mat2 (m2) and store in mat2 (dest). * - * m1, m2 and dest matrices can be same matrix, it is possible to write this: + * m1, m2 and dest matrices can be same matrix, it is possible to write this: * * @code * mat2 m = GLM_MAT2_IDENTITY_INIT; * glm_mat2_mul(m, m, m); * @endcode * - * @param[in] m1 left matrix - * @param[in] m2 right matrix - * @param[out] dest destination matrix + * @param[in] m1 mat2 (left) + * @param[in] m2 mat2 (right) + * @param[out] dest destination (result, mat2) */ CGLM_INLINE void @@ -157,32 +172,44 @@ glm_mat2_mul(mat2 m1, mat2 m2, mat2 dest) { } /*! - * @brief transpose mat2 and store in dest + * @brief Multiply mat2 (m) by vec2 (v) and store in vec2 (dest). * - * source matrix will not be transposed unless dest is m - * - * @param[in] m matrix - * @param[out] dest result + * @param[in] m mat2 (left) + * @param[in] v vec2 (right, column vector) + * @param[out] dest destination (result, column vector) */ CGLM_INLINE void -glm_mat2_transpose_to(mat2 m, mat2 dest) { +glm_mat2_mulv(mat2 m, vec2 v, vec2 dest) { + dest[0] = m[0][0] * v[0] + m[1][0] * v[1]; + dest[1] = m[0][1] * v[0] + m[1][1] * v[1]; +} + +/*! + * @brief Transpose mat2 (mat) and store in mat2 (dest). + * + * @param[in] mat mat2 (left) + * @param[out] dest destination (result, mat2) + */ +CGLM_INLINE +void +glm_mat2_transpose_to(mat2 mat, mat2 dest) { #if defined(__wasm__) && defined(__wasm_simd128__) - glm_mat2_transp_wasm(m, dest); + glm_mat2_transp_wasm(mat, dest); #elif defined( __SSE__ ) || defined( __SSE2__ ) - glm_mat2_transp_sse2(m, dest); + glm_mat2_transp_sse2(mat, dest); #else - 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[0][0] = mat[0][0]; + dest[0][1] = mat[1][0]; + dest[1][0] = mat[0][1]; + dest[1][1] = mat[1][1]; #endif } /*! - * @brief transpose mat2 and store result in same matrix + * @brief Transpose mat2 (m) and store result in the same matrix. * - * @param[in, out] m source and dest + * @param[in, out] m mat2 (src, dest) */ CGLM_INLINE void @@ -194,39 +221,10 @@ glm_mat2_transpose(mat2 m) { } /*! - * @brief multiply mat2 with vec2 (column vector) and store in dest vector + * @brief Multiply mat2 (m) by scalar constant (s). * - * @param[in] m mat2 (left) - * @param[in] v vec2 (right, column vector) - * @param[out] dest vec2 (result, column vector) - */ -CGLM_INLINE -void -glm_mat2_mulv(mat2 m, vec2 v, vec2 dest) { - dest[0] = m[0][0] * v[0] + m[1][0] * v[1]; - dest[1] = m[0][1] * v[0] + m[1][1] * v[1]; -} - -/*! - * @brief trace of matrix - * - * sum of the elements on the main diagonal from upper left to the lower right - * - * @param[in] m matrix - */ -CGLM_INLINE -float -glm_mat2_trace(mat2 m) { - return m[0][0] + m[1][1]; -} - -/*! - * @brief scale (multiply with scalar) matrix - * - * multiply matrix with scalar - * - * @param[in, out] m matrix - * @param[in] s scalar + * @param[in, out] m mat2 (src, dest) + * @param[in] s float (scalar) */ CGLM_INLINE void @@ -247,23 +245,10 @@ glm_mat2_scale(mat2 m, float s) { } /*! - * @brief mat2 determinant + * @brief Inverse mat2 (mat) and store in mat2 (dest). * - * @param[in] mat matrix - * - * @return determinant - */ -CGLM_INLINE -float -glm_mat2_det(mat2 mat) { - return mat[0][0] * mat[1][1] - mat[1][0] * mat[0][1]; -} - -/*! - * @brief inverse mat2 and store in dest - * - * @param[in] mat matrix - * @param[out] dest inverse matrix + * @param[in] mat mat2 (left) + * @param[out] dest destination (result, inverse mat2) */ CGLM_INLINE void @@ -281,11 +266,11 @@ glm_mat2_inv(mat2 mat, mat2 dest) { } /*! - * @brief swap two matrix columns + * @brief Swap two columns in mat2 (mat) and store in same matrix. * - * @param[in,out] mat matrix - * @param[in] col1 col1 - * @param[in] col2 col2 + * @param[in, out] mat mat2 (src, dest) + * @param[in] col1 Column 1 array index + * @param[in] col2 Column 2 array index */ CGLM_INLINE void @@ -303,11 +288,11 @@ glm_mat2_swap_col(mat2 mat, int col1, int col2) { } /*! - * @brief swap two matrix rows + * @brief Swap two rows in mat2 (mat) and store in same matrix. * - * @param[in,out] mat matrix - * @param[in] row1 row1 - * @param[in] row2 row2 + * @param[in, out] mat mat2 (src, dest) + * @param[in] row1 Row 1 array index + * @param[in] row2 Row 2 array index */ CGLM_INLINE void @@ -325,18 +310,47 @@ glm_mat2_swap_row(mat2 mat, int row1, int row2) { } /*! - * @brief helper for R (row vector) * M (matrix) * C (column vector) + * @brief Returns mat2 determinant. * - * rmc stands for Row * Matrix * Column + * @param[in] m mat2 (src) * - * the result is scalar because R * M = Matrix1x2 (row vector), - * then Matrix1x2 * Vec2 (column vector) = Matrix1x1 (Scalar) + * @return[out] mat2 determinant (float) + */ +CGLM_INLINE +float +glm_mat2_det(mat2 m) { + return m[0][0] * m[1][1] - m[1][0] * m[0][1]; +} + +/*! + * @brief Returns trace of matrix. Which is: * - * @param[in] r row vector or matrix1x2 - * @param[in] m matrix2x2 - * @param[in] c column vector or matrix2x1 + * The sum of the elements on the main diagonal from + * upper left corner to the bottom right corner. * - * @return scalar value e.g. Matrix1x1 + * @param[in] m mat2 (src) + * + * @return[out] mat2 trace (float) + */ +CGLM_INLINE +float +glm_mat2_trace(mat2 m) { + return m[0][0] + m[1][1]; +} + +/*! + * @brief Helper for R (row vector) * M (matrix) * C (column vector) + * + * rmc stands for Row * Matrix * Column + * + * the result is scalar because M * C = ResC (1x2, column vector), + * then if you take the dot_product(R (2x1), ResC (1x2)) = scalar value. + * + * @param[in] r vec2 (2x1, row vector) + * @param[in] m mat2 (2x2, matrix) + * @param[in] c vec2 (1x2, column vector) + * + * @return[out] Scalar value (float, 1x1) */ CGLM_INLINE float @@ -346,19 +360,4 @@ glm_mat2_rmc(vec2 r, mat2 m, vec2 c) { return glm_vec2_dot(r, tmp); } -/*! - * @brief Create mat2 matrix from pointer - * - * @param[in] src pointer to an array of floats - * @param[out] dest matrix - */ -CGLM_INLINE -void -glm_mat2_make(const float * __restrict src, mat2 dest) { - dest[0][0] = src[0]; - dest[0][1] = src[1]; - dest[1][0] = src[2]; - dest[1][1] = src[3]; -} - #endif /* cglm_mat2_h */ diff --git a/include/cglm/struct/mat2.h b/include/cglm/struct/mat2.h index 5942ced..915c1be 100644 --- a/include/cglm/struct/mat2.h +++ b/include/cglm/struct/mat2.h @@ -13,21 +13,20 @@ GLM_MAT2_ZERO Functions: - CGLM_INLINE void glms_mat2_identity(mat2 mat) - CGLM_INLINE void glms_mat2_identity_array(mat2 * restrict mat, size_t count) - CGLM_INLINE void glms_mat2_zero(mat2 mat) - CGLM_INLINE void glms_mat2_mul(mat2 m1, mat2 m2, mat2 dest) - CGLM_INLINE void glms_mat2_transpose_to(mat2 m, mat2 dest) - CGLM_INLINE void glms_mat2_transpose(mat2 m) - CGLM_INLINE void glms_mat2_mulv(mat2 m, vec2 v, vec2 dest) - CGLM_INLINE float glms_mat2_trace(mat2 m) - CGLM_INLINE void glms_mat2_scale(mat2 m, float s) - CGLM_INLINE float glms_mat2_det(mat2 mat) - CGLM_INLINE void glms_mat2_inv(mat2 mat, mat2 dest) - CGLM_INLINE void glms_mat2_swap_col(mat2 mat, int col1, int col2) - CGLM_INLINE void glms_mat2_swap_row(mat2 mat, int row1, int row2) - CGLM_INLINE float glms_mat2_rmc(vec2 r, mat2 m, vec2 c) CGLM_INLINE mat2s glms_mat2_make(const float * __restrict src); + CGLM_INLINE mat2s glms_mat2_identity(void) + CGLM_INLINE void glms_mat2_identity_array(mat2 * restrict mats, size_t count) + CGLM_INLINE mat2s glms_mat2_zero(void) + CGLM_INLINE mat2s glms_mat2_mul(mat2 m1, mat2 m2) + CGLM_INLINE vec2s glms_mat2_mulv(mat2 m, vec2 v) + CGLM_INLINE mat2s glms_mat2_transpose(mat2 m) + CGLM_INLINE mat2s glms_mat2_scale(mat2 m, float s) + CGLM_INLINE mat2s glms_mat2_inv(mat2 m) + CGLM_INLINE mat2s glms_mat2_swap_col(mat2 mat, int col1, int col2) + CGLM_INLINE mat2s glms_mat2_swap_row(mat2 mat, int row1, int row2) + CGLM_INLINE float glms_mat2_det(mat2 m) + CGLM_INLINE float glms_mat2_trace(mat2 m) + CGLM_INLINE float glms_mat2_rmc(vec2 r, mat2 m, vec2 c) */ #ifndef cglms_mat2_h @@ -48,7 +47,23 @@ #define GLMS_MAT2_ZERO ((mat2s)GLMS_MAT2_ZERO_INIT) /*! - * @brief make given matrix identity. It is identical with below, + * @brief Returns mat2s (r) from pointer (src). + * + * @param[in] src pointer to an array of floats + * @return[out] r constructed mat2s from raw pointer + */ +CGLM_INLINE +mat2s +glms_mat2_(make)(const float * __restrict src) { + mat2s r; + glm_mat2_make(src, r.raw); + return r; +} + +/*! + * @brief Return a identity mat2s (r). + * + * The same thing may be achieved with either of bellow methods, * but it is more easy to do that with this func especially for members * e.g. glm_mat2_identity(aStruct->aMatrix); * @@ -59,7 +74,7 @@ * mat2 mat = GLM_MAT2_IDENTITY_INIT; * @endcode * - * @returns identity matrix + * @return[out] r constructed mat2s from raw pointer */ CGLM_INLINE mat2s @@ -70,28 +85,26 @@ glms_mat2_(identity)(void) { } /*! - * @brief make given matrix array's each element identity matrix + * @brief Given an array of mat2s’s (mats) make each matrix an identity matrix. * - * @param[in, out] mat matrix array (must be aligned (16) - * if alignment is not disabled) - * - * @param[in] count count of matrices + * @param[in, out] mats Array of mat2s’s (must be aligned (16/32) if alignment is not disabled) + * @param[in] count Array size of mats or number of matrices */ CGLM_INLINE void -glms_mat2_(identity_array)(mat2s * __restrict mat, size_t count) { +glms_mat2_(identity_array)(mat2s * __restrict mats, size_t count) { CGLM_ALIGN_MAT mat2s t = GLMS_MAT2_IDENTITY_INIT; size_t i; for (i = 0; i < count; i++) { - glm_mat2_copy(t.raw, mat[i].raw); + glm_mat2_copy(t.raw, mats[i].raw); } } /*! - * @brief make given matrix zero. + * @brief Return zero'd out mat2 (r). * - * @returns matrix + * @return[out] r constructed mat2s from raw pointer */ CGLM_INLINE mat2s @@ -102,19 +115,18 @@ glms_mat2_(zero)(void) { } /*! - * @brief multiply m1 and m2 to dest + * @brief Multiply mat2 (m1) by mat2 (m2) and return in mat2s (r) * - * m1, m2 and dest matrices can be same matrix, it is possible to write this: + * m1 and m2 matrices can be the same matrix, it is possible to write this: * * @code * mat2 m = GLM_MAT2_IDENTITY_INIT; - * r = glms_mat2_mul(m, m); + * mat2s r = glms_mat2_mul(m, m); * @endcode * - * @param[in] m1 left matrix - * @param[in] m2 right matrix - * - * @returns destination matrix + * @param[in] m1 mat2s (left) + * @param[in] m2 mat2s (right) + * @return[out] r constructed mat2s from raw pointers */ CGLM_INLINE mat2s @@ -124,26 +136,12 @@ glms_mat2_(mul)(mat2s m1, mat2s m2) { return r; } -/*! - * @brief transpose mat2 +/* + * @brief Multiply mat2s (m) by vec2s (v) and return in vec2s (r). * - * @param[in] m matrix to transpose - * - * @returns transposed matrix - */ -CGLM_INLINE -mat2s -glms_mat2_(transpose)(mat2s m) { - glm_mat2_transpose(m.raw); - return m; -} - -/*! - * @brief multiply mat2 with vec2 (column vector) and store in dest vector - * - * @param[in] m mat2 (left) - * @param[in] v vec2 (right, column vector) - * @returns vec2 (result, column vector) + * @param[in] m mat2s (left) + * @param[in] v vec2s (right, column vector) + * @return[out] r constructed vec2s from raw pointers */ CGLM_INLINE vec2s @@ -154,26 +152,24 @@ glms_mat2_(mulv)(mat2s m, vec2s v) { } /*! - * @brief trace of matrix + * @brief Transpose mat2s (m) and store result in the same matrix. * - * sum of the elements on the main diagonal from upper left to the lower right - * - * @param[in] m matrix + * @param[in] m mat2s (src) + * @return[out] m constructed mat2s from raw pointers */ CGLM_INLINE -float -glms_mat2_(trace)(mat2s m) { - return glm_mat2_trace(m.raw); +mat2s +glms_mat2_(transpose)(mat2s m) { + glm_mat2_transpose(m.raw); + return m; } /*! - * @brief scale (multiply with scalar) matrix + * @brief Multiply mat2s (m) by scalar constant (s) * - * multiply matrix with scalar - * - * @param[in, out] m matrix - * @param[in] s scalar - * @returns matrix + * @param[in] m mat2s (src) + * @param[in] s scalar value + * @return[out] m constructed mat2s from raw pointers */ CGLM_INLINE mat2s @@ -183,39 +179,26 @@ glms_mat2_(scale)(mat2s m, float s) { } /*! - * @brief mat2 determinant + * @brief Inverse mat2s (m) and return in mat2s (r). * - * @param[in] mat matrix - * - * @return determinant - */ -CGLM_INLINE -float -glms_mat2_(det)(mat2s mat) { - return glm_mat2_det(mat.raw); -} - -/*! - * @brief inverse mat2 and store in dest - * - * @param[in] mat matrix - * @returns matrix + * @param[in] m mat2s (left, src) + * @return[out] r constructed mat2s from raw pointers */ CGLM_INLINE mat2s -glms_mat2_(inv)(mat2s mat) { +glms_mat2_(inv)(mat2s m) { mat2s r; - glm_mat2_inv(mat.raw, r.raw); + glm_mat2_inv(m.raw, r.raw); return r; } /*! - * @brief swap two matrix columns + * @brief Swap two columns in mat2s (mat) and store in same matrix. * - * @param[in] mat matrix - * @param[in] col1 col1 - * @param[in] col2 col2 - * @returns matrix + * @param[in] mat mat2s + * @param[in] col1 column 1 array index + * @param[in] col2 column 2 array index + * @return[out] mat constructed mat2s from raw pointers columns swapped */ CGLM_INLINE mat2s @@ -225,12 +208,12 @@ glms_mat2_(swap_col)(mat2s mat, int col1, int col2) { } /*! - * @brief swap two matrix rows + * @brief Swap two rows in mat2s (mat) and store in same matrix. * - * @param[in] mat matrix - * @param[in] row1 row1 - * @param[in] row2 row2 - * @returns matrix + * @param[in] mat mat2s + * @param[in] row1 row 1 array index + * @param[in] row2 row 2 array index + * @return[out] mat constructed mat2s from raw pointers rows swapped */ CGLM_INLINE mat2s @@ -240,18 +223,47 @@ glms_mat2_(swap_row)(mat2s mat, int row1, int row2) { } /*! - * @brief helper for R (row vector) * M (matrix) * C (column vector) + * @brief Returns mat2 determinant. * - * rmc stands for Row * Matrix * Column + * @param[in] m mat2 (src) * - * the result is scalar because R * M = Matrix1x2 (row vector), - * then Matrix1x2 * Vec2 (column vector) = Matrix1x1 (Scalar) + * @return[out] mat2s raw pointers determinant (float) + */ +CGLM_INLINE +float +glms_mat2_(det)(mat2s m) { + return glm_mat2_det(m.raw); +} + +/*! + * @brief Returns trace of matrix. Which is: * - * @param[in] r row vector or matrix1x2 - * @param[in] m matrix2x2 - * @param[in] c column vector or matrix2x1 + * The sum of the elements on the main diagonal from + * upper left corner to the bottom right corner. * - * @return scalar value e.g. Matrix1x1 + * @param[in] m mat2 (m) + * + * @return[out] mat2s raw pointers trace (float) + */ +CGLM_INLINE +float +glms_mat2_(trace)(mat2s m) { + return glm_mat2_trace(m.raw); +} + +/*! + * @brief Helper for R (row vector) * M (matrix) * C (column vector) + * + * rmc stands for Row * Matrix * Column + * + * the result is scalar because M * C = ResC (1x2, column vector), + * then if you take the dot_product(R (2x1), ResC (1x2)) = scalar value. + * + * @param[in] r vec2s (2x1, row vector) + * @param[in] m mat2s (2x2, matrix) + * @param[in] c vec2s (1x2, column vector) + * + * @return[out] Scalar value (float, 1x1) */ CGLM_INLINE float @@ -259,18 +271,4 @@ glms_mat2_(rmc)(vec2s r, mat2s m, vec2s c) { return glm_mat2_rmc(r.raw, m.raw, c.raw); } -/*! - * @brief Create mat2 matrix from pointer - * - * @param[in] src pointer to an array of floats - * @return constructed matrix from raw pointer - */ -CGLM_INLINE -mat2s -glms_mat2_(make)(const float * __restrict src) { - mat2s r; - glm_mat2_make(src, r.raw); - return r; -} - #endif /* cglms_mat2_h */ diff --git a/src/mat2.c b/src/mat2.c index 3f0750c..48795c3 100644 --- a/src/mat2.c +++ b/src/mat2.c @@ -8,6 +8,12 @@ #include "../include/cglm/cglm.h" #include "../include/cglm/call.h" +CGLM_EXPORT +void +glmc_mat2_make(const float * __restrict src, mat2 dest) { + glm_mat2_make(src, dest); +} + CGLM_EXPORT void glmc_mat2_copy(mat2 mat, mat2 dest) { @@ -16,20 +22,20 @@ glmc_mat2_copy(mat2 mat, mat2 dest) { CGLM_EXPORT void -glmc_mat2_identity(mat2 mat) { - glm_mat2_identity(mat); +glmc_mat2_identity(mat2 m) { + glm_mat2_identity(m); } CGLM_EXPORT void -glmc_mat2_identity_array(mat2 * __restrict mat, size_t count) { - glm_mat2_identity_array(mat, count); +glmc_mat2_identity_array(mat2 * __restrict mats, size_t count) { + glm_mat2_identity_array(mats, count); } CGLM_EXPORT void -glmc_mat2_zero(mat2 mat) { - glm_mat2_zero(mat); +glmc_mat2_zero(mat2 m) { + glm_mat2_zero(m); } CGLM_EXPORT @@ -40,8 +46,14 @@ glmc_mat2_mul(mat2 m1, mat2 m2, mat2 dest) { CGLM_EXPORT void -glmc_mat2_transpose_to(mat2 m, mat2 dest) { - glm_mat2_transpose_to(m, dest); +glmc_mat2_mulv(mat2 m, vec2 v, vec2 dest) { + glm_mat2_mulv(m, v, dest); +} + +CGLM_EXPORT +void +glmc_mat2_transpose_to(mat2 mat, mat2 dest) { + glm_mat2_transpose_to(mat, dest); } CGLM_EXPORT @@ -50,30 +62,12 @@ glmc_mat2_transpose(mat2 m) { glm_mat2_transpose(m); } -CGLM_EXPORT -void -glmc_mat2_mulv(mat2 m, vec2 v, vec2 dest) { - glm_mat2_mulv(m, v, dest); -} - -CGLM_EXPORT -float -glmc_mat2_trace(mat2 m) { - return glm_mat2_trace(m); -} - CGLM_EXPORT void glmc_mat2_scale(mat2 m, float s) { glm_mat2_scale(m, s); } -CGLM_EXPORT -float -glmc_mat2_det(mat2 mat) { - return glm_mat2_det(mat); -} - CGLM_EXPORT void glmc_mat2_inv(mat2 mat, mat2 dest) { @@ -94,12 +88,18 @@ glmc_mat2_swap_row(mat2 mat, int row1, int row2) { CGLM_EXPORT float -glmc_mat2_rmc(vec2 r, mat2 m, vec2 c) { - return glm_mat2_rmc(r, m, c); +glmc_mat2_det(mat2 m) { + return glm_mat2_det(m); } CGLM_EXPORT -void -glmc_mat2_make(const float * __restrict src, mat2 dest) { - glm_mat2_make(src, dest); +float +glmc_mat2_trace(mat2 m) { + return glm_mat2_trace(m); +} + +CGLM_EXPORT +float +glmc_mat2_rmc(vec2 r, mat2 m, vec2 c) { + return glm_mat2_rmc(r, m, c); } From 27a3ddc9288653c4be888a23bcb8485955a57410 Mon Sep 17 00:00:00 2001 From: Vincent Davis Jr Date: Sat, 5 Apr 2025 22:08:48 -0400 Subject: [PATCH 3/3] gitignore: ignore vim swp files Signed-off-by: Vincent Davis Jr --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index 21c2eec..4682895 100644 --- a/.gitignore +++ b/.gitignore @@ -82,3 +82,4 @@ cmake-build-debug xcode/* .vscode .build +*.swp