// Intersect ray r with the triangle abc. If it hits returns true,
// and puts the t parameter, barycentric coordinates, normal, object id,
// and object material in the isect object
bool TrimeshFace::intersectLocal( const ray& r, isect& i ) const
{
const Vec3d& a = parent->vertices[ids[0]];
const Vec3d& b = parent->vertices[ids[1]];
const Vec3d& c = parent->vertices[ids[2]];
// tangent vectors
Vec3d t1 = b - a;
Vec3d t2 = c - a;
Vec3d n = crossProd(t1,t2);
double D = -n*a;
// if the surface is parallel to the ray there is no intersection
if(r.getDirection()*n == 0)
{
return false;
}
double t = -(n*r.getPosition() + D)/(n*r.getDirection() );
if (t <= RAY_EPSILON)
return false;
// point of intersection with the same plane (doesn't mean intersection with triangle) p(t)=p+t*d
Vec3d p = r.at(t);
// triangle area
double A = n.length()/2.0;
// barycentric coords
double wa = crossProd(c-b, p-b).length() / (2.0*A);
double wb = crossProd(a-c, p-c).length() / (2.0*A);
double wc = crossProd(b-a, p-a).length() / (2.0*A);
if((wa >= 0.0) && (wb >= 0.0) && (wc >= 0.0) && (wa+wb+wc-1.0 <= 0.00001)) {
i.setT(t);
i.setBary(wa, wb, wc);
if (parent->normals.size() == 0) {
i.setN(n);
} else {
Vec3d inter_n = wa*parent->normals[ids[0]] + wb*parent->normals[ids[1]]
+ wc*parent->normals[ids[2]];
inter_n.normalize();
i.setN(inter_n);
}
i.setObject(this);
if (parent->materials.size() == 0) {
i.setMaterial(this->getMaterial() );
} else {
Material inter_m = wa*(*parent->materials[ids[0]]);
inter_m += wb*(*parent->materials[ids[1]]);
inter_m += wc*(*parent->materials[ids[2]]);
i.setMaterial(inter_m);
}
return true;
}
return false;
}
// Get any intersection with an object. Return information about the
// intersection through the reference parameter.
bool Scene::intersect( const ray& r, isect& i ) const {
double tmin = 0.0;
double tmax = 0.0;
bool have_one = false;
typedef vector<Geometry*>::const_iterator iter;
for( iter j = objects.begin(); j != objects.end(); ++j ) {
isect cur;
if( (*j)->intersect( r, cur ) ) {
if( !have_one || (cur.t < i.t) ) {
i = cur;
have_one = true;
}
}
}
if( !have_one ) i.setT(1000.0);
// if debugging,
intersectCache.push_back( std::make_pair(r,i) );
return have_one;
}
bool Trimesh::intersectLocal(const ray&r, isect&i) const
{
double tmin = 0.0;
double tmax = 0.0;
typedef Faces::const_iterator iter;
bool have_one = false;
for( iter j = faces.begin(); j != faces.end(); ++j ) {
isect cur;
if( (*j)->intersectLocal( r, cur ) )
{
if( !have_one || (cur.t < i.t) )
{
i = cur;
have_one = true;
}
}
}
if( !have_one ) i.setT(1000.0);
return have_one;
}
bool Box::intersectLocal( const ray& r, isect& i ) const
{
Vec3d p = r.getPosition();
Vec3d d = r.getDirection();
int it;
double x, y, t, bestT;
int mod0, mod1, mod2, bestIndex;
bestT = HUGE_DOUBLE;
bestIndex = -1;
for(it=0; it<6; it++){
mod0 = it%3;
if(d[mod0] == 0){
continue;
}
t = ((it/3) - 0.5 - p[mod0]) / d[mod0];
if(t < RAY_EPSILON || t > bestT){
continue;
}
mod1 = (it+1)%3;
mod2 = (it+2)%3;
x = p[mod1]+t*d[mod1];
y = p[mod2]+t*d[mod2];
if( x<=0.5 && x>=-0.5 &&
y<=0.5 && y>=-0.5)
{
if(bestT > t){
bestT = t;
bestIndex = it;
}
}
}
if(bestIndex < 0) return false;
i.setT(bestT);
i.setObject(this);
Vec3d intersect_point = r.at(i.t);
int i1 = (bestIndex + 1) % 3;
int i2 = (bestIndex + 2) % 3;
if(bestIndex < 3)
{
i.setN(Vec3d(-double(bestIndex == 0), -double(bestIndex == 1), -double(bestIndex == 2)));
i.setUVCoordinates( Vec2d( 0.5 - intersect_point[ min(i1, i2) ],
0.5 + intersect_point[ max(i1, i2) ] ) );
}
else
{
i.setN(Vec3d(double(bestIndex==3), double(bestIndex == 4), double(bestIndex == 5)));
i.setUVCoordinates( Vec2d( 0.5 + intersect_point[ min(i1, i2) ],
0.5 + intersect_point[ max(i1, i2) ] ) );
}
return true;
}
bool Cone::intersectLocal(ray& r, isect& i) const
{
bool ret = false;
const int x = 0, y = 1, z = 2; // For the dumb array indexes for the vectors
Vec3d normal;
Vec3d R0 = r.getPosition();
Vec3d Rd = r.getDirection();
double pz = R0[2];
double dz = Rd[2];
double a = Rd[x]*Rd[x] + Rd[y]*Rd[y] - beta_squared * Rd[z]*Rd[z];
if( a == 0.0) return false; // We're in the x-y plane, no intersection
double b = 2 * (R0[x]*Rd[x] + R0[y]*Rd[y] - beta_squared * ((R0[z] + gamma) * Rd[z]));
double c = -beta_squared*(gamma + R0[z])*(gamma + R0[z]) + R0[x] * R0[x] + R0[y] * R0[y];
double discriminant = b * b - 4 * a * c;
double farRoot, nearRoot, theRoot = RAY_EPSILON;
bool farGood, nearGood;
if(discriminant <= 0) return false; // No intersection
discriminant = sqrt(discriminant);
// We have two roots, so calculate them
nearRoot = (-b + discriminant) / ( 2 * a );
farRoot = (-b - discriminant) / ( 2 * a );
// This is confusing, but it figures out which
// root is closer and puts into theRoot
nearGood = isGoodRoot(r.at(nearRoot));
if(nearGood && (nearRoot > theRoot))
{
theRoot = nearRoot;
normal = Vec3d((r.at(theRoot))[x], (r.at(theRoot))[y], -2.0 * beta_squared * (r.at(theRoot)[z] + gamma));
}
farGood = isGoodRoot(r.at(farRoot));
if(farGood && ( (nearGood && farRoot < theRoot) || farRoot > RAY_EPSILON) )
{
theRoot = farRoot;
normal = Vec3d((r.at(theRoot))[x], (r.at(theRoot))[y], -2.0 * beta_squared * (r.at(theRoot)[z] + gamma));
}
// In case we are _inside_ the _uncapped_ cone, we need to flip the normal.
// Essentially, the cone in this case is a double-sided surface
// and has _2_ normals
if( !capped && (normal * r.getDirection()) > 0 )
normal = -normal;
// These are to help with finding caps
double t1 = (-pz)/dz;
double t2 = (height-pz)/dz;
Vec3d p( r.at( t1 ) );
if(capped) {
if( p[0]*p[0] + p[1]*p[1] <= b_radius*b_radius)
{
if(t1 < theRoot && t1 > RAY_EPSILON)
{
theRoot = t1;
if( dz > 0.0 ) {
// Intersection with cap at z = 0.
normal = Vec3d( 0.0, 0.0, -1.0 );
} else {
normal = Vec3d( 0.0, 0.0, 1.0 );
}
}
}
Vec3d q( r.at( t2 ) );
if( q[0]*q[0] + q[1]*q[1] <= t_radius*t_radius)
{
if(t2 < theRoot && t2 > RAY_EPSILON)
{
theRoot = t2;
if( dz > 0.0 ) {
// Intersection with interior of cap at z = 1.
normal = Vec3d( 0.0, 0.0, 1.0 );
} else {
normal = Vec3d( 0.0, 0.0, -1.0 );
}
}
}
}
if(theRoot <= RAY_EPSILON) return false;
i.setT(theRoot);
normal.normalize();
i.setN(normal);
i.obj = this;
i.setMaterial(this->getMaterial());
return true;
return ret;
}
