/**
* graphene_euler_to_vec3:
* @e: a #graphene_euler_t
* @res: (out caller-allocates): return location for a #graphene_vec3_t
*
* Retrieves the angles of a #graphene_euler_t and initializes a
* #graphene_vec3_t with them.
*
* Since: 1.2
*/
void
graphene_euler_to_vec3 (const graphene_euler_t *e,
graphene_vec3_t *res)
{
graphene_vec3_init_from_vec3 (res, &e->angles);
graphene_vec3_scale (res, (180.f / GRAPHENE_PI), res);
}
/**
* graphene_ray_init:
* @r: the #graphene_ray_t to initialize
* @origin: (nullable): the origin of the ray
* @direction: (nullable): the direction vector
*
* Initializes the given #graphene_ray_t using the given @origin
* and @direction values.
*
* Returns: (transfer none): the initialized ray
*
* Since: 1.4
*/
graphene_ray_t *
graphene_ray_init (graphene_ray_t *r,
const graphene_point3d_t *origin,
const graphene_vec3_t *direction)
{
if (origin != NULL)
graphene_point3d_to_vec3 (origin, &r->origin);
else
graphene_vec3_init_from_vec3 (&r->origin, graphene_vec3_zero ());
if (direction != NULL)
graphene_vec3_normalize (direction, &r->direction);
else
graphene_vec3_init_from_vec3 (&r->direction, graphene_vec3_zero ());
return r;
}
/**
* graphene_triangle_init_from_point3d:
* @t: the #graphene_triangle_t to initialize
* @a: (nullable): a #graphene_point3d_t
* @b: (nullable): a #graphene_point3d_t
* @c: (nullable): a #graphene_point3d_t
*
* Initializes a #graphene_triangle_t using the three given 3D points.
*
* Returns: (transfer none): the initialized #graphene_triangle_t
*
* Since: 1.2
*/
graphene_triangle_t *
graphene_triangle_init_from_point3d (graphene_triangle_t *t,
const graphene_point3d_t *a,
const graphene_point3d_t *b,
const graphene_point3d_t *c)
{
if (a != NULL)
graphene_point3d_to_vec3 (a, &t->a);
else
graphene_vec3_init_from_vec3 (&t->a, graphene_vec3_zero ());
if (b != NULL)
graphene_point3d_to_vec3 (b, &t->b);
else
graphene_vec3_init_from_vec3 (&t->b, graphene_vec3_zero ());
if (c != NULL)
graphene_point3d_to_vec3 (c, &t->c);
else
graphene_vec3_init_from_vec3 (&t->b, graphene_vec3_zero ());
return t;
}
/**
* graphene_triangle_init_from_vec3:
* @t: the #graphene_triangle_t to initialize
* @a: (nullable): a #graphene_vec3_t
* @b: (nullable): a #graphene_vec3_t
* @c: (nullable): a #graphene_vec3_t
*
* Initializes a #graphene_triangle_t using the three given vectors.
*
* Returns: (transfer none): the initialized #graphene_triangle_t
*
* Since: 1.2
*/
graphene_triangle_t *
graphene_triangle_init_from_vec3 (graphene_triangle_t *t,
const graphene_vec3_t *a,
const graphene_vec3_t *b,
const graphene_vec3_t *c)
{
if (a != NULL)
t->a = *a;
else
graphene_vec3_init_from_vec3 (&t->a, graphene_vec3_zero ());
if (b != NULL)
t->b = *b;
else
graphene_vec3_init_from_vec3 (&t->b, graphene_vec3_zero ());
if (c != NULL)
t->c = *c;
else
graphene_vec3_init_from_vec3 (&t->c, graphene_vec3_zero ());
return t;
}
/**
* graphene_euler_init_from_vec3:
* @e: the #graphene_euler_t to initialize
* @v: (nullable): a #graphene_vec3_t containing the rotation
* angles in degrees
* @order: the order used to apply the rotations
*
* Initializes a #graphene_euler_t using the angles contained in a
* #graphene_vec3_t.
*
* If the #graphene_vec3_t @v is %NULL, the #graphene_euler_t will be
* initialized with all angles set to 0.
*
* Returns: (transfer none): the initialized #graphene_euler_t
*
* Since: 1.2
*/
graphene_euler_t *
graphene_euler_init_from_vec3 (graphene_euler_t *e,
const graphene_vec3_t *v,
graphene_euler_order_t order)
{
if (v != NULL)
graphene_vec3_scale (v, (GRAPHENE_PI / 180.f), &e->angles);
else
graphene_vec3_init_from_vec3 (&e->angles, graphene_vec3_zero ());
e->order = order;
return e;
}
/**
* graphene_triangle_get_normal:
* @t: a #graphene_triangle_t
* @res: (out caller-allocates): return location for the normal vector
*
* Computes the normal vector of the given #graphene_triangle_t.
*
* Since: 1.2
*/
void
graphene_triangle_get_normal (const graphene_triangle_t *t,
graphene_vec3_t *res)
{
graphene_vec3_t v1, v2, tmp;
float length_sq;
graphene_vec3_subtract (&t->c, &t->b, &v1);
graphene_vec3_subtract (&t->a, &t->b, &v2);
graphene_vec3_cross (&v1, &v2, &tmp);
length_sq = graphene_vec3_dot (&tmp, &tmp);
if (length_sq > 0)
graphene_vec3_scale (&tmp, 1.f / sqrtf (length_sq), res);
else
graphene_vec3_init_from_vec3 (res, graphene_vec3_zero ());
}
/**
* graphene_ray_get_closest_point_to_point:
* @r: a #graphene_ray_t
* @p: a #graphene_point3d_t
* @res: (out caller-allocates): return location for the closest point3d
*
* Computes the point on the given #graphene_ray_t that is closest to the
* given point @p.
*
* Since: 1.4
*/
void
graphene_ray_get_closest_point_to_point (const graphene_ray_t *r,
const graphene_point3d_t *p,
graphene_point3d_t *res)
{
graphene_vec3_t point, result;
float distance;
graphene_point3d_to_vec3 (p, &point);
graphene_vec3_subtract (&point, &r->origin, &result);
distance = graphene_vec3_dot (&result, &r->direction);
if (distance < 0)
graphene_vec3_init_from_vec3 (&result, &r->origin);
else
{
graphene_vec3_scale (&r->direction, distance, &result);
graphene_vec3_add (&result, &r->origin, &result);
}
graphene_point3d_init_from_vec3 (res, &result);
}
/**
* graphene_ray_get_direction:
* @r: a #graphene_ray_t
* @direction: (out caller-allocates): return location for the direction
*
* Retrieves the direction of the given #graphene_ray_t.
*
* Since: 1.4
*/
void
graphene_ray_get_direction (const graphene_ray_t *r,
graphene_vec3_t *direction)
{
graphene_vec3_init_from_vec3 (direction, &r->direction);
}
