External/cglm
1
0
Fork 0
mirror of https://github.com/recp/cglm.git synced 2025-10-03 16:51:35 +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_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
~~~~~~~~~~~~~~~~~~~~~~~
@@ -51,28 +60,70 @@ Functions documentation
| *[in]* **src** pointer to an array of floats
| *[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
.. code-block:: c
glm_mat4x2_mul(mat4x2, mat2x4, mat4);
glm_mat4x2_mul(mat4x2, mat2x4, mat2);
Parameters:
| *[in]* **m1** left matrix (mat4x2)
| *[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:
| *[in]* **m** mat4x2 (left)
| *[in]* **v** vec2 (right, column vector)
| *[in]* **v** vec4 (right, 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)
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
void
glmc_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat4 dest);
glmc_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat2 dest);
CGLM_EXPORT
void
glmc_mat4x2_mulv(mat4x2 m, vec2 v, vec4 dest);
glmc_mat4x2_mulv(mat4x2 m, vec4 v, vec2 dest);
CGLM_EXPORT
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_zero(mat4x2 mat);
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_mulv(mat4x2 m, vec2 v, vec4 dest);
CGLM_INLINE void glm_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat2 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_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
*
* @code
* glm_mat4x2_mul(mat4x2, mat2x4, mat4);
* glm_mat4x2_mul(mat4x2, mat2x4, mat2);
* @endcode
*
* @param[in] m1 left matrix (mat4x2)
* @param[in] m2 right matrix (mat2x4)
* @param[out] dest destination matrix (mat4)
* @param[out] dest destination matrix (mat2)
*/
CGLM_INLINE
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],
a10 = m1[1][0], a11 = m1[1][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],
b10 = m2[1][0], b11 = m2[1][1], b12 = m2[1][2], b13 = m2[1][3];
dest[0][0] = a00 * b00 + a01 * b10;
dest[0][1] = a00 * b01 + a01 * b11;
dest[0][2] = a00 * b02 + a01 * b12;
dest[0][3] = a00 * b03 + a01 * b13;
dest[0][0] = a00 * b00 + a10 * b01 + a20 * b02 + a30 * b03;
dest[0][1] = a01 * b00 + a11 * b01 + a21 * b02 + a31 * b03;
dest[1][0] = a10 * b00 + a11 * b10;
dest[1][1] = a10 * b01 + a11 * b11;
dest[1][2] = a10 * b02 + a11 * b12;
dest[1][3] = a10 * b03 + a11 * b13;
dest[2][0] = a20 * b00 + a21 * b10;
dest[2][1] = a20 * b01 + a21 * b11;
dest[2][2] = a20 * b02 + a21 * b12;
dest[2][3] = a20 * b03 + a21 * b13;
dest[3][0] = a30 * b00 + a31 * b10;
dest[3][1] = a30 * b01 + a31 * b11;
dest[3][2] = a30 * b02 + a31 * b12;
dest[3][3] = a30 * b03 + a31 * b13;
dest[1][0] = a00 * b10 + a10 * b11 + a20 * b12 + a30 * b13;
dest[1][1] = a01 * b10 + a11 * b11 + a21 * b12 + 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] v vector (right, column vector)
@@ -138,13 +124,11 @@ glm_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat4 dest) {
*/
CGLM_INLINE
void
glm_mat4x2_mulv(mat4x2 m, vec2 v, vec4 dest) {
float v0 = v[0], v1 = v[1];
glm_mat4x2_mulv(mat4x2 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;
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;
dest[0] = m[0][0] * v0 + m[1][0] * v1 + m[2][0] * v2 + m[3][0] * v3;
dest[1] = m[0][1] * v0 + m[1][1] * v1 + m[2][1] * v2 + m[3][1] * v3;
}
/*!

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

@@ -13,8 +13,8 @@
Functions:
CGLM_INLINE mat4x2s glms_mat4x2_zero(void);
CGLM_INLINE mat4x2s glms_mat4x2_make(const 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 mat2s glms_mat4x2_mul(mat4x2s m1, mat2x4s m2);
CGLM_INLINE vec2s glms_mat4x2_mulv(mat4x2s m, vec4s v);
CGLM_INLINE mat2x4s glms_mat4x2_transpose(mat4x2s m);
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] m2 right matrix (mat2x4s)
* @returns destination matrix (mat4s)
* @returns destination matrix (mat2s)
*/
CGLM_INLINE
mat4s
mat2s
glms_mat4x2_(mul)(mat4x2s m1, mat2x4s m2) {
mat4s r;
mat2s r;
glm_mat4x2_mul(m1.raw, m2.raw, r.raw);
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] v vector (right, column vector)
* @param[out] dest result vector
* @returns destination vector (vec2s)
*/
CGLM_INLINE
vec4s
glms_mat4x2_(mulv)(mat4x2s m, vec2s v) {
vec4s r;
vec2s
glms_mat4x2_(mulv)(mat4x2s m, vec4s v) {
vec2s r;
glm_mat4x2_mulv(m.raw, v.raw, r.raw);
return r;
}

4
src/mat4x2.c
View File

@@ -28,13 +28,13 @@ glmc_mat4x2_make(const float * __restrict src, mat4x2 dest) {
CGLM_EXPORT
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);
}
CGLM_EXPORT
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);
}

24
test/src/test_mat4x2.h
View File

@@ -87,40 +87,40 @@ 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;
mat2 m3 = GLM_MAT2_ZERO_INIT;
mat2 m4 = GLM_MAT2_ZERO_INIT;
int i, j, k;
int c, r, 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];
for (r = 0; r < 2; r++) {
for (c = 0; c < 2; c++) {
for (k = 0; k < 4; k++) {
m4[c][r] += m1[k][r] * m2[c][k];
}
}
}
GLM(mat4x2_mul)(m1, m2, m3);
ASSERTIFY(test_assert_mat4_eq(m3, m4))
ASSERTIFY(test_assert_mat2_eq(m3, m4))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, mat4x2_mulv) {
mat4x2 mat = A_MATRIX4X2;
vec2 v = {11.0f, 21.0f};
vec4 v = {11.0f, 21.0f, 31.0f, 41.0f};
int i;
vec4 dest;
vec2 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];
for (i = 0; i < 2; i++) {
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))
}