Spectrum Li(const RayDifferential &r, RadianceQueryRecord &rRec) const {
/* Some aliases and local variables */
const Scene *scene = rRec.scene;
Intersection &its = rRec.its;
MediumSamplingRecord mRec;
RayDifferential ray(r);
Spectrum Li(0.0f);
bool nullChain = true, scattered = false;
Float eta = 1.0f;
/* Perform the first ray intersection (or ignore if the
intersection has already been provided). */
rRec.rayIntersect(ray);
Spectrum throughput(1.0f);
if (m_maxDepth == 1)
rRec.type &= RadianceQueryRecord::EEmittedRadiance;
/**
* Note: the logic regarding maximum path depth may appear a bit
* strange. This is necessary to get this integrator's output to
* exactly match the output of other integrators under all settings
* of this parameter.
*/
while (rRec.depth <= m_maxDepth || m_maxDepth < 0) {
/* ==================================================================== */
/* Radiative Transfer Equation sampling */
/* ==================================================================== */
if (rRec.medium && rRec.medium->sampleDistance(Ray(ray, 0, its.t), mRec, rRec.sampler)) {
/* Sample the integral
\int_x^y tau(x, x') [ \sigma_s \int_{S^2} \rho(\omega,\omega') L(x,\omega') d\omega' ] dx'
*/
const PhaseFunction *phase = rRec.medium->getPhaseFunction();
throughput *= mRec.sigmaS * mRec.transmittance / mRec.pdfSuccess;
/* ==================================================================== */
/* Direct illumination sampling */
/* ==================================================================== */
/* Estimate the single scattering component if this is requested */
if (rRec.type & RadianceQueryRecord::EDirectMediumRadiance) {
DirectSamplingRecord dRec(mRec.p, mRec.time);
int maxInteractions = m_maxDepth - rRec.depth - 1;
Spectrum value = scene->sampleAttenuatedEmitterDirect(
dRec, rRec.medium, maxInteractions,
rRec.nextSample2D(), rRec.sampler);
if (!value.isZero())
Li += throughput * value * phase->eval(
PhaseFunctionSamplingRecord(mRec, -ray.d, dRec.d));
}
/* Stop if multiple scattering was not requested, or if the path gets too long */
if ((rRec.depth + 1 >= m_maxDepth && m_maxDepth > 0) ||
!(rRec.type & RadianceQueryRecord::EIndirectMediumRadiance))
break;
/* ==================================================================== */
/* Phase function sampling / Multiple scattering */
/* ==================================================================== */
PhaseFunctionSamplingRecord pRec(mRec, -ray.d);
Float phaseVal = phase->sample(pRec, rRec.sampler);
if (phaseVal == 0)
break;
throughput *= phaseVal;
/* Trace a ray in this direction */
ray = Ray(mRec.p, pRec.wo, ray.time);
ray.mint = 0;
scene->rayIntersect(ray, its);
nullChain = false;
scattered = true;
} else {
/* Sample
tau(x, y) * (Surface integral). This happens with probability mRec.pdfFailure
Account for this and multiply by the proper per-color-channel transmittance.
*/
if (rRec.medium)
throughput *= mRec.transmittance / mRec.pdfFailure;
if (!its.isValid()) {
/* If no intersection could be found, possibly return
attenuated radiance from a background luminaire */
if ((rRec.type & RadianceQueryRecord::EEmittedRadiance)
&& (!m_hideEmitters || scattered)) {
Spectrum value = throughput * scene->evalEnvironment(ray);
if (rRec.medium)
value *= rRec.medium->evalTransmittance(ray);
Li += value;
}
break;
}
/* Possibly include emitted radiance if requested */
if (its.isEmitter() && (rRec.type & RadianceQueryRecord::EEmittedRadiance)
&& (!m_hideEmitters || scattered))
Li += throughput * its.Le(-ray.d);
/* Include radiance from a subsurface integrator if requested */
if (its.hasSubsurface() && (rRec.type & RadianceQueryRecord::ESubsurfaceRadiance))
Li += throughput * its.LoSub(scene, rRec.sampler, -ray.d, rRec.depth);
/* Prevent light leaks due to the use of shading normals */
Float wiDotGeoN = -dot(its.geoFrame.n, ray.d),
wiDotShN = Frame::cosTheta(its.wi);
if (m_strictNormals && wiDotGeoN * wiDotShN < 0)
break;
/* ==================================================================== */
/* Direct illumination sampling */
/* ==================================================================== */
const BSDF *bsdf = its.getBSDF(ray);
/* Estimate the direct illumination if this is requested */
if (rRec.type & RadianceQueryRecord::EDirectSurfaceRadiance &&
(bsdf->getType() & BSDF::ESmooth)) {
DirectSamplingRecord dRec(its);
int maxInteractions = m_maxDepth - rRec.depth - 1;
Spectrum value = scene->sampleAttenuatedEmitterDirect(
dRec, its, rRec.medium, maxInteractions,
rRec.nextSample2D(), rRec.sampler);
if (!value.isZero()) {
/* Allocate a record for querying the BSDF */
BSDFSamplingRecord bRec(its, its.toLocal(dRec.d));
bRec.sampler = rRec.sampler;
Float woDotGeoN = dot(its.geoFrame.n, dRec.d);
/* Prevent light leaks due to the use of shading normals */
if (!m_strictNormals ||
woDotGeoN * Frame::cosTheta(bRec.wo) > 0)
Li += throughput * value * bsdf->eval(bRec);
}
}
/* ==================================================================== */
/* BSDF sampling / Multiple scattering */
/* ==================================================================== */
/* Sample BSDF * cos(theta) */
BSDFSamplingRecord bRec(its, rRec.sampler, ERadiance);
Spectrum bsdfVal = bsdf->sample(bRec, rRec.nextSample2D());
if (bsdfVal.isZero())
break;
/* Recursively gather indirect illumination? */
int recursiveType = 0;
if ((rRec.depth + 1 < m_maxDepth || m_maxDepth < 0) &&
(rRec.type & RadianceQueryRecord::EIndirectSurfaceRadiance))
recursiveType |= RadianceQueryRecord::ERadianceNoEmission;
/* Recursively gather direct illumination? This is a bit more
complicated by the fact that this integrator can create connection
through index-matched medium transitions (ENull scattering events) */
if ((rRec.depth < m_maxDepth || m_maxDepth < 0) &&
(rRec.type & RadianceQueryRecord::EDirectSurfaceRadiance) &&
(bRec.sampledType & BSDF::EDelta) &&
(!(bRec.sampledType & BSDF::ENull) || nullChain)) {
recursiveType |= RadianceQueryRecord::EEmittedRadiance;
nullChain = true;
} else {
nullChain &= bRec.sampledType == BSDF::ENull;
}
/* Potentially stop the recursion if there is nothing more to do */
if (recursiveType == 0)
break;
rRec.type = recursiveType;
/* Prevent light leaks due to the use of shading normals */
const Vector wo = its.toWorld(bRec.wo);
Float woDotGeoN = dot(its.geoFrame.n, wo);
if (woDotGeoN * Frame::cosTheta(bRec.wo) <= 0 && m_strictNormals)
break;
/* Keep track of the throughput, medium, and relative
refractive index along the path */
throughput *= bsdfVal;
eta *= bRec.eta;
if (its.isMediumTransition())
rRec.medium = its.getTargetMedium(wo);
/* In the next iteration, trace a ray in this direction */
ray = Ray(its.p, wo, ray.time);
scene->rayIntersect(ray, its);
scattered |= bRec.sampledType != BSDF::ENull;
}
if (rRec.depth++ >= m_rrDepth) {
/* Russian roulette: try to keep path weights equal to one,
while accounting for the solid angle compression at refractive
index boundaries. Stop with at least some probability to avoid
getting stuck (e.g. due to total internal reflection) */
Float q = std::min(throughput.max() * eta * eta, (Float) 0.95f);
if (rRec.nextSample1D() >= q)
break;
throughput /= q;
}
}
avgPathLength.incrementBase();
avgPathLength += rRec.depth;
return Li;
}
Spectrum Li(const RayDifferential &r, RadianceQueryRecord &rRec) const {
/* Some aliases and local variables */
const Scene *scene = rRec.scene;
Intersection &its = rRec.its;
RayDifferential ray(r);
Spectrum Li(0.0f);
bool scattered = false;
/* Perform the first ray intersection (or ignore if the
intersection has already been provided). */
rRec.rayIntersect(ray);
ray.mint = Epsilon;
Spectrum throughput(1.0f);
Float eta = 1.0f;
while (rRec.depth <= m_maxDepth || m_maxDepth < 0) {
if (!its.isValid()) {
/* If no intersection could be found, potentially return
radiance from a environment luminaire if it exists */
if ((rRec.type & RadianceQueryRecord::EEmittedRadiance)
&& (!m_hideEmitters || scattered))
Li += throughput * scene->evalEnvironment(ray);
break;
}
const BSDF *bsdf = its.getBSDF(ray);
/* Possibly include emitted radiance if requested */
if (its.isEmitter() && (rRec.type & RadianceQueryRecord::EEmittedRadiance)
&& (!m_hideEmitters || scattered))
Li += throughput * its.Le(-ray.d);
/* Include radiance from a subsurface scattering model if requested */
if (its.hasSubsurface() && (rRec.type & RadianceQueryRecord::ESubsurfaceRadiance))
Li += throughput * its.LoSub(scene, rRec.sampler, -ray.d, rRec.depth);
if ((rRec.depth >= m_maxDepth && m_maxDepth > 0)
|| (m_strictNormals && dot(ray.d, its.geoFrame.n)
* Frame::cosTheta(its.wi) >= 0)) {
/* Only continue if:
1. The current path length is below the specifed maximum
2. If 'strictNormals'=true, when the geometric and shading
normals classify the incident direction to the same side */
break;
}
/* ==================================================================== */
/* Direct illumination sampling */
/* ==================================================================== */
/* Estimate the direct illumination if this is requested */
DirectSamplingRecord dRec(its);
if (rRec.type & RadianceQueryRecord::EDirectSurfaceRadiance &&
(bsdf->getType() & BSDF::ESmooth)) {
Spectrum value = scene->sampleEmitterDirect(dRec, rRec.nextSample2D());
if (!value.isZero()) {
const Emitter *emitter = static_cast<const Emitter *>(dRec.object);
/* Allocate a record for querying the BSDF */
BSDFSamplingRecord bRec(its, its.toLocal(dRec.d), ERadiance);
/* Evaluate BSDF * cos(theta) */
const Spectrum bsdfVal = bsdf->eval(bRec);
/* Prevent light leaks due to the use of shading normals */
if (!bsdfVal.isZero() && (!m_strictNormals
|| dot(its.geoFrame.n, dRec.d) * Frame::cosTheta(bRec.wo) > 0)) {
/* Calculate prob. of having generated that direction
using BSDF sampling */
Float bsdfPdf = (emitter->isOnSurface() && dRec.measure == ESolidAngle)
? bsdf->pdf(bRec) : 0;
/* Weight using the power heuristic */
Float weight = miWeight(dRec.pdf, bsdfPdf);
Li += throughput * value * bsdfVal * weight;
}
}
}
/* ==================================================================== */
/* BSDF sampling */
/* ==================================================================== */
/* Sample BSDF * cos(theta) */
Float bsdfPdf;
BSDFSamplingRecord bRec(its, rRec.sampler, ERadiance);
Spectrum bsdfWeight = bsdf->sample(bRec, bsdfPdf, rRec.nextSample2D());
if (bsdfWeight.isZero())
break;
scattered |= bRec.sampledType != BSDF::ENull;
/* Prevent light leaks due to the use of shading normals */
const Vector wo = its.toWorld(bRec.wo);
Float woDotGeoN = dot(its.geoFrame.n, wo);
if (m_strictNormals && woDotGeoN * Frame::cosTheta(bRec.wo) <= 0)
break;
bool hitEmitter = false;
Spectrum value;
/* Trace a ray in this direction */
ray = Ray(its.p, wo, ray.time);
if (scene->rayIntersect(ray, its)) {
/* Intersected something - check if it was a luminaire */
if (its.isEmitter()) {
value = its.Le(-ray.d);
dRec.setQuery(ray, its);
hitEmitter = true;
}
} else {
/* Intersected nothing -- perhaps there is an environment map? */
const Emitter *env = scene->getEnvironmentEmitter();
if (env) {
if (m_hideEmitters && !scattered)
break;
value = env->evalEnvironment(ray);
if (!env->fillDirectSamplingRecord(dRec, ray))
break;
hitEmitter = true;
} else {
break;
}
}
/* Keep track of the throughput and relative
refractive index along the path */
throughput *= bsdfWeight;
eta *= bRec.eta;
/* If a luminaire was hit, estimate the local illumination and
weight using the power heuristic */
if (hitEmitter &&
(rRec.type & RadianceQueryRecord::EDirectSurfaceRadiance)) {
/* Compute the prob. of generating that direction using the
implemented direct illumination sampling technique */
const Float lumPdf = (!(bRec.sampledType & BSDF::EDelta)) ?
scene->pdfEmitterDirect(dRec) : 0;
Li += throughput * value * miWeight(bsdfPdf, lumPdf);
}
/* ==================================================================== */
/* Indirect illumination */
/* ==================================================================== */
/* Set the recursive query type. Stop if no surface was hit by the
BSDF sample or if indirect illumination was not requested */
if (!its.isValid() || !(rRec.type & RadianceQueryRecord::EIndirectSurfaceRadiance))
break;
rRec.type = RadianceQueryRecord::ERadianceNoEmission;
if (rRec.depth++ >= m_rrDepth) {
/* Russian roulette: try to keep path weights equal to one,
while accounting for the solid angle compression at refractive
index boundaries. Stop with at least some probability to avoid
getting stuck (e.g. due to total internal reflection) */
Float q = std::min(throughput.max() * eta * eta, (Float) 0.95f);
if (rRec.nextSample1D() >= q)
break;
throughput /= q;
}
}
/* Store statistics */
avgPathLength.incrementBase();
avgPathLength += rRec.depth;
return Li;
}
Spectrum Li(const RayDifferential &r, RadianceQueryRecord &rRec) const {
/* Some aliases and local variables */
const Scene *scene = rRec.scene;
Intersection &its = rRec.its;
RayDifferential ray(r);
Spectrum Li(0.0f);
/* Perform the first ray intersection (or ignore if the
intersection has already been provided). */
rRec.rayIntersect(ray);
ray.mint = Epsilon;
Spectrum pathThroughput(1.0f);
while (rRec.depth <= m_maxDepth || m_maxDepth < 0) {
if (!its.isValid()) {
/* If no intersection could be found, potentially return
radiance from a background luminaire if it exists */
if (rRec.type & RadianceQueryRecord::EEmittedRadiance)
Li += pathThroughput * scene->LeBackground(ray);
break;
}
const BSDF *bsdf = its.getBSDF(ray);
if (EXPECT_NOT_TAKEN(bsdf == NULL)) {
/* The MI path tracer doesn't support
surfaces without a BSDF (e.g. medium transitions)
-- give up. */
break;
}
/* Possibly include emitted radiance if requested */
if (its.isLuminaire() && (rRec.type & RadianceQueryRecord::EEmittedRadiance))
Li += pathThroughput * its.Le(-ray.d);
/* Include radiance from a subsurface integrator if requested */
if (its.hasSubsurface() && (rRec.type & RadianceQueryRecord::ESubsurfaceRadiance))
Li += pathThroughput * its.LoSub(scene, rRec.sampler, -ray.d, rRec.depth);
if (m_maxDepth > 0 && rRec.depth >= m_maxDepth)
break;
/* ==================================================================== */
/* Luminaire sampling */
/* ==================================================================== */
/* Prevent light leaks due to the use of shading normals */
Float wiDotGeoN = -dot(its.geoFrame.n, ray.d),
wiDotShN = Frame::cosTheta(its.wi);
if (wiDotGeoN * wiDotShN < 0 && m_strictNormals)
break;
/* Estimate the direct illumination if this is requested */
LuminaireSamplingRecord lRec;
if (rRec.type & RadianceQueryRecord::EDirectSurfaceRadiance &&
scene->sampleLuminaire(its.p, ray.time, lRec, rRec.nextSample2D())) {
/* Allocate a record for querying the BSDF */
const Vector wo = -lRec.d;
const BSDFQueryRecord bRec(its, its.toLocal(wo));
/* Evaluate BSDF * cos(theta) */
const Spectrum bsdfVal = bsdf->fCos(bRec);
Float woDotGeoN = dot(its.geoFrame.n, wo);
/* Prevent light leaks due to the use of shading normals */
if (!bsdfVal.isZero() && (!m_strictNormals
|| woDotGeoN * Frame::cosTheta(bRec.wo) > 0)) {
/* Calculate prob. of having sampled that direction
using BSDF sampling */
Float bsdfPdf = (lRec.luminaire->isIntersectable()
|| lRec.luminaire->isBackgroundLuminaire()) ?
bsdf->pdf(bRec) : 0;
/* Weight using the power heuristic */
const Float weight = miWeight(lRec.pdf, bsdfPdf);
Li += pathThroughput * lRec.value * bsdfVal * weight;
}
}
/* ==================================================================== */
/* BSDF sampling */
/* ==================================================================== */
/* Sample BSDF * cos(theta) */
BSDFQueryRecord bRec(its);
Float bsdfPdf;
Spectrum bsdfVal = bsdf->sampleCos(bRec, bsdfPdf, rRec.nextSample2D());
if (bsdfVal.isZero())
break;
bsdfVal /= bsdfPdf;
/* Prevent light leaks due to the use of shading normals */
const Vector wo = its.toWorld(bRec.wo);
Float woDotGeoN = dot(its.geoFrame.n, wo);
if (woDotGeoN * Frame::cosTheta(bRec.wo) <= 0 && m_strictNormals)
break;
/* Trace a ray in this direction */
ray = Ray(its.p, wo, ray.time);
bool hitLuminaire = false;
if (scene->rayIntersect(ray, its)) {
/* Intersected something - check if it was a luminaire */
if (its.isLuminaire()) {
lRec = LuminaireSamplingRecord(its, -ray.d);
lRec.value = its.Le(-ray.d);
hitLuminaire = true;
}
} else {
/* No intersection found. Possibly, there is a background
luminaire such as an environment map? */
if (scene->hasBackgroundLuminaire()) {
lRec.luminaire = scene->getBackgroundLuminaire();
lRec.value = lRec.luminaire->Le(ray);
lRec.d = -ray.d;
hitLuminaire = true;
} else {
rRec.depth++;
break;
}
}
/* If a luminaire was hit, estimate the local illumination and
weight using the power heuristic */
if (hitLuminaire &&
(rRec.type & RadianceQueryRecord::EDirectSurfaceRadiance)) {
/* Prob. of having generated this sample using luminaire sampling */
const Float lumPdf = (!(bRec.sampledType & BSDF::EDelta)) ?
scene->pdfLuminaire(ray.o, lRec) : 0;
const Float weight = miWeight(bsdfPdf, lumPdf);
Li += pathThroughput * lRec.value * bsdfVal * weight;
}
/* ==================================================================== */
/* Indirect illumination */
/* ==================================================================== */
/* Set the recursive query type */
/* Stop if no surface was hit by the BSDF sample or if indirect illumination
was not requested */
if (!its.isValid() || !(rRec.type & RadianceQueryRecord::EIndirectSurfaceRadiance))
break;
rRec.type = RadianceQueryRecord::ERadianceNoEmission;
/* Russian roulette - Possibly stop the recursion. Don't do this when
dealing with a transmission component, since solid angle compression
factors cause problems with the heuristic below */
if (rRec.depth >= m_rrDepth && !(bRec.sampledType & BSDF::ETransmission)) {
/* Assuming that BSDF importance sampling is perfect,
'bsdfVal.max()' should equal the maximum albedo
over all spectral samples */
Float approxAlbedo = std::min((Float) 0.9f, bsdfVal.max());
if (rRec.nextSample1D() > approxAlbedo)
break;
else
pathThroughput /= approxAlbedo;
}
pathThroughput *= bsdfVal;
rRec.depth++;
}
/* Store statistics */
avgPathLength.incrementBase();
avgPathLength += rRec.depth;
return Li;
}
