External/cglm
1
0
Fork 0
mirror of https://github.com/recp/cglm.git synced 2025-10-04 17:09:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #410 from EasyIP2023/bugfix/mat4x2-multiplication

Browse Source 
mat4x2: fix multiplication functions
This commit is contained in:
Recep Aslantas
2024-03-31 23:43:11 +03:00
committed by GitHub
parent 17d8b83a38 85165dd3e3
commit f07d75c680
6 changed files with 97 additions and 62 deletions
Download Patch File Download Diff File Expand all files Collapse all files

63
docs/source/mat4x2.rst
View File

@@ -23,6 +23,15 @@ Functions:
#. :c:func:`glm_mat4x2_transpose` #. :c:func:`glm_mat4x2_transpose`
#. :c:func:`glm_mat4x2_scale` #. :c:func:`glm_mat4x2_scale`
Represented
~~~~~~~~~~~
.. csv-table:: mat4x2
:header: "", "column 1", "column 2", "column 3", "column4"
"row 1", "m00", "m10", "m20", "m30"
"row 2", "m01", "m11", "m21", "m31"
Functions documentation Functions documentation
~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~
@@ -51,28 +60,70 @@ Functions documentation
| *[in]* **src** pointer to an array of floats | *[in]* **src** pointer to an array of floats
| *[out]* **dest** destination matrix4x2 | *[out]* **dest** destination matrix4x2
.. c:function:: void glm_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat4 dest) .. c:function:: void glm_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat2 dest)
multiply m1 and m2 to dest multiply m1 and m2 to dest
.. code-block:: c .. code-block:: c
glm_mat4x2_mul(mat4x2, mat2x4, mat4); glm_mat4x2_mul(mat4x2, mat2x4, mat2);
Parameters: Parameters:
| *[in]* **m1** left matrix (mat4x2) | *[in]* **m1** left matrix (mat4x2)
| *[in]* **m2** right matrix (mat2x4) | *[in]* **m2** right matrix (mat2x4)
| *[out]* **dest** destination matrix (mat4) | *[out]* **dest** destination matrix (mat2)
.. c:function:: void glm_mat4x2_mulv(mat4x2 m, vec2 v, vec4 dest) .. csv-table:: mat4x2
:header: "", "column 1", "column 2", "column 3", "column 4"
multiply mat4x2 with vec2 (column vector) and store in dest vector "row 1", "a00", "a10", "a20", "a30"
"row 2", "a01", "a11", "a21", "a31"
.. csv-table:: mat2x4
:header: "", "column 1", "column 2"
"row 1", "b00", "b10"
"row 2", "b01", "b11"
"row 3", "b02", "b12"
"row 4", "b03", "b13"
.. csv-table:: mat2x2
:header: "", "column 1", "column 2"
"row 1", "a00 * b00 + a10 * b01 + a20 * b02 + a30 * b03", "a00 * b10 + a10 * b11 + a20 * b12 + a30 * b13"
"row 2", "a01 * b00 + a11 * b01 + a21 * b02 + a31 * b03", "a01 * b10 + a11 * b11 + a21 * b12 + a31 * b13"
.. c:function:: void glm_mat4x2_mulv(mat4x2 m, vec4 v, vec2 dest)
multiply mat4x2 with vec4 (column vector) and store in dest vector
Parameters: Parameters:
| *[in]* **m** mat4x2 (left) | *[in]* **m** mat4x2 (left)
| *[in]* **v** vec2 (right, column vector) | *[in]* **v** vec4 (right, column vector)
| *[out]* **dest** destination (result, column vector) | *[out]* **dest** destination (result, column vector)
.. csv-table:: mat4x2
:header: "", "column 1", "column 2", "column 3"
"row 1", "m00", "m10", "m20"
"row 2", "m01", "m11", "m21"
"row 3", "m02", "m12", "m22"
"row 4", "m03", "m13", "m23"
.. csv-table:: column vec4 (1x4)
:header: "", "column 1"
"row 1", "v0"
"row 2", "v1"
"row 3", "v2"
"row 4", "v3"
.. csv-table:: column vec2 (1x2)
:header: "", "column 1"
"row 1", "m00 * v0 + m10 * v1 + m20 * v2 + m30 * v3"
"row 2", "m01 * v0 + m11 * v1 + m21 * v2 + m31 * v3"
.. c:function:: void glm_mat4x2_transpose(mat4x2 m, mat2x4 dest) .. c:function:: void glm_mat4x2_transpose(mat4x2 m, mat2x4 dest)
transpose matrix and store in dest transpose matrix and store in dest

4
include/cglm/call/mat4x2.h
View File

@@ -27,11 +27,11 @@ glmc_mat4x2_make(const float * __restrict src, mat4x2 dest);
CGLM_EXPORT CGLM_EXPORT
void void
glmc_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat4 dest); glmc_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat2 dest);
CGLM_EXPORT CGLM_EXPORT
void void
glmc_mat4x2_mulv(mat4x2 m, vec2 v, vec4 dest); glmc_mat4x2_mulv(mat4x2 m, vec4 v, vec2 dest);
CGLM_EXPORT CGLM_EXPORT
void void

44
include/cglm/mat4x2.h
View File

@@ -14,8 +14,8 @@
CGLM_INLINE void glm_mat4x2_copy(mat4x2 mat, 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_zero(mat4x2 mat);
CGLM_INLINE void glm_mat4x2_make(const float * __restrict src, mat4x2 dest); CGLM_INLINE void glm_mat4x2_make(const float * __restrict src, mat4x2 dest);
CGLM_INLINE void glm_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat4 dest); CGLM_INLINE void glm_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat2 dest);
CGLM_INLINE void glm_mat4x2_mulv(mat4x2 m, vec2 v, vec4 dest); CGLM_INLINE void glm_mat4x2_mulv(mat4x2 m, vec4 v, vec2 dest);
CGLM_INLINE void glm_mat4x2_transpose(mat4x2 m, mat2x4 dest); CGLM_INLINE void glm_mat4x2_transpose(mat4x2 m, mat2x4 dest);
CGLM_INLINE void glm_mat4x2_scale(mat4x2 m, float s); CGLM_INLINE void glm_mat4x2_scale(mat4x2 m, float s);
*/ */
@@ -90,16 +90,16 @@ glm_mat4x2_make(const float * __restrict src, mat4x2 dest) {
* @brief multiply m1 and m2 to dest * @brief multiply m1 and m2 to dest
* *
* @code * @code
* glm_mat4x2_mul(mat4x2, mat2x4, mat4); * glm_mat4x2_mul(mat4x2, mat2x4, mat2);
* @endcode * @endcode
* *
* @param[in] m1 left matrix (mat4x2) * @param[in] m1 left matrix (mat4x2)
* @param[in] m2 right matrix (mat2x4) * @param[in] m2 right matrix (mat2x4)
* @param[out] dest destination matrix (mat4) * @param[out] dest destination matrix (mat2)
*/ */
CGLM_INLINE CGLM_INLINE
void void
glm_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat4 dest) { glm_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat2 dest) {
float a00 = m1[0][0], a01 = m1[0][1], float a00 = m1[0][0], a01 = m1[0][1],
a10 = m1[1][0], a11 = m1[1][1], a10 = m1[1][0], a11 = m1[1][1],
a20 = m1[2][0], a21 = m1[2][1], a20 = m1[2][0], a21 = m1[2][1],
@@ -108,29 +108,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], 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]; b10 = m2[1][0], b11 = m2[1][1], b12 = m2[1][2], b13 = m2[1][3];
dest[0][0] = a00 * b00 + a01 * b10; dest[0][0] = a00 * b00 + a10 * b01 + a20 * b02 + a30 * b03;
dest[0][1] = a00 * b01 + a01 * b11; dest[0][1] = a01 * b00 + a11 * b01 + a21 * b02 + a31 * b03;
dest[0][2] = a00 * b02 + a01 * b12;
dest[0][3] = a00 * b03 + a01 * b13;
dest[1][0] = a10 * b00 + a11 * b10; dest[1][0] = a00 * b10 + a10 * b11 + a20 * b12 + a30 * b13;
dest[1][1] = a10 * b01 + a11 * b11; dest[1][1] = a01 * b10 + a11 * b11 + a21 * b12 + a31 * b13;
dest[1][2] = a10 * b02 + a11 * b12;
dest[1][3] = a10 * b03 + a11 * b13;
dest[2][0] = a20 * b00 + a21 * b10;
dest[2][1] = a20 * b01 + a21 * b11;
dest[2][2] = a20 * b02 + a21 * b12;
dest[2][3] = a20 * b03 + a21 * b13;
dest[3][0] = a30 * b00 + a31 * b10;
dest[3][1] = a30 * b01 + a31 * b11;
dest[3][2] = a30 * b02 + a31 * b12;
dest[3][3] = a30 * b03 + a31 * b13;
} }
/*! /*!
* @brief multiply matrix with column vector and store in dest vector * @brief multiply matrix with column vector and store in dest column vector
* *
* @param[in] m matrix (left) * @param[in] m matrix (left)
* @param[in] v vector (right, column vector) * @param[in] v vector (right, column vector)
@@ -138,13 +124,11 @@ glm_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat4 dest) {
*/ */
CGLM_INLINE CGLM_INLINE
void void
glm_mat4x2_mulv(mat4x2 m, vec2 v, vec4 dest) { glm_mat4x2_mulv(mat4x2 m, vec4 v, vec2 dest) {
float v0 = v[0], v1 = v[1]; float v0 = v[0], v1 = v[1], v2 = v[2], v3 = v[3];
dest[0] = m[0][0] * v0 + m[0][1] * v1; dest[0] = m[0][0] * v0 + m[1][0] * v1 + m[2][0] * v2 + m[3][0] * v3;
dest[1] = m[1][0] * v0 + m[1][1] * v1; dest[1] = m[0][1] * v0 + m[1][1] * v1 + m[2][1] * v2 + m[3][1] * v3;
dest[2] = m[2][0] * v0 + m[2][1] * v1;
dest[3] = m[3][0] * v0 + m[3][1] * v1;
} }
/*! /*!

20
include/cglm/struct/mat4x2.h
View File

@@ -13,8 +13,8 @@
Functions: Functions:
CGLM_INLINE mat4x2s glms_mat4x2_zero(void); CGLM_INLINE mat4x2s glms_mat4x2_zero(void);
CGLM_INLINE mat4x2s glms_mat4x2_make(const float * __restrict src); CGLM_INLINE mat4x2s glms_mat4x2_make(const float * __restrict src);
CGLM_INLINE mat4s glms_mat4x2_mul(mat4x2s m1, mat2x4s m2); CGLM_INLINE mat2s glms_mat4x2_mul(mat4x2s m1, mat2x4s m2);
CGLM_INLINE vec4s glms_mat4x2_mulv(mat4x2s m, vec2s v); CGLM_INLINE vec2s glms_mat4x2_mulv(mat4x2s m, vec4s v);
CGLM_INLINE mat2x4s glms_mat4x2_transpose(mat4x2s m); CGLM_INLINE mat2x4s glms_mat4x2_transpose(mat4x2s m);
CGLM_INLINE mat4x2s glms_mat4x2_scale(mat4x2s m, float s); CGLM_INLINE mat4x2s glms_mat4x2_scale(mat4x2s m, float s);
*/ */
@@ -71,27 +71,27 @@ glms_mat4x2_(make)(const float * __restrict src) {
* *
* @param[in] m1 left matrix (mat4x2s) * @param[in] m1 left matrix (mat4x2s)
* @param[in] m2 right matrix (mat2x4s) * @param[in] m2 right matrix (mat2x4s)
* @returns destination matrix (mat4s) * @returns destination matrix (mat2s)
*/ */
CGLM_INLINE CGLM_INLINE
mat4s mat2s
glms_mat4x2_(mul)(mat4x2s m1, mat2x4s m2) { glms_mat4x2_(mul)(mat4x2s m1, mat2x4s m2) {
mat4s r; mat2s r;
glm_mat4x2_mul(m1.raw, m2.raw, r.raw); glm_mat4x2_mul(m1.raw, m2.raw, r.raw);
return r; return r;
} }
/*! /*!
* @brief multiply matrix with column vector and store in dest vector * @brief multiply matrix with column vector and store in dest column vector
* *
* @param[in] m matrix (left) * @param[in] m matrix (left)
* @param[in] v vector (right, column vector) * @param[in] v vector (right, column vector)
* @param[out] dest result vector * @returns destination vector (vec2s)
*/ */
CGLM_INLINE CGLM_INLINE
vec4s vec2s
glms_mat4x2_(mulv)(mat4x2s m, vec2s v) { glms_mat4x2_(mulv)(mat4x2s m, vec4s v) {
vec4s r; vec2s r;
glm_mat4x2_mulv(m.raw, v.raw, r.raw); glm_mat4x2_mulv(m.raw, v.raw, r.raw);
return r; return r;
} }

4
src/mat4x2.c
View File

@@ -28,13 +28,13 @@ glmc_mat4x2_make(const float * __restrict src, mat4x2 dest) {
CGLM_EXPORT CGLM_EXPORT
void void
glmc_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat4 dest) { glmc_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat2 dest) {
glm_mat4x2_mul(m1, m2, dest); glm_mat4x2_mul(m1, m2, dest);
} }
CGLM_EXPORT CGLM_EXPORT
void void
glmc_mat4x2_mulv(mat4x2 m, vec2 v, vec4 dest) { glmc_mat4x2_mulv(mat4x2 m, vec4 v, vec2 dest) {
glm_mat4x2_mulv(m, v, dest); glm_mat4x2_mulv(m, v, dest);
} }

24
test/src/test_mat4x2.h
View File

@@ -87,40 +87,40 @@ TEST_IMPL(GLM_PREFIX, mat4x2_mul) {
mat4x2 m1 = GLM_MAT4X2_ZERO_INIT; mat4x2 m1 = GLM_MAT4X2_ZERO_INIT;
mat2x4 m2 = GLM_MAT2X4_ZERO_INIT; mat2x4 m2 = GLM_MAT2X4_ZERO_INIT;
mat4 m3 = GLM_MAT4_ZERO_INIT; mat2 m3 = GLM_MAT2_ZERO_INIT;
mat4 m4 = GLM_MAT4_ZERO_INIT; mat2 m4 = GLM_MAT2_ZERO_INIT;
int i, j, k; int c, r, k;
test_rand_mat4x2(m1); test_rand_mat4x2(m1);
test_rand_mat2x4(m2); test_rand_mat2x4(m2);
for (i = 0; i < 4; i++) { for (r = 0; r < 2; r++) {
for (j = 0; j < 4; j++) { for (c = 0; c < 2; c++) {
for (k = 0; k < 2; k++) { for (k = 0; k < 4; k++) {
m4[i][j] += m1[i][k] * m2[k][j]; m4[c][r] += m1[k][r] * m2[c][k];
} }
} }
} }
GLM(mat4x2_mul)(m1, m2, m3); GLM(mat4x2_mul)(m1, m2, m3);
ASSERTIFY(test_assert_mat4_eq(m3, m4)) ASSERTIFY(test_assert_mat2_eq(m3, m4))
TEST_SUCCESS TEST_SUCCESS
} }
TEST_IMPL(GLM_PREFIX, mat4x2_mulv) { TEST_IMPL(GLM_PREFIX, mat4x2_mulv) {
mat4x2 mat = A_MATRIX4X2; mat4x2 mat = A_MATRIX4X2;
vec2 v = {11.0f, 21.0f}; vec4 v = {11.0f, 21.0f, 31.0f, 41.0f};
int i; int i;
vec4 dest; vec2 dest;
float res = 0.0; float res = 0.0;
GLM(mat4x2_mulv)(mat, v, dest); GLM(mat4x2_mulv)(mat, v, dest);
for (i = 0; i < 4; i++) { for (i = 0; i < 2; i++) {
res = mat[i][0] * v[0] + mat[i][1] * v[1]; res = mat[0][i] * v[0] + mat[1][i] * v[1] + mat[2][i] * v[2] + mat[3][i] * v[3];
ASSERT(test_eq(dest[i], res)) ASSERT(test_eq(dest[i], res))
} }