On Mon, 09 Nov 2015 16:38:33 -0800 "se.osadchy" <[email protected]> said:
hey cedric... did you even TEST this?
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
