bool AtlasGeomChunkTracer::castLeafRay(const Point2I pos, const Point3F &start,
const Point3F &end, const F32 &startT,
const F32 &endT, RayInfo *info)
{
if(AtlasInstance::smRayCollisionDebugLevel == AtlasInstance::RayCollisionDebugToColTree)
{
const F32 invSize = 1.f / F32(BIT(mTreeDepth-1));
// This is a bit of a hack. But good for testing.
// Do collision against the collision tree leaf bounding box and return the result...
F32 t; Point3F n;
Box3F box;
box.minExtents.set(Point3F(F32(pos.x ) * invSize, F32(pos.y ) * invSize, getSquareMin(0, pos)));
box.maxExtents.set(Point3F(F32(pos.x+1) * invSize, F32(pos.y+1) * invSize, getSquareMax(0, pos)));
//Con::printf(" checking at xy = {%f, %f}->{%f, %f}, [%d, %d]", start.x, start.y, end.x, end.y, pos.x, pos.y);
if(box.collideLine(start, end, &t, &n) && t >= startT && t <= endT)
{
info->t = t;
info->normal = n;
return true;
}
return false;
}
else if( AtlasInstance::smRayCollisionDebugLevel == AtlasInstance::RayCollisionDebugToMesh )
{
bool haveHit = false;
U32 currentIdx = 0;
U32 numIdx = mChunk->mIndexCount;
F32 bestT = F32_MAX;
U32 bestTri = -1;
Point2F bestBary;
while( !haveHit && currentIdx < numIdx )
{
const Point3F& a = mChunk->mVert[ mChunk->mIndex[ currentIdx ] ].point;
const Point3F& b = mChunk->mVert[ mChunk->mIndex[ currentIdx + 1 ] ].point;
const Point3F& c = mChunk->mVert[ mChunk->mIndex[ currentIdx + 2 ] ].point;
F32 localT;
Point2F localBary;
// Do the cast, using our conveniently precalculated ray delta...
if(castRayTriangle(mRayStart, mRayDelta, a,b,c, localT, localBary))
{
if(localT < bestT)
{
// And it hit before anything else we've seen.
bestTri = currentIdx;
bestT = localT;
bestBary = localBary;
haveHit = true;
}
}
currentIdx += 3;
}
// Fill in extra info for the hit.
if(!haveHit)
return false;
// Calculate the normal, we skip that for the initial check.
Point3F norm; // Hi norm!
const Point3F &a = mChunk->mVert[mChunk->mIndex[bestTri+0]].point;
const Point3F &b = mChunk->mVert[mChunk->mIndex[bestTri+1]].point;
const Point3F &c = mChunk->mVert[mChunk->mIndex[bestTri+2]].point;
const Point2F &aTC = mChunk->mVert[mChunk->mIndex[bestTri+0]].texCoord;
const Point2F &bTC = mChunk->mVert[mChunk->mIndex[bestTri+1]].texCoord;
const Point2F &cTC = mChunk->mVert[mChunk->mIndex[bestTri+2]].texCoord;
// Store everything relevant into the info structure.
info->t = bestT;
const Point3F e0 = b-a;
const Point3F e1 = c-a;
info->normal = mCross(e1, e0);
info->normal.normalize();
// Calculate and store the texture coords.
const Point2F e0TC = bTC-aTC;
const Point2F e1TC = cTC-aTC;
info->texCoord = e0TC * bestBary.x + e1TC * bestBary.y + aTC;
// Return true, we hit something!
return true;
}
else
{
// Get the triangle list...
U16 *triOffset = mChunk->mColIndicesBuffer +
mChunk->mColIndicesOffsets[pos.x * BIT(mChunk->mColTreeDepth-1) + pos.y];
// Store best hit results...
bool gotHit = false;
F32 bestT = F32_MAX;
U16 bestTri = -1, offset;
Point2F bestBary;
while((offset = *triOffset) != 0xFFFF)
{
// Advance to the next triangle..
triOffset++;
// Get each triangle, and do a raycast against it.
Point3F a,b,c;
AssertFatal(offset < mChunk->mIndexCount,
"AtlasGeomTracer2::castLeafRay - offset past end of index list.");
a = mChunk->mVert[mChunk->mIndex[offset+0]].point;
b = mChunk->mVert[mChunk->mIndex[offset+1]].point;
c = mChunk->mVert[mChunk->mIndex[offset+2]].point;
/*Con::printf(" o testing triangle %d ({%f,%f,%f},{%f,%f,%f},{%f,%f,%f})",
offset, a.x, a.y, a.z, b.x, b.y, b.z, c.x, c.y, c.z); */
F32 localT;
Point2F localBary;
// Do the cast, using our conveniently precalculated ray delta...
if(castRayTriangle(mRayStart, mRayDelta, a,b,c, localT, localBary))
{
//Con::printf(" - hit triangle %d at t=%f", offset, localT);
// The ray intersected, but we have to make sure we hit actually on
// the line segment. (ie, a ray isn't a ray, Ray.)
// BJGTODO - This should prevent some nasty edge cases, but we
// seem to be calculating the wrong start and end T's.
// So I've disabled this for now but it will cause
// problems later!
//if(localT < startT || localT > endT)
// continue;
// It really, really hit, wow!
if(localT < bestT)
{
// And it hit before anything else we've seen.
bestTri = offset;
bestT = localT;
bestBary = localBary;
gotHit = true;
}
}
else
{
//Con::printf(" - didn't hit triangle %d at t=%f", offset, localT);
}
}
// Fill in extra info for the hit.
if(!gotHit)
return false;
// Calculate the normal, we skip that for the initial check.
Point3F norm; // Hi norm!
const Point3F &a = mChunk->mVert[mChunk->mIndex[bestTri+0]].point;
const Point3F &b = mChunk->mVert[mChunk->mIndex[bestTri+1]].point;
const Point3F &c = mChunk->mVert[mChunk->mIndex[bestTri+2]].point;
const Point2F &aTC = mChunk->mVert[mChunk->mIndex[bestTri+0]].texCoord;
const Point2F &bTC = mChunk->mVert[mChunk->mIndex[bestTri+1]].texCoord;
const Point2F &cTC = mChunk->mVert[mChunk->mIndex[bestTri+2]].texCoord;
// Store everything relevant into the info structure.
info->t = bestT;
const Point3F e0 = b-a;
const Point3F e1 = c-a;
info->normal = mCross(e1, e0);
info->normal.normalize();
// Calculate and store the texture coords.
const Point2F e0TC = bTC-aTC;
const Point2F e1TC = cTC-aTC;
info->texCoord = e0TC * bestBary.x + e1TC * bestBary.y + aTC;
// Return true, we hit something!
return true;
}
}
