Barycentric coordinates doesn't always work(3d) - c++

Question

I have a 3d box made of 12 triangles centered at the origin. I launch a ray from the origin to random directions, the goal is to get the face that intersects with the ray.
I do this by searching all the ray/plane intersections and then determining the face their on(if any) with the Barycentric coordinates(u,v,w).
this works correctly only half the time, and generally yields unexpected results:
float triangleAREA(vec3 a, vec3 b, vec3 c)
{
return(length(cross(b-a, c-a)) / 2);
}
int isINtriangle(vec3 a, vec3 b, vec3 c, vec3 p)
{
float total_area = triangleAREA(a, b, c);
float u = triangleAREA(a, b, p);
float v = triangleAREA(a, c, p);
float w = triangleAREA(c, b, p);
if (u + v + w != total_area)
return Ray::_NOintersection;
else
{
if (u == 0 || v == 0 || w == 0)
return Ray::_Onedge_OnVertex;
else
return Ray::_INtriangle;
}
}
this is how I check if the intersection is in the same direction as the ray:
vec3 a = normalize(ray_direction); vec3 b = normalize(intersect);
if (
a.x > b.x - 1 && a.x < b.x + 1 &&
a.z > b.z - 1 && a.z < b.z + 1 &&
a.y > b.y - 1 && a.y < b.y + 1
)
this is all new to me, any help would be awesome !

Answer 1

This code
if (u + v + w != total_area)
is unreliable for floats. Floats don’t work same way as integers, tests for the exact equality rarely make any sense.
You should do something completely different instead. Here’s one method. The code is untested but conceptually it should work, I did similar things many times.
#include <assert.h>
// 0 when [0,p] ray goes through [0,t1,t2] plane.
// Otherwise, the sign tells relative orientation of the ray and the plane.
inline float crossDot( vec3 t1, vec3 t2, vec3 p )
{
// Depending on winding order of triangles, and coordinate system (right versus left handed),
// you may need to flip the cross() arguments
return dot( cross( t1, t2 ), p );
}
// The triangle is [a, b, c], the points must have consistent winding,
// i.e. when viewed from [0,0,0] the order must be either clockwise or counterclockwise,
// for all triangles of your mesh.
// p does not need to be normalized, length is ignored, only direction is used.
int testRayTriangle( vec3 a, vec3 b, vec3 c, vec3 p )
{
// If this assert fails because zero, you have a zero-area triangle, or a triangle that goes through [0,0,0].
// If this assert fails because negative, you need to flip cross() arguments, or fix winding order in the mesh.
assert( crossDot( a, b, c ) > 0 );
const float e1 = crossDot( a, b, p );
const float e2 = crossDot( b, c, p );
const float e3 = crossDot( c, a, p );
if( e1 < 0 || e2 < 0 || e3 < 0 )
return Ray::_NOintersection; // The ray points outwards in relation to some side plane
if( e1 > 0 && e2 > 0 && e3 > 0 )
return Ray::_INtriangle; // The ray points inwards in relation to all 3 side planes
// The ray goes through a side plane
return Ray::_Onedge_OnVertex;
}
The above code assumes eventually you gonna have more complicated meshes than your 12-triangles unit cube. If all you need is unit cube, find longest absolute dimension of your random vector, this + sign of that coordinate will tell you which of the 6 cube planes it gonna intersect. If there’s no longest dimension e.g. your ray direction is [1,1,0] then the ray goes through an edge or vertex of the cube. Otherwise, test 2 other coordinates to find which of the 2 triangles it intersects.