On Tue, Nov 10, 2015 at 3:52 AM, Carsten Haitzler <[email protected]> wrote:
> On Mon, 09 Nov 2015 16:38:33 -0800 "se.osadchy" <[email protected]> said:
> hey cedric... did you even TEST this?
I just noticed that I switched my default backend back to software a
few month back due to some crash in the driver after a few days,
forgot about it and assumed it was gl today when testing things...
> literally evas gl engine doesn't work anymore... because....
>
>
> +/**
> + * @brief Set normal of the given matrix.
> + *
> + * @param out The result mtrix of normal
> + * @param m The matrix
> + *
> + * @since 1.17
> + */
> +EAPI void eina_normal3_matrix_get(Eina_Matrix3 *out, const Eina_Matrix4 *m);
>
> BUT.... the actual code is:
>
> EAPI void
> eina_normal_matrix3_get(Eina_Matrix3 *out, const Eina_Matrix4 *m)
> {
> /* Normal matrix is a transposed matrix of inversed modelview.
> * And we need only upper-left 3x3 terms to work with. */
>
> ...
>
> and evas gl engine uses the api that's in .h .. but fails to load as a
> result.....
>
> this is a silly mistake - sure... not that deep and evil, but this should get
> caught...
>
>> cedric pushed a commit to branch master.
>>
>> http://git.enlightenment.org/core/efl.git/commit/?id=3d77f55f910a844b45019238ed458bf62e6c1c20
>>
>> commit 3d77f55f910a844b45019238ed458bf62e6c1c20
>> Author: se.osadchy <[email protected]>
>> Date: Mon Nov 9 14:37:42 2015 -0800
>>
>> evas: refactor duplicated data structure with eina_matrix.
>>
>> Summary: Move data structure and functionality to eina_matrix from
>> evas_mat.
>> Reviewers: raster, Hermet, cedric
>>
>> Subscribers: Oleksander, cedric
>>
>> Differential Revision: https://phab.enlightenment.org/D3020
>>
>> Signed-off-by: Cedric BAIL <[email protected]>
>> ---
>> src/lib/eina/eina_matrix.c | 413 +++++++--
>> src/lib/eina/eina_matrix.h | 275 +++++-
>> src/lib/evas/canvas/evas_canvas3d_camera.c | 12 +-
>> src/lib/evas/canvas/evas_canvas3d_light.c | 6 +-
>> src/lib/evas/canvas/evas_canvas3d_scene.c | 8 +-
>> src/lib/evas/include/evas_3d_utils.h | 929 +++
>> +----------------- src/lib/evas/include/evas_private.h | 16
>> +-
>> src/modules/evas/engines/gl_common/evas_gl_3d.c | 70 +-
>> .../evas/engines/gl_common/evas_gl_3d_private.h | 12 +-
>> .../evas/engines/gl_common/evas_gl_3d_shader.c | 44 +-
>> src/tests/eina/eina_test_matrix.c | 282 +++++++
>> 11 files changed, 1120 insertions(+), 947 deletions(-)
>>
>> diff --git a/src/lib/eina/eina_matrix.c b/src/lib/eina/eina_matrix.c
>> index 4263322..a7bdddf 100644
>> --- a/src/lib/eina/eina_matrix.c
>> +++ b/src/lib/eina/eina_matrix.c
>> @@ -939,113 +939,348 @@ eina_matrix4_transpose(Eina_Matrix4 *out, const
>> Eina_Matrix4 *in) }
>>
>> EAPI void
>> -eina_matrix4_multiply(Eina_Matrix4 *out,
>> - const Eina_Matrix4 *a, const Eina_Matrix4 *b)
>> +eina_matrix4_multiply_copy(Eina_Matrix4 *out,
>> + const Eina_Matrix4 *mat_a, const Eina_Matrix4 *mat_b)
>> {
>> - // FIXME: start implementing SSE multiplication here
>> - MATRIX_XX(out) =
>> - MATRIX_XX(a) * MATRIX_XX(b)
>> - + MATRIX_XY(a) * MATRIX_YX(b)
>> - + MATRIX_XZ(a) * MATRIX_ZX(b)
>> - + MATRIX_XW(a) * MATRIX_WX(b);
>> + if (out != mat_a && out != mat_b)
>> + {
>> + eina_matrix4_multiply(out, mat_a, mat_b);
>> + }
>> + else
>> + {
>> + Eina_Matrix4 result;
>>
>> - MATRIX_XY(out) =
>> - MATRIX_XX(a) * MATRIX_XY(b)
>> - + MATRIX_XY(a) * MATRIX_YY(b)
>> - + MATRIX_XZ(a) * MATRIX_ZY(b)
>> - + MATRIX_XW(a) * MATRIX_WY(b);
>> + eina_matrix4_multiply(&result, mat_a, mat_b);
>> + eina_matrix4_copy(out, &result);
>> + }
>> +}
>>
>> - MATRIX_XZ(out) =
>> - MATRIX_XX(a) * MATRIX_XZ(b)
>> - + MATRIX_XY(a) * MATRIX_YZ(b)
>> - + MATRIX_XZ(a) * MATRIX_ZZ(b)
>> - + MATRIX_XW(a) * MATRIX_WZ(b);
>> +EAPI void
>> +eina_matrix4_identity(Eina_Matrix4 *out)
>> +{
>> + memset(out, 0, sizeof (Eina_Matrix4));
>>
>> - MATRIX_XW(out) =
>> - MATRIX_XX(a) * MATRIX_XW(b)
>> - + MATRIX_XY(a) * MATRIX_YW(b)
>> - + MATRIX_XZ(a) * MATRIX_ZW(b)
>> - + MATRIX_XW(a) * MATRIX_WW(b);
>> + MATRIX_XX(out) = 1.0;
>> + MATRIX_YY(out) = 1.0;
>> + MATRIX_ZZ(out) = 1.0;
>> + MATRIX_WW(out) = 1.0;
>> +}
>>
>> - MATRIX_YX(out) =
>> - MATRIX_YX(a) * MATRIX_XX(b)
>> - + MATRIX_YY(a) * MATRIX_YX(b)
>> - + MATRIX_YZ(a) * MATRIX_ZX(b)
>> - + MATRIX_YW(a) * MATRIX_WX(b);
>> +EAPI Eina_Matrix_Type
>> +eina_matrix2_type_get(const Eina_Matrix2 *m)
>> +{
>> + if ((MATRIX_XX(m) == 1) && (MATRIX_XY(m) == 0) &&
>> + (MATRIX_YX(m) == 0) && (MATRIX_YY(m) == 1))
>> + return EINA_MATRIX_TYPE_IDENTITY;
>> + return EINA_MATRIX_TYPE_AFFINE;
>> +}
>>
>> - MATRIX_YY(out) =
>> - MATRIX_YX(a) * MATRIX_XY(b)
>> - + MATRIX_YY(a) * MATRIX_YY(b)
>> - + MATRIX_YZ(a) * MATRIX_ZY(b)
>> - + MATRIX_YW(a) * MATRIX_WY(b);
>> +EAPI void
>> +eina_matrix4_array_set(Eina_Matrix4 *m, const double *v)
>> +{
>> + memcpy(&MATRIX_XX(m), v, sizeof(double) * 16);
>> +}
>>
>> - MATRIX_YZ(out) =
>> - MATRIX_YX(a) * MATRIX_XZ(b)
>> - + MATRIX_YY(a) * MATRIX_YZ(b)
>> - + MATRIX_YZ(a) * MATRIX_ZZ(b)
>> - + MATRIX_YW(a) * MATRIX_WZ(b);
>> +EAPI void
>> +eina_matrix4_copy(Eina_Matrix4 *dst, const Eina_Matrix4 *src)
>> +{
>> + memcpy(dst, src, sizeof(Eina_Matrix4));
>> +}
>>
>> - MATRIX_YW(out) =
>> - MATRIX_YX(a) * MATRIX_XW(b)
>> - + MATRIX_YY(a) * MATRIX_YW(b)
>> - + MATRIX_YZ(a) * MATRIX_ZW(b)
>> - + MATRIX_YW(a) * MATRIX_WW(b);
>> +EAPI void
>> +eina_matrix4_multiply(Eina_Matrix4 *out, const Eina_Matrix4 *mat_a,
>> + const Eina_Matrix4 *mat_b)
>> +{
>> + if (eina_matrix4_type_get(mat_a) & EINA_MATRIX_TYPE_IDENTITY)
>> + {
>> + eina_matrix4_copy(out, mat_b);
>> + return;
>> + }
>>
>> - MATRIX_ZX(out) =
>> - MATRIX_ZX(a) * MATRIX_XX(b)
>> - + MATRIX_ZY(a) * MATRIX_YX(b)
>> - + MATRIX_ZZ(a) * MATRIX_ZX(b)
>> - + MATRIX_ZW(a) * MATRIX_WX(b);
>> + if (eina_matrix4_type_get(mat_b) & EINA_MATRIX_TYPE_IDENTITY)
>> + {
>> + eina_matrix4_copy(out, mat_a);
>> + return;
>> + }
>>
>> - MATRIX_ZY(out) =
>> - MATRIX_ZX(a) * MATRIX_XY(b)
>> - + MATRIX_ZY(a) * MATRIX_YY(b)
>> - + MATRIX_ZZ(a) * MATRIX_ZY(b)
>> - + MATRIX_ZW(a) * MATRIX_WY(b);
>> + MATRIX_XX(out) = MATRIX_XX(mat_a) * MATRIX_XX(mat_b) + MATRIX_YX(mat_a) *
>> MATRIX_XY(mat_b) +
>> + MATRIX_ZX(mat_a) * MATRIX_XZ(mat_b) + mat_a->wx *
>> MATRIX_XW(mat_b);
>> + MATRIX_YX(out) = MATRIX_XX(mat_a) * MATRIX_YX(mat_b) + MATRIX_YX(mat_a) *
>> MATRIX_YY(mat_b) +
>> + MATRIX_ZX(mat_a) * MATRIX_YZ(mat_b) + mat_a->wx *
>> MATRIX_YW(mat_b);
>> + MATRIX_ZX(out) = MATRIX_XX(mat_a) * MATRIX_ZX(mat_b) + MATRIX_YX(mat_a) *
>> MATRIX_ZY(mat_b) +
>> + MATRIX_ZX(mat_a) * MATRIX_ZZ(mat_b) + mat_a->wx *
>> MATRIX_ZW(mat_b);
>> + MATRIX_WX(out) = MATRIX_XX(mat_a) * MATRIX_WX(mat_b) + MATRIX_YX(mat_a) *
>> MATRIX_WY(mat_b) +
>> + MATRIX_ZX(mat_a) * MATRIX_WZ(mat_b) + mat_a->wx *
>> MATRIX_WW(mat_b); +
>> + MATRIX_XY(out) = MATRIX_XY(mat_a) * MATRIX_XX(mat_b) + MATRIX_YY(mat_a) *
>> MATRIX_XY(mat_b) +
>> + MATRIX_ZY(mat_a) * MATRIX_XZ(mat_b) + mat_a->wy *
>> MATRIX_XW(mat_b);
>> + MATRIX_YY(out) = MATRIX_XY(mat_a) * MATRIX_YX(mat_b) + MATRIX_YY(mat_a) *
>> MATRIX_YY(mat_b) +
>> + MATRIX_ZY(mat_a) * MATRIX_YZ(mat_b) + mat_a->wy *
>> MATRIX_YW(mat_b);
>> + MATRIX_ZY(out) = MATRIX_XY(mat_a) * MATRIX_ZX(mat_b) + MATRIX_YY(mat_a) *
>> MATRIX_ZY(mat_b) +
>> + MATRIX_ZY(mat_a) * MATRIX_ZZ(mat_b) + mat_a->wy *
>> MATRIX_ZW(mat_b);
>> + MATRIX_WY(out) = MATRIX_XY(mat_a) * MATRIX_WX(mat_b) + MATRIX_YY(mat_a) *
>> MATRIX_WY(mat_b) +
>> + MATRIX_ZY(mat_a) * MATRIX_WZ(mat_b) + mat_a->wy *
>> MATRIX_WW(mat_b); +
>> + MATRIX_XZ(out) = MATRIX_XZ(mat_a) * MATRIX_XX(mat_b) + MATRIX_YZ(mat_a) *
>> MATRIX_XY(mat_b) +
>> + MATRIX_ZZ(mat_a) * MATRIX_XZ(mat_b) + mat_a->wz *
>> MATRIX_XW(mat_b);
>> + MATRIX_YZ(out) = MATRIX_XZ(mat_a) * MATRIX_YX(mat_b) + MATRIX_YZ(mat_a) *
>> MATRIX_YY(mat_b) +
>> + MATRIX_ZZ(mat_a) * MATRIX_YZ(mat_b) + mat_a->wz *
>> MATRIX_YW(mat_b);
>> + MATRIX_ZZ(out) = MATRIX_XZ(mat_a) * MATRIX_ZX(mat_b) + MATRIX_YZ(mat_a) *
>> MATRIX_ZY(mat_b) +
>> + MATRIX_ZZ(mat_a) * MATRIX_ZZ(mat_b) + mat_a->wz *
>> MATRIX_ZW(mat_b);
>> + MATRIX_WZ(out) = MATRIX_XZ(mat_a) * MATRIX_WX(mat_b) + MATRIX_YZ(mat_a) *
>> MATRIX_WY(mat_b) +
>> + MATRIX_ZZ(mat_a) * MATRIX_WZ(mat_b) + mat_a->wz *
>> MATRIX_WW(mat_b); +
>> + MATRIX_XW(out) = MATRIX_XW(mat_a) * MATRIX_XX(mat_b) + MATRIX_YW(mat_a) *
>> MATRIX_XY(mat_b) +
>> + MATRIX_ZW(mat_a) * MATRIX_XZ(mat_b) + mat_a->ww *
>> MATRIX_XW(mat_b);
>> + MATRIX_YW(out) = MATRIX_XW(mat_a) * MATRIX_YX(mat_b) + MATRIX_YW(mat_a) *
>> MATRIX_YY(mat_b) +
>> + MATRIX_ZW(mat_a) * MATRIX_YZ(mat_b) + mat_a->ww *
>> MATRIX_YW(mat_b);
>> + MATRIX_ZW(out) = MATRIX_XW(mat_a) * MATRIX_ZX(mat_b) + MATRIX_YW(mat_a) *
>> MATRIX_ZY(mat_b) +
>> + MATRIX_ZW(mat_a) * MATRIX_ZZ(mat_b) + mat_a->ww *
>> MATRIX_ZW(mat_b);
>> + MATRIX_WW(out) = MATRIX_XW(mat_a) * MATRIX_WX(mat_b) + MATRIX_YW(mat_a) *
>> MATRIX_WY(mat_b) +
>> + MATRIX_ZW(mat_a) * MATRIX_WZ(mat_b) + mat_a->ww *
>> MATRIX_WW(mat_b); +}
>>
>> - MATRIX_ZZ(out) =
>> - MATRIX_ZX(a) * MATRIX_XZ(b)
>> - + MATRIX_ZY(a) * MATRIX_YZ(b)
>> - + MATRIX_ZZ(a) * MATRIX_ZZ(b)
>> - + MATRIX_ZW(a) * MATRIX_WZ(b);
>> +EAPI void
>> +eina_matrix4_ortho_set(Eina_Matrix4 *m,
>> + double left, double right, double bottom, double top,
>> + double dnear, double dfar)
>> +{
>> + double w = right - left;
>> + double h = top - bottom;
>> + double depth = dnear - dfar;
>> +
>> + MATRIX_XX(m) = 2.0f / w;
>> + MATRIX_XY(m) = 0.0f;
>> + MATRIX_XZ(m) = 0.0f;
>> + MATRIX_XW(m) = 0.0f;
>> +
>> + MATRIX_YX(m) = 0.0f;
>> + MATRIX_YY(m) = 2.0f / h;
>> + MATRIX_YZ(m) = 0.0f;
>> + MATRIX_YW(m) = 0.0f;
>> +
>> + MATRIX_ZX(m) = 0.0f;
>> + MATRIX_ZY(m) = 0.0f;
>> + MATRIX_ZZ(m) = 2.0f / depth;
>> + MATRIX_ZW(m) = 0.0f;
>> +
>> + MATRIX_WX(m) = -(right + left) / w;
>> + MATRIX_WY(m) = -(top + bottom) / h;
>> + MATRIX_WZ(m) = (dfar + dnear) / depth;
>> + MATRIX_WW(m) = 1.0f;
>> +}
>>
>> - MATRIX_ZW(out) =
>> - MATRIX_ZX(a) * MATRIX_XW(b)
>> - + MATRIX_ZY(a) * MATRIX_YW(b)
>> - + MATRIX_ZZ(a) * MATRIX_ZW(b)
>> - + MATRIX_ZW(a) * MATRIX_WW(b);
>> +EAPI void
>> +eina_matrix3_array_set(Eina_Matrix3 *m, const double *v)
>> +{
>> + memcpy(&MATRIX_XX(m), v, sizeof(double) * 9);
>> +}
>>
>> - MATRIX_WX(out) =
>> - MATRIX_WX(a) * MATRIX_XX(b)
>> - + MATRIX_WY(a) * MATRIX_YX(b)
>> - + MATRIX_WZ(a) * MATRIX_ZX(b)
>> - + MATRIX_WW(a) * MATRIX_WX(b);
>> +EAPI void
>> +eina_matrix3_copy(Eina_Matrix3 *dst, const Eina_Matrix3 *src)
>> +{
>> + memcpy(dst, src, sizeof(Eina_Matrix3));
>> +}
>>
>> - MATRIX_WY(out) =
>> - MATRIX_WX(a) * MATRIX_XY(b)
>> - + MATRIX_WY(a) * MATRIX_YY(b)
>> - + MATRIX_WZ(a) * MATRIX_ZY(b)
>> - + MATRIX_WW(a) * MATRIX_WY(b);
>> +EAPI void
>> +eina_matrix3_multiply(Eina_Matrix3 *out, const Eina_Matrix3 *mat_a, const
>> Eina_Matrix3 *mat_b) +{
>> + if (eina_matrix3_type_get(mat_a) & EINA_MATRIX_TYPE_IDENTITY)
>> + {
>> + eina_matrix3_copy(out, mat_b);
>> + return;
>> + }
>>
>> - MATRIX_WZ(out) =
>> - MATRIX_WX(a) * MATRIX_XZ(b)
>> - + MATRIX_WY(a) * MATRIX_YZ(b)
>> - + MATRIX_WZ(a) * MATRIX_ZZ(b)
>> - + MATRIX_WW(a) * MATRIX_WZ(b);
>> + if (eina_matrix3_type_get(mat_b) & EINA_MATRIX_TYPE_IDENTITY)
>> + {
>> + eina_matrix3_copy(out, mat_a);
>> + return;
>> + }
>>
>> - MATRIX_WW(out) =
>> - MATRIX_WX(a) * MATRIX_XW(b)
>> - + MATRIX_WY(a) * MATRIX_YW(b)
>> - + MATRIX_WZ(a) * MATRIX_ZW(b)
>> - + MATRIX_WW(a) * MATRIX_WW(b);
>> + MATRIX_XX(out) = MATRIX_XX(mat_b) * MATRIX_XX(mat_a) + MATRIX_YX(mat_b) *
>> MATRIX_XY(mat_a) + MATRIX_ZX(mat_b) * MATRIX_XZ(mat_a);
>> + MATRIX_XY(out) = MATRIX_XY(mat_b) * MATRIX_XX(mat_a) + MATRIX_YY(mat_b) *
>> MATRIX_XY(mat_a) + MATRIX_ZY(mat_b) * MATRIX_XZ(mat_a);
>> + MATRIX_XZ(out) = MATRIX_XZ(mat_b) * MATRIX_XX(mat_a) + MATRIX_YZ(mat_b) *
>> MATRIX_XY(mat_a) + MATRIX_ZZ(mat_b) * MATRIX_XZ(mat_a); +
>> + MATRIX_YX(out) = MATRIX_XX(mat_b) * MATRIX_YX(mat_a) + MATRIX_YX(mat_b) *
>> MATRIX_YY(mat_a) + MATRIX_ZX(mat_b) * MATRIX_YZ(mat_a);
>> + MATRIX_YY(out) = MATRIX_XY(mat_b) * MATRIX_YX(mat_a) + MATRIX_YY(mat_b) *
>> MATRIX_YY(mat_a) + MATRIX_ZY(mat_b) * MATRIX_YZ(mat_a);
>> + MATRIX_YZ(out) = MATRIX_XZ(mat_b) * MATRIX_YX(mat_a) + MATRIX_YZ(mat_b) *
>> MATRIX_YY(mat_a) + MATRIX_ZZ(mat_b) * MATRIX_YZ(mat_a); +
>> + MATRIX_ZX(out) = MATRIX_XX(mat_b) * MATRIX_ZX(mat_a) + MATRIX_YX(mat_b) *
>> MATRIX_ZY(mat_a) + MATRIX_ZX(mat_b) * MATRIX_ZZ(mat_a);
>> + MATRIX_ZY(out) = MATRIX_XY(mat_b) * MATRIX_ZX(mat_a) + MATRIX_YY(mat_b) *
>> MATRIX_ZY(mat_a) + MATRIX_ZY(mat_b) * MATRIX_ZZ(mat_a);
>> + MATRIX_ZZ(out) = MATRIX_XZ(mat_b) * MATRIX_ZX(mat_a) + MATRIX_YZ(mat_b) *
>> MATRIX_ZY(mat_a) + MATRIX_ZZ(mat_b) * MATRIX_ZZ(mat_a); }
>>
>> EAPI void
>> -eina_matrix4_identity(Eina_Matrix4 *out)
>> +eina_matrix3_multiply_copy(Eina_Matrix3 *out, const Eina_Matrix3 *mat_a,
>> const Eina_Matrix3 *mat_b) {
>> - memset(out, 0, sizeof (Eina_Matrix4));
>> - MATRIX_XX(out) = 1;
>> - MATRIX_YY(out) = 1;
>> - MATRIX_ZZ(out) = 1;
>> - MATRIX_WW(out) = 1;
>> + if (out != mat_a && out != mat_b)
>> + {
>> + eina_matrix3_multiply(out, mat_a, mat_b);
>> + }
>> + else
>> + {
>> + Eina_Matrix3 tmp;
>> +
>> + eina_matrix3_multiply(&tmp, mat_a, mat_b);
>> + eina_matrix3_copy(out, &tmp);
>> + }
>> +}
>> +
>> +EAPI void
>> +eina_matrix3_position_transform_set(Eina_Matrix3 *out, const double p_x,
>> + const
>> double p_y) +{
>> + eina_matrix3_identity(out);
>> + MATRIX_XZ(out) = p_x;
>> + MATRIX_YZ(out) = p_y;
>> +}
>> +
>> +EAPI void
>> +eina_matrix3_scale_transform_set(Eina_Matrix3 *out, double s_x, double s_y)
>> +{
>> + eina_matrix3_identity(out);
>> + MATRIX_XX(out) = s_x;
>> + MATRIX_YY(out) = s_y;
>> +}
>> +
>> +EAPI void
>> +eina_normal_matrix3_get(Eina_Matrix3 *out, const Eina_Matrix4 *m)
>> +{
>> + /* Normal matrix is a transposed matrix of inversed modelview.
>> + * And we need only upper-left 3x3 terms to work with. */
>> +
>> + double det;
>> +
>> + double a = MATRIX_XX(m);
>> + double b = MATRIX_YX(m);
>> + double c = MATRIX_ZX(m);
>> +
>> + double d = MATRIX_XY(m);
>> + double e = MATRIX_YY(m);
>> + double f = MATRIX_ZY(m);
>> +
>> + double g = MATRIX_XZ(m);
>> + double h = MATRIX_YZ(m);
>> + double i = MATRIX_ZZ(m);
>> +
>> + det = a * e * i + b * f * g + c * d * h - g * e * c - h * f * a - i * d *
>> b;
>> + det = 1.0 / det;
>> +
>> + MATRIX_XX(out) = (e * i - f * h) * det;
>> + MATRIX_XY(out) = (h * c - i * b) * det;
>> + MATRIX_XZ(out) = (b * f - c * e) * det;
>> +
>> + MATRIX_YX(out) = (g * f - d * i) * det;
>> + MATRIX_YY(out) = (a * i - g * c) * det;
>> + MATRIX_YZ(out) = (d * c - a * f) * det;
>> +
>> + MATRIX_ZX(out) = (d * h - g * e) * det;
>> + MATRIX_ZY(out) = (g * b - a * h) * det;
>> + MATRIX_ZZ(out) = (a * e - d * b) * det;
>> +}
>> +
>> +EAPI void
>> +eina_matrix2_values_set(Eina_Matrix2 *m,
>> + double xx, double xy,
>> + double yx, double yy)
>> +{
>> + MATRIX_XX(m) = xx;
>> + MATRIX_XY(m) = xy;
>> + MATRIX_YX(m) = yx;
>> + MATRIX_YY(m) = yy;
>> +}
>> +
>> +EAPI void
>> +eina_matrix2_values_get(const Eina_Matrix2 *m,
>> + double *xx, double *xy,
>> + double *yx, double *yy)
>> +{
>> + if (xx) *xx = MATRIX_XX(m);
>> + if (xy) *xy = MATRIX_XY(m);
>> + if (yx) *yx = MATRIX_YX(m);
>> + if (yy) *yy = MATRIX_YY(m);
>> +}
>> +
>> +EAPI void
>> +eina_matrix2_inverse(Eina_Matrix2 *out, const Eina_Matrix2 *mat)
>> +{
>> + double det;
>> +
>> + if (eina_matrix2_type_get(mat) & EINA_MATRIX_TYPE_IDENTITY)
>> + {
>> + eina_matrix2_copy(out, mat);
>> + return;
>> + }
>> +
>> + det = MATRIX_XX(mat) * MATRIX_YY(mat) - MATRIX_YX(mat) * MATRIX_XY(mat);
>> +
>> + if (det == 0.0)
>> + return;
>> +
>> + det = 1.0 / det;
>> +
>> + MATRIX_XX(out) = MATRIX_YY(mat) * det;
>> + MATRIX_XY(out) = -MATRIX_XY(mat) * det;
>> + MATRIX_YX(out) = -MATRIX_YX(mat) * det;
>> + MATRIX_YY(out) = MATRIX_XX(mat) * det;
>> +}
>> +
>> +EAPI void
>> +eina_matrix2_identity(Eina_Matrix2 *m)
>> +{
>> + MATRIX_XX(m) = 1.0;
>> + MATRIX_XY(m) = 0.0;
>> +
>> + MATRIX_YX(m) = 0.0;
>> + MATRIX_YY(m) = 1.0;
>> +}
>> +
>> +EAPI void
>> +eina_matrix2_array_set(Eina_Matrix2 *m, const double *v)
>> +{
>> + memcpy(&MATRIX_XX(m), v, sizeof(double) * 4);
>> +}
>> +
>> +EAPI void
>> +eina_matrix2_copy(Eina_Matrix2 *dst, const Eina_Matrix2 *src)
>> +{
>> + memcpy(dst, src, sizeof(Eina_Matrix2));
>> +}
>> +
>> +EAPI void
>> +eina_matrix2_multiply(Eina_Matrix2 *out, const Eina_Matrix2 *mat_a, const
>> Eina_Matrix2 *mat_b) +{
>> + if (eina_matrix2_type_get(mat_a) & EINA_MATRIX_TYPE_IDENTITY)
>> + {
>> + eina_matrix2_copy(out, mat_b);
>> + return;
>> + }
>> +
>> + if (eina_matrix2_type_get(mat_b) & EINA_MATRIX_TYPE_IDENTITY)
>> + {
>> + eina_matrix2_copy(out, mat_a);
>> + return;
>> + }
>> +
>> + MATRIX_XX(out) = MATRIX_XX(mat_a) * MATRIX_XX(mat_b) + MATRIX_YX(mat_a) *
>> MATRIX_XY(mat_b);
>> + MATRIX_YX(out) = MATRIX_XX(mat_a) * MATRIX_YX(mat_b) + MATRIX_YX(mat_a) *
>> MATRIX_YY(mat_b); +
>> + MATRIX_XY(out) = MATRIX_XY(mat_a) * MATRIX_XX(mat_b) + MATRIX_YY(mat_a) *
>> MATRIX_XY(mat_b);
>> + MATRIX_YY(out) = MATRIX_XY(mat_a) * MATRIX_YX(mat_b) + MATRIX_YY(mat_a) *
>> MATRIX_YY(mat_b); +}
>> +
>> +EAPI void
>> +eina_matrix2_multiply_copy(Eina_Matrix2 *out, const Eina_Matrix2 *mat_a,
>> const Eina_Matrix2 *mat_b) +{
>> + if (out != mat_a && out != mat_b)
>> + {
>> + eina_matrix2_multiply(out, mat_a, mat_b);
>> + }
>> + else
>> + {
>> + Eina_Matrix2 tmp;
>> +
>> + eina_matrix2_multiply(&tmp, mat_a, mat_b);
>> + eina_matrix2_copy(out, &tmp);
>> + }
>> }
>> diff --git a/src/lib/eina/eina_matrix.h b/src/lib/eina/eina_matrix.h
>> index 0558c98..af3b024 100644
>> --- a/src/lib/eina/eina_matrix.h
>> +++ b/src/lib/eina/eina_matrix.h
>> @@ -429,6 +429,23 @@ struct _Eina_Matrix4
>> };
>>
>> /**
>> + * @}
>> + * @defgroup Eina_Matrix2 Matrices in floating point
>> + * @ingroup Eina_Basic
>> + * @brief Matrix definition and operations
>> + * @{
>> + */
>> +
>> +typedef struct _Eina_Matrix2 Eina_Matrix2;
>> +struct _Eina_Matrix2
>> +{
>> + double xx;
>> + double xy;
>> +
>> + double yx;
>> + double yy;
>> +};
>> +/**
>> * @brief Return the type of the given floating point matrix.
>> *
>> * @param m The floating point matrix.
>> @@ -597,11 +614,265 @@ EAPI void eina_matrix4_identity(Eina_Matrix4 *out);
>> * @param a The first member of the multiplication
>> * @param b The second member of the multiplication
>> *
>> + * @since 1.17
>> + */
>> +EAPI void eina_matrix4_multiply_copy(Eina_Matrix4 *out,
>> + const Eina_Matrix4 *mat_a, const
>> Eina_Matrix4 *mat_b); +
>> +/**
>> + * @brief Set array to matrix.
>> + *
>> + * @param m The rsult matrix
>> + * @param v The the array[16] for set
>> + *
>> + * Set to matrix first 16 elements from array
>> + *
>> + * @since 1.17
>> + */
>> +EAPI void eina_matrix4_array_set(Eina_Matrix4 *m, const double *v);
>> +
>> +/**
>> + * @brief Copy matrix.
>> + *
>> + * @param dst The matrix copy
>> + * @param src The matrix for copy.
>> + *
>> + * @since 1.17
>> + */
>> +EAPI void eina_matrix4_copy(Eina_Matrix4 *dst, const Eina_Matrix4 *src);
>> +
>> +/**
>> + * @brief Multiply two matrix with check
>> + *
>> + * @param out The resulting matrix
>> + * @param a The first member of the multiplication
>> + * @param b The second member of the multiplication
>> + *
>> + * @since 1.17
>> + */
>> +EAPI void eina_matrix4_multiply(Eina_Matrix4 *out, const Eina_Matrix4
>> *mat_a,
>> + const Eina_Matrix4 *mat_b);
>> +
>> +/**
>> + * @brief Set orthogonality matrix
>> + *
>> + * @param m The resulting matrix
>> + * @param right The right value
>> + * @param left The left value
>> + * @param bottom The bottom value
>> + * @param top The top value
>> + * @param dneat The dnear value
>> + * @param dfar The dfar value
>> + *
>> + * @since 1.17
>> + */
>> +EAPI void eina_matrix4_ortho_set(Eina_Matrix4 *m,
>> + double left, double right, double bottom,
>> double top,
>> + double dnear, double dfar);
>> +
>> +/**
>> + * @brief Set array to matrix.
>> + *
>> + * @param m The rsult matrix
>> + * @param v The the array[9] for set
>> + *
>> + * Set to matrix first 9 elements from array
>> + *
>> + * @since 1.17
>> + */
>> +EAPI void eina_matrix3_array_set(Eina_Matrix3 *m, const double *v);
>> +
>> +/**
>> + * @brief Copy matrix.
>> + *
>> + * @param dst The matrix copy
>> + * @param src The matrix for copy.
>> + *
>> * @since 1.16
>> */
>> -EAPI void eina_matrix4_multiply(Eina_Matrix4 *out,
>> - const Eina_Matrix4 *a, const Eina_Matrix4
>> *b); +EAPI void eina_matrix3_copy(Eina_Matrix3 *dst, const Eina_Matrix3
>> *src);
>> +
>> +/*
>> + * @brief Multiply two matrix
>> + *
>> + * @param out The resulting matrix
>> + * @param a The first member of the multiplication
>> + * @param b The second member of the multiplication
>> + *
>> + * @since 1.17
>> + */
>> +EAPI void eina_matrix3_multiply(Eina_Matrix3 *out, const Eina_Matrix3
>> *mat_a,
>> + const Eina_Matrix3 *mat_b);
>> +
>> +/**
>> + * @brief Multiply two matrix
>> + *
>> + * @param out The resulting matrix
>> + * @param a The first member of the multiplication
>> + * @param b The second member of the multiplication
>> + *
>> + * @since 1.17
>> + */
>> +EAPI void eina_matrix3_multiply_copy(Eina_Matrix3 *out, const Eina_Matrix3
>> *mat_a,
>> + const Eina_Matrix3 *mat_b);
>> +
>> +/**
>> + * @brief Transform scale of matrix
>> + *
>> + * @param out The resulting matrix
>> + * @param s_x The scale value for x
>> + * @param s_y The scale value for y
>> + *
>> + * @since 1.17
>> + */
>> +EAPI void eina_matrix3_scale_transform_set(Eina_Matrix3 *out, double s_x,
>> double s_y); +
>> +/**
>> + * @brief Transform position of matrix
>> + *
>> + * @param out The resulting matrix
>> + * @param p_x The position value for x
>> + * @param p_y The position value for y
>> + *
>> + * @since 1.17
>> + */
>> +EAPI void eina_matrix3_position_transform_set(Eina_Matrix3 *out, const
>> double p_x,
>> + const double p_y);
>> +
>> +/**
>> + * @brief Set normal of the given matrix.
>> + *
>> + * @param out The result mtrix of normal
>> + * @param m The matrix
>> + *
>> + * @since 1.17
>> + */
>> +EAPI void eina_normal3_matrix_get(Eina_Matrix3 *out, const Eina_Matrix4 *m);
>> +
>> +/**
>> + * @brief Set the values of the coefficients of the given floating
>> + * point matrix.
>> + *
>> + * @param m The floating point matrix.
>> + * @param xx The first coefficient value.
>> + * @param xy The second coefficient value.
>> + * @param yx The fourth coefficient value.
>> + * @param yy The fifth coefficient value.
>> + *
>> + * This function sets the values of the coefficients of the matrix
>> + * @p m. No check is done on @p m.
>> + *
>> + * @see eina_matrix2_values_get()
>> + *
>> + * @since 1.17
>> + */
>> +EAPI void eina_matrix2_values_set(Eina_Matrix2 *m, double xx, double xy,
>> + double yx, double yy);
>>
>> +/**
>> + * @brief Get the values of the coefficients of the given floating
>> + * point matrix.
>> + *
>> + * @param m The floating point matrix.
>> + * @param xx The first coefficient value.
>> + * @param xy The second coefficient value.
>> + * @param yx The fourth coefficient value.
>> + * @param yy The fifth coefficient value.
>> + *
>> + * This function gets the values of the coefficients of the matrix
>> + * @p m. No check is done on @p m.
>> + *
>> + * @see eina_matrix2_values_set()
>> + *
>> + * @since 1.17
>> + */
>> +EAPI void eina_matrix2_values_get(const Eina_Matrix2 *m, double *xx, double
>> *xy,
>> + double *yx, double *yy);
>> +
>> +/**
>> + * @brief Compute the inverse with check of the given matrix.
>> + *
>> + * @param m The matrix to inverse.
>> + * @param m2 The inverse matrix.
>> + *
>> + * This function inverse the matrix @p m and stores the result in
>> + * @p m2. No check is done on @p m or @p m2. If @p m can not be
>> + * invertible, then @p m2 is set to the identity matrix.
>> + *
>> + * @since 1.17
>> + */
>> +EAPI void eina_matrix2_inverse(Eina_Matrix2 *out, const Eina_Matrix2 *mat);
>> +
>> +/**
>> + * @brief Set the given floating point matrix to the identity matrix.
>> + *
>> + * @param m The floating point matrix to set
>> + *
>> + * This function sets @p m to the identity matrix. No check is done on
>> + * @p m.
>> + *
>> + * @since 1.17
>> + */
>> +EAPI void eina_matrix2_identity(Eina_Matrix2 *m);
>> +
>> +/**
>> + * @brief Set array to matrix.
>> + *
>> + * @param m The rsult matrix
>> + * @param v The the array[4] for set
>> + *
>> + * Set to matrix first 4 elements from array
>> + *
>> + * @since 1.17
>> + */
>> +EAPI void eina_matrix2_array_set(Eina_Matrix2 *m, const double *v);
>> +
>> +/**
>> + * @brief Copy matrix.
>> + *
>> + * @param dst The matrix copy
>> + * @param src The matrix for copy.
>> + *
>> + * @since 1.17
>> + */
>> +EAPI void eina_matrix2_copy(Eina_Matrix2 *dst, const Eina_Matrix2 *src);
>> +
>> +/**
>> + * @brief Multiply two matrix
>> + *
>> + * @param out The resulting matrix
>> + * @param a The first member of the multiplication
>> + * @param b The second member of the multiplication
>> + *
>> + * @since 1.17
>> + */
>> +EAPI void eina_matrix2_multiply(Eina_Matrix2 *out, const Eina_Matrix2
>> *mat_a,
>> + const Eina_Matrix2 *mat_b);
>> +
>> +/**
>> + * @brief Multiply two matrix with check
>> + *
>> + * @param out The resulting matrix
>> + * @param a The first member of the multiplication
>> + * @param b The second member of the multiplication
>> + *
>> + * @since 1.17
>> + */
>> +EAPI void eina_matrix2_multiply_copy(Eina_Matrix2 *out, const Eina_Matrix2
>> *mat_a,
>> + const Eina_Matrix2 *mat_b);
>> +
>> +/**
>> + * @brief Return the type of the given floating point matrix.
>> + *
>> + * @param m The floating point matrix.
>> + * @return The type of the matrix.
>> + *
>> + * This function returns the type of the matrix @p m. No check is done
>> + * on @p m.
>> + *
>> + * @since 1.17
>> + */
>> +EAPI Eina_Matrix_Type eina_matrix2_type_get(const Eina_Matrix2 *m);
>>
>> /**
>> * @}
>> diff --git a/src/lib/evas/canvas/evas_canvas3d_camera.c
>> b/src/lib/evas/canvas/evas_canvas3d_camera.c index 802bccf..9f874e2 100644
>> --- a/src/lib/evas/canvas/evas_canvas3d_camera.c
>> +++ b/src/lib/evas/canvas/evas_canvas3d_camera.c
>> @@ -109,7 +109,7 @@ EOLIAN static void
>> _evas_canvas3d_camera_projection_matrix_set(Eo *obj,
>> Evas_Canvas3D_Camera_Data *pd, const Evas_Real *matrix)
>> {
>> - evas_mat4_array_set(&pd->projection, matrix);
>> + eina_matrix4_array_set(&pd->projection, matrix);
>> eo_do(obj, evas_canvas3d_object_change
>> (EVAS_CANVAS3D_STATE_CAMERA_PROJECTION, NULL)); }
>>
>> @@ -118,7 +118,7 @@ _evas_canvas3d_camera_projection_matrix_get(const Eo *obj
>> EINA_UNUSED, Evas_Canvas3D_Camera_Data *pd,
>> Evas_Real *matrix)
>> {
>> - memcpy(matrix, &pd->projection.m[0], sizeof(Evas_Real) * 16);
>> + memcpy(matrix, &pd->projection.xx, sizeof(Evas_Real) * 16);
>> }
>>
>> EOLIAN static void
>> @@ -152,15 +152,15 @@ _evas_canvas3d_camera_projection_ortho_set(Eo *obj,
>> Evas_Canvas3D_Camera_Data *p Evas_Real bottom, Evas_Real top,
>> Evas_Real dnear, Evas_Real dfar)
>> {
>> - evas_mat4_ortho_set(&pd->projection, left, right, bottom, top, dnear,
>> dfar);
>> + eina_matrix4_ortho_set(&pd->projection, left, right, bottom, top, dnear,
>> dfar); eo_do(obj, evas_canvas3d_object_change
>> (EVAS_CANVAS3D_STATE_CAMERA_PROJECTION, NULL)); }
>>
>> EOLIAN static Eina_Bool
>> _evas_canvas3d_camera_node_visible_get(Eo *obj EINA_UNUSED,
>> Evas_Canvas3D_Camera_Data *pd, Evas_Canvas3D_Node *camera_node,
>> Evas_Canvas3D_Node *node, Evas_Canvas3D_Frustum_Mode key) {
>> - Evas_Mat4 matrix_vp;
>> - Evas_Vec4 planes[6];
>> + Eina_Matrix4 matrix_vp;
>> + Eina_Quaternion planes[6];
>> Evas_Canvas3D_Node_Data *pd_node = eo_data_scope_get(node,
>> EVAS_CANVAS3D_NODE_CLASS); Evas_Canvas3D_Node_Data *pd_camera =
>> eo_data_scope_get(camera_node, EVAS_CANVAS3D_NODE_CLASS); Evas_Vec3
>> central_point; @@ -178,7 +178,7 @@ _evas_canvas3d_camera_node_visible_get(Eo
>> *obj EINA_UNUSED, Evas_Canvas3D_Camera }
>>
>> /*get need matrix like multiply projection matrix with view matrix*/
>> - evas_mat4_multiply(&matrix_vp, &pd->projection,
>> &pd_camera->data.camera.matrix_world_to_eye);
>> + eina_matrix4_multiply(&matrix_vp, &pd->projection,
>> &pd_camera->data.camera.matrix_world_to_eye);
>> evas_frustum_calculate(planes, &matrix_vp);
>>
>> diff --git a/src/lib/evas/canvas/evas_canvas3d_light.c
>> b/src/lib/evas/canvas/evas_canvas3d_light.c index d207d9b..2d7facd 100644
>> --- a/src/lib/evas/canvas/evas_canvas3d_light.c
>> +++ b/src/lib/evas/canvas/evas_canvas3d_light.c
>> @@ -259,7 +259,7 @@ EOLIAN static void
>> _evas_canvas3d_light_projection_matrix_set(Eo *obj, Evas_Canvas3D_Light_Data
>> *pd, const Evas_Real *matrix)
>> {
>> - evas_mat4_array_set(&pd->projection, matrix);
>> + eina_matrix4_array_set(&pd->projection, matrix);
>> eo_do(obj, evas_canvas3d_object_change
>> (EVAS_CANVAS3D_STATE_LIGHT_PROJECTION, NULL)); }
>>
>> @@ -268,7 +268,7 @@ _evas_canvas3d_light_projection_matrix_get(const Eo *obj
>> EINA_UNUSED, Evas_Canvas3D_Light_Data *pd,
>> Evas_Real *matrix)
>> {
>> - memcpy(matrix, &pd->projection.m[0], sizeof(Evas_Real) * 16);
>> + memcpy(matrix, &pd->projection.xx, sizeof(Evas_Real) * 16);
>> }
>>
>> EOLIAN static void
>> @@ -302,7 +302,7 @@ _evas_canvas3d_light_projection_ortho_set(Eo *obj,
>> Evas_Canvas3D_Light_Data *pd, Evas_Real bottom, Evas_Real top,
>> Evas_Real dnear, Evas_Real dfar)
>> {
>> - evas_mat4_ortho_set(&pd->projection, left, right, bottom, top, dnear,
>> dfar);
>> + eina_matrix4_ortho_set(&pd->projection, left, right, bottom, top, dnear,
>> dfar); eo_do(obj, evas_canvas3d_object_change
>> (EVAS_CANVAS3D_STATE_LIGHT_PROJECTION, NULL)); }
>>
>> diff --git a/src/lib/evas/canvas/evas_canvas3d_scene.c
>> b/src/lib/evas/canvas/evas_canvas3d_scene.c index 13dd68a..6bc4487 100644
>> --- a/src/lib/evas/canvas/evas_canvas3d_scene.c
>> +++ b/src/lib/evas/canvas/evas_canvas3d_scene.c
>> @@ -554,7 +554,7 @@ _node_pick(Evas_Canvas3D_Node *node, void *data)
>> {
>> Evas_Ray3 ray;
>> Evas_Canvas3D_Pick_Data *pick = (Evas_Canvas3D_Pick_Data *)data;
>> - Evas_Mat4 mvp;
>> + Eina_Matrix4 mvp;
>> Evas_Canvas3D_Node_Data *pd_node = eo_data_scope_get(node,
>> EVAS_CANVAS3D_NODE_CLASS);
>> if (! evas_box3_ray3_intersect(&pd_node->aabb, &pick->ray_world))
>> @@ -569,7 +569,7 @@ _node_pick(Evas_Canvas3D_Node *node, void *data)
>> void *ptr;
>>
>> /* Transform ray into local coordinate space. */
>> - evas_mat4_multiply(&mvp, &pick->matrix_vp,
>> &pd_node->data.mesh.matrix_local_to_world);
>> + eina_matrix4_multiply(&mvp, &pick->matrix_vp,
>> &pd_node->data.mesh.matrix_local_to_world); evas_ray3_init(&ray, pick->x,
>> pick->y, &mvp);
>> itr = eina_hash_iterator_data_new(pd_node->data.mesh.node_meshes);
>> @@ -690,7 +690,7 @@ _evas_canvas3d_scene_pick(const Eo *obj,
>> Evas_Canvas3D_Scene_Data *pd, Evas_Real eo_do(obj,
>> evas_canvas3d_object_update
>> ()); pd_camera_node = eo_data_scope_get(pd->camera_node,
>> EVAS_CANVAS3D_NODE_CLASS); pd_camera = eo_data_scope_get
>> (pd_camera_node->data.camera.camera, EVAS_CANVAS3D_CAMERA_CLASS);
>> - evas_mat4_multiply(&data.matrix_vp,
>> + eina_matrix4_multiply(&data.matrix_vp,
>> &pd_camera->projection,
>> &pd_camera_node->data.camera.matrix_world_to_eye);
>>
>> @@ -736,7 +736,7 @@ _evas_canvas3d_scene_exist(const Eo *obj,
>> Evas_Canvas3D_Scene_Data *pd, Evas_Rea eo_do(obj, evas_canvas3d_object_update
>> ()); pd_camera_node = eo_data_scope_get(pd->camera_node,
>> EVAS_CANVAS3D_NODE_CLASS); pd_camera = eo_data_scope_get
>> (pd_camera_node->data.camera.camera, EVAS_CANVAS3D_CAMERA_CLASS);
>> - evas_mat4_multiply(&data.matrix_vp,
>> + eina_matrix4_multiply(&data.matrix_vp,
>> &pd_camera->projection,
>> &pd_camera_node->data.camera.matrix_world_to_eye);
>>
>> diff --git a/src/lib/evas/include/evas_3d_utils.h
>> b/src/lib/evas/include/evas_3d_utils.h index dfa0b39..23d338d 100644
>> --- a/src/lib/evas/include/evas_3d_utils.h
>> +++ b/src/lib/evas/include/evas_3d_utils.h
>> @@ -16,9 +16,6 @@ typedef struct _Evas_Color Evas_Color;
>> typedef struct _Evas_Vec2 Evas_Vec2;
>> typedef struct _Evas_Vec3 Evas_Vec3;
>> typedef struct _Evas_Vec4 Evas_Vec4;
>> -typedef struct _Evas_Mat2 Evas_Mat2;
>> -typedef struct _Evas_Mat3 Evas_Mat3;
>> -typedef struct _Evas_Mat4 Evas_Mat4;
>> typedef struct _Evas_Box2 Evas_Box2;
>> typedef struct _Evas_Box3 Evas_Box3;
>> typedef struct _Evas_Line3 Evas_Line3;
>> @@ -55,24 +52,6 @@ struct _Evas_Vec4
>> Evas_Real w;
>> };
>>
>> -struct _Evas_Mat2
>> -{
>> - Evas_Real m[4];
>> - int flags;
>> -};
>> -
>> -struct _Evas_Mat3
>> -{
>> - Evas_Real m[9];
>> - int flags;
>> -};
>> -
>> -struct _Evas_Mat4
>> -{
>> - Evas_Real m[16];
>> - int flags;
>> -};
>> -
>> struct _Evas_Box2
>> {
>> Evas_Vec2 p0;
>> @@ -204,34 +183,34 @@ evas_vec2_normalize(Evas_Vec2 *out, const Evas_Vec2 *v)
>> }
>>
>> static inline void
>> -evas_vec2_transform(Evas_Vec2 *out, const Evas_Mat2 *m, const Evas_Vec2 *v)
>> +evas_vec2_transform(Evas_Vec2 *out, const Eina_Matrix2 *m, const Evas_Vec2
>> *v) {
>> Evas_Vec2 tmp;
>>
>> - tmp.x = (m->m[0] * v->x) + (m->m[2] * v->y);
>> - tmp.y = (m->m[1] * v->x) + (m->m[3] * v->y);
>> + tmp.x = (m->xx * v->x) + (m->yx * v->y);
>> + tmp.y = (m->xy * v->x) + (m->yy * v->y);
>>
>> evas_vec2_copy(out, &tmp);
>> }
>>
>> static inline void
>> -evas_vec2_homogeneous_position_transform(Evas_Vec2 *out, const Evas_Mat3 *m,
>> const Evas_Vec2 *v) +evas_vec2_homogeneous_position_transform(Evas_Vec2 *out,
>> const Eina_Matrix3 *m, const Evas_Vec2 *v) {
>> Evas_Vec2 tmp;
>>
>> - tmp.x = (m->m[0] * v->x) + (m->m[3] * v->y) + m->m[6];
>> - tmp.y = (m->m[1] * v->x) + (m->m[4] * v->y) + m->m[7];
>> + tmp.x = (m->xx * v->x) + (m->yx * v->y) + m->zx;
>> + tmp.y = (m->xy * v->x) + (m->yy * v->y) + m->zy;
>>
>> - evas_vec2_scale(out, &tmp, 1.0 / ((m->m[2] * v->x) + (m->m[5] * v->y) +
>> m->m[8]));
>> + evas_vec2_scale(out, &tmp, 1.0 / ((m->xz * v->x) + (m->yz * v->y) +
>> m->zz)); }
>>
>> static inline void
>> -evas_vec2_homogeneous_direction_transform(Evas_Vec2 *out, const Evas_Mat3
>> *m, const Evas_Vec2 *v) +evas_vec2_homogeneous_direction_transform(Evas_Vec2
>> *out, const Eina_Matrix3 *m, const Evas_Vec2 *v) {
>> Evas_Vec2 tmp;
>>
>> - tmp.x = (m->m[0] * v->x) + (m->m[3] * v->y);
>> - tmp.y = (m->m[1] * v->x) + (m->m[4] * v->y);
>> + tmp.x = (m->xx * v->x) + (m->yx * v->y);
>> + tmp.y = (m->xy * v->x) + (m->yy * v->y);
>>
>> evas_vec2_copy(out, &tmp);
>> }
>> @@ -366,56 +345,56 @@ evas_vec3_normalize(Evas_Vec3 *out, const Evas_Vec3 *v)
>> }
>>
>> static inline void
>> -evas_vec3_transform(Evas_Vec3 *out, const Evas_Vec3 *v, const Evas_Mat3 *m)
>> +evas_vec3_transform(Evas_Vec3 *out, const Evas_Vec3 *v, const Eina_Matrix3
>> *m) {
>> Evas_Vec3 tmp;
>>
>> - if (m->flags & EVAS_MATRIX_IS_IDENTITY)
>> + if (eina_matrix3_type_get(m) & EINA_MATRIX_TYPE_IDENTITY)
>> {
>> evas_vec3_copy(out, v);
>> return;
>> }
>>
>> - tmp.x = (m->m[0] * v->x) + (m->m[3] * v->y) + (m->m[6] * v->z);
>> - tmp.y = (m->m[1] * v->x) + (m->m[4] * v->y) + (m->m[7] * v->z);
>> - tmp.z = (m->m[2] * v->x) + (m->m[5] * v->y) + (m->m[8] * v->z);
>> + tmp.x = (m->xx * v->x) + (m->yx * v->y) + (m->zx * v->z);
>> + tmp.y = (m->xy * v->x) + (m->yy * v->y) + (m->zy * v->z);
>> + tmp.z = (m->xz * v->x) + (m->yz * v->y) + (m->zz * v->z);
>>
>> evas_vec3_copy(out, &tmp);
>> }
>>
>> static inline void
>> -evas_vec3_homogeneous_position_transform(Evas_Vec3 *out, const Evas_Vec3 *v,
>> const Evas_Mat4 *m) +evas_vec3_homogeneous_position_transform(Evas_Vec3 *out,
>> const Evas_Vec3 *v, const Eina_Matrix4 *m) {
>> Evas_Vec3 tmp;
>>
>> - if (m->flags & EVAS_MATRIX_IS_IDENTITY)
>> + if (eina_matrix4_type_get(m) & EINA_MATRIX_TYPE_IDENTITY)
>> {
>> evas_vec3_copy(out, v);
>> return;
>> }
>>
>> - tmp.x = (m->m[0] * v->x) + (m->m[4] * v->y) + (m->m[8] * v->z) + m->m
>> [12];
>> - tmp.y = (m->m[1] * v->x) + (m->m[5] * v->y) + (m->m[9] * v->z) + m->m
>> [13];
>> - tmp.z = (m->m[2] * v->x) + (m->m[6] * v->y) + (m->m[10] * v->z) + m->m
>> [14];
>> + tmp.x = (m->xx * v->x) + (m->zw * v->y) + (m->zx * v->z) + m->wx;
>> + tmp.y = (m->xy * v->x) + (m->yx * v->y) + (m->zy * v->z) + m->wy;
>> + tmp.z = (m->xz * v->x) + (m->yz * v->y) + (m->zz * v->z) + m->wz;
>>
>> evas_vec3_scale(out, &tmp,
>> - 1.0 / ((m->m[3] * v->x) + (m->m[7] * v->y) + (m->m[11] *
>> v->z) + m->m[15]));
>> + 1.0 / ((m->xw * v->x) + (m->yw * v->y) + (m->zw * v->z) +
>> m->ww)); }
>>
>> static inline void
>> -evas_vec3_homogeneous_direction_transform(Evas_Vec3 *out, const Evas_Vec3
>> *v, const Evas_Mat4 *m) +evas_vec3_homogeneous_direction_transform(Evas_Vec3
>> *out, const Evas_Vec3 *v, const Eina_Matrix4 *m) {
>> Evas_Vec3 tmp;
>>
>> - if (m->flags & EVAS_MATRIX_IS_IDENTITY)
>> + if (eina_matrix4_type_get(m) & EINA_MATRIX_TYPE_IDENTITY)
>> {
>> evas_vec3_copy(out, v);
>> return;
>> }
>>
>> - tmp.x = (m->m[0] * v->x) + (m->m[4] * v->y) + (m->m[8] * v->z);
>> - tmp.y = (m->m[1] * v->x) + (m->m[5] * v->y) + (m->m[9] * v->z);
>> - tmp.z = (m->m[2] * v->x) + (m->m[6] * v->y) + (m->m[10] * v->z);
>> + tmp.x = (m->xx * v->x) + (m->zw * v->y) + (m->zx * v->z);
>> + tmp.y = (m->xy * v->x) + (m->yx * v->y) + (m->zy * v->z);
>> + tmp.z = (m->xz * v->x) + (m->yz * v->y) + (m->zz * v->z);
>>
>> evas_vec3_copy(out, &tmp);
>> }
>> @@ -581,20 +560,20 @@ evas_vec4_normalize(Evas_Vec4 *out, const Evas_Vec4 *v)
>> }
>>
>> static inline void
>> -evas_vec4_transform(Evas_Vec4 *out, const Evas_Vec4 *v, const Evas_Mat4 *m)
>> +evas_vec4_transform(Evas_Vec4 *out, const Evas_Vec4 *v, const Eina_Matrix4
>> *m) {
>> Evas_Vec4 tmp;
>>
>> - if (m->flags & EVAS_MATRIX_IS_IDENTITY)
>> + if (eina_matrix4_type_get(m) & EINA_MATRIX_TYPE_IDENTITY)
>> {
>> evas_vec4_copy(out, v);
>> return;
>> }
>>
>> - tmp.x = (m->m[0] * v->x) + (m->m[4] * v->y) + (m->m[ 8] * v->z) + (m->m
>> [12] * v->w);
>> - tmp.y = (m->m[1] * v->x) + (m->m[5] * v->y) + (m->m[ 9] * v->z) + (m->m
>> [13] * v->w);
>> - tmp.z = (m->m[2] * v->x) + (m->m[6] * v->y) + (m->m[10] * v->z) + (m->m
>> [14] * v->w);
>> - tmp.w = (m->m[3] * v->x) + (m->m[7] * v->y) + (m->m[11] * v->z) + (m->m
>> [15] * v->w);
>> + tmp.x = (m->xx * v->x) + (m->yx * v->y) + (m->zx * v->z) + (m->wx *
>> v->w);
>> + tmp.y = (m->xy * v->x) + (m->yy * v->y) + (m->zy * v->z) + (m->wy *
>> v->w);
>> + tmp.z = (m->xz * v->x) + (m->yz * v->y) + (m->zz * v->z) + (m->wz *
>> v->w);
>> + tmp.w = (m->xw * v->x) + (m->yw * v->y) + (m->zw * v->z) + (m->ww *
>> v->w);
>>
>> evas_vec4_copy(out, &tmp);
>> }
>> @@ -745,108 +724,8 @@ evas_vec4_homogeneous_direction_set(Evas_Vec4 *out,
>> const Evas_Vec3 *v) out->w = 0.0;
>> }
>>
>> -/* 4x4 matrix */
>> static inline void
>> -evas_mat4_identity_set(Evas_Mat4 *m)
>> -{
>> - m->m[0] = 1.0;
>> - m->m[1] = 0.0;
>> - m->m[2] = 0.0;
>> - m->m[3] = 0.0;
>> -
>> - m->m[4] = 0.0;
>> - m->m[5] = 1.0;
>> - m->m[6] = 0.0;
>> - m->m[7] = 0.0;
>> -
>> - m->m[8] = 0.0;
>> - m->m[9] = 0.0;
>> - m->m[10] = 1.0;
>> - m->m[11] = 0.0;
>> -
>> - m->m[12] = 0.0;
>> - m->m[13] = 0.0;
>> - m->m[14] = 0.0;
>> - m->m[15] = 1.0;
>> -
>> - m->flags = EVAS_MATRIX_IS_IDENTITY;
>> -}
>> -
>> -static inline void
>> -evas_mat4_array_set(Evas_Mat4 *m, const Evas_Real *v)
>> -{
>> - memcpy(&m->m[0], v, sizeof(Evas_Real) * 16);
>> - m->flags = 0;
>> -}
>> -
>> -static inline void
>> -evas_mat4_copy(Evas_Mat4 *dst, const Evas_Mat4 *src)
>> -{
>> - memcpy(dst, src, sizeof(Evas_Mat4));
>> -}
>> -
>> -static inline void
>> -evas_mat4_nocheck_multiply(Evas_Mat4 *out, const Evas_Mat4 *mat_a,
>> - const Evas_Mat4 *mat_b)
>> -{
>> - Evas_Real *d = out->m;
>> - const Evas_Real *a = mat_a->m;
>> - const Evas_Real *b = mat_b->m;
>> -
>> - if (mat_a->flags & EVAS_MATRIX_IS_IDENTITY)
>> - {
>> - evas_mat4_copy(out, mat_b);
>> - return;
>> - }
>> -
>> - if (mat_b->flags & EVAS_MATRIX_IS_IDENTITY)
>> - {
>> - evas_mat4_copy(out, mat_a);
>> - return;
>> - }
>> -
>> - d[ 0] = a[ 0] * b[ 0] + a[ 4] * b[ 1] + a[ 8] * b[ 2] + a[12] * b [3];
>> - d[ 4] = a[ 0] * b[ 4] + a[ 4] * b[ 5] + a[ 8] * b[ 6] + a[12] * b [7];
>> - d[ 8] = a[ 0] * b[ 8] + a[ 4] * b[ 9] + a[ 8] * b[10] + a[12] * b[11];
>> - d[12] = a[ 0] * b[12] + a[ 4] * b[13] + a[ 8] * b[14] + a[12] * b[15];
>> -
>> - d[ 1] = a[ 1] * b[ 0] + a[ 5] * b[ 1] + a[ 9] * b[ 2] + a[13] * b [3];
>> - d[ 5] = a[ 1] * b[ 4] + a[ 5] * b[ 5] + a[ 9] * b[ 6] + a[13] * b [7];
>> - d[ 9] = a[ 1] * b[ 8] + a[ 5] * b[ 9] + a[ 9] * b[10] + a[13] * b[11];
>> - d[13] = a[ 1] * b[12] + a[ 5] * b[13] + a[ 9] * b[14] + a[13] * b[15];
>> -
>> - d[ 2] = a[ 2] * b[ 0] + a[ 6] * b[ 1] + a[10] * b[ 2] + a[14] * b [3];
>> - d[ 6] = a[ 2] * b[ 4] + a[ 6] * b[ 5] + a[10] * b[ 6] + a[14] * b [7];
>> - d[10] = a[ 2] * b[ 8] + a[ 6] * b[ 9] + a[10] * b[10] + a[14] * b[11];
>> - d[14] = a[ 2] * b[12] + a[ 6] * b[13] + a[10] * b[14] + a[14] * b[15];
>> -
>> - d[ 3] = a[ 3] * b[ 0] + a[ 7] * b[ 1] + a[11] * b[ 2] + a[15] * b [3];
>> - d[ 7] = a[ 3] * b[ 4] + a[ 7] * b[ 5] + a[11] * b[ 6] + a[15] * b [7];
>> - d[11] = a[ 3] * b[ 8] + a[ 7] * b[ 9] + a[11] * b[10] + a[15] * b[11];
>> - d[15] = a[ 3] * b[12] + a[ 7] * b[13] + a[11] * b[14] + a[15] * b[15];
>> -
>> - out->flags = 0;
>> -}
>> -
>> -static inline void
>> -evas_mat4_multiply(Evas_Mat4 *out, const Evas_Mat4 *mat_a,
>> - const Evas_Mat4 *mat_b)
>> -{
>> - if (out != mat_a && out != mat_b)
>> - {
>> - evas_mat4_nocheck_multiply(out, mat_a, mat_b);
>> - }
>> - else
>> - {
>> - Evas_Mat4 result;
>> -
>> - evas_mat4_nocheck_multiply(&result, mat_a, mat_b);
>> - evas_mat4_copy(out, &result);
>> - }
>> -}
>> -
>> -static inline void
>> -evas_mat4_look_at_set(Evas_Mat4 *m,
>> +evas_mat4_look_at_set(Eina_Matrix4 *m,
>> const Evas_Vec3 *pos, const Evas_Vec3 *center, const
>> Evas_Vec3 *up) {
>> Evas_Vec3 x, y, z;
>> @@ -860,31 +739,29 @@ evas_mat4_look_at_set(Evas_Mat4 *m,
>> evas_vec3_cross_product(&y, &z, &x);
>> evas_vec3_normalize(&y, &y);
>>
>> - m->m[ 0] = x.x;
>> - m->m[ 1] = y.x;
>> - m->m[ 2] = z.x;
>> - m->m[ 3] = 0.0;
>> + m->xx = x.x;
>> + m->xy = y.x;
>> + m->xz = z.x;
>> + m->xw = 0.0;
>>
>> - m->m[ 4] = x.y;
>> - m->m[ 5] = y.y;
>> - m->m[ 6] = z.y;
>> - m->m[ 7] = 0.0;
>> + m->yx = x.y;
>> + m->yy = y.y;
>> + m->yz = z.y;
>> + m->yw = 0.0;
>>
>> - m->m[ 8] = x.z;
>> - m->m[ 9] = y.z;
>> - m->m[10] = z.z;
>> - m->m[11] = 0.0;
>> + m->zx = x.z;
>> + m->zy = y.z;
>> + m->zz = z.z;
>> + m->zw = 0.0;
>>
>> - m->m[12] = -evas_vec3_dot_product(&x, pos);
>> - m->m[13] = -evas_vec3_dot_product(&y, pos);
>> - m->m[14] = -evas_vec3_dot_product(&z, pos);
>> - m->m[15] = 1.0;
>> -
>> - m->flags = 0;
>> + m->wx = -evas_vec3_dot_product(&x, pos);
>> + m->wy = -evas_vec3_dot_product(&y, pos);
>> + m->wz = -evas_vec3_dot_product(&z, pos);
>> + m->ww = 1.0;
>> }
>>
>> static inline void
>> -evas_mat4_frustum_set(Evas_Mat4 *m,
>> +evas_mat4_frustum_set(Eina_Matrix4 *m,
>> Evas_Real left, Evas_Real right, Evas_Real bottom,
>> Evas_Real top, Evas_Real dnear, Evas_Real dfar)
>> {
>> @@ -893,534 +770,25 @@ evas_mat4_frustum_set(Evas_Mat4 *m,
>> Evas_Real depth = dnear - dfar;
>> Evas_Real near_2 = 2.0f * dnear;
>>
>> - m->m[ 0] = near_2 / w;
>> - m->m[ 1] = 0.0f;
>> - m->m[ 2] = 0.0f;
>> - m->m[ 3] = 0.0f;
>> -
>> - m->m[ 4] = 0.0f;
>> - m->m[ 5] = near_2 / h;
>> - m->m[ 6] = 0.0f;
>> - m->m[ 7] = 0.0f;
>> + m->xx = near_2 / w;
>> + m->xy = 0.0f;
>> + m->xz = 0.0f;
>> + m->xw = 0.0f;
>>
>> - m->m[ 8] = (right + left) / w;
>> - m->m[ 9] = (top + bottom) / h;
>> - m->m[10] = (dfar + dnear) / depth;
>> - m->m[11] = -1.0f;
>> + m->yx = 0.0f;
>> + m->yy = near_2 / h;
>> + m->yz = 0.0f;
>> + m->yw = 0.0f;
>>
>> - m->m[12] = 0.0f;
>> - m->m[13] = 0.0f;
>> - m->m[14] = near_2 * dfar / depth;
>> - m->m[15] = 0.0f;
>> + m->zx = (right + left) / w;
>> + m->zy = (top + bottom) / h;
>> + m->zz = (dfar + dnear) / depth;
>> + m->zw = -1.0f;
>>
>> - m->flags = 0;
>> -}
>> -
>> -static inline void
>> -evas_mat4_ortho_set(Evas_Mat4 *m,
>> - Evas_Real left, Evas_Real right, Evas_Real bottom,
>> Evas_Real top,
>> - Evas_Real dnear, Evas_Real dfar)
>> -{
>> - Evas_Real w = right - left;
>> - Evas_Real h = top - bottom;
>> - Evas_Real depth = dnear - dfar;
>> -
>> - m->m[ 0] = 2.0f / w;
>> - m->m[ 1] = 0.0f;
>> - m->m[ 2] = 0.0f;
>> - m->m[ 3] = 0.0f;
>> -
>> - m->m[ 4] = 0.0f;
>> - m->m[ 5] = 2.0f / h;
>> - m->m[ 6] = 0.0f;
>> - m->m[ 7] = 0.0f;
>> -
>> - m->m[ 8] = 0.0f;
>> - m->m[ 9] = 0.0f;
>> - m->m[10] = 2.0f / depth;
>> - m->m[11] = 0.0f;
>> -
>> - m->m[12] = -(right + left) / w;
>> - m->m[13] = -(top + bottom) / h;
>> - m->m[14] = (dfar + dnear) / depth;
>> - m->m[15] = 1.0f;
>> -
>> - m->flags = 0;
>> -}
>> -
>> -static inline void
>> -evas_mat4_nocheck_inverse(Evas_Mat4 *out, const Evas_Mat4 *mat)
>> -{
>> - Evas_Real *d = out->m;
>> - const Evas_Real *m = mat->m;
>> - Evas_Real det;
>> -
>> - if (mat->flags & EVAS_MATRIX_IS_IDENTITY)
>> - {
>> - evas_mat4_copy(out, mat);
>> - return;
>> - }
>> -
>> - d[ 0] = m[ 5] * m[10] * m[15] -
>> - m[ 5] * m[11] * m[14] -
>> - m[ 9] * m[ 6] * m[15] +
>> - m[ 9] * m[ 7] * m[14] +
>> - m[13] * m[ 6] * m[11] -
>> - m[13] * m[ 7] * m[10];
>> -
>> - d[ 4] = -m[ 4] * m[10] * m[15] +
>> - m[ 4] * m[11] * m[14] +
>> - m[ 8] * m[ 6] * m[15] -
>> - m[ 8] * m[ 7] * m[14] -
>> - m[12] * m[ 6] * m[11] +
>> - m[12] * m[ 7] * m[10];
>> -
>> - d[ 8] = m[ 4] * m[ 9] * m[15] -
>> - m[ 4] * m[11] * m[13] -
>> - m[ 8] * m[ 5] * m[15] +
>> - m[ 8] * m[ 7] * m[13] +
>> - m[12] * m[ 5] * m[11] -
>> - m[12] * m[ 7] * m[ 9];
>> -
>> - d[12] = -m[ 4] * m[ 9] * m[14] +
>> - m[ 4] * m[10] * m[13] +
>> - m[ 8] * m[ 5] * m[14] -
>> - m[ 8] * m[ 6] * m[13] -
>> - m[12] * m[ 5] * m[10] +
>> - m[12] * m[ 6] * m[ 9];
>> -
>> - d[ 1] = -m[ 1] * m[10] * m[15] +
>> - m[ 1] * m[11] * m[14] +
>> - m[ 9] * m[ 2] * m[15] -
>> - m[ 9] * m[ 3] * m[14] -
>> - m[13] * m[ 2] * m[11] +
>> - m[13] * m[ 3] * m[10];
>> -
>> - d[ 5] = m[ 0] * m[10] * m[15] -
>> - m[ 0] * m[11] * m[14] -
>> - m[ 8] * m[ 2] * m[15] +
>> - m[ 8] * m[ 3] * m[14] +
>> - m[12] * m[ 2] * m[11] -
>> - m[12] * m[ 3] * m[10];
>> -
>> - d[ 9] = -m[ 0] * m[ 9] * m[15] +
>> - m[ 0] * m[11] * m[13] +
>> - m[ 8] * m[ 1] * m[15] -
>> - m[ 8] * m[ 3] * m[13] -
>> - m[12] * m[ 1] * m[11] +
>> - m[12] * m[ 3] * m[ 9];
>> -
>> - d[13] = m[ 0] * m[ 9] * m[14] -
>> - m[ 0] * m[10] * m[13] -
>> - m[ 8] * m[ 1] * m[14] +
>> - m[ 8] * m[ 2] * m[13] +
>> - m[12] * m[ 1] * m[10] -
>> - m[12] * m[ 2] * m[ 9];
>> -
>> - d[ 2] = m[ 1] * m[ 6] * m[15] -
>> - m[ 1] * m[ 7] * m[14] -
>> - m[ 5] * m[ 2] * m[15] +
>> - m[ 5] * m[ 3] * m[14] +
>> - m[13] * m[ 2] * m[ 7] -
>> - m[13] * m[ 3] * m[ 6];
>> -
>> - d[ 6] = -m[ 0] * m[ 6] * m[15] +
>> - m[ 0] * m[ 7] * m[14] +
>> - m[ 4] * m[ 2] * m[15] -
>> - m[ 4] * m[ 3] * m[14] -
>> - m[12] * m[ 2] * m[ 7] +
>> - m[12] * m[ 3] * m[ 6];
>> -
>> - d[10] = m[ 0] * m[ 5] * m[15] -
>> - m[ 0] * m[ 7] * m[13] -
>> - m[ 4] * m[ 1] * m[15] +
>> - m[ 4] * m[ 3] * m[13] +
>> - m[12] * m[ 1] * m[ 7] -
>> - m[12] * m[ 3] * m[ 5];
>> -
>> - d[14] = -m[ 0] * m[ 5] * m[14] +
>> - m[ 0] * m[ 6] * m[13] +
>> - m[ 4] * m[ 1] * m[14] -
>> - m[ 4] * m[ 2] * m[13] -
>> - m[12] * m[ 1] * m[ 6] +
>> - m[12] * m[ 2] * m[ 5];
>> -
>> - d[ 3] = -m[ 1] * m[ 6] * m[11] +
>> - m[ 1] * m[ 7] * m[10] +
>> - m[ 5] * m[ 2] * m[11] -
>> - m[ 5] * m[ 3] * m[10] -
>> - m[ 9] * m[ 2] * m[ 7] +
>> - m[ 9] * m[ 3] * m[ 6];
>> -
>> - d[ 7] = m[ 0] * m[ 6] * m[11] -
>> - m[ 0] * m[ 7] * m[10] -
>> - m[ 4] * m[ 2] * m[11] +
>> - m[ 4] * m[ 3] * m[10] +
>> - m[ 8] * m[ 2] * m[ 7] -
>> - m[ 8] * m[ 3] * m[ 6];
>> -
>> - d[11] = -m[ 0] * m[ 5] * m[11] +
>> - m[ 0] * m[ 7] * m[ 9] +
>> - m[ 4] * m[ 1] * m[11] -
>> - m[ 4] * m[ 3] * m[ 9] -
>> - m[ 8] * m[ 1] * m[ 7] +
>> - m[ 8] * m[ 3] * m[ 5];
>> -
>> - d[15] = m[ 0] * m[ 5] * m[10] -
>> - m[ 0] * m[ 6] * m[ 9] -
>> - m[ 4] * m[ 1] * m[10] +
>> - m[ 4] * m[ 2] * m[ 9] +
>> - m[ 8] * m[ 1] * m[ 6] -
>> - m[ 8] * m[ 2] * m[ 5];
>> -
>> - det = m[0] * d[0] + m[1] * d[4] + m[2] * d[8] + m[3] * d[12];
>> -
>> - if (det == 0.0) return;
>> -
>> - det = 1.0 / det;
>> -
>> - d[ 0] *= det;
>> - d[ 1] *= det;
>> - d[ 2] *= det;
>> - d[ 3] *= det;
>> - d[ 4] *= det;
>> - d[ 5] *= det;
>> - d[ 6] *= det;
>> - d[ 7] *= det;
>> - d[ 8] *= det;
>> - d[ 9] *= det;
>> - d[10] *= det;
>> - d[11] *= det;
>> - d[12] *= det;
>> - d[13] *= det;
>> - d[14] *= det;
>> - d[15] *= det;
>> -
>> - out->flags = 0;
>> -}
>> -
>> -static inline void
>> -evas_mat4_inverse(Evas_Mat4 *out, const Evas_Mat4 *mat)
>> -{
>> - if (out != mat)
>> - {
>> - evas_mat4_nocheck_inverse(out, mat);
>> - }
>> - else
>> - {
>> - Evas_Mat4 tmp;
>> -
>> - evas_mat4_nocheck_inverse(&tmp, mat);
>> - evas_mat4_copy(out, &tmp);
>> - }
>> -}
>> -
>> -static inline void
>> -evas_normal_matrix_get(Evas_Mat3 *out, const Evas_Mat4 *m)
>> -{
>> - /* Normal matrix is a transposed matirx of inversed modelview.
>> - * And we need only upper-left 3x3 terms to work with. */
>> -
>> - Evas_Real det;
>> - Evas_Real a = m->m[0];
>> - Evas_Real b = m->m[4];
>> - Evas_Real c = m->m[8];
>> - Evas_Real d = m->m[1];
>> - Evas_Real e = m->m[5];
>> - Evas_Real f = m->m[9];
>> - Evas_Real g = m->m[2];
>> - Evas_Real h = m->m[6];
>> - Evas_Real i = m->m[10];
>> -
>> - det = a * e * i + b * f * g + c * d * h - g * e * c - h * f * a - i * d *
>> b;
>> - det = 1.0 / det;
>> -
>> - out->m[0] = (e * i - f * h) * det;
>> - out->m[1] = (h * c - i * b) * det;
>> - out->m[2] = (b * f - c * e) * det;
>> - out->m[3] = (g * f - d * i) * det;
>> - out->m[4] = (a * i - g * c) * det;
>> - out->m[5] = (d * c - a * f) * det;
>> - out->m[6] = (d * h - g * e) * det;
>> - out->m[7] = (g * b - a * h) * det;
>> - out->m[8] = (a * e - d * b) * det;
>> -
>> - out->flags = 0;
>> -}
>> -
>> -/* 3x3 matrix */
>> -static inline void
>> -evas_mat3_identity_set(Evas_Mat3 *m)
>> -{
>> - m->m[0] = 1.0;
>> - m->m[1] = 0.0;
>> - m->m[2] = 0.0;
>> - m->m[3] = 0.0;
>> - m->m[4] = 1.0;
>> - m->m[5] = 0.0;
>> - m->m[6] = 0.0;
>> - m->m[7] = 0.0;
>> - m->m[8] = 1.0;
>> -
>> - m->flags = EVAS_MATRIX_IS_IDENTITY;
>> -}
>> -
>> -static inline void
>> -evas_mat3_array_set(Evas_Mat3 *m, const Evas_Real *v)
>> -{
>> - memcpy(&m->m[0], v, sizeof(Evas_Real) * 9);
>> - m->flags = 0;
>> -}
>> -
>> -static inline void
>> -evas_mat3_copy(Evas_Mat3 *dst, const Evas_Mat3 *src)
>> -{
>> - memcpy(dst, src, sizeof(Evas_Mat3));
>> -}
>> -
>> -static inline void
>> -evas_mat3_nocheck_multiply(Evas_Mat3 *out, const Evas_Mat3 *mat_a, const
>> Evas_Mat3 *mat_b) -{
>> - Evas_Real *d = out->m;
>> - const Evas_Real *a = mat_a->m;
>> - const Evas_Real *b = mat_b->m;
>> -
>> - if (mat_a->flags & EVAS_MATRIX_IS_IDENTITY)
>> - {
>> - evas_mat3_copy(out, mat_b);
>> - return;
>> - }
>> -
>> - if (mat_b->flags & EVAS_MATRIX_IS_IDENTITY)
>> - {
>> - evas_mat3_copy(out, mat_a);
>> - return;
>> - }
>> -
>> - d[0] = a[0] * b[0] + a[3] * b[1] + a[6] * b[2];
>> - d[3] = a[0] * b[3] + a[3] * b[4] + a[6] * b[5];
>> - d[6] = a[0] * b[6] + a[3] * b[7] + a[6] * b[8];
>> -
>> - d[1] = a[1] * b[0] + a[4] * b[1] + a[7] * b[2];
>> - d[4] = a[1] * b[3] + a[4] * b[4] + a[7] * b[5];
>> - d[7] = a[1] * b[6] + a[4] * b[7] + a[7] * b[8];
>> -
>> - d[2] = a[2] * b[0] + a[5] * b[1] + a[8] * b[2];
>> - d[5] = a[2] * b[3] + a[5] * b[4] + a[8] * b[5];
>> - d[8] = a[2] * b[6] + a[5] * b[7] + a[8] * b[8];
>> -
>> - out->flags = 0;
>> -}
>> -
>> -static inline void
>> -evas_mat3_multiply(Evas_Mat3 *out, const Evas_Mat3 *mat_a, const Evas_Mat3
>> *mat_b) -{
>> - if (out != mat_a && out != mat_b)
>> - {
>> - evas_mat3_nocheck_multiply(out, mat_a, mat_b);
>> - }
>> - else
>> - {
>> - Evas_Mat3 tmp;
>> -
>> - evas_mat3_nocheck_multiply(&tmp, mat_a, mat_b);
>> - evas_mat3_copy(out, &tmp);
>> - }
>> -}
>> -
>> -static inline void
>> -evas_mat3_nocheck_inverse(Evas_Mat3 *out, const Evas_Mat3 *mat)
>> -{
>> - Evas_Real *d = &out->m[0];
>> - const Evas_Real *m = &mat->m[0];
>> - Evas_Real det;
>> -
>> - if (mat->flags & EVAS_MATRIX_IS_IDENTITY)
>> - {
>> - evas_mat3_copy(out, mat);
>> - return;
>> - }
>> -
>> - d[0] = m[4] * m[8] - m[7] * m[5];
>> - d[1] = m[7] * m[2] - m[1] * m[8];
>> - d[2] = m[1] * m[5] - m[4] * m[2];
>> - d[3] = m[6] * m[5] - m[3] * m[8];
>> - d[4] = m[0] * m[8] - m[6] * m[2];
>> - d[5] = m[3] * m[2] - m[0] * m[5];
>> - d[6] = m[3] * m[7] - m[6] * m[4];
>> - d[7] = m[6] * m[1] - m[0] * m[7];
>> - d[8] = m[0] * m[4] - m[3] * m[1];
>> -
>> - det = m[0] * d[0] + m[1] * d[3] + m[2] * d[6];
>> -
>> - if (det == 0.0)
>> - return;
>> -
>> - det = 1.0 / det;
>> -
>> - d[0] *= det;
>> - d[1] *= det;
>> - d[2] *= det;
>> - d[3] *= det;
>> - d[4] *= det;
>> - d[5] *= det;
>> - d[6] *= det;
>> - d[7] *= det;
>> - d[8] *= det;
>> -
>> - out->flags = 0;
>> -}
>> -
>> -static inline void
>> -evas_mat3_invserse(Evas_Mat3 *out, const Evas_Mat3 *mat)
>> -{
>> - if (out != mat)
>> - {
>> - evas_mat3_nocheck_inverse(out, mat);
>> - }
>> - else
>> - {
>> - Evas_Mat3 tmp;
>> -
>> - evas_mat3_nocheck_inverse(&tmp, mat);
>> - evas_mat3_copy(out, &tmp);
>> - }
>> -}
>> -
>> -static inline void
>> -evas_mat3_set_position_transform(Evas_Mat3 *out, const Evas_Real p_x,
>> - const
>> Evas_Real p_y) -{
>> - evas_mat3_identity_set(out);
>> - out->m[2] = p_x;
>> - out->m[5] = p_y;
>> - if ((fabs(p_x) > FLT_EPSILON) ||
>> - (fabs(p_y) > FLT_EPSILON))
>> - out->flags = 0;
>> -}
>> -
>> -static inline void
>> -evas_mat3_set_scale_transform(Evas_Mat3 *out, Evas_Real s_x, Evas_Real s_y)
>> -{
>> - evas_mat3_identity_set(out);
>> - out->m[0] = s_x;
>> - out->m[4] = s_y;
>> - if ((fabs(s_x - 1.0) > FLT_EPSILON) ||
>> - (fabs(s_y - 1.0) > FLT_EPSILON))
>> - out->flags = 0;
>> -}
>> -
>> -/* 2x2 matrix */
>> -static inline void
>> -evas_mat2_identity_set(Evas_Mat2 *m)
>> -{
>> - m->m[0] = 1.0;
>> - m->m[1] = 0.0;
>> - m->m[2] = 0.0;
>> - m->m[3] = 1.0;
>> -
>> - m->flags = EVAS_MATRIX_IS_IDENTITY;
>> -}
>> -
>> -static inline void
>> -evas_mat2_array_set(Evas_Mat2 *m, const Evas_Real *v)
>> -{
>> - memcpy(&m->m[0], v, sizeof(Evas_Real) * 4);
>> - m->flags = 0;
>> -}
>> -
>> -static inline void
>> -evas_mat2_copy(Evas_Mat2 *dst, const Evas_Mat2 *src)
>> -{
>> - memcpy(dst, src, sizeof(Evas_Mat2));
>> -}
>> -
>> -static inline void
>> -evas_mat2_nocheck_multiply(Evas_Mat2 *out, const Evas_Mat2 *mat_a, const
>> Evas_Mat2 *mat_b) -{
>> - Evas_Real *d = &out->m[0];
>> - const Evas_Real *a = &mat_a->m[0];
>> - const Evas_Real *b = &mat_b->m[0];
>> -
>> - if (mat_a->flags & EVAS_MATRIX_IS_IDENTITY)
>> - {
>> - evas_mat2_copy(out, mat_b);
>> - return;
>> - }
>> -
>> - if (mat_b->flags & EVAS_MATRIX_IS_IDENTITY)
>> - {
>> - evas_mat2_copy(out, mat_a);
>> - return;
>> - }
>> -
>> - d[0] = a[0] * b[0] + a[2] * b[1];
>> - d[2] = a[0] * b[2] + a[2] * b[3];
>> -
>> - d[1] = a[1] * b[0] + a[3] * b[1];
>> - d[3] = a[1] * b[2] + a[3] * b[3];
>> -
>> - out->flags = 0;
>> -}
>> -
>> -static inline void
>> -evas_mat2_multiply(Evas_Mat2 *out, const Evas_Mat2 *mat_a, const Evas_Mat2
>> *mat_b) -{
>> - if (out != mat_a && out != mat_b)
>> - {
>> - evas_mat2_nocheck_multiply(out, mat_a, mat_b);
>> - }
>> - else
>> - {
>> - Evas_Mat2 tmp;
>> -
>> - evas_mat2_nocheck_multiply(&tmp, mat_a, mat_b);
>> - evas_mat2_copy(out, &tmp);
>> - }
>> -}
>> -
>> -static inline void
>> -evas_mat2_nocheck_inverse(Evas_Mat2 *out, const Evas_Mat2 *mat)
>> -{
>> - Evas_Real *d = &out->m[0];
>> - const Evas_Real *m = &mat->m[0];
>> - Evas_Real det;
>> -
>> - if (mat->flags & EVAS_MATRIX_IS_IDENTITY)
>> - {
>> - evas_mat2_copy(out, mat);
>> - return;
>> - }
>> -
>> - det = m[0] * m[3] - m[2] * m[1];
>> -
>> - if (det == 0.0)
>> - return;
>> -
>> - det = 1.0 / det;
>> -
>> - d[0] = m[3] * det;
>> - d[1] = -m[1] * det;
>> - d[2] = -m[2] * det;
>> - d[3] = m[0] * det;
>> -
>> - out->flags = 0;
>> -}
>> -
>> -static inline void
>> -evas_mat2_invserse(Evas_Mat2 *out, const Evas_Mat2 *mat)
>> -{
>> - if (out != mat)
>> - {
>> - evas_mat2_nocheck_inverse(out, mat);
>> - }
>> - else
>> - {
>> - Evas_Mat2 tmp;
>> -
>> - evas_mat2_nocheck_inverse(&tmp, mat);
>> - evas_mat2_copy(out, &tmp);
>> - }
>> + m->wx = 0.0f;
>> + m->wy = 0.0f;
>> + m->wz = near_2 * dfar / depth;
>> + m->ww = 0.0f;
>> }
>>
>> static inline void
>> @@ -1467,13 +835,13 @@ evas_box3_union(Evas_Box3 *out, const Evas_Box3 *a,
>> const Evas_Box3 *b) }
>>
>> static inline void
>> -evas_box3_transform(Evas_Box3 *out EINA_UNUSED, const Evas_Box3 *box
>> EINA_UNUSED, const Evas_Mat4 *mat EINA_UNUSED) +evas_box3_transform(Evas_Box3
>> *out EINA_UNUSED, const Evas_Box3 *box EINA_UNUSED, const Eina_Matrix4 *mat
>> EINA_UNUSED) { /* TODO: */
>> }
>>
>> static inline void
>> -evas_mat4_position_get(const Evas_Mat4 *matrix, Evas_Vec4 *position)
>> +evas_mat4_position_get(const Eina_Matrix4 *matrix, Evas_Vec4 *position)
>> {
>> Evas_Vec4 pos;
>>
>> @@ -1486,7 +854,7 @@ evas_mat4_position_get(const Evas_Mat4 *matrix,
>> Evas_Vec4 *position) }
>>
>> static inline void
>> -evas_mat4_direction_get(const Evas_Mat4 *matrix, Evas_Vec3 *direction)
>> +evas_mat4_direction_get(const Eina_Matrix4 *matrix, Evas_Vec3 *direction)
>> {
>> /* TODO: Check correctness. */
>>
>> @@ -1540,7 +908,7 @@ evas_vec4_quaternion_inverse(Evas_Vec4 *out, const
>> Evas_Vec4 *q) }
>>
>> static inline void
>> -evas_vec4_quaternion_rotation_matrix_get(const Evas_Vec4 *q, Evas_Mat3 *mat)
>> +evas_vec4_quaternion_rotation_matrix_get(const Evas_Vec4 *q, Eina_Matrix3
>> *mat) {
>> Evas_Real x, y, z;
>> Evas_Real xx, xy, xz;
>> @@ -1565,57 +933,55 @@ evas_vec4_quaternion_rotation_matrix_get(const
>> Evas_Vec4 *q, Evas_Mat3 *mat) wy = q->w * y;
>> wz = q->w * z;
>>
>> - mat->m[0] = 1.0 - yy - zz;
>> - mat->m[1] = xy + wz;
>> - mat->m[2] = xz - wy;
>> - mat->m[3] = xy - wz;
>> - mat->m[4] = 1.0 - xx - zz;
>> - mat->m[5] = yz + wx;
>> - mat->m[6] = xz + wy;
>> - mat->m[7] = yz - wx;
>> - mat->m[8] = 1.0 - xx - yy;
>> + mat->xx = 1.0 - yy - zz;
>> + mat->xy = xy + wz;
>> + mat->xz = xz - wy;
>> + mat->yx = xy - wz;
>> + mat->yy = 1.0 - xx - zz;
>> + mat->yz = yz + wx;
>> + mat->zx = xz + wy;
>> + mat->zy = yz - wx;
>> + mat->zz = 1.0 - xx - yy;
>> }
>>
>> static inline void
>> -evas_mat4_build(Evas_Mat4 *out,
>> +evas_mat4_build(Eina_Matrix4 *out,
>> const Evas_Vec3 *position, const Evas_Vec4 *orientation,
>> const Evas_Vec3 *scale) {
>> - Evas_Mat3 rot;
>> + Eina_Matrix3 rot;
>>
>> evas_vec4_quaternion_rotation_matrix_get(orientation, &rot);
>>
>> - out->m[ 0] = scale->x * rot.m[0];
>> - out->m[ 1] = scale->x * rot.m[1];
>> - out->m[ 2] = scale->x * rot.m[2];
>> - out->m[ 3] = 0.0;
>> -
>> - out->m[ 4] = scale->y * rot.m[3];
>> - out->m[ 5] = scale->y * rot.m[4];
>> - out->m[ 6] = scale->y * rot.m[5];
>> - out->m[ 7] = 0.0;
>> + out->xx = scale->x * rot.xx;
>> + out->xy = scale->y * rot.xy;
>> + out->xz = scale->z * rot.xz;
>> + out->xw = 0.0;
>>
>> - out->m[ 8] = scale->z * rot.m[6];
>> - out->m[ 9] = scale->z * rot.m[7];
>> - out->m[10] = scale->z * rot.m[8];
>> - out->m[11] = 0.0;
>> + out->yx = scale->x * rot.yx;
>> + out->yy = scale->y * rot.yy;
>> + out->yz = scale->z * rot.yz;
>> + out->yw = 0.0;
>>
>> - out->m[12] = position->x;
>> - out->m[13] = position->y;
>> - out->m[14] = position->z;
>> - out->m[15] = 1.0;
>> + out->zx = scale->x * rot.zx;
>> + out->zy = scale->y * rot.zy;
>> + out->zz = scale->z * rot.zz;
>> + out->zw = 0.0;
>>
>> - out->flags = 0;
>> + out->wx = position->x;
>> + out->wy = position->y;
>> + out->wz = position->z;
>> + out->ww = 1.0;
>> }
>>
>> static inline void
>> -evas_mat4_inverse_build(Evas_Mat4 *out, const Evas_Vec3 *position,
>> +evas_mat4_inverse_build(Eina_Matrix4 *out, const Evas_Vec3 *position,
>> const Evas_Vec4 *orientation, const Evas_Vec3
>> *scale)
>> {
>> Evas_Vec4 inv_rotation;
>> Evas_Vec3 inv_scale;
>> Evas_Vec3 inv_translate;
>>
>> - Evas_Mat3 rot;
>> + Eina_Matrix3 rot;
>>
>> /* Inverse scale. */
>> evas_vec3_set(&inv_scale, 1.0 / scale->x, 1.0 / scale->y, 1.0 /
>> scale->z);
>> @@ -1631,27 +997,25 @@ evas_mat4_inverse_build(Evas_Mat4 *out, const
>> Evas_Vec3 *position, /* Get 3x3 rotation matrix. */
>> evas_vec4_quaternion_rotation_matrix_get(&inv_rotation, &rot);
>>
>> - out->m[ 0] = inv_scale.x * rot.m[0];
>> - out->m[ 1] = inv_scale.y * rot.m[1];
>> - out->m[ 2] = inv_scale.z * rot.m[2];
>> - out->m[ 3] = 0.0;
>> + out->xx = inv_scale.x * rot.xx;
>> + out->xy = inv_scale.y * rot.xy;
>> + out->xz = inv_scale.z * rot.xz;
>> + out->xw = 0.0;
>>
>> - out->m[ 4] = inv_scale.x * rot.m[3];
>> - out->m[ 5] = inv_scale.y * rot.m[4];
>> - out->m[ 6] = inv_scale.z * rot.m[5];
>> - out->m[ 7] = 0.0;
>> + out->yx = inv_scale.x * rot.yx;
>> + out->yy = inv_scale.y * rot.yy;
>> + out->yz = inv_scale.z * rot.yz;
>> + out->yw = 0.0;
>>
>> - out->m[ 8] = inv_scale.x * rot.m[6];
>> - out->m[ 9] = inv_scale.y * rot.m[7];
>> - out->m[10] = inv_scale.z * rot.m[8];
>> - out->m[11] = 0.0;
>> + out->zx = inv_scale.x * rot.zx;
>> + out->zy = inv_scale.y * rot.zy;
>> + out->zz = inv_scale.z * rot.zz;
>> + out->zw = 0.0;
>>
>> - out->m[12] = inv_translate.x;
>> - out->m[13] = inv_translate.y;
>> - out->m[14] = inv_translate.z;
>> - out->m[15] = 1.0;
>> -
>> - out->flags = 0;
>> + out->wx = inv_translate.x;
>> + out->wy = inv_translate.y;
>> + out->wz = inv_translate.z;
>> + out->ww = 1.0;
>> }
>>
>> static inline void
>> @@ -1673,16 +1037,16 @@ evas_color_blend(Evas_Color *dst, const Evas_Color
>> *c0, const Evas_Color *c1, Ev }
>>
>> static inline void
>> -evas_ray3_init(Evas_Ray3 *ray, Evas_Real x, Evas_Real y, const Evas_Mat4
>> *mvp) +evas_ray3_init(Evas_Ray3 *ray, Evas_Real x, Evas_Real y, const
>> Eina_Matrix4 *mvp) {
>> - Evas_Mat4 mat;
>> + Eina_Matrix4 mat;
>> Evas_Vec4 dnear, dfar;
>>
>> memset(&mat, 0, sizeof (mat));
>>
>> /* Get the matrix which transforms from normalized device coordinate to
>> modeling coodrinate. */
>> - evas_mat4_inverse(&mat, mvp);
>> + eina_matrix4_inverse(&mat, mvp);
>>
>> /* Transform near point. */
>> dnear.x = x;
>> @@ -2123,38 +1487,35 @@ evas_is_box_in_frustum(Evas_Box3 *box, Evas_Vec4
>> *planes) }
>>
>> static inline void
>> -evas_frustum_calculate(Evas_Vec4 *planes, Evas_Mat4 *matrix_vp)
>> +evas_frustum_calculate(Evas_Vec4 *planes, Eina_Matrix4 *matrix_vp)
>> {
>> int i;
>> - evas_vec4_set(&planes[0], matrix_vp->m[3] - matrix_vp->m[0],
>> - matrix_vp->m[7] - matrix_vp->m[4],
>> - matrix_vp->m[11] - matrix_vp->m[8],
>> - matrix_vp->m[15] - matrix_vp->m[12]);
>> -
>> - evas_vec4_set(&planes[1], matrix_vp->m[3] + matrix_vp->m[0],
>> - matrix_vp->m[7] + matrix_vp->m[4],
>> - matrix_vp->m[11] + matrix_vp->m[8],
>> - matrix_vp->m[15] + matrix_vp->m[12]);
>> -
>> - evas_vec4_set(&planes[2], matrix_vp->m[3] + matrix_vp->m[1],
>> - matrix_vp->m[7] + matrix_vp->m[5],
>> - matrix_vp->m[11] + matrix_vp->m[9],
>> - matrix_vp->m[15] + matrix_vp->m[13]);
>> -
>> - evas_vec4_set(&planes[3], matrix_vp->m[3] - matrix_vp->m[1],
>> - matrix_vp->m[7] - matrix_vp->m[5],
>> - matrix_vp->m[11] - matrix_vp->m[9],
>> - matrix_vp->m[15] - matrix_vp->m[13]);
>> -
>> - evas_vec4_set(&planes[4], matrix_vp->m[3] - matrix_vp->m[2],
>> - matrix_vp->m[7] - matrix_vp->m[6],
>> - matrix_vp->m[11] - matrix_vp->m[10],
>> - matrix_vp->m[15] - matrix_vp->m[14]);
>> -
>> - evas_vec4_set(&planes[5], matrix_vp->m[3] + matrix_vp->m[2],
>> - matrix_vp->m[7] + matrix_vp->m[6],
>> - matrix_vp->m[11] + matrix_vp->m[10],
>> - matrix_vp->m[15] + matrix_vp->m[14]);
>> +
>> + evas_vec4_set(&planes[0], matrix_vp->xw - matrix_vp->xx,
>> + matrix_vp->yw - matrix_vp->yx,
>> + matrix_vp->zw - matrix_vp->zx,
>> + matrix_vp->ww - matrix_vp->wx);
>> + evas_vec4_set(&planes[1], matrix_vp->xw - matrix_vp->xx,
>> + matrix_vp->yw - matrix_vp->yx,
>> + matrix_vp->zw - matrix_vp->zx,
>> + matrix_vp->ww - matrix_vp->wx);
>> + evas_vec4_set(&planes[2], matrix_vp->xw - matrix_vp->xx,
>> + matrix_vp->yw - matrix_vp->yx,
>> + matrix_vp->zw - matrix_vp->zx,
>> + matrix_vp->ww - matrix_vp->wx);
>> + evas_vec4_set(&planes[3], matrix_vp->xw - matrix_vp->xx,
>> + matrix_vp->yw - matrix_vp->yx,
>> + matrix_vp->zw - matrix_vp->zx,
>> + matrix_vp->ww - matrix_vp->wx);
>> + evas_vec4_set(&planes[4], matrix_vp->xw - matrix_vp->xx,
>> + matrix_vp->yw - matrix_vp->yx,
>> + matrix_vp->zw - matrix_vp->zx,
>> + matrix_vp->ww - matrix_vp->wx);
>> + evas_vec4_set(&planes[5], matrix_vp->xw - matrix_vp->xx,
>> + matrix_vp->yw - matrix_vp->yx,
>> + matrix_vp->zw - matrix_vp->zx,
>> + matrix_vp->ww - matrix_vp->wx);
>> +
>> for (i = 0; i < 6; i++)
>> {
>> evas_plane_normalize(&planes[i]);
>> diff --git a/src/lib/evas/include/evas_private.h
>> b/src/lib/evas/include/evas_private.h index f01c931..5e110dd 100644
>> --- a/src/lib/evas/include/evas_private.h
>> +++ b/src/lib/evas/include/evas_private.h
>> @@ -268,18 +268,18 @@ struct _Evas_Canvas3D_Node
>> union {
>> struct {
>> Evas_Canvas3D_Camera *camera;
>> - Evas_Mat4 matrix_world_to_eye;
>> + Eina_Matrix4 matrix_world_to_eye;
>> } camera;
>>
>> struct {
>> Evas_Canvas3D_Light *light;
>> - Evas_Mat4 matrix_local_to_world;
>> + Eina_Matrix4 matrix_local_to_world;
>> } light;
>>
>> struct {
>> Eina_List *meshes;
>> Eina_Hash *node_meshes;
>> - Evas_Mat4 matrix_local_to_world;
>> + Eina_Matrix4 matrix_local_to_world;
>> } mesh;
>> } data;
>>
>> @@ -296,7 +296,7 @@ struct _Evas_Canvas3D_Node
>>
>> struct _Evas_Canvas3D_Camera
>> {
>> - Evas_Mat4 projection;
>> + Eina_Matrix4 projection;
>> Eina_Hash *nodes;
>> };
>>
>> @@ -315,7 +315,7 @@ struct _Evas_Canvas3D_Light
>> Evas_Real atten_const;
>> Evas_Real atten_linear;
>> Evas_Real atten_quad;
>> - Evas_Mat4 projection;
>> + Eina_Matrix4 projection;
>>
>> Eina_Hash *nodes;
>> };
>> @@ -457,7 +457,7 @@ struct _Evas_Canvas3D_Pick_Data
>> {
>> /* Input */
>> Evas_Real x, y;
>> - Evas_Mat4 matrix_vp;
>> + Eina_Matrix4 matrix_vp;
>> Evas_Ray3 ray_world;
>>
>> /* Output */
>> @@ -1834,10 +1834,10 @@ struct _Evas_Imaging_Font
>>
>> struct _Evas_Proxy_Render_Data
>> {
>> - Evas_Object *eo_proxy;
>> Evas_Object_Protected_Data *proxy_obj;
>> - Evas_Object *eo_src;
>> Evas_Object_Protected_Data *src_obj;
>> + Evas_Object *eo_proxy;
>> + Evas_Object *eo_src;
>> Eina_Bool source_clip : 1;
>> };
>>
>> diff --git a/src/modules/evas/engines/gl_common/evas_gl_3d.c
>> b/src/modules/evas/engines/gl_common/evas_gl_3d.c index 68fc15f..1bc8fd1
>> 100644
>> --- a/src/modules/evas/engines/gl_common/evas_gl_3d.c
>> +++ b/src/modules/evas/engines/gl_common/evas_gl_3d.c
>> @@ -2,12 +2,12 @@
>> #include "evas_gl_3d_private.h"
>>
>> #define RENDER_MESH_NODE_ITERATE_BEGIN
>> #(param) \
>> - Evas_Mat4
>> matrix_mv;
>> \
>> - Evas_Mat4
>> matrix_mvp;
>> \
>> + Eina_Matrix4
>> matrix_mv;
>> \
>> + Eina_Matrix4
>> matrix_mvp;
>> \ Eina_Iterator
>> *it;
>> \ void
>> *ptr;
>> \
>> - evas_mat4_multiply(&matrix_mv, matrix_##param,
>> &pd_mesh_node->data.mesh.matrix_local_to_world); \
>> - evas_mat4_multiply(&matrix_mvp, &pd->projection,
>> &matrix_mv); \
>> + eina_matrix4_multiply(&matrix_mv, matrix_##param,
>> &pd_mesh_node->data.mesh.matrix_local_to_world); \
>> + eina_matrix4_multiply(&matrix_mvp, &pd->projection,
>> &matrix_mv); \ it =
>> eina_hash_iterator_data_new
>> (pd_mesh_node->data.mesh.node_meshes); \ while
>> (eina_iterator_next(it,
>> &ptr)) \
>> {
>> \
>> @@ -49,7 +49,7 @@ e3d_texture_new(Eina_Bool use_atlas) return NULL; }
>> - evas_mat3_identity_set(&texture->trans);
>> + eina_matrix3_identity(&texture->trans);
>>
>> texture->w = 0;
>> texture->h = 0;
>> @@ -94,7 +94,7 @@ e3d_texture_set(Evas_Engine_GL_Context *gc,
>> E3D_Texture *texture,
>> Evas_GL_Image *im)
>> {
>> - Evas_Mat3 pt,st;
>> + Eina_Matrix3 pt,st;
>> Evas_Real pt_x, pt_y, st_x, st_y;
>>
>> texture->surface = im;
>> @@ -115,9 +115,9 @@ e3d_texture_set(Evas_Engine_GL_Context *gc,
>> st_x = im->tex->pt->w ? (im->w/(Evas_Real)im->tex->pt->w) : 1.0;
>> st_y = im->tex->pt->h ? (im->h/(Evas_Real)im->tex->pt->h) : 1.0;
>> /*Build adjusting matrix for texture unit coordinates*/
>> - evas_mat3_set_position_transform(&pt, pt_x, pt_y);
>> - evas_mat3_set_scale_transform(&st, st_x, st_y);
>> - evas_mat3_multiply(&texture->trans, &st, &pt);
>> + eina_matrix3_position_transform_set(&pt, pt_x, pt_y);
>> + eina_matrix3_scale_transform_set(&st, st_x, st_y);
>> + eina_matrix3_multiply(&texture->trans, &st, &pt);
>> }
>> }
>>
>> @@ -898,7 +898,7 @@ _material_texture_build(E3D_Draw_Data *data, int frame,
>> static inline void
>> _light_build(E3D_Draw_Data *data,
>> const Evas_Canvas3D_Node *light,
>> - const Evas_Mat4 *matrix_eye)
>> + const Eina_Matrix4 *matrix_eye)
>> {
>> Evas_Canvas3D_Node_Data *pd_light_node = eo_data_scope_get(light,
>> EVAS_CANVAS3D_NODE_CLASS); Evas_Canvas3D_Light *l = pd_light_node ?
>> pd_light_node->data.light.light : NULL; @@ -966,10 +966,10 @@ _light_build
>> (E3D_Draw_Data *data, static inline Eina_Bool
>> _mesh_draw_data_build(E3D_Draw_Data *data,
>> Evas_Canvas3D_Mesh *mesh, int frame,
>> - const Evas_Mat4 *matrix_eye,
>> - const Evas_Mat4 *matrix_mv,
>> - const Evas_Mat4 *matrix_mvp,
>> - const Evas_Mat4 *matrix_light,
>> + const Eina_Matrix4 *matrix_eye,
>> + const Eina_Matrix4 *matrix_mv,
>> + const Eina_Matrix4 *matrix_mvp,
>> + const Eina_Matrix4 *matrix_light,
>> const Evas_Canvas3D_Node *light)
>> {
>> Eina_List *l, *r;
>> @@ -1011,10 +1011,10 @@ _mesh_draw_data_build(E3D_Draw_Data *data,
>> data->index_format = pdmesh->index_format;
>> data->indices = pdmesh->indices;
>>
>> - evas_mat4_copy(&data->matrix_mvp, matrix_mvp);
>> - evas_mat4_copy(&data->matrix_mv, matrix_mv);
>> + eina_matrix4_copy(&data->matrix_mvp, matrix_mvp);
>> + eina_matrix4_copy(&data->matrix_mv, matrix_mv);
>> if (matrix_light != NULL)
>> - evas_mat4_copy(&data->matrix_light, matrix_light);
>> + eina_matrix4_copy(&data->matrix_light, matrix_light);
>>
>> _mesh_frame_find(mesh, frame, &l, &r);
>>
>> @@ -1073,7 +1073,7 @@ _mesh_draw_data_build(E3D_Draw_Data *data,
>> BUILD(material_texture, MATERIAL_ATTRIB_EMISSION, EINA_FALSE);
>>
>> _light_build(data, light, matrix_eye);
>> - evas_normal_matrix_get(&data->matrix_normal, matrix_mv);
>> + eina_normal3_matrix_get(&data->matrix_normal, matrix_mv);
>>
>> if (_flags_need_tex_coord(data->flags))
>> BUILD(vertex_attrib, VERTEX_ATTRIB_TEXCOORD, EINA_FALSE);
>> @@ -1094,7 +1094,7 @@ _mesh_draw_data_build(E3D_Draw_Data *data,
>> BUILD(material_texture, MATERIAL_ATTRIB_EMISSION, EINA_FALSE);
>>
>> _light_build(data, light, matrix_eye);
>> - evas_normal_matrix_get(&data->matrix_normal, matrix_mv);
>> + eina_normal3_matrix_get(&data->matrix_normal, matrix_mv);
>>
>> if (_flags_need_tex_coord(data->flags))
>> BUILD(vertex_attrib, VERTEX_ATTRIB_TEXCOORD, EINA_FALSE);
>> @@ -1124,7 +1124,7 @@ _mesh_draw_data_build(E3D_Draw_Data *data,
>> BUILD(material_texture, MATERIAL_ATTRIB_EMISSION, EINA_FALSE);
>>
>> _light_build(data, light, matrix_eye);
>> - evas_normal_matrix_get(&data->matrix_normal, matrix_mv);
>> + eina_normal3_matrix_get(&data->matrix_normal, matrix_mv);
>> }
>>
>> int num;
>> @@ -1143,7 +1143,7 @@ _mesh_draw_data_build(E3D_Draw_Data *data,
>>
>> static inline void
>> _mesh_draw(E3D_Renderer *renderer, Evas_Canvas3D_Mesh *mesh, int frame,
>> Evas_Canvas3D_Node *light,
>> - const Evas_Mat4 *matrix_eye, const Evas_Mat4 *matrix_mv, const
>> Evas_Mat4 *matrix_mvp, const Evas_Mat4 *matrix_light)
>> + const Eina_Matrix4 *matrix_eye, const Eina_Matrix4 *matrix_mv,
>> const Eina_Matrix4 *matrix_mvp, const Eina_Matrix4 *matrix_light) {
>> E3D_Draw_Data data;
>>
>> @@ -1154,7 +1154,7 @@ _mesh_draw(E3D_Renderer *renderer, Evas_Canvas3D_Mesh
>> *mesh, int frame, Evas_Can }
>>
>> void _shadowmap_render(E3D_Drawable *drawable, E3D_Renderer *renderer,
>> - Evas_Canvas3D_Scene_Public_Data *data, Evas_Mat4
>> *matrix_light_eye,
>> + Evas_Canvas3D_Scene_Public_Data *data, Eina_Matrix4
>> *matrix_light_eye, Evas_Canvas3D_Node *light)
>> {
>> Eina_List *l;
>> @@ -1162,7 +1162,7 @@ void _shadowmap_render(E3D_Drawable *drawable,
>> E3D_Renderer *renderer, Evas_Canvas3D_Shade_Mode shade_mode;
>> Eina_Bool blend_enabled;
>> Evas_Color c = {1.0, 1.0, 1.0, 1.0};
>> - Evas_Mat4 matrix_vp;
>> + Eina_Matrix4 matrix_vp;
>>
>> glEnable(GL_POLYGON_OFFSET_FILL);
>> glPolygonOffset(data->depth_offset, data->depth_constant);
>> @@ -1178,7 +1178,7 @@ void _shadowmap_render(E3D_Drawable *drawable,
>> E3D_Renderer *renderer, EVAS_CANVAS3D_LIGHT_CLASS);
>>
>> Evas_Vec4 planes[6];
>> - evas_mat4_multiply(&matrix_vp, &pd->projection, matrix_light_eye);
>> + eina_matrix4_multiply(&matrix_vp, &pd->projection, matrix_light_eye);
>> evas_frustum_calculate(planes, &matrix_vp);
>>
>> EINA_LIST_FOREACH(data->mesh_nodes, l, n)
>> @@ -1212,9 +1212,9 @@ e3d_drawable_scene_render(E3D_Drawable *drawable,
>> E3D_Renderer *renderer, Evas_C {
>> Eina_List *l;
>> Evas_Canvas3D_Node *n;
>> - const Evas_Mat4 *matrix_eye;
>> + const Eina_Matrix4 *matrix_eye;
>> Evas_Canvas3D_Node *light;
>> - Evas_Mat4 matrix_light_eye, matrix_vp;;
>> + Eina_Matrix4 matrix_light_eye, matrix_vp;;
>> Evas_Canvas3D_Light_Data *ld = NULL;
>> Evas_Canvas3D_Node_Data *pd_light_node;
>> Evas_Vec4 planes[6];
>> @@ -1240,13 +1240,13 @@ e3d_drawable_scene_render(E3D_Drawable *drawable,
>> E3D_Renderer *renderer, Evas_C e3d_renderer_target_set(renderer, drawable);
>> e3d_renderer_clear(renderer, &data->bg_color);
>>
>> - evas_mat4_multiply(&matrix_vp, &pd->projection, matrix_eye);
>> + eina_matrix4_multiply(&matrix_vp, &pd->projection, matrix_eye);
>> evas_frustum_calculate(planes, &matrix_vp);
>> EINA_LIST_FOREACH(data->mesh_nodes, l, n)
>> {
>> - Evas_Mat4 matrix_mv;
>> - Evas_Mat4 matrix_light;
>> - Evas_Mat4 matrix_mvp;
>> + Eina_Matrix4 matrix_mv;
>> + Eina_Matrix4 matrix_light;
>> + Eina_Matrix4 matrix_mvp;
>> Eina_Iterator *it;
>> void *ptr;
>> Evas_Canvas3D_Node_Data *pd_mesh_node = eo_data_scope_get(n,
>> EVAS_CANVAS3D_NODE_CLASS); @@ -1257,14 +1257,14 @@ e3d_drawable_scene_render
>> (E3D_Drawable *drawable, E3D_Renderer *renderer, Evas_C
>> if (data->shadows_enabled)
>> {
>> - evas_mat4_multiply(&matrix_mv, &matrix_light_eye,
>> + eina_matrix4_multiply(&matrix_mv, &matrix_light_eye,
>> &pd_mesh_node->data.mesh.matrix_local_to_world);
>> - evas_mat4_multiply(&matrix_light, &ld->projection,
>> + eina_matrix4_multiply(&matrix_light, &ld->projection,
>> &matrix_mv);
>> }
>>
>> - evas_mat4_multiply(&matrix_mv, matrix_eye,
>> &pd_mesh_node->data.mesh.matrix_local_to_world);
>> - evas_mat4_multiply(&matrix_mvp, &pd->projection,
>> + eina_matrix4_multiply(&matrix_mv, matrix_eye,
>> &pd_mesh_node->data.mesh.matrix_local_to_world);
>> + eina_matrix4_multiply(&matrix_mvp, &pd->projection,
>> &matrix_mv);
>>
>> it = eina_hash_iterator_data_new
>> (pd_mesh_node->data.mesh.node_meshes); @@ -1290,7 +1290,7 @@ Eina_Bool
>> e3d_drawable_scene_render_to_texture(E3D_Drawable *drawable, E3D_Renderer
>> *renderer, Evas_Canvas3D_Scene_Public_Data *data)
>> {
>> - const Evas_Mat4 *matrix_eye;
>> + const Eina_Matrix4 *matrix_eye;
>> Evas_Canvas3D_Shade_Mode shade_mode;
>> Eina_Stringshare *tmp;
>> Eina_Iterator *itmn;
>> diff --git a/src/modules/evas/engines/gl_common/evas_gl_3d_private.h
>> b/src/modules/evas/engines/gl_common/evas_gl_3d_private.h index
>> a05eba7..03970be 100644
>> --- a/src/modules/evas/engines/gl_common/evas_gl_3d_private.h
>> +++ b/src/modules/evas/engines/gl_common/evas_gl_3d_private.h
>> @@ -56,10 +56,10 @@ struct _E3D_Draw_Data
>> E3D_Shader_Flag flags;
>> Evas_Canvas3D_Shade_Mode mode;
>>
>> - Evas_Mat4 matrix_mvp;
>> - Evas_Mat4 matrix_mv;
>> - Evas_Mat3 matrix_normal;
>> - Evas_Mat4 matrix_light;
>> + Eina_Matrix4 matrix_mvp;
>> + Eina_Matrix4 matrix_mv;
>> + Eina_Matrix3 matrix_normal;
>> + Eina_Matrix4 matrix_light;
>>
>> struct {
>> Evas_Canvas3D_Vertex_Buffer vertex0;
>> @@ -96,7 +96,7 @@ struct _E3D_Draw_Data
>> Eina_Bool alpha_test_enabled :1;
>>
>> struct {
>> - Evas_Vec4 position;
>> + Eina_Quaternion position;
>> Evas_Vec3 spot_dir;
>> Evas_Real spot_exp;
>> Evas_Real spot_cutoff_cos;
>> @@ -125,7 +125,7 @@ struct _E3D_Texture
>>
>> Evas_GL_Image *surface;
>> /*Tranformation matrix, use it for adjusting texture unit coordinates*/
>> - Evas_Mat3 trans;
>> + Eina_Matrix3 trans;
>>
>> GLuint tex;
>>
>> diff --git a/src/modules/evas/engines/gl_common/evas_gl_3d_shader.c
>> b/src/modules/evas/engines/gl_common/evas_gl_3d_shader.c index
>> 8beeb3d..23b551d 100644
>> --- a/src/modules/evas/engines/gl_common/evas_gl_3d_shader.c
>> +++ b/src/modules/evas/engines/gl_common/evas_gl_3d_shader.c
>> @@ -373,6 +373,35 @@ _program_uniform_init(E3D_Program *program)
>> }
>> }
>>
>> +#define UNIFORM_MATRIX3_FOREACH(m, data) \
>> + m[0] = data.xx; \
>> + m[1] = data.xy; \
>> + m[2] = data.xz; \
>> + m[3] = data.yx; \
>> + m[4] = data.yy; \
>> + m[5] = data.yz; \
>> + m[6] = data.zx; \
>> + m[7] = data.zy; \
>> + m[8] = data.zz;
>> +
>> +#define UNIFORM_MATRIX4_FOREACH(m, data) \
>> + m[0] = data.xx; \
>> + m[1] = data.xy; \
>> + m[2] = data.xz; \
>> + m[3] = data.xw; \
>> + m[4] = data.yx; \
>> + m[5] = data.yy; \
>> + m[6] = data.yz; \
>> + m[7] = data.yw; \
>> + m[8] = data.zx; \
>> + m[9] = data.zy; \
>> + m[10] = data.zz; \
>> + m[11] = data.zw; \
>> + m[12] = data.wx; \
>> + m[13] = data.wy; \
>> + m[14] = data.wz; \
>> + m[15] = data.ww;
>> +
>> static inline void
>> _uniform_upload(E3D_Uniform u, GLint loc, const E3D_Draw_Data *data)
>> {
>> @@ -380,8 +409,7 @@ _uniform_upload(E3D_Uniform u, GLint loc, const
>> E3D_Draw_Data *data) if (data->materials
>> [attrib].tex##tn) \
>> { \
>> float m[9]; \
>> - for(int i = 0 ; i < 9 ; i+
>> +) \
>> - m[i] = data->materials[attrib].tex##tn->trans.m
>> [i]; \
>> + UNIFORM_MATRIX3_FOREACH(m, data->materials
>> [attrib].tex##tn->trans); \ glUniformMatrix3fv(loc, 1, EINA_FALSE, &m
>> [0]); \ }
>>
>> @@ -389,29 +417,25 @@ _uniform_upload(E3D_Uniform u, GLint loc, const
>> E3D_Draw_Data *data) {
>> case E3D_UNIFORM_MATRIX_MVP: {
>> float m[16];
>> - for(int i = 0 ; i <16 ; i++)
>> - m[i] = data->matrix_mvp.m[i];
>> + UNIFORM_MATRIX4_FOREACH(m, data->matrix_mvp);
>> glUniformMatrix4fv(loc, 1, EINA_FALSE, &m[0]);
>> break;
>> }
>> case E3D_UNIFORM_MATRIX_MV: {
>> float m[16];
>> - for(int i = 0 ; i <16 ; i++)
>> - m[i] = data->matrix_mv.m[i];
>> + UNIFORM_MATRIX4_FOREACH(m, data->matrix_mv);
>> glUniformMatrix4fv(loc, 1, EINA_FALSE, &m[0]);
>> break;
>> }
>> case E3D_UNIFORM_MATRIX_NORMAL: {
>> float m[9];
>> - for(int i = 0 ; i <9 ; i++)
>> - m[i] = data->matrix_normal.m[i];
>> + UNIFORM_MATRIX3_FOREACH(m, data->matrix_normal);
>> glUniformMatrix3fv(loc, 1, EINA_FALSE, &m[0]);
>> break;
>> }
>> case E3D_UNIFORM_MATRIX_LIGHT: {
>> float m[16];
>> - for(int i = 0 ; i <16 ; i++)
>> - m[i] = data->matrix_light.m[i];
>> + UNIFORM_MATRIX4_FOREACH(m, data->matrix_light);
>> glUniformMatrix4fv(loc, 1, EINA_FALSE, &m[0]);
>> break;
>> }
>> diff --git a/src/tests/eina/eina_test_matrix.c
>> b/src/tests/eina/eina_test_matrix.c index fcee52f..11cc2c6 100644
>> --- a/src/tests/eina/eina_test_matrix.c
>> +++ b/src/tests/eina/eina_test_matrix.c
>> @@ -20,12 +20,106 @@
>> # include "config.h"
>> #endif
>>
>> +#define DBL_EPSILON 0.0000001
>> +
>> #include <math.h>
>> #include <stdio.h>
>>
>> #include "eina_suite.h"
>> #include "Eina.h"
>>
>> +START_TEST(eina_matrix2)
>> +{
>> + Eina_Matrix2 m;
>> + Eina_Matrix2 n;
>> + double xx, xy, yx, yy;
>> +
>> + eina_init();
>> +
>> + eina_matrix2_values_set(&m,
>> + 1, 0,
>> + 0, 1);
>> + fail_if(eina_matrix2_type_get(&m) != EINA_MATRIX_TYPE_IDENTITY);
>> +
>> + eina_matrix2_inverse(&n, &m);
>> + fail_if(eina_matrix2_type_get(&n) != EINA_MATRIX_TYPE_IDENTITY);
>> +
>> + eina_matrix2_values_get(&m,
>> + &xx, &xy,
>> + &yx, &yy);
>> +
>> + fail_if(xx != yy ||
>> + yy != 1);
>> + fail_if(xy != yx ||
>> + xy != 0);
>> +
>> + eina_shutdown();
>> +}
>> +END_TEST
>> +
>> +START_TEST(eina_matrix2_operation)
>> +{
>> + Eina_Matrix2 m1, m2, m3;
>> + double xx, xy, yx, yy;
>> + double arr[] = {1, 1, 1, 1};
>> +
>> + eina_matrix2_values_set(&m2,
>> + 2, 3,
>> + 3, 2);
>> + eina_matrix2_inverse(&m1, &m2);
>> + eina_matrix2_values_get(&m1,
>> + &xx, &xy,
>> + &yx, &yy);
>> + fail_if((xx - (-0.4) > DBL_EPSILON) || (xy - 0.6 > DBL_EPSILON) ||
>> + (yx - 0.6 > DBL_EPSILON) || (yy - (-0.4) > DBL_EPSILON));
>> +
>> + eina_matrix2_identity(&m1);
>> + eina_matrix2_values_get(&m1,
>> + &xx, &xy,
>> + &yx, &yy);
>> + fail_if(xx != yy ||
>> + yy != 1 ||
>> + xy != yx ||
>> + xy != 0);
>> +
>> + eina_matrix2_array_set(&m1, &arr);
>> + eina_matrix2_values_get(&m1,
>> + &xx, &xy,
>> + &yx, &yy);
>> + fail_if(xx != yy ||
>> + yx != xy ||
>> + xy != 1);
>> +
>> + eina_matrix2_copy(&m2, &m1);
>> + eina_matrix2_values_get(&m2,
>> + &xx, &xy,
>> + &yx, &yy);
>> + fail_if(xx != yy ||
>> + yx != xy ||
>> + xy != 1);
>> +
>> + eina_matrix2_values_set(&m1,
>> + 2, 3,
>> + 3, 2);
>> + eina_matrix2_multiply_copy(&m3, &m1, &m2);
>> + eina_matrix2_values_get(&m3,
>> + &xx, &xy,
>> + &yx, &yy);
>> + fail_if(xx != yy ||
>> + yx != xy ||
>> + xy != 5);
>> +
>> + eina_matrix2_multiply(&m3, &m1, &m2);
>> + eina_matrix2_values_get(&m3,
>> + &xx, &xy,
>> + &yx, &yy);
>> + fail_if(xx != yy ||
>> + yx != xy ||
>> + xy != 5);
>> +
>> +}
>> +END_TEST
>> +
>> START_TEST(eina_matrix4)
>> {
>> Eina_Matrix4 m;
>> @@ -77,6 +171,128 @@ START_TEST(eina_matrix4)
>> }
>> END_TEST
>>
>> +START_TEST(eina_matrix4_operation)
>> +{
>> + double det;
>> + double l=5, r=4, b=4, t=3, dn=3, df=2;
>> + Eina_Matrix4 m, m1, m2;
>> + double xx, xy, xz, xw,
>> + yx, yy, yz, yw,
>> + zx, zy, zz, zw,
>> + wx, wy, wz, ww;
>> + const double arr[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
>> +
>> + eina_matrix4_values_set(&m,
>> + 0, 0, 2, 0,
>> + 2, 0, 0, 0,
>> + 0, 0, 0, 2,
>> + 0, 2, 0, 0);
>> + det = eina_matrix4_determinant(&m);
>> + fail_if(det != -16);
>> +
>> + eina_matrix4_inverse(&m1, &m);
>> + eina_matrix4_values_get(&m1,
>> + &xx, &xy, &xz, &xw,
>> + &yx, &yy, &yz, &yw,
>> + &zx, &zy, &zz, &zw,
>> + &wx, &wy, &wz, &ww);
>> + fail_if (xy != 0.5 ||
>> + yw != xy ||
>> + zx != yw ||
>> + wz != zx);
>> +
>> + eina_matrix4_identity(&m1);
>> + eina_matrix4_values_get(&m1,
>> + &xx, &xy, &xz, &xw,
>> + &yx, &yy, &yz, &yw,
>> + &zx, &zy, &zz, &zw,
>> + &wx, &wy, &wz, &ww);
>> + fail_if (xx != 1 ||
>> + yy != xx ||
>> + zz != yy ||
>> + ww != zz);
>> +
>> + eina_matrix4_values_set(&m1,
>> + 0, 2, 2, 0,
>> + 2, 0, 0, 2,
>> + 2, 0, 0, 2,
>> + 0, 2, 2, 0);
>> + eina_matrix4_multiply_copy(&m2, &m1, &m);
>> + eina_matrix4_values_get(&m2,
>> + &xx, &xy, &xz, &xw,
>> + &yx, &yy, &yz, &yw,
>> + &zx, &zy, &zz, &zw,
>> + &wx, &wy, &wz, &ww);
>> + fail_if (xx != 4 ||
>> + xw != xx ||
>> + yy != xw ||
>> + yz != yy ||
>> + zy != yz ||
>> + zz != yy ||
>> + wx != xx ||
>> + ww != zy);
>> +
>> + eina_matrix4_multiply(&m2, &m1, &m);
>> + eina_matrix4_values_get(&m2,
>> + &xx, &xy, &xz, &xw,
>> + &yx, &yy, &yz, &yw,
>> + &zx, &zy, &zz, &zw,
>> + &wx, &wy, &wz, &ww);
>> + fail_if (xx != 4 ||
>> + xw != xx ||
>> + yy != xw ||
>> + yz != yy ||
>> + zy != yz ||
>> + zz != yy ||
>> + wx != xx ||
>> + ww != zy);
>> +
>> + eina_matrix4_array_set(&m1, &arr);
>> + eina_matrix4_values_get(&m1,
>> + &xx, &xy, &xz, &xw,
>> + &yx, &yy, &yz, &yw,
>> + &zx, &zy, &zz, &zw,
>> + &wx, &wy, &wz, &ww);
>> + fail_if (xx != 1 ||
>> + xw != xx ||
>> + yy != xw ||
>> + yz != yy ||
>> + zy != yz ||
>> + zz != yy ||
>> + wx != xx ||
>> + ww != zy);
>> +
>> + eina_matrix4_copy(&m, &m1);
>> + eina_matrix4_values_get(&m1,
>> + &xx, &xy, &xz, &xw,
>> + &yx, &yy, &yz, &yw,
>> + &zx, &zy, &zz, &zw,
>> + &wx, &wy, &wz, &ww);
>> + fail_if (xx != 1 ||
>> + xw != xx ||
>> + yy != xw ||
>> + yz != yy ||
>> + zy != yz ||
>> + zz != yy ||
>> + wx != xx ||
>> + ww != zy);
>> +
>> + eina_matrix4_ortho_set(&m, l, r, b, t, dn, df);
>> + eina_matrix4_values_get(&m,
>> + &xx, &xy, &xz, &xw,
>> + &yx, &yy, &yz, &yw,
>> + &zx, &zy, &zz, &zw,
>> + &wx, &wy, &wz, &ww);
>> + fail_if (xx != -2 ||
>> + yy != -2 ||
>> + zz != 2 ||
>> + wx != 9 ||
>> + wy != 7 ||
>> + wz != 5 ||
>> + ww != 1);
>> +}
>> +END_TEST
>> +
>> START_TEST(eina_matrix4_2_3)
>> {
>> Eina_Matrix4 m4;
>> @@ -155,6 +371,7 @@ START_TEST(eina_matrix3_operations)
>> yx, yy, yz,
>> zx, zy, zz;
>> double tx = 20, ty = 30, ret;
>> + const double arr[] = {1, 1, 1, 1, 1, 1, 1, 1, 1};
>>
>> eina_matrix3_values_set(&m1,
>> 1, 0, 0,
>> @@ -305,6 +522,68 @@ START_TEST(eina_matrix3_operations)
>> fail_if (xx != 24 || xy != -12 || xz != -2 ||
>> yx != 5 || yy != 3 || yz != -5 ||
>> zx != -4 || zy != 2 || zz != 4);
>> +
>> + eina_matrix3_values_set(&m2,
>> + 2, 2, 2,
>> + 1, 1, 1,
>> + 3, 3, 3);
>> + eina_matrix3_values_set(&m3,
>> + 3, 3, 3,
>> + 2, 2, 2,
>> + 1, 1, 1);
>> + eina_matrix3_multiply_copy(&m1, &m2, &m3);
>> + eina_matrix3_values_get(&m1,
>> + &xx, &xy, &xz,
>> + &yx, &yy, &yz,
>> + &zx, &zy, &zz);
>> + fail_if (xx != 12 || xy != 12 || xz != 12 ||
>> + yx != 6 || yy != 6 || yz != 6 ||
>> + zx != 18 || zy != 18 || zz != 18);
>> +
>> + eina_matrix3_values_set(&m2,
>> + 2, 2, 2,
>> + 1, 1, 1,
>> + 0, 0, 0);
>> + eina_matrix3_multiply(&m1, &m2, &m3);
>> + eina_matrix3_values_get(&m1,
>> + &xx, &xy, &xz,
>> + &yx, &yy, &yz,
>> + &zx, &zy, &zz);
>> + fail_if (xx != 12 || xy != 12 || xz != 12 ||
>> + yx != 6 || yy != 6 || yz != 6 ||
>> + zx != 0 || zy != 0 || zz != 0);
>> +
>> + eina_matrix3_copy(&m1, &m2);
>> + eina_matrix3_values_get(&m1,
>> + &xx, &xy, &xz,
>> + &yx, &yy, &yz,
>> + &zx, &zy, &zz);
>> + fail_if (xx != 2 || xy != 2 || xz != 2 ||
>> + yx != 1 || yy != 1 || yz != 1 ||
>> + zx != 0 || zy != 0 || zz != 0);
>> +
>> + eina_matrix3_array_set(&m1, &arr);
>> + eina_matrix3_values_get(&m1,
>> + &xx, &xy, &xz,
>> + &yx, &yy, &yz,
>> + &zx, &zy, &zz);
>> + fail_if (xx != 1 || xy != 1 || xz != 1 ||
>> + yx != 1 || yy != 1 || yz != 1 ||
>> + zx != 1 || zy != 1 || zz != 1);
>> +
>> + eina_matrix3_position_transform_set(&m3, 5, 3);
>> + eina_matrix3_values_get(&m3,
>> + &xx, &xy, &xz,
>> + &yx, &yy, &yz,
>> + &zx, &zy, &zz);
>> + fail_if (xz != 5 || yz != 3);
>> +
>> + eina_matrix3_scale_transform_set(&m2, 6, 7);
>> + eina_matrix3_values_get(&m2,
>> + &xx, &xy, &xz,
>> + &yx, &yy, &yz,
>> + &zx, &zy, &zz);
>> + fail_if (xx != 6 || yy != 7);
>> }
>> END_TEST
>>
>> @@ -427,7 +706,10 @@ END_TEST
>> void
>> eina_test_matrix(TCase *tc)
>> {
>> + tcase_add_test(tc, eina_matrix2);
>> + tcase_add_test(tc, eina_matrix2_operation);
>> tcase_add_test(tc, eina_matrix4);
>> + tcase_add_test(tc, eina_matrix4_operation);
>> tcase_add_test(tc, eina_matrix4_2_3);
>> tcase_add_test(tc, eina_matrix3);
>> tcase_add_test(tc, eina_matrix3_operations);
>>
>> --
>>
>>
>
>
> --
> ------------- Codito, ergo sum - "I code, therefore I am" --------------
> The Rasterman (Carsten Haitzler) [email protected]
>
>
> ------------------------------------------------------------------------------
> _______________________________________________
> enlightenment-devel mailing list
> [email protected]
> https://lists.sourceforge.net/lists/listinfo/enlightenment-devel
>
--
Cedric BAIL
------------------------------------------------------------------------------
_______________________________________________
enlightenment-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/enlightenment-devel
