bool Disk::Intersect(const Ray &r, float *tHit, float *rayEpsilon,
DifferentialGeometry *dg) const {
// Transform _Ray_ to object space
Ray ray;
(*WorldToObject)(r, &ray);
// Compute plane intersection for disk
if (fabsf(ray.d.z) < 1e-7) return false;
float thit = (height - ray.o.z) / ray.d.z;
if (thit < ray.mint || thit > ray.maxt)
return false;
// See if hit point is inside disk radii and $\phimax$
Point phit = ray(thit);
float dist2 = phit.x * phit.x + phit.y * phit.y;
if (dist2 > radius * radius || dist2 < innerRadius * innerRadius)
return false;
// Test disk $\phi$ value against $\phimax$
float phi = atan2f(phit.y, phit.x);
if (phi < 0) phi += 2. * M_PI;
if (phi > phiMax)
return false;
// Find parametric representation of disk hit
float u = phi / phiMax;
float oneMinusV = ((sqrtf(dist2)-innerRadius) /
(radius-innerRadius));
float invOneMinusV = (oneMinusV > 0.f) ? (1.f / oneMinusV) : 0.f;
float v = 1.f - oneMinusV;
Vector dpdu(-phiMax * phit.y, phiMax * phit.x, 0.);
Vector dpdv(-phit.x * invOneMinusV, -phit.y * invOneMinusV, 0.);
dpdu *= phiMax * INV_TWOPI;
dpdv *= (radius - innerRadius) / radius;
Normal dndu(0,0,0), dndv(0,0,0);
// Initialize _DifferentialGeometry_ from parametric information
const Transform &o2w = *ObjectToWorld;
*dg = DifferentialGeometry(o2w(phit), o2w(dpdu), o2w(dpdv),
o2w(dndu), o2w(dndv), u, v, this);
// Update _tHit_ for quadric intersection
*tHit = thit;
// Compute _rayEpsilon_ for quadric intersection
*rayEpsilon = 5e-4f * *tHit;
return true;
}
bool DistanceEstimator::Intersect(const Ray &r, float *tHit, float *rayEpsilon,
DifferentialGeometry *dg) const {
bool succeed = DoesIntersect(r, tHit);
if (!succeed) return false;
Ray ray;
(*WorldToObject)(r, &ray);
Point p = ray(*tHit);
*rayEpsilon = DE_params.hitEpsilon * DE_params.rayEpsilonMultiplier;
Vector n = CalculateNormal(p, DE_params.normalEpsilon);
Vector DPDU, DPDV;
CoordinateSystem(n, &DPDU, &DPDV);
const Transform &o2w = *ObjectToWorld;
*dg = DifferentialGeometry(o2w(p), o2w(DPDU), o2w(DPDV), Normal(), Normal(), 0, 0, this);
return true;
}
bool Sphere::intersect(const Ray& ray, RaySurfIntersection& res)const{
res.shp = NULL;
//Transform ray to object space
const Ray rOb = w2o(ray);
const Vector o = Vector(rOb.getOrigin().x, rOb.getOrigin().y, rOb.getOrigin().z);
const Vector d = rOb.getDir();
const float A = d.dot(d);
const float B = 2.0f * (d.dot(o));
const float C = o.dot(o) - (r * r);
struct MathUtils::QuadraticEqnRes<float> slv =
MathUtils::solveQuadratic<float>(A, B, C);
float tHitFinal = 0.0f; //After the below code this will eventually be set to
//the first hit point in front of the camera
if(slv.solCount == 0){
return false;
}else if(slv.solCount == 1){
tHitFinal = slv.sol1;
if(tHitFinal < 0.0f){
//No solutions in front of camera
return false;
}
}else{ //2 solutions
//Find smallest t value that is > 0.0f
if(slv.sol1 < 0.0f && slv.sol2 < 0.0f){
//No solutions in front of camera
return false;
}else{
//At least one hit in front of camera
slv.sol1 = slv.sol1 < 0.0f ? Constants::MAX_FLOAT_VAL : slv.sol1;
slv.sol2 = slv.sol2 < 0.0f ? Constants::MAX_FLOAT_VAL : slv.sol2;
tHitFinal = std::min<float>(slv.sol1, slv.sol2);
}
}
//Make sure hit is in front of camera
Assert(tHitFinal >= 0.0f);
res.tHit = tHitFinal;
res.locWS = ray(res.tHit);
Vector normalVecAtHit = res.locWS - o2w(Point(0.0f,0.0f,0.0f));
res.n = normalVecAtHit.getNormalized();
res.shp = this;
return true;
}
bool Sphere::Intersect(const Ray &r, Float *distance, Float *rayEpsilon,
DifferentialGeometry *dg) const {
Ray ray;
(*worldToLocal)(r, &ray);
// Compute quadratic sphere coefficients
Float A = ray.d.x * ray.d.x + ray.d.y * ray.d.y + ray.d.z * ray.d.z;
Float B = 2 * (ray.d.x * ray.o.x + ray.d.y * ray.o.y + ray.d.z * ray.o.z);
Float C = ray.o.x * ray.o.x + ray.o.y * ray.o.y + ray.o.z * ray.o.z
- mRad * mRad;
Float t0, t1;
if (!Quadratic(A, B, C, &t0, &t1))
return false;
// Compute intersection distance along ray
if (t0 > ray.maxT || t1 < ray.minT)
return false;
Float thit = t0;
if (t0 < ray.minT) {
thit = t1;
if (thit > ray.maxT)
return false;
}
//这里开始计算参数化变量
//计算phi
Point phit;
Float phi;
phit = ray(thit);
if (phit.x == 0.f && phit.y == 0.f)
phit.x = 1e-5f * mRad; //排除除零的情况
phi = atan2f(phit.y, phit.x);
if (phi < 0.)
phi += 2.f * Pi; //保证phi在2PI之中
//判断是否在Z坐标之间的裁剪空间中
if ((mZMin > -mRad && phit.z < mZMin) || (mZMax < mRad && phit.z > mZMax)
|| phi > mPhiMax) {
if (thit == t1)
return false;
if (t1 > ray.maxT)
return false;
thit = t1;
phit = ray(thit);
if (phit.x == 0.f && phit.y == 0.f)
phit.x = 1e-5f * mRad;
phi = atan2f(phit.y, phit.x);
if (phi < 0.)
phi += 2.f * Pi;
if ((mZMin > -mRad && phit.z < mZMin)
|| (mZMax < mRad && phit.z > mZMax) || phi > mPhiMax)
return false;
}
// Find parametric representation of sphere hit
//寻找参数化的u和v
Float u = phi / mPhiMax;
Float theta = acosf(Clamp(phit.z / mRad, -1.f, 1.f));
Float v = (theta - mThetaMin) / (mThetaMax - mThetaMin);
// 计算偏导 偏导还不是很熟悉,所以这里照搬了PBRT的公式,详细公式可以查阅PBRT
Float zradius = sqrtf(phit.x * phit.x + phit.y * phit.y);
Float invzradius = 1.f / zradius;
Float cosphi = phit.x * invzradius;
Float sinphi = phit.y * invzradius;
Vector3f dpdu(-mPhiMax * phit.y, mPhiMax * phit.x, 0);
Vector3f dpdv = (mThetaMax - mThetaMin)
* Vector3f(phit.z * cosphi, phit.z * sinphi, -mRad * sinf(theta));
//计算法线的偏导
Vector3f d2Pduu = -mPhiMax * mPhiMax * Vector3f(phit.x, phit.y, 0);
Vector3f d2Pduv = (mThetaMax - mThetaMin) * phit.z * mPhiMax
* Vector3f(-sinphi, cosphi, 0.);
Vector3f d2Pdvv = -(mThetaMax - mThetaMin) * (mThetaMax - mThetaMin)
* Vector3f(phit.x, phit.y, phit.z);
Float E = Dot(dpdu, dpdu);
Float F = Dot(dpdu, dpdv);
Float G = Dot(dpdv, dpdv);
Vector3f N = Normalize(Cross(dpdu, dpdv));
Float e = Dot(N, d2Pduu);
Float f = Dot(N, d2Pduv);
Float g = Dot(N, d2Pdvv);
Float invEGF2 = 1.f / (E * G - F * F);
Normal dndu = Normal(
(f * F - e * G) * invEGF2 * dpdu
+ (e * F - f * E) * invEGF2 * dpdv);
Normal dndv = Normal(
(g * F - f * G) * invEGF2 * dpdu
+ (f * F - g * E) * invEGF2 * dpdv);
const Transform &o2w = *localToWorld;
*dg = DifferentialGeometry(o2w(phit), o2w(dpdu), o2w(dpdv), o2w(dndu),
o2w(dndv), u, v, this);
*distance = thit;
*rayEpsilon = 5e-4f * *distance; //交点处的Float误差
return true;
}
// 1. -- intersection or not.
// 2. -- fill differentialGeometry
bool Sphere::Intersect(const Ray &r, float *tHit, float *rayEpsilon,
DifferentialGeometry *dg) const {
float phi;
Point phit;
// Transform _Ray_ to object space
Ray ray;
(*WorldToObject)(r, &ray);
// 1. -- intersection or not.
// Compute quadratic sphere coefficients
float A = ray.d.x*ray.d.x + ray.d.y*ray.d.y + ray.d.z*ray.d.z;
float B = 2 * (ray.d.x*ray.o.x + ray.d.y*ray.o.y + ray.d.z*ray.o.z);
float C = ray.o.x*ray.o.x + ray.o.y*ray.o.y +
ray.o.z*ray.o.z - radius*radius;
// Solve quadratic equation for _t_ values
float t0, t1;
if (!Quadratic(A, B, C, &t0, &t1)) // in pbrt.h: Find quadratic discriminant
return false;
// Compute intersection distance along ray
if (t0 > ray.maxt || t1 < ray.mint)
return false;
float thit = t0;
if (t0 < ray.mint) {
thit = t1;
if (thit > ray.maxt) return false;
}
// Compute sphere hit position and $\phi$
phit = ray(thit);
if (phit.x == 0.f && phit.y == 0.f) phit.x = 1e-5f * radius;
phi = atan2f(phit.y, phit.x);
if (phi < 0.) phi += 2.f*M_PI;
// Test sphere intersection against clipping parameters
if ((zmin > -radius && phit.z < zmin) ||
(zmax < radius && phit.z > zmax) || phi > phiMax) {
if (thit == t1) return false;
if (t1 > ray.maxt) return false;
thit = t1;
// Compute sphere hit position and $\phi$
phit = ray(thit);
if (phit.x == 0.f && phit.y == 0.f) phit.x = 1e-5f * radius;
phi = atan2f(phit.y, phit.x);
if (phi < 0.) phi += 2.f*M_PI;
if ((zmin > -radius && phit.z < zmin) ||
(zmax < radius && phit.z > zmax) || phi > phiMax)
return false;
}
// 2. -- fill differentialGeometry
// Find parametric representation of sphere hit
float u = phi / phiMax;
float theta = acosf(Clamp(phit.z / radius, -1.f, 1.f));
float v = (theta - thetaMin) / (thetaMax - thetaMin);
// Compute sphere $\dpdu$ and $\dpdv$
float zradius = sqrtf(phit.x*phit.x + phit.y*phit.y);
float invzradius = 1.f / zradius;
float cosphi = phit.x * invzradius;
float sinphi = phit.y * invzradius;
Vector dpdu(-phiMax * phit.y, phiMax * phit.x, 0);
Vector dpdv = (thetaMax-thetaMin) *
Vector(phit.z * cosphi, phit.z * sinphi,
-radius * sinf(theta));
// Compute sphere $\dndu$ and $\dndv$
Vector d2Pduu = -phiMax * phiMax * Vector(phit.x, phit.y, 0);
Vector d2Pduv = (thetaMax - thetaMin) * phit.z * phiMax *
Vector(-sinphi, cosphi, 0.);
Vector d2Pdvv = -(thetaMax - thetaMin) * (thetaMax - thetaMin) *
Vector(phit.x, phit.y, phit.z);
// Compute coefficients for fundamental forms
float E = Dot(dpdu, dpdu);
float F = Dot(dpdu, dpdv);
float G = Dot(dpdv, dpdv);
Vector N = Normalize(Cross(dpdu, dpdv));
float e = Dot(N, d2Pduu);
float f = Dot(N, d2Pduv);
float g = Dot(N, d2Pdvv);
// Compute $\dndu$ and $\dndv$ from fundamental form coefficients
float invEGF2 = 1.f / (E*G - F*F);
Normal dndu = Normal((f*F - e*G) * invEGF2 * dpdu +
(e*F - f*E) * invEGF2 * dpdv);
Normal dndv = Normal((g*F - f*G) * invEGF2 * dpdu +
(f*F - g*E) * invEGF2 * dpdv);
// Initialize _DifferentialGeometry_ from parametric information
const Transform &o2w = *ObjectToWorld;
*dg = DifferentialGeometry(o2w(phit), o2w(dpdu), o2w(dpdv),
o2w(dndu), o2w(dndv), u, v, this);
// Update _tHit_ for quadric intersection
*tHit = thit;
// Compute _rayEpsilon_ for quadric intersection
*rayEpsilon = 5e-4f * *tHit;
return true;
}
bool Cone::Intersect(const Ray &r, float *tHit, float *rayEpsilon,
DifferentialGeometry *dg) const {
float phi;
pbrt::Point phit;
// Transform _Ray_ to object space
Ray ray;
(*WorldToObject)(r, &ray);
// Compute quadratic cone coefficients
float k = radius / height;
k = k*k;
float A = ray.d.x * ray.d.x + ray.d.y * ray.d.y -
k * ray.d.z * ray.d.z;
float B = 2 * (ray.d.x * ray.o.x + ray.d.y * ray.o.y -
k * ray.d.z * (ray.o.z-height) );
float C = ray.o.x * ray.o.x + ray.o.y * ray.o.y -
k * (ray.o.z -height) * (ray.o.z-height);
// Solve quadratic equation for _t_ values
float t0, t1;
if (!Quadratic(A, B, C, &t0, &t1))
return false;
// Compute intersection distance along ray
if (t0 > ray.maxt || t1 < ray.mint)
return false;
float thit = t0;
if (t0 < ray.mint) {
thit = t1;
if (thit > ray.maxt) return false;
}
// Compute cone inverse mapping
phit = ray(thit);
phi = atan2f(phit.y, phit.x);
if (phi < 0.) phi += 2.f*M_PI;
// Test cone intersection against clipping parameters
if (phit.z < 0 || phit.z > height || phi > phiMax) {
if (thit == t1) return false;
thit = t1;
if (t1 > ray.maxt) return false;
// Compute cone inverse mapping
phit = ray(thit);
phi = atan2f(phit.y, phit.x);
if (phi < 0.) phi += 2.f*M_PI;
if (phit.z < 0 || phit.z > height || phi > phiMax)
return false;
}
// Find parametric representation of cone hit
float u = phi / phiMax;
float v = phit.z / height;
// Compute cone $\dpdu$ and $\dpdv$
Vector dpdu(-phiMax * phit.y, phiMax * phit.x, 0);
Vector dpdv(-phit.x / (1.f - v),
-phit.y / (1.f - v), height);
// Compute cone $\dndu$ and $\dndv$
Vector d2Pduu = -phiMax * phiMax *
Vector(phit.x, phit.y, 0.);
Vector d2Pduv = phiMax / (1.f - v) *
Vector(phit.y, -phit.x, 0.);
Vector d2Pdvv(0, 0, 0);
// Compute coefficients for fundamental forms
float E = Dot(dpdu, dpdu);
float F = Dot(dpdu, dpdv);
float G = Dot(dpdv, dpdv);
Vector N = Normalize(Cross(dpdu, dpdv));
float e = Dot(N, d2Pduu);
float f = Dot(N, d2Pduv);
float g = Dot(N, d2Pdvv);
// Compute $\dndu$ and $\dndv$ from fundamental form coefficients
float invEGF2 = 1.f / (E*G - F*F);
Normal dndu = Normal((f*F - e*G) * invEGF2 * dpdu +
(e*F - f*E) * invEGF2 * dpdv);
Normal dndv = Normal((g*F - f*G) * invEGF2 * dpdu +
(f*F - g*E) * invEGF2 * dpdv);
// Initialize _DifferentialGeometry_ from parametric information
const Transform &o2w = *ObjectToWorld;
*dg = DifferentialGeometry(o2w(phit), o2w(dpdu), o2w(dpdv),
o2w(dndu), o2w(dndv), u, v, this);
// Update _tHit_ for quadric intersection
*tHit = thit;
// Compute _rayEpsilon_ for quadric intersection
*rayEpsilon = 5e-4f * *tHit;
return true;
}
bool Hyperboloid::Intersect(const Ray &r, float *tHit,
float *rayEpsilon, DifferentialGeometry *dg) const {
float phi, v;
Point phit;
// Transform _Ray_ to object space
Ray ray;
(*WorldToObject)(r, &ray);
// Compute quadratic hyperboloid coefficients
float A = a*ray.d.x*ray.d.x +
a*ray.d.y*ray.d.y -
c*ray.d.z*ray.d.z;
float B = 2.f * (a*ray.d.x*ray.o.x +
a*ray.d.y*ray.o.y -
c*ray.d.z*ray.o.z);
float C = a*ray.o.x*ray.o.x +
a*ray.o.y*ray.o.y -
c*ray.o.z*ray.o.z - 1;
// Solve quadratic equation for _t_ values
float t0, t1;
if (!Quadratic(A, B, C, &t0, &t1))
return false;
// Compute intersection distance along ray
if (t0 > ray.maxt || t1 < ray.mint)
return false;
float thit = t0;
if (t0 < ray.mint) {
thit = t1;
if (thit > ray.maxt) return false;
}
// Compute hyperboloid inverse mapping
phit = ray(thit);
v = (phit.z - p1.z)/(p2.z - p1.z);
Point pr = (1.f-v) * p1 + v * p2;
phi = atan2f(pr.x*phit.y - phit.x*pr.y,
phit.x*pr.x + phit.y*pr.y);
if (phi < 0)
phi += 2*M_PI;
// Test hyperboloid intersection against clipping parameters
if (phit.z < zmin || phit.z > zmax || phi > phiMax) {
if (thit == t1) return false;
thit = t1;
if (t1 > ray.maxt) return false;
// Compute hyperboloid inverse mapping
phit = ray(thit);
v = (phit.z - p1.z)/(p2.z - p1.z);
Point pr = (1.f-v) * p1 + v * p2;
phi = atan2f(pr.x*phit.y - phit.x*pr.y,
phit.x*pr.x + phit.y*pr.y);
if (phi < 0)
phi += 2*M_PI;
if (phit.z < zmin || phit.z > zmax || phi > phiMax)
return false;
}
// Compute parametric representation of hyperboloid hit
float u = phi / phiMax;
// Compute hyperboloid $\dpdu$ and $\dpdv$
float cosphi = cosf(phi), sinphi = sinf(phi);
Vector dpdu(-phiMax * phit.y, phiMax * phit.x, 0.);
Vector dpdv((p2.x-p1.x) * cosphi - (p2.y-p1.y) * sinphi,
(p2.x-p1.x) * sinphi + (p2.y-p1.y) * cosphi,
p2.z-p1.z);
// Compute hyperboloid $\dndu$ and $\dndv$
Vector d2Pduu = -phiMax * phiMax *
Vector(phit.x, phit.y, 0);
Vector d2Pduv = phiMax *
Vector(-dpdv.y, dpdv.x, 0.);
Vector d2Pdvv(0, 0, 0);
// Compute coefficients for fundamental forms
float E = Dot(dpdu, dpdu);
float F = Dot(dpdu, dpdv);
float G = Dot(dpdv, dpdv);
Vector N = Normalize(Cross(dpdu, dpdv));
float e = Dot(N, d2Pduu);
float f = Dot(N, d2Pduv);
float g = Dot(N, d2Pdvv);
// Compute $\dndu$ and $\dndv$ from fundamental form coefficients
float invEGF2 = 1.f / (E*G - F*F);
Normal dndu = Normal((f*F - e*G) * invEGF2 * dpdu +
(e*F - f*E) * invEGF2 * dpdv);
Normal dndv = Normal((g*F - f*G) * invEGF2 * dpdu +
(f*F - g*E) * invEGF2 * dpdv);
// Initialize _DifferentialGeometry_ from parametric information
const Transform &o2w = *ObjectToWorld;
*dg = DifferentialGeometry(o2w(phit), o2w(dpdu), o2w(dpdv),
o2w(dndu), o2w(dndv), u, v, this);
// Update _tHit_ for quadric intersection
*tHit = thit;
// Compute _rayEpsilon_ for quadric intersection
*rayEpsilon = 5e-4f * *tHit;
return true;
}
bool Rectangle::Intersect(const Ray &r, float *tHit, float *rayEpsilon,
DifferentialGeometry *dg) const {
// Transform _Ray_ to object space
Ray ray;
(*WorldToObject)(r, &ray);
// Compute plane intersection for disk
// Checks if the plane is parallel to the ray or not
// We can get the direction of the ray
// If the Z component of the direction of the ray is zero
// then, the ray is parallel to the plane and in such case
// there is no intersection point between the ray and the plane.
if (fabsf(ray.d.z) < 1e-7)
return false;
// Now, the direction of the ray is not parallel to the plane
// We have to check if the intersection happens or not
// We have to compute the parametric t where the ray intersects the plane
// We want to find t such that the z-component of the ray intersects the plane
// The ray "line" equation is l = l0 + (l1 - l0) * t
// l1 - l0 will give us the distance between the two points on the plane
// Then t is the ratio and in such case it should be between 0 and 1
// Considering that the rectangle completely lies in the z plane
/// distance = l1 - l0
/// thit = (l - l0) / distance
// But since we assume that the plane is located at height
// Then, the point l is at height on the plane
/// l = height
float thit = (height - ray.o.z) / ray.d.z;
// Then we check if the thit is between the ratio of 0 and 1 that is mapped
// between ray.mint and ray.maxt, if not retrun false
if (thit < ray.mint || thit > ray.maxt)
return false;
// Then we see if the point lies inside the disk or not
// Substitute the thit in the ray equation to get hit point on the ray
Point phit = ray(thit);
// We have to make sure that the interesction lies inside the plane
if (!(phit.x < x/2 && phit.x > -x/2 && phit.y < y/2 && phit.y > -y/2))
return false;
// Assuming that the plane is formed from the following 4 points
// P0, P1, P2, P3
//
// p0 *---------------* p1
// | |
// | |
// | |
// | O |
// | |
// | |
// | |
// p2 *---------------* p3 -> X
//
// P0 @ (-x/2, y/2)
// P1 @ (x/2, y/2)
// P2 @ (-x/2, -y/2)
// P3 @ (x/2, -y/2)
Point P0(-x/2, y/2, height), P1(x/2, y/2, height);
Point P2(-x/2, -y/2, height), P3(x/2, -y/2, height);
/// Now, we have to find the parametric form of the plane in terms of (u,v)
/// Plane equation can be formed by at least 3 points P0, P1, P2
/// P0 -> P1 (vector 1)
/// P0 -> p2 (vector 2)
/// An arbitrary point on the plane p is found in the following parametric form
/// P = P0 + (P1 - P0) u + (P2 - P0) v
/// Now we need to express two explicit equations of u and v
/// So, we have to construct the system of equation that solves for u and v
///
/// Since we have found the intersection point between the plane and the line
/// we have to use it to formalize the system of equations that will be used
/// to find the parametric form of the plane
/// Plane equation is : P = P0 + (P1 - P0) u + (P2 - P0) v
/// Ray equation is : l = l0 + (l1 - l0) * thit
/// But l = P, then
/// l0 + (l1 - l0) * thit = P0 + (P1 - P0) * u + (P2 - P0) * v
/// l0 - P0 = (l0 - l1) * thit + (P1 - P0) * u + (P2 - P0) * v
/// MAPPING : l0 = ray.o
/// [l0.x - P0.x] = [l0.x - l1.x P1.x - P0.x P2.x - P0.x] [t]
/// [l0.y - P0.y] = [l0.y - l1.y P1.y - P0.y P2.y - P0.y] [u]
/// [l0.z - P0.z] = [l0.z - l1.z P1.z - P0.z P2.z - P0.z] [v]
///
/// Then, we should find the inverse of the matrix in order to
/// solve for u,v and t for check
// System AX = B
float a11 = ray.o.x - 0;
float a12 = P1.x - P0.x;
float a13 = P2.x - P0.x;
float a21 = ray.o.y - 0;
float a22 = P1.y - P0.y;
float a23 = P2.y - P0.y;
float a31 = ray.o.y - height;
float a32 = P1.z - P0.z;
float a33 = P2.z - P0.z;
float b1 = -7;
float b2 = -2;
float b3 = 14;
float x1 = 0;
float x2 = 0;
float x3 = 0;
Imath::M33f A(a11,a12,a13,a21,a22,a23,a31,a32,a33), AInverted;
Imath::V3f X(x1, x2, x3);
Imath::V3f B(b1,b2, b3);
// This operation has been checked and working for getting
// the correct inverse of the matrix A
AInverted = A.invert(false);
x1 = AInverted[0][0] * B[0] +
AInverted[0][1] * B[1] +
AInverted[0][2] * B[2];
x2 = AInverted[1][0] * B[0] +
AInverted[1][1] * B[1] +
AInverted[1][2] * B[2];
x3 = AInverted[2][0] * B[0] +
AInverted[2][1] * B[1] +
AInverted[2][2] * B[2];
/// Then we have u = something, and v = something
///
/// Then we come for the derivatives, so we have to find the derivatives
/// from the parametric forms defined above for the plane equations
/// dpdu = (P1 - P0)
/// dpdv = (P2 - P0)
///
/// For the normal we have the always fixed direction in y
/// So the derivative for the normal is zero
/// dndu = (0, 0, 0) dndv = (0, 0, 0)
///
/// Then we can construct the DifferentilGeometry and go ahead
// Find parametric representation of disk hit
float u = x2;
float v = x3;
Vector dpdu(P1.x - P0.x, P1.y - P0.y, P1.z - P0.z);
Vector dpdv(P2.x - P0.x, P2.y - P0.y, P2.z - P0.z);
Normal dndu(0,0,0), dndv(0,0,0);
// Initialize _DifferentialGeometry_ from parametric information
const Transform &o2w = *ObjectToWorld;
*dg = DifferentialGeometry(o2w(phit), o2w(dpdu), o2w(dpdv),
o2w(dndu), o2w(dndv), u, v, this);
// Update _tHit_ for quadric intersection
*tHit = thit;
// Compute _rayEpsilon_ for quadric intersection
*rayEpsilon = 5e-4f * *tHit;
return true;
}
bool Sphere::intersect(const Ray &ray, float *t_hit, float *ray_epsilon, DifferentialGeometry *diff_geo) const
{
// Transform Ray to object space
Ray w_ray;
(*world_to_object)(ray, &w_ray);
// Compute quadratic sphere coefficients
float phi;
Point phit;
float A = w_ray.d.x * w_ray.d.x + w_ray.d.y * w_ray.d.y + w_ray.d.z * w_ray.d.z;
float B = 2 * (w_ray.d.x * w_ray.o.x + w_ray.d.y * w_ray.o.y + w_ray.d.z * w_ray.o.z);
float C = w_ray.o.x*w_ray.o.x + w_ray.o.y*w_ray.o.y + w_ray.o.z*w_ray.o.z - _radius*_radius;
// Solve quadratic equation for t values
float t0, t1;
if (!quadratic(A, B, C, &t0, &t1))
return false;
// Compute intersection distance along ray
if (t0 > w_ray.maxt || t1 < w_ray.mint)
return false;
float thit = t0;
if (t0 < w_ray.mint) {
thit = t1;
if (thit > w_ray.maxt) return false;
}
// Compute sphere hit position and phi
phit = w_ray(thit);
if (phit.x == 0.f && phit.y == 0.f) phit.x = 1e-5f * _radius;
phi = atan2f(phit.y, phit.x);
if (phi < 0.) phi += 2.f * M_PI;
// Test sphere intersection against clipping parameters
if ((_z_min > -_radius && phit.z < _z_min) ||
(_z_max < _radius && phit.z > _z_max) || phi > _phi_max) { // clip t0(t1)
if (thit == t1) return false;
if (t1 > w_ray.maxt) return false;
thit = t1;
// Compute sphere hit position and phi
phit = w_ray(thit);
if (phit.x == 0.f && phit.y == 0.f) phit.x = 1e-5f * _radius;
phi = atan2f(phit.y, phit.x);
if (phi < 0.) phi += 2.f * M_PI;
if ((_z_min > -_radius && phit.z < _z_min) ||
(_z_max < _radius && phit.z > _z_max) || phi > _phi_max) // clip t1
return false;
}
// Find parametric representatio n of sphere hit
float u = phi / _phi_max;
float theta = acosf(clamp(phit.z / _radius, -1.f, 1.f));
float v = (theta - _theta_min) / (_theta_max - _theta_min);
float z_radius = sqrtf(phit.x * phit.x + phit.y * phit.y);
float inv_z_radius = 1.f / z_radius;
float cos_phi = phit.x * inv_z_radius;
float sin_phi = phit.y * inv_z_radius;
Vec3 dpdu(-_phi_max * phit.y, _phi_max * phit.x, 0);
Vec3 dpdv = (_theta_max - _theta_min) *
Vec3(phit.z * cos_phi, phit.z * sin_phi, _radius * sinf(theta));
//auto d2Pduu = -_phi_max * _phi_max * Vec3(phit.x, phit.y, 0);
//auto d2Pduv = (_theta_max - _theta_min) * phit.z * _phi_max * Vec3(-sin_phi, cos_phi, 0.f);
//auto d2Pdvv = (_theta_max - _theta_min) * (_theta_max - _theta_min) * Vec3(phit.x, phit.y, phit.z);
//Normal dndu, dndv;
//calc_dndu_dndv(dpdu, dpdv, d2Pduu, d2Pduv, d2Pdvv, &dndu, &dndv);
Normal dndu(dpdu);
Normal dndv(dpdv);
const auto &o2w = *object_to_world;
*diff_geo = DifferentialGeometry(o2w(phit), o2w(dpdu), o2w(dpdv),
o2w(dndu), o2w(dndv), u, v, this);
*t_hit = thit;
*ray_epsilon = 5e-4f * *t_hit;
return true;
}
