void RoughCoatBsdf::substrateEvalAndPdf(const SurfaceScatterEvent &event, float eta,
float Fi, float cosThetaTi, float &pdf, Vec3f &brdf) const
{
const Vec3f &wi = event.wi;
const Vec3f &wo = event.wo;
float cosThetaTo;
float Fo = Fresnel::dielectricReflectance(eta, wo.z(), cosThetaTo);
if (Fi == 1.0f || Fo == 1.0f) {
pdf = 0.0f;
brdf = Vec3f(0.0f);
return;
}
Vec3f wiSubstrate(wi.x()*eta, wi.y()*eta, std::copysign(cosThetaTi, wi.z()));
Vec3f woSubstrate(wo.x()*eta, wo.y()*eta, std::copysign(cosThetaTo, wo.z()));
pdf = _substrate->pdf(event.makeWarpedQuery(wiSubstrate, woSubstrate));
pdf *= eta*eta*std::abs(wo.z()/cosThetaTo);
float compressionProjection = eta*eta*wo.z()/cosThetaTo;
Vec3f substrateF = _substrate->eval(event.makeWarpedQuery(wiSubstrate, woSubstrate));
if (_scaledSigmaA.max() > 0.0f)
substrateF *= std::exp(_scaledSigmaA*(-1.0f/cosThetaTo - 1.0f/cosThetaTi));
brdf = compressionProjection*(1.0f - Fi)*(1.0f - Fo)*substrateF;
}
bool TraceBase::handleSurface(SurfaceScatterEvent &event, IntersectionTemporary &data,
IntersectionInfo &info, const Medium *&medium,
int bounce, bool adjoint, bool enableLightSampling, Ray &ray,
Vec3f &throughput, Vec3f &emission, bool &wasSpecular,
Medium::MediumState &state, Vec3f *transmittance)
{
const Bsdf &bsdf = *info.bsdf;
// For forward events, the transport direction does not matter (since wi = -wo)
Vec3f transparency = bsdf.eval(event.makeForwardEvent(), false);
float transparencyScalar = transparency.avg();
Vec3f wo;
if (event.sampler->nextBoolean(transparencyScalar) ){
wo = ray.dir();
event.pdf = transparencyScalar;
event.weight = transparency/transparencyScalar;
event.sampledLobe = BsdfLobes::ForwardLobe;
throughput *= event.weight;
} else {
if (!adjoint) {
if (enableLightSampling && bounce < _settings.maxBounces - 1)
emission += estimateDirect(event, medium, bounce + 1, ray, transmittance)*throughput;
if (info.primitive->isEmissive() && bounce >= _settings.minBounces) {
if (!enableLightSampling || wasSpecular || !info.primitive->isSamplable())
emission += info.primitive->evalDirect(data, info)*throughput;
}
}
event.requestedLobe = BsdfLobes::AllLobes;
if (!bsdf.sample(event, adjoint))
return false;
wo = event.frame.toGlobal(event.wo);
if (!isConsistent(event, wo))
return false;
throughput *= event.weight;
wasSpecular = event.sampledLobe.hasSpecular();
if (!wasSpecular)
ray.setPrimaryRay(false);
}
bool geometricBackside = (wo.dot(info.Ng) < 0.0f);
medium = info.primitive->selectMedium(medium, geometricBackside);
state.reset();
ray = ray.scatter(ray.hitpoint(), wo, info.epsilon);
return true;
}
float RoughCoatBsdf::pdf(const SurfaceScatterEvent &event) const
{
bool sampleR = event.requestedLobe.test(BsdfLobes::GlossyReflectionLobe);
bool sampleT = event.requestedLobe.test(_substrate->lobes());
if (!sampleT && !sampleR)
return 0.0f;
if (event.wi.z() <= 0.0f || event.wo.z() <= 0.0f)
return 0.0f;
const Vec3f &wi = event.wi;
const Vec3f &wo = event.wo;
float eta = 1.0f/_ior;
float cosThetaTi, cosThetaTo;
float Fi = Fresnel::dielectricReflectance(eta, wi.z(), cosThetaTi);
float Fo = Fresnel::dielectricReflectance(eta, wo.z(), cosThetaTo);
float specularProbability;
if (sampleR && sampleT) {
float substrateWeight = _avgTransmittance*(1.0f - Fi);
float specularWeight = Fi;
specularProbability = specularWeight/(specularWeight + substrateWeight);
} else {
specularProbability = sampleR ? 1.0f : 0.0f;
}
float glossyPdf = 0.0f;
if (sampleR)
glossyPdf = RoughDielectricBsdf::pdfBase(event, true, false, (*_roughness)[*event.info].x(), _ior, _distribution);
float substratePdf = 0.0f;
if (sampleT) {
if (Fi < 1.0f && Fo < 1.0f) {
Vec3f wiSubstrate(wi.x()*eta, wi.y()*eta, std::copysign(cosThetaTi, wi.z()));
Vec3f woSubstrate(wo.x()*eta, wo.y()*eta, std::copysign(cosThetaTo, wo.z()));
substratePdf = _substrate->pdf(event.makeWarpedQuery(wiSubstrate, woSubstrate));
substratePdf *= eta*eta*std::abs(wo.z()/cosThetaTo);
}
}
return glossyPdf*specularProbability + substratePdf*(1.0f - specularProbability);
}
Vec3f RoughCoatBsdf::eval(const SurfaceScatterEvent &event) const
{
bool sampleR = event.requestedLobe.test(BsdfLobes::GlossyReflectionLobe);
bool sampleT = event.requestedLobe.test(_substrate->lobes());
if (!sampleT && !sampleR)
return Vec3f(0.0f);
if (event.wi.z() <= 0.0f || event.wo.z() <= 0.0f)
return Vec3f(0.0f);
Vec3f glossyR(0.0f);
if (sampleR)
glossyR = RoughDielectricBsdf::evalBase(event, true, false, (*_roughness)[*event.info].x(), _ior, _distribution);
Vec3f substrateR(0.0f);
if (sampleT) {
const Vec3f &wi = event.wi;
const Vec3f &wo = event.wo;
float eta = 1.0f/_ior;
float cosThetaTi, cosThetaTo;
float Fi = Fresnel::dielectricReflectance(eta, wi.z(), cosThetaTi);
float Fo = Fresnel::dielectricReflectance(eta, wo.z(), cosThetaTo);
if (Fi == 1.0f || Fo == 1.0f)
return glossyR;
Vec3f wiSubstrate(wi.x()*eta, wi.y()*eta, std::copysign(cosThetaTi, wi.z()));
Vec3f woSubstrate(wo.x()*eta, wo.y()*eta, std::copysign(cosThetaTo, wo.z()));
float compressionProjection = eta*eta*wo.z()/cosThetaTo;
Vec3f substrateF = _substrate->eval(event.makeWarpedQuery(wiSubstrate, woSubstrate));
if (_scaledSigmaA.max() > 0.0f)
substrateF *= std::exp(_scaledSigmaA*(-1.0f/cosThetaTo - 1.0f/cosThetaTi));
substrateR = compressionProjection*(1.0f - Fi)*(1.0f - Fo)*substrateF;
}
return glossyR + substrateR;
}
Vec3f PhotonTracer::traceSample(Vec2u pixel, const KdTree<Photon> &surfaceTree,
const KdTree<VolumePhoton> *mediumTree, PathSampleGenerator &sampler,
float gatherRadius)
{
PositionSample point;
if (!_scene->cam().samplePosition(sampler, point))
return Vec3f(0.0f);
DirectionSample direction;
if (!_scene->cam().sampleDirection(sampler, point, pixel, direction))
return Vec3f(0.0f);
sampler.advancePath();
Vec3f throughput = point.weight*direction.weight;
Ray ray(point.p, direction.d);
ray.setPrimaryRay(true);
IntersectionTemporary data;
IntersectionInfo info;
const Medium *medium = _scene->cam().medium().get();
Vec3f result(0.0f);
int bounce = 0;
bool didHit = _scene->intersect(ray, data, info);
while ((medium || didHit) && bounce < _settings.maxBounces - 1) {
if (medium) {
if (mediumTree) {
Vec3f beamEstimate(0.0f);
mediumTree->beamQuery(ray.pos(), ray.dir(), ray.farT(), [&](const VolumePhoton &p, float t, float distSq) {
Ray mediumQuery(ray);
mediumQuery.setFarT(t);
beamEstimate += (3.0f*INV_PI*sqr(1.0f - distSq/p.radiusSq))/p.radiusSq
*medium->phaseFunction(p.pos)->eval(ray.dir(), -p.dir)
*medium->transmittance(mediumQuery)*p.power;
});
result += throughput*beamEstimate;
}
throughput *= medium->transmittance(ray);
}
if (!didHit)
break;
const Bsdf &bsdf = *info.bsdf;
SurfaceScatterEvent event = makeLocalScatterEvent(data, info, ray, &sampler);
Vec3f transparency = bsdf.eval(event.makeForwardEvent(), false);
float transparencyScalar = transparency.avg();
Vec3f wo;
if (sampler.nextBoolean(DiscreteTransparencySample, transparencyScalar)) {
wo = ray.dir();
throughput *= transparency/transparencyScalar;
} else {
event.requestedLobe = BsdfLobes::SpecularLobe;
if (!bsdf.sample(event, false))
break;
wo = event.frame.toGlobal(event.wo);
throughput *= event.weight;
}
bool geometricBackside = (wo.dot(info.Ng) < 0.0f);
medium = info.primitive->selectMedium(medium, geometricBackside);
ray = ray.scatter(ray.hitpoint(), wo, info.epsilon);
if (std::isnan(ray.dir().sum() + ray.pos().sum()))
break;
if (std::isnan(throughput.sum()))
break;
sampler.advancePath();
bounce++;
if (bounce < _settings.maxBounces)
didHit = _scene->intersect(ray, data, info);
}
if (!didHit) {
if (!medium && _scene->intersectInfinites(ray, data, info))
result += throughput*info.primitive->evalDirect(data, info);
return result;
}
if (info.primitive->isEmissive())
result += throughput*info.primitive->evalDirect(data, info);
int count = surfaceTree.nearestNeighbours(ray.hitpoint(), _photonQuery.get(), _distanceQuery.get(),
_settings.gatherCount, gatherRadius);
if (count == 0)
return result;
const Bsdf &bsdf = *info.bsdf;
SurfaceScatterEvent event = makeLocalScatterEvent(data, info, ray, &sampler);
Vec3f surfaceEstimate(0.0f);
for (int i = 0; i < count; ++i) {
event.wo = event.frame.toLocal(-_photonQuery[i]->dir);
// Asymmetry due to shading normals already compensated for when storing the photon,
// so we don't use the adjoint BSDF here
surfaceEstimate += _photonQuery[i]->power*bsdf.eval(event, false)/std::abs(event.wo.z());
}
float radiusSq = count == int(_settings.gatherCount) ? _distanceQuery[0] : gatherRadius*gatherRadius;
result += throughput*surfaceEstimate*(INV_PI/radiusSq);
return result;
}
inline Vec3f TraceBase::generalizedShadowRayImpl(PathSampleGenerator &sampler,
Ray &ray,
const Medium *medium,
const Primitive *endCap,
int bounce,
bool startsOnSurface,
bool endsOnSurface,
float &pdfForward,
float &pdfBackward) const
{
IntersectionTemporary data;
IntersectionInfo info;
float initialFarT = ray.farT();
Vec3f throughput(1.0f);
do {
bool didHit = _scene->intersect(ray, data, info) && info.primitive != endCap;
if (didHit) {
if (!info.bsdf->lobes().hasForward())
return Vec3f(0.0f);
SurfaceScatterEvent event = makeLocalScatterEvent(data, info, ray, nullptr);
// For forward events, the transport direction does not matter (since wi = -wo)
Vec3f transparency = info.bsdf->eval(event.makeForwardEvent(), false);
if (transparency == 0.0f)
return Vec3f(0.0f);
if (ComputePdfs) {
float transparencyScalar = transparency.avg();
pdfForward *= transparencyScalar;
pdfBackward *= transparencyScalar;
}
throughput *= transparency;
bounce++;
if (bounce >= _settings.maxBounces)
return Vec3f(0.0f);
}
if (medium) {
if (ComputePdfs) {
float forward, backward;
throughput *= medium->transmittanceAndPdfs(sampler, ray, startsOnSurface, didHit || endsOnSurface, forward, backward);
pdfForward *= forward;
pdfBackward *= backward;
} else {
throughput *= medium->transmittance(sampler, ray, startsOnSurface, endsOnSurface);
}
}
if (info.primitive == nullptr || info.primitive == endCap)
return bounce >= _settings.minBounces ? throughput : Vec3f(0.0f);
medium = info.primitive->selectMedium(medium, !info.primitive->hitBackside(data));
startsOnSurface = true;
ray.setPos(ray.hitpoint());
initialFarT -= ray.farT();
ray.setNearT(info.epsilon);
ray.setFarT(initialFarT);
} while(true);
return Vec3f(0.0f);
}