kimcinoo
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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 <cedric@osg.samsung.com>
This commit is contained in:
se.osadchy 2015-11-09 14:37:42 -08:00 committed by Cedric BAIL
parent 3031a4a5c6
commit 3d77f55f91
11 changed files with 1133 additions and 960 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

437
src/lib/eina/eina_matrix.c
View File

@ -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);
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);
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_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);
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);
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);
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);
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);
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_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);
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);
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);
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);
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);
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);
eina_matrix4_multiply(&result, mat_a, mat_b);
eina_matrix4_copy(out, &result);
}
}
EAPI void
eina_matrix4_identity(Eina_Matrix4 *out)
{
memset(out, 0, sizeof (Eina_Matrix4));
MATRIX_XX(out) = 1;
MATRIX_YY(out) = 1;
MATRIX_ZZ(out) = 1;
MATRIX_WW(out) = 1;
MATRIX_XX(out) = 1.0;
MATRIX_YY(out) = 1.0;
MATRIX_ZZ(out) = 1.0;
MATRIX_WW(out) = 1.0;
}
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;
}
EAPI void
eina_matrix4_array_set(Eina_Matrix4 *m, const double *v)
{
memcpy(&MATRIX_XX(m), v, sizeof(double) * 16);
}
EAPI void
eina_matrix4_copy(Eina_Matrix4 *dst, const Eina_Matrix4 *src)
{
memcpy(dst, src, sizeof(Eina_Matrix4));
}
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;
}
if (eina_matrix4_type_get(mat_b) & EINA_MATRIX_TYPE_IDENTITY)
{
eina_matrix4_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_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);
}
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;
}
EAPI void
eina_matrix3_array_set(Eina_Matrix3 *m, const double *v)
{
memcpy(&MATRIX_XX(m), v, sizeof(double) * 9);
}
EAPI void
eina_matrix3_copy(Eina_Matrix3 *dst, const Eina_Matrix3 *src)
{
memcpy(dst, src, sizeof(Eina_Matrix3));
}
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;
}
if (eina_matrix3_type_get(mat_b) & EINA_MATRIX_TYPE_IDENTITY)
{
eina_matrix3_copy(out, mat_a);
return;
}
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_matrix3_multiply_copy(Eina_Matrix3 *out, const Eina_Matrix3 *mat_a, const Eina_Matrix3 *mat_b)
{
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);
}
}

275
src/lib/eina/eina_matrix.h
View File

@ -428,6 +428,23 @@ struct _Eina_Matrix4
double ww; /**< ww in w' = (x * wx) + (y * wy) + (z * wz) + ww */
};
/**
* @}
* @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.
*
@ -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);
/**
* @}

12
src/lib/evas/canvas/evas_canvas3d_camera.c
View File

@ -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);

6
src/lib/evas/canvas/evas_canvas3d_light.c
View File

@ -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));
}

8
src/lib/evas/canvas/evas_canvas3d_scene.c
View File

@ -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);

931
src/lib/evas/include/evas_3d_utils.h
View File

File diff suppressed because it is too large Load Diff

16
src/lib/evas/include/evas_private.h
View File

@ -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;
};

70
src/modules/evas/engines/gl_common/evas_gl_3d.c
View File

@ -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;

12
src/modules/evas/engines/gl_common/evas_gl_3d_private.h
View File

@ -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;

44
src/modules/evas/engines/gl_common/evas_gl_3d_shader.c
View File

@ -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;
}

282
src/tests/eina/eina_test_matrix.c
View File

@ -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);