In all definitions I can find of Barycentric coordinates they:

- Can not be negative numbers
- Always sum to 1

If you take a look below where w1 & w2 are calculated, you’ll see a third number w0 that is commented out. This looks to be the Barycentric coordinates that are calculated in Ray.class. Even leaving w0 uncommented and only taking a look at w1 & w2, I’m thinking these are wrong, because they do indeed return negative numbers. As far as I can tell, the output always sums to one… but not in a nonsensical manor, like (for instance):

(w0, w1, w2)

(-11.157536, 11.193249, 0.96428657)

You’ll also notice in the comments above w1, w2 this:

// these weights can be used to determine

// interpolated values, such as texture coord.

// eg. texcoord s,t at intersection point:

// s = w0*s0 + w1*s1 + w2*s2;
// t = w0*t0 + w1

*t1 + w2*t2;

Has anyone actually tried doing this? because it WILL NOT produce even remotely close results in its current form.

Here is the method from Ray.class in question:

[java]

private boolean intersects(Vector3f v0, Vector3f v1, Vector3f v2,

Vector3f store, boolean doPlanar, boolean quad) {

TempVars vars = TempVars.get();

```
Vector3f tempVa = vars.vect1,
tempVb = vars.vect2,
tempVc = vars.vect3,
tempVd = vars.vect4;
Vector3f diff = origin.subtract(v0, tempVa);
Vector3f edge1 = v1.subtract(v0, tempVb);
Vector3f edge2 = v2.subtract(v0, tempVc);
Vector3f norm = edge1.cross(edge2, tempVd);
float dirDotNorm = direction.dot(norm);
float sign;
if (dirDotNorm > FastMath.FLT_EPSILON) {
sign = 1;
} else if (dirDotNorm < -FastMath.FLT_EPSILON) {
sign = -1f;
dirDotNorm = -dirDotNorm;
} else {
// ray and triangle/quad are parallel
vars.release();
return false;
}
float dirDotDiffxEdge2 = sign * direction.dot(diff.cross(edge2, edge2));
if (dirDotDiffxEdge2 >= 0.0f) {
float dirDotEdge1xDiff = sign
* direction.dot(edge1.crossLocal(diff));
if (dirDotEdge1xDiff >= 0.0f) {
if (!quad ? dirDotDiffxEdge2 + dirDotEdge1xDiff <= dirDotNorm : dirDotEdge1xDiff <= dirDotNorm) {
float diffDotNorm = -sign * diff.dot(norm);
if (diffDotNorm >= 0.0f) {
// this method always returns
vars.release();
// ray intersects triangle
// if storage vector is null, just return true,
if (store == null) {
return true;
}
// else fill in.
float inv = 1f / dirDotNorm;
float t = diffDotNorm * inv;
if (!doPlanar) {
store.set(origin).addLocal(direction.x * t,
direction.y * t, direction.z * t);
} else {
// these weights can be used to determine
// interpolated values, such as texture coord.
// eg. texcoord s,t at intersection point:
// s = w0*s0 + w1*s1 + w2*s2;
// t = w0*t0 + w1*t1 + w2*t2;
float w1 = dirDotDiffxEdge2 * inv;
float w2 = dirDotEdge1xDiff * inv;
//float w0 = 1.0f - w1 - w2;
store.set(t, w1, w2);
}
return true;
}
}
}
}
vars.release();
return false;
}
```

[/java]