float graphene_matrix_get_y_scale (const graphene_matrix_t *m) { g_return_val_if_fail (m != NULL, 0.f); return graphene_simd4f_get_y (m->value.y); }
float graphene_matrix_get_value (const graphene_matrix_t *m, unsigned int row, unsigned int col) { graphene_simd4f_t r; float c = 0.f; g_return_val_if_fail (m != NULL, 0.f); g_return_val_if_fail (row >= 0 && row < 4, 0.f); g_return_val_if_fail (col >= 0 && row < 4, 0.f); switch (row) { case 0: r = m->value.x; break; case 1: r = m->value.y; break; case 2: r = m->value.z; break; case 3: r = m->value.w; break; default: g_assert_not_reached (); } switch (col) { case 0: c = graphene_simd4f_get_x (r); break; case 1: c = graphene_simd4f_get_y (r); break; case 2: c = graphene_simd4f_get_z (r); break; case 3: c = graphene_simd4f_get_w (r); break; default: g_assert_not_reached (); } return c; }
static graphene_quaternion_t * graphene_quaternion_init_from_simd4f (graphene_quaternion_t *q, graphene_simd4f_t v) { q->x = graphene_simd4f_get_x (v); q->y = graphene_simd4f_get_y (v); q->z = graphene_simd4f_get_z (v); q->w = graphene_simd4f_get_w (v); return q; }
/** * graphene_matrix_get_value: * @m: a #grapheme_matrix_t * @row: the row index * @col: the column index * * Retrieves the value at the given @row and @col index. * * Returns: the value at the given indices * * Since: 1.0 */ float graphene_matrix_get_value (const graphene_matrix_t *m, unsigned int row, unsigned int col) { graphene_simd4f_t r; float c = 0.f; switch (row) { case 0: r = m->value.x; break; case 1: r = m->value.y; break; case 2: r = m->value.z; break; case 3: r = m->value.w; break; default: return 0.f; } switch (col) { case 0: c = graphene_simd4f_get_x (r); break; case 1: c = graphene_simd4f_get_y (r); break; case 2: c = graphene_simd4f_get_z (r); break; case 3: c = graphene_simd4f_get_w (r); break; default: return 0; } return c; }
static void matrix_project (gpointer data_) { MatrixBench *data = data_; int i; for (i = 0; i < N_ROUNDS; i++) { graphene_simd4f_t pback, qback, uback; float t, x, y; graphene_simd4x4f_vec3_mul (&(data->a[i]), &(data->pa[i]), &pback); graphene_simd4x4f_vec3_mul (&(data->a[i]), &(data->qa[i]), &qback); uback = graphene_simd4f_sub (data->pa[i], pback); t = -1.0f * graphene_simd4f_get_z (pback) / graphene_simd4f_get_z (uback); x = graphene_simd4f_get_x (pback) + t * graphene_simd4f_get_x (uback); y = graphene_simd4f_get_y (pback) + t * graphene_simd4f_get_y (uback); data->ra[i] = graphene_simd4f_init (x, y, 0.f, 0.f); } }
/** * graphene_matrix_transform_point: * @m: a #graphene_matrix_t * @p: a #graphene_point_t * @res: (out caller-allocates): return location for the * transformed #graphene_point_t * * Transforms the given #graphene_point_t using the matrix @m. * * Since: 1.0 */ void graphene_matrix_transform_point (const graphene_matrix_t *m, const graphene_point_t *p, graphene_point_t *res) { graphene_simd4f_t vec3; vec3 = graphene_simd4f_init (p->x, p->y, 0.0f, 0.0f); graphene_simd4x4f_vec3_mul (&m->value, &vec3, &vec3); res->x = graphene_simd4f_get_x (vec3); res->y = graphene_simd4f_get_y (vec3); }
/** * graphene_point_near: * @a: a #graphene_point_t * @b: a #graphene_point_t * @epsilon: threshold between the two points * * Checks whether the two points @a and @b are within * the threshold of @epsilon. * * Returns: `true` if the distance is within @epsilon * * Since: 1.0 */ bool graphene_point_near (const graphene_point_t *a, const graphene_point_t *b, float epsilon) { graphene_simd4f_t s_a, s_b, res; if (a == b) return true; s_a = graphene_simd4f_init (a->x, a->y, 0.f, 0.f); s_b = graphene_simd4f_init (b->x, b->y, 0.f, 0.f); res = graphene_simd4f_sub (s_a, s_b); return fabsf (graphene_simd4f_get_x (res)) < epsilon && fabsf (graphene_simd4f_get_y (res)) < epsilon; }
/** * graphene_quaternion_init_from_angle_vec3: * @q: a #graphene_quaternion_t * @angle: the rotation on a given axis, in degrees * @axis: the axis of rotation, expressed as a vector * * Initializes a #graphene_quaternion_t using an @angle on a * specific @axis. * * Returns: (transfer none): the initialized quaternion * * Since: 1.0 */ graphene_quaternion_t * graphene_quaternion_init_from_angle_vec3 (graphene_quaternion_t *q, float angle, const graphene_vec3_t *axis) { float rad, sin_a, cos_a; graphene_simd4f_t axis_n; rad = GRAPHENE_DEG_TO_RAD (angle); sin_a = sinf (rad / 2.f); cos_a = cosf (rad / 2.f); axis_n = graphene_simd4f_mul (graphene_simd4f_normalize3 (axis->value), graphene_simd4f_splat (sin_a)); q->x = graphene_simd4f_get_x (axis_n); q->y = graphene_simd4f_get_y (axis_n); q->z = graphene_simd4f_get_z (axis_n); q->w = cos_a; return q; }
/** * graphene_point_distance: * @a: a #graphene_point_t * @b: a #graphene_point_t * @d_x: (out) (optional): distance component on the X axis * @d_y: (out) (optional): distance component on the Y axis * * Computes the distance between @a and @b. * * Returns: the distance between the two points * * Since: 1.0 */ float graphene_point_distance (const graphene_point_t *a, const graphene_point_t *b, float *d_x, float *d_y) { graphene_simd4f_t s_a, s_b, res; if (a == b) return 0.f; s_a = graphene_simd4f_init (a->x, a->y, 0.f, 0.f); s_b = graphene_simd4f_init (b->x, b->y, 0.f, 0.f); res = graphene_simd4f_sub (s_a, s_b); if (d_x != NULL) *d_x = fabsf (graphene_simd4f_get_x (res)); if (d_y != NULL) *d_y = fabsf (graphene_simd4f_get_y (res)); return graphene_simd4f_get_x (graphene_simd4f_length2 (res)); }
/** * graphene_simd4f_get_y: * @s: a #graphene_simd4f_t * * Retrieves the second component of @s. * * Returns: the second component of a #graphene_simd4f_t * * Since: 1.0 */ float (graphene_simd4f_get_y) (const graphene_simd4f_t s) { return graphene_simd4f_get_y (s); }
static gboolean matrix_decompose_3d (const graphene_matrix_t *m, graphene_point3d_t *scale_r, float shear_r[3], graphene_quaternion_t *rotate_r, graphene_point3d_t *translate_r, graphene_vec4_t *perspective_r) { graphene_matrix_t local, perspective; float shear_xy, shear_xz, shear_yz; float scale_x, scale_y, scale_z; graphene_simd4f_t dot, cross; if (graphene_matrix_get_value (m, 3, 3) == 0.f) return FALSE; local = *m; /* normalize the matrix */ graphene_matrix_normalize (&local, &local); /* perspective is used to solve for the perspective component, * but it also provides an easy way to test for singularity of * the upper 3x3 component */ perspective = local; perspective.value.w = graphene_simd4f_init (0.f, 0.f, 0.f, 1.f); if (graphene_matrix_determinant (&perspective) == 0.f) return FALSE; /* isolate the perspective */ if (graphene_simd4f_is_zero3 (local.value.w)) { graphene_matrix_t tmp; /* perspective_r is the right hand side of the equation */ perspective_r->value = local.value.w; /* solve the equation by inverting perspective and multiplying * the inverse with the perspective vector */ graphene_matrix_inverse (&perspective, &tmp); graphene_matrix_transpose_transform_vec4 (&tmp, perspective_r, perspective_r); /* clear the perspective partition */ local.value.w = graphene_simd4f_init (0.f, 0.f, 0.f, 1.f); } else graphene_vec4_init (perspective_r, 0.f, 0.f, 0.f, 1.f); /* next, take care of the translation partition */ translate_r->x = graphene_simd4f_get_x (local.value.w); translate_r->y = graphene_simd4f_get_y (local.value.w); translate_r->z = graphene_simd4f_get_z (local.value.w); local.value.w = graphene_simd4f_init (0.f, 0.f, 0.f, graphene_simd4f_get_w (local.value.w)); /* now get scale and shear */ /* compute the X scale factor and normalize the first row */ scale_x = graphene_simd4f_get_x (graphene_simd4f_length4 (local.value.x)); local.value.x = graphene_simd4f_div (local.value.x, graphene_simd4f_splat (scale_x)); /* compute XY shear factor and the second row orthogonal to the first */ shear_xy = graphene_simd4f_get_x (graphene_simd4f_dot4 (local.value.x, local.value.y)); local.value.y = graphene_simd4f_sub (local.value.y, graphene_simd4f_mul (local.value.x, graphene_simd4f_splat (shear_xy))); /* now, compute the Y scale factor and normalize the second row */ scale_y = graphene_simd4f_get_x (graphene_simd4f_length4 (local.value.y)); local.value.y = graphene_simd4f_div (local.value.y, graphene_simd4f_splat (scale_y)); shear_xy /= scale_y; /* compute XZ and YZ shears, make the third row orthogonal */ shear_xz = graphene_simd4f_get_x (graphene_simd4f_dot4 (local.value.x, local.value.z)); local.value.z = graphene_simd4f_sub (local.value.z, graphene_simd4f_mul (local.value.x, graphene_simd4f_splat (shear_xz))); shear_yz = graphene_simd4f_get_x (graphene_simd4f_dot4 (local.value.y, local.value.z)); local.value.z = graphene_simd4f_sub (local.value.z, graphene_simd4f_mul (local.value.y, graphene_simd4f_splat (shear_yz))); /* next, get the Z scale and normalize the third row */ scale_z = graphene_simd4f_get_x (graphene_simd4f_length4 (local.value.z)); local.value.z = graphene_simd4f_div (local.value.z, graphene_simd4f_splat (scale_z)); shear_xz /= scale_z; shear_yz /= scale_z; shear_r[XY_SHEAR] = shear_xy; shear_r[XZ_SHEAR] = shear_xz; shear_r[YZ_SHEAR] = shear_yz; /* at this point, the matrix is orthonormal. we check for a * coordinate system flip. if the determinant is -1, then * negate the matrix and the scaling factors */ dot = graphene_simd4f_cross3 (local.value.y, local.value.z); cross = graphene_simd4f_dot4 (local.value.x, dot); if (graphene_simd4f_get_x (cross) < 0.f) { scale_x *= -1.f; scale_y *= -1.f; scale_z *= -1.f; graphene_simd4f_mul (local.value.x, graphene_simd4f_splat (-1.f)); graphene_simd4f_mul (local.value.y, graphene_simd4f_splat (-1.f)); graphene_simd4f_mul (local.value.z, graphene_simd4f_splat (-1.f)); } graphene_point3d_init (scale_r, scale_x, scale_y, scale_z); /* get the rotations out */ graphene_quaternion_init_from_matrix (rotate_r, &local); return TRUE; }
/** * graphene_vec3_get_y: * @v: a #graphene_vec3_t * * Retrieves the second component of the given vector @v. * * Returns: the value of the second component of the vector * * Since: 1.0 */ float graphene_vec3_get_y (const graphene_vec3_t *v) { return graphene_simd4f_get_y (v->value); }
/** * graphene_matrix_get_y_scale: * @m: a #graphene_matrix_t * * Retrieves the scaling factor on the Y axis in @m. * * Returns: the value of the scaling factor * * Since: 1.0 */ float graphene_matrix_get_y_scale (const graphene_matrix_t *m) { return graphene_simd4f_get_y (m->value.y); }