Spectrum DiffusePRTIntegrator::Li(const Scene *scene, const Renderer *,
const RayDifferential &ray, const Intersection &isect,
const Sample *sample, MemoryArena &arena) const {
Spectrum L = 0.f;
Vector wo = -ray.d;
// Compute emitted light if ray hit an area light source
L += isect.Le(wo);
// Evaluate BSDF at hit point
BSDF *bsdf = isect.GetBSDF(ray, arena);
const Point &p = bsdf->dgShading.p;
const Normal &n = bsdf->dgShading.nn;
// Compute reflected radiance using diffuse PRT
// Project diffuse transfer function at point to SH
Spectrum *c_transfer = arena.Alloc<Spectrum>(SHTerms(lmax));
SHComputeDiffuseTransfer(p, Faceforward(n, wo), isect.rayEpsilon,
scene, *sample->rng, nSamples, lmax, c_transfer);
// Compute integral of product of incident radiance and transfer function
Spectrum LT = 0.f;
for (int i = 0; i < SHTerms(lmax); ++i)
LT += c_in[i] * c_transfer[i];
// Compute reflectance at point for diffuse transfer
const int sqrtRhoSamples = 6;
float rhoRSamples[2*sqrtRhoSamples*sqrtRhoSamples];
StratifiedSample2D(rhoRSamples, sqrtRhoSamples, sqrtRhoSamples, *sample->rng);
Spectrum Kd = bsdf->rho(wo, sqrtRhoSamples*sqrtRhoSamples, rhoRSamples,
BSDF_ALL_REFLECTION) * INV_PI;
return L + Kd * LT.Clamp();
}
static Spectrum L(const Scene *scene, const Renderer *renderer,
const Camera *camera, MemoryArena &arena, RNG &rng, int maxDepth,
bool ignoreDirect, const MLTSample &sample) {
// Generate camera ray from Metropolis sample
RayDifferential ray;
float cameraWeight = camera->GenerateRayDifferential(sample.cameraSample,
&ray);
Spectrum pathThroughput = cameraWeight, L = 0.;
bool specularBounce = false, allSpecular = true;
for (int pathLength = 0; pathLength < maxDepth; ++pathLength) {
// Find next intersection in Metropolis light path
Intersection isect;
if (!scene->Intersect(ray, &isect)) {
bool includeLe = ignoreDirect ? (specularBounce && !allSpecular) :
(pathLength == 0 || specularBounce);
if (includeLe)
for (uint32_t i = 0; i < scene->lights.size(); ++i)
L += pathThroughput * scene->lights[i]->Le(ray);
break;
}
if (ignoreDirect ? (specularBounce && !allSpecular) :
(specularBounce || pathLength == 0))
L += pathThroughput * isect.Le(-ray.d);
BSDF *bsdf = isect.GetBSDF(ray, arena);
const Point &p = bsdf->dgShading.p;
const Normal &n = bsdf->dgShading.nn;
Vector wo = -ray.d;
const PathSample &ps = sample.pathSamples[pathLength];
// Sample direct illumination for Metropolis path vertex
if (!ignoreDirect || pathLength > 0) {
LightSample lightSample(ps.lightDir0, ps.lightDir1, ps.lightNum0);
BSDFSample bsdfSample(ps.bsdfLightDir0, ps.bsdfLightDir1,
ps.bsdfLightComponent);
uint32_t lightNum = Floor2Int(ps.lightNum1 * scene->lights.size());
lightNum = min(lightNum, (uint32_t)(scene->lights.size()-1));
const Light *light = scene->lights[lightNum];
L += pathThroughput *
EstimateDirect(scene, renderer, arena, light, p, n, wo,
isect.rayEpsilon, sample.cameraSample.time, bsdf, rng,
lightSample, bsdfSample);
}
// Sample direction for outgoing Metropolis path direction
BSDFSample outgoingBSDFSample(ps.bsdfDir0, ps.bsdfDir1,
ps.bsdfComponent);
Vector wi;
float pdf;
BxDFType flags;
Spectrum f = bsdf->Sample_f(wo, &wi, outgoingBSDFSample,
&pdf, BSDF_ALL, &flags);
if (f.IsBlack() || pdf == 0.)
break;
specularBounce = (flags & BSDF_SPECULAR) != 0;
allSpecular &= specularBounce;
pathThroughput *= f * AbsDot(wi, n) / pdf;
ray = RayDifferential(p, wi, ray, isect.rayEpsilon);
//pathThroughput *= renderer->Transmittance(scene, ray, NULL, rng, arena);
}
return L;
}
Spectrum EstimateDirect(const Scene *scene, const Renderer *renderer,
MemoryArena &arena, const Light *light, const Point &p,
const Normal &n, const Vector &wo, float rayEpsilon, float time,
const BSDF *bsdf, RNG &rng, const LightSample &lightSample,
const BSDFSample &bsdfSample, BxDFType flags) {
Spectrum Ld(0.);
// Sample light source with multiple importance sampling
Vector wi;
float lightPdf, bsdfPdf;
VisibilityTester visibility;
Spectrum Li = light->Sample_L(p, rayEpsilon, lightSample, time,
&wi, &lightPdf, &visibility);
if (lightPdf > 0. && !Li.IsBlack()) {
Spectrum f = bsdf->f(wo, wi, flags);
if (!f.IsBlack() && visibility.Unoccluded(scene)) {
// Add light's contribution to reflected radiance
Li *= visibility.Transmittance(scene, renderer, NULL, rng, arena);
if (light->IsDeltaLight())
Ld += f * Li * (AbsDot(wi, n) / lightPdf);
else {
bsdfPdf = bsdf->Pdf(wo, wi, flags);
float weight = PowerHeuristic(1, lightPdf, 1, bsdfPdf);
Ld += f * Li * (AbsDot(wi, n) * weight / lightPdf);
}
}
}
// Sample BSDF with multiple importance sampling
if (!light->IsDeltaLight()) {
BxDFType sampledType;
Spectrum f = bsdf->Sample_f(wo, &wi, bsdfSample, &bsdfPdf, flags,
&sampledType);
if (!f.IsBlack() && bsdfPdf > 0.) {
float weight = 1.f;
if (!(sampledType & BSDF_SPECULAR)) {
lightPdf = light->Pdf(p, wi);
if (lightPdf == 0.)
return Ld;
weight = PowerHeuristic(1, bsdfPdf, 1, lightPdf);
}
// Add light contribution from BSDF sampling
Intersection lightIsect;
Spectrum Li(0.f);
RayDifferential ray(p, wi, rayEpsilon, INFINITY, time);
if (scene->Intersect(ray, &lightIsect)) {
if (lightIsect.primitive->GetAreaLight() == light)
Li = lightIsect.Le(-wi);
}
else
//Li = light->Le(ray,);
Li = Spectrum(0.);
if (!Li.IsBlack()) {
Li *= renderer->Transmittance(scene, ray, NULL, rng, arena);
Ld += f * Li * AbsDot(wi, n) * weight / bsdfPdf;
}
}
}
return Ld;
}
Spectrum DipoleSubsurfaceIntegrator::Li(const Scene *scene, const Renderer *renderer,
const RayDifferential &ray, const Intersection &isect,
const Sample *sample, RNG &rng, MemoryArena &arena) const {
Spectrum L(0.);
Vector wo = -ray.d;
// Compute emitted light if ray hit an area light source
L += isect.Le(wo);
// Evaluate BSDF at hit point
BSDF *bsdf = isect.GetBSDF(ray, arena);
const Point &p = bsdf->dgShading.p;
const Normal &n = bsdf->dgShading.nn;
Spectrum rho_dr = Spectrum(1.0f);
// Evaluate BSSRDF and possibly compute subsurface scattering
BSSRDF *bssrdf = isect.GetBSSRDF(ray, arena);
if (bssrdf && octree) {
Spectrum sigma_a = bssrdf->sigma_a();
Spectrum sigmap_s = bssrdf->sigma_prime_s();
Spectrum sigmap_t = sigmap_s + sigma_a;
if (!sigmap_t.IsBlack()) {
// Use hierarchical integration to evaluate reflection from dipole model
PBRT_SUBSURFACE_STARTED_OCTREE_LOOKUP(const_cast<Point *>(&p));
DiffusionReflectance Rd(sigma_a, sigmap_s, bssrdf->eta());
Spectrum Mo = octree->Mo(octreeBounds, p, Rd, maxError);
FresnelDielectric fresnel(1.f, bssrdf->eta());
Spectrum Ft = Spectrum(1.f) - fresnel.Evaluate(AbsDot(wo, n));
float Fdt = 1.f - Fdr(bssrdf->eta());
// modulate SSS contribution by rho_dr
//L += (INV_PI * Ft) * (Fdt * Mo);
rho_dr = wet->integrate_BRDF(bsdf, ray.d, 10, BxDFType(BSDF_REFLECTION | BSDF_GLOSSY));
L += (INV_PI * Ft) * (Fdt * Mo) * (Spectrum(1.0f) - rho_dr);
//L += (INV_PI * Ft) * (Fdt * Mo) * (Spectrum(0.0f));
PBRT_SUBSURFACE_FINISHED_OCTREE_LOOKUP();
}
}
L += UniformSampleAllLights(scene, renderer, arena, p, n,
wo, isect.rayEpsilon, ray.time, bsdf, sample, rng, lightSampleOffsets,
bsdfSampleOffsets);
if (ray.depth < maxSpecularDepth) {
// Trace rays for specular reflection and refraction.
//TODO: this has no effect?
L += SpecularReflect(ray, bsdf, rng, isect, renderer, scene,
sample, arena);
L += SpecularTransmit(ray, bsdf, rng, isect,
renderer, scene, sample, arena);
}
return L;
}
Spectrum IrradianceCacheIntegrator::pathL(Ray &r, const Scene *scene,
const Renderer *renderer, const Sample *sample, MemoryArena &arena) const {
Spectrum L(0.f);
Spectrum pathThroughput = 1.;
RayDifferential ray(r);
bool specularBounce = false;
for (int pathLength = 0; ; ++pathLength) {
// Find next vertex of path
Intersection isect;
if (!scene->Intersect(ray, &isect))
break;
if (pathLength == 0)
r.maxt = ray.maxt;
else if (pathLength == 1)
pathThroughput *= renderer->Transmittance(scene, ray, sample, arena, NULL);
else
pathThroughput *= renderer->Transmittance(scene, ray, NULL, arena, sample->rng);
// Possibly add emitted light at path vertex
if (specularBounce)
L += pathThroughput * isect.Le(-ray.d);
// Evaluate BSDF at hit point
BSDF *bsdf = isect.GetBSDF(ray, arena);
// Sample illumination from lights to find path contribution
const Point &p = bsdf->dgShading.p;
const Normal &n = bsdf->dgShading.nn;
Vector wo = -ray.d;
L += pathThroughput *
UniformSampleOneLight(scene, renderer, arena, p, n, wo, isect.rayEpsilon,
bsdf, sample);
if (pathLength+1 == maxIndirectDepth) break;
// Sample BSDF to get new path direction
// Get random numbers for sampling new direction, \mono{bs1}, \mono{bs2}, and \mono{bcs}
Vector wi;
float pdf;
BxDFType flags;
Spectrum f = bsdf->Sample_f(wo, &wi, BSDFSample(*sample->rng),
&pdf, BSDF_ALL, &flags);
if (f.IsBlack() || pdf == 0.)
break;
specularBounce = (flags & BSDF_SPECULAR) != 0;
pathThroughput *= f * AbsDot(wi, n) / pdf;
ray = RayDifferential(p, wi, ray, isect.rayEpsilon);
// Possibly terminate the path
if (pathLength > 2) {
float rrProb = min(1.f, pathThroughput.y());
if (sample->rng->RandomFloat() > rrProb)
break;
pathThroughput /= rrProb;
}
}
return L;
}
Spectrum DirectLightingIntegrator::Li(const Scene *scene,
const Renderer *renderer, const RayDifferential &ray,
const Intersection &isect, const Sample *sample, RNG &rng, MemoryArena &arena) const {
Spectrum L(0.f);
// Evaluate BSDF at hit point
BSDF *bsdf = isect.GetBSDF(ray, arena);
Vector wo = -ray.d;
const Point &p = bsdf->dgShading.p;
const Normal &n = bsdf->dgShading.nn;
// Compute emitted light if ray hit an area light source
L += isect.Le(wo);
// Compute direct lighting for _DirectLightingIntegrator_ integrator
if (scene->lights.size() > 0) {
// Apply direct lighting strategy
switch (strategy) {
case SAMPLE_ALL_UNIFORM:
L += UniformSampleAllLights(scene, renderer, arena, p, n, wo,
isect.rayEpsilon, ray.time, bsdf, sample, rng,
lightSampleOffsets, bsdfSampleOffsets);
break;
case SAMPLE_ONE_UNIFORM:
L += UniformSampleOneLight(scene, renderer, arena, p, n, wo,
isect.rayEpsilon, ray.time, bsdf, sample, rng,
lightNumOffset, lightSampleOffsets, bsdfSampleOffsets);
break;
}
}
if (ray.depth + 1 < maxDepth) {
Vector wi;
// Trace rays for specular reflection and refraction
Spectrum reflection(0.f);
Spectrum refraction(0.f);
reflection = SpecularReflect(ray, bsdf, rng, isect, renderer, scene,
sample,arena);
refraction = SpecularTransmit(ray, bsdf, rng, isect, renderer, scene,
sample, arena);
L += reflection;
L += refraction;
}
//printf("Size %i \n", NaiadFoam::cur->FoamPlane().size());
return L*bsdf->dgShading.mult;
}
// WhittedIntegrator Method Definitions
Spectrum WhittedIntegrator::Li(const Scene *scene,
const Renderer *renderer, const RayDifferential &ray,
const Intersection &isect, const Sample *sample,
MemoryArena &arena) const {
Spectrum L(0.);
// Compute emitted and reflected light at ray intersection point
// Evaluate BSDF at hit point
BSDF *bsdf = isect.GetBSDF(ray, arena);
// Initialize common variables for Whitted integrator
const Point &p = bsdf->dgShading.p;
const Normal &n = bsdf->dgShading.nn;
Vector wo = -ray.d;
// Compute emitted light if ray hit an area light source
L += isect.Le(wo);
// Add contribution of each light source
Vector wi;
for (u_int i = 0; i < scene->lights.size(); ++i) {
VisibilityTester visibility;
float pdf;
Spectrum Li = scene->lights[i]->Sample_L(p, isect.rayEpsilon,
LightSample(*sample->rng), sample->time, &wi, &pdf, &visibility);
if (Li.IsBlack() || pdf == 0.f) continue;
Li /= pdf;
Spectrum f = bsdf->f(wo, wi);
if (!f.IsBlack() && visibility.Unoccluded(scene))
L += f * Li * AbsDot(wi, n) *
visibility.Transmittance(scene, renderer,
sample, NULL, arena);
}
if (ray.depth + 1 < maxDepth) {
// Trace rays for specular reflection and refraction
L += SpecularReflect(ray, bsdf, *sample->rng, isect, renderer,
scene, sample, arena);
L += SpecularTransmit(ray, bsdf, *sample->rng, isect, renderer,
scene, sample, arena);
}
return L;
}
Spectrum IrradianceCacheIntegrator::Li(const Scene *scene,
const Renderer *renderer, const RayDifferential &ray, const Intersection &isect,
const Sample *sample, RNG &rng, MemoryArena &arena) const {
Spectrum L(0.);
// Evaluate BSDF at hit point
BSDF *bsdf = isect.GetBSDF(ray, arena);
Vector wo = -ray.d;
const Point &p = bsdf->dgShading.p;
const Normal &n = bsdf->dgShading.nn;
L += isect.Le(wo);
// Compute direct lighting for irradiance cache
L += UniformSampleAllLights(scene, renderer, arena, p, n, wo,
isect.rayEpsilon, ray.time, bsdf, sample, rng,
lightSampleOffsets, bsdfSampleOffsets);
// Compute indirect lighting for irradiance cache
if (ray.depth + 1 < maxSpecularDepth) {
Vector wi;
// Trace rays for specular reflection and refraction
L += SpecularReflect(ray, bsdf, rng, isect, renderer, scene, sample,
arena);
L += SpecularTransmit(ray, bsdf, rng, isect, renderer, scene, sample,
arena);
}
// Estimate indirect lighting with irradiance cache
Normal ng = isect.dg.nn;
ng = Faceforward(ng, wo);
// Compute pixel spacing in world space at intersection point
float pixelSpacing = sqrtf(Cross(isect.dg.dpdx, isect.dg.dpdy).Length());
BxDFType flags = BxDFType(BSDF_REFLECTION | BSDF_DIFFUSE | BSDF_GLOSSY);
L += indirectLo(p, ng, pixelSpacing, wo, isect.rayEpsilon,
bsdf, flags, rng, scene, renderer, arena);
flags = BxDFType(BSDF_TRANSMISSION | BSDF_DIFFUSE | BSDF_GLOSSY);
L += indirectLo(p, -ng, pixelSpacing, wo, isect.rayEpsilon,
bsdf, flags, rng, scene, renderer, arena);
return L;
}
// radiance along a specific ray direction
Spectrum DirectLight::Li( const Ray& r , const PixelSample& ps ) const
{
if( r.m_Depth > max_recursive_depth )
return 0.0f;
// get the intersection between the ray and the scene
Intersection ip;
// evaluate light directly
if( false == scene.GetIntersect( r , &ip ) )
return scene.Le( r );
Spectrum li = ip.Le( -r.m_Dir );
// eavluate direct light
unsigned light_num = scene.LightNum();
for( unsigned i = 0 ; i < light_num ; ++i )
{
const Light* light = scene.GetLight(i);
li += EvaluateDirect( r , scene , light , ip , LightSample(true) , BsdfSample(true), BXDF_TYPE( BXDF_ALL ) );
}
return li;
}
Spectrum PhotonIntegrator::Li(const Scene *scene, const Renderer *renderer,
const RayDifferential &ray, const Intersection &isect,
const Sample *sample, RNG &rng, MemoryArena &arena) const {
Spectrum L(0.);
Vector wo = -ray.d;
// Compute emitted light if ray hit an area light source
L += isect.Le(wo);
// Evaluate BSDF at hit pbrt::Point
BSDF *bsdf = isect.GetBSDF(ray, arena);
const pbrt::Point &p = bsdf->dgShading.p;
const Normal &n = bsdf->dgShading.nn;
L += UniformSampleAllLights(scene, renderer, arena, p, n,
wo, isect.rayEpsilon, ray.time, bsdf, sample, rng,
lightSampleOffsets, bsdfSampleOffsets);
// Compute caustic lighting for photon map integrator
ClosePhoton *lookupBuf = arena.Alloc<ClosePhoton>(nLookup);
L += LPhoton(causticMap, nCausticPaths, nLookup, lookupBuf, bsdf,
rng, isect, wo, maxDistSquared);
// Compute indirect lighting for photon map integrator
if (finalGather && indirectMap != NULL) {
#if 1
// Do one-bounce final gather for photon map
BxDFType nonSpecular = BxDFType(BSDF_REFLECTION |
BSDF_TRANSMISSION | BSDF_DIFFUSE | BSDF_GLOSSY);
if (bsdf->NumComponents(nonSpecular) > 0) {
// Find indirect photons around point for importance sampling
const uint32_t nIndirSamplePhotons = 50;
PhotonProcess proc(nIndirSamplePhotons,
arena.Alloc<ClosePhoton>(nIndirSamplePhotons));
float searchDist2 = maxDistSquared;
while (proc.nFound < nIndirSamplePhotons) {
float md2 = searchDist2;
proc.nFound = 0;
indirectMap->Lookup(p, proc, md2);
searchDist2 *= 2.f;
}
// Copy photon directions to local array
Vector *photonDirs = arena.Alloc<Vector>(nIndirSamplePhotons);
for (uint32_t i = 0; i < nIndirSamplePhotons; ++i)
photonDirs[i] = proc.photons[i].photon->wi;
// Use BSDF to do final gathering
Spectrum Li = 0.;
for (int i = 0; i < gatherSamples; ++i) {
// Sample random direction from BSDF for final gather ray
Vector wi;
float pdf;
BSDFSample bsdfSample(sample, bsdfGatherSampleOffsets, i);
Spectrum fr = bsdf->Sample_f(wo, &wi, bsdfSample,
&pdf, BxDFType(BSDF_ALL & ~BSDF_SPECULAR));
if (fr.IsBlack() || pdf == 0.f) continue;
Assert(pdf >= 0.f);
// Trace BSDF final gather ray and accumulate radiance
RayDifferential bounceRay(p, wi, ray, isect.rayEpsilon);
Intersection gatherIsect;
if (scene->Intersect(bounceRay, &gatherIsect)) {
// Compute exitant radiance _Lindir_ using radiance photons
Spectrum Lindir = 0.f;
Normal nGather = gatherIsect.dg.nn;
nGather = Faceforward(nGather, -bounceRay.d);
RadiancePhotonProcess proc(nGather);
float md2 = INFINITY;
radianceMap->Lookup(gatherIsect.dg.p, proc, md2);
if (proc.photon != NULL)
Lindir = proc.photon->Lo;
Lindir *= renderer->Transmittance(scene, bounceRay, NULL, rng, arena);
// Compute MIS weight for BSDF-sampled gather ray
// Compute PDF for photon-sampling of direction _wi_
float photonPdf = 0.f;
float conePdf = UniformConePdf(cosGatherAngle);
for (uint32_t j = 0; j < nIndirSamplePhotons; ++j)
if (Dot(photonDirs[j], wi) > .999f * cosGatherAngle)
photonPdf += conePdf;
photonPdf /= nIndirSamplePhotons;
float wt = PowerHeuristic(gatherSamples, pdf, gatherSamples, photonPdf);
Li += fr * Lindir * (AbsDot(wi, n) * wt / pdf);
}
}
L += Li / gatherSamples;
// Use nearby photons to do final gathering
Li = 0.;
for (int i = 0; i < gatherSamples; ++i) {
// Sample random direction using photons for final gather ray
BSDFSample gatherSample(sample, indirGatherSampleOffsets, i);
int photonNum = min((int)nIndirSamplePhotons - 1,
Floor2Int(gatherSample.uComponent * nIndirSamplePhotons));
// Sample gather ray direction from _photonNum_
Vector vx, vy;
CoordinateSystem(photonDirs[photonNum], &vx, &vy);
Vector wi = UniformSampleCone(gatherSample.uDir[0], gatherSample.uDir[1],
cosGatherAngle, vx, vy, photonDirs[photonNum]);
// Trace photon-sampled final gather ray and accumulate radiance
Spectrum fr = bsdf->f(wo, wi);
if (fr.IsBlack()) continue;
RayDifferential bounceRay(p, wi, ray, isect.rayEpsilon);
Intersection gatherIsect;
PBRT_PHOTON_MAP_STARTED_GATHER_RAY(&bounceRay);
if (scene->Intersect(bounceRay, &gatherIsect)) {
// Compute exitant radiance _Lindir_ using radiance photons
Spectrum Lindir = 0.f;
Normal nGather = gatherIsect.dg.nn;
nGather = Faceforward(nGather, -bounceRay.d);
RadiancePhotonProcess proc(nGather);
float md2 = INFINITY;
radianceMap->Lookup(gatherIsect.dg.p, proc, md2);
if (proc.photon != NULL)
Lindir = proc.photon->Lo;
Lindir *= renderer->Transmittance(scene, bounceRay, NULL, rng, arena);
// Compute PDF for photon-sampling of direction _wi_
float photonPdf = 0.f;
float conePdf = UniformConePdf(cosGatherAngle);
for (uint32_t j = 0; j < nIndirSamplePhotons; ++j)
if (Dot(photonDirs[j], wi) > .999f * cosGatherAngle)
photonPdf += conePdf;
photonPdf /= nIndirSamplePhotons;
// Compute MIS weight for photon-sampled gather ray
float bsdfPdf = bsdf->Pdf(wo, wi);
float wt = PowerHeuristic(gatherSamples, photonPdf, gatherSamples, bsdfPdf);
Li += fr * Lindir * AbsDot(wi, n) * wt / photonPdf;
}
PBRT_PHOTON_MAP_FINISHED_GATHER_RAY(&bounceRay);
}
L += Li / gatherSamples;
}
#else
// for debugging / examples: use the photon map directly
Normal nn = Faceforward(n, -ray.d);
RadiancePhotonProcess proc(nn);
float md2 = INFINITY;
radianceMap->Lookup(p, proc, md2);
if (proc.photon)
L += proc.photon->Lo;
#endif
}
else
L += LPhoton(indirectMap, nIndirectPaths, nLookup, lookupBuf,
bsdf, rng, isect, wo, maxDistSquared);
if (ray.depth+1 < maxSpecularDepth) {
Vector wi;
// Trace rays for specular reflection and refraction
L += SpecularReflect(ray, bsdf, rng, isect, renderer, scene, sample,
arena);
L += SpecularTransmit(ray, bsdf, rng, isect, renderer, scene, sample,
arena);
}
return L;
}
// WhittedIntegrator [ surface integrator ] Method Definitions
Spectrum WhittedIntegrator::Li(const Scene *scene,
const Renderer *renderer, const RayDifferential &ray,
const Intersection &isect, const Sample *sample, RNG &rng,
MemoryArena &arena) const {
Spectrum L(0.);
// Compute emitted and reflected light at ray intersection point
// Evaluate BSDF at hit point
BSDF *bsdf = isect.GetBSDF(ray, arena); // return BSDF of the material of the hit primitive
// Initialize common variables for Whitted integrator
const pbrt::Point &p = bsdf->dgShading.p;
const Normal &n = bsdf->dgShading.nn;
Vector wo = -ray.d;
// Compute emitted light at the intersection point. The emiited light exists if
// the intersection occured at an area light source; otherwise, it is zero.
L += isect.Le(wo);
// Add contribution of each light source
for (uint32_t i = 0; i < scene->lights.size(); ++i) {
Vector wi;
float pdf;
VisibilityTester visibility;
Spectrum Li = scene->lights[i]->Sample_L(p, isect.rayEpsilon,
LightSample(rng), ray.time, &wi, &pdf, &visibility);
// if light is a delta light, then "reflection" direction wi is set to the light direction with pdf =1
if (Li.IsBlack() || pdf == 0.f) continue;
Spectrum f = bsdf->f(wo, wi);
//
// compute the fraction of light to be reflected from wi to wo.
// ONLY non-delta BXDF, e.g. Lambertian (diffuse reflection) contributes to f here.
if (!f.IsBlack() && visibility.Unoccluded(scene))
// bsdf indicates that some of the incident
// light from direction wi is in fact scattered to the direction wo
L += f * Li * AbsDot(wi, n) *
visibility.Transmittance(scene, renderer,
sample, rng, arena) / pdf;
}
// consider the specular reflection and the specular transmission;
// you can get this component only when the light sources are NOT delta distribution.
// there's no possible way that the peaks of the two delta distributions (the glass
// and the point light) match. it is not possible
// to get a highlight of a point light source in a mirror.
if (ray.depth + 1 < maxDepth) {
// Trace rays for specular reflection and refraction
L += SpecularReflect(ray, bsdf, rng, isect, renderer, scene, sample,
arena);
L += SpecularTransmit(ray, bsdf, rng, isect, renderer, scene, sample,
arena);
}
return L;
}
// WhittedIntegrator Method Definitions
Spectrum WhittedIntegrator::Li(const Scene *scene,
const RayDifferential &ray, const Sample *sample,
float *alpha) const {
Intersection isect;
Spectrum L(0.);
bool hitSomething;
// Search for ray-primitive intersection
hitSomething = scene->Intersect(ray, &isect);
if (!hitSomething) {
// Handle ray with no intersection
if (alpha) *alpha = 0.;
for (u_int i = 0; i < scene->lights.size(); ++i)
L += scene->lights[i]->Le(ray);
if (alpha && !L.Black()) *alpha = 1.;
return L;
}
else {
// Initialize _alpha_ for ray hit
if (alpha) *alpha = 1.;
// Compute emitted and reflected light at ray intersection point
// Evaluate BSDF at hit point
BSDF *bsdf = isect.GetBSDF(ray);
// Initialize common variables for Whitted integrator
const Point &p = bsdf->dgShading.p;
const Normal &n = bsdf->dgShading.nn;
Vector wo = -ray.d;
// Compute emitted light if ray hit an area light source
L += isect.Le(wo);
// Add contribution of each light source
Vector wi;
for (u_int i = 0; i < scene->lights.size(); ++i) {
VisibilityTester visibility;
Spectrum Li = scene->lights[i]->Sample_L(p, &wi, &visibility);
if (Li.Black()) continue;
Spectrum f = bsdf->f(wo, wi);
if (!f.Black() && visibility.Unoccluded(scene))
L += f * Li * AbsDot(wi, n) * visibility.Transmittance(scene);
}
if (rayDepth++ < maxDepth) {
// Trace rays for specular reflection and refraction
Spectrum f = bsdf->Sample_f(wo, &wi,
BxDFType(BSDF_REFLECTION | BSDF_SPECULAR));
if (!f.Black() && AbsDot(wi, n) > 0.f) {
// Compute ray differential _rd_ for specular reflection
RayDifferential rd(p, wi);
rd.hasDifferentials = true;
rd.rx.o = p + isect.dg.dpdx;
rd.ry.o = p + isect.dg.dpdy;
// Compute differential reflected directions
Normal dndx = bsdf->dgShading.dndu * bsdf->dgShading.dudx +
bsdf->dgShading.dndv * bsdf->dgShading.dvdx;
Normal dndy = bsdf->dgShading.dndu * bsdf->dgShading.dudy +
bsdf->dgShading.dndv * bsdf->dgShading.dvdy;
Vector dwodx = -ray.rx.d - wo, dwody = -ray.ry.d - wo;
float dDNdx = Dot(dwodx, n) + Dot(wo, dndx);
float dDNdy = Dot(dwody, n) + Dot(wo, dndy);
rd.rx.d = wi -
dwodx + 2 * Vector(Dot(wo, n) * dndx +
dDNdx * n);
rd.ry.d = wi -
dwody + 2 * Vector(Dot(wo, n) * dndy +
dDNdy * n);
L += scene->Li(rd, sample) * f * AbsDot(wi, n);
}
f = bsdf->Sample_f(wo, &wi,
BxDFType(BSDF_TRANSMISSION | BSDF_SPECULAR));
if (!f.Black() && AbsDot(wi, n) > 0.f) {
// Compute ray differential _rd_ for specular transmission
RayDifferential rd(p, wi);
rd.hasDifferentials = true;
rd.rx.o = p + isect.dg.dpdx;
rd.ry.o = p + isect.dg.dpdy;
float eta = bsdf->eta;
Vector w = -wo;
if (Dot(wo, n) < 0) eta = 1.f / eta;
Normal dndx = bsdf->dgShading.dndu * bsdf->dgShading.dudx + bsdf->dgShading.dndv * bsdf->dgShading.dvdx;
Normal dndy = bsdf->dgShading.dndu * bsdf->dgShading.dudy + bsdf->dgShading.dndv * bsdf->dgShading.dvdy;
Vector dwodx = -ray.rx.d - wo, dwody = -ray.ry.d - wo;
float dDNdx = Dot(dwodx, n) + Dot(wo, dndx);
float dDNdy = Dot(dwody, n) + Dot(wo, dndy);
float mu = eta * Dot(w, n) - Dot(wi, n);
float dmudx = (eta - (eta*eta*Dot(w,n))/Dot(wi, n)) * dDNdx;
float dmudy = (eta - (eta*eta*Dot(w,n))/Dot(wi, n)) * dDNdy;
rd.rx.d = wi + eta * dwodx - Vector(mu * dndx + dmudx * n);
rd.ry.d = wi + eta * dwody - Vector(mu * dndy + dmudy * n);
L += scene->Li(rd, sample) * f * AbsDot(wi, n);
}
}
--rayDepth;
}
return L;
}
Spectrum PhotonIntegrator::Li(const Scene *scene,
const RayDifferential &ray, const Sample *sample,
float *alpha) const {
// Compute reflected radiance with photon map
Spectrum L(0.);
Intersection isect;
if (scene->Intersect(ray, &isect)) {
if (alpha) *alpha = 1.;
Vector wo = -ray.d;
// Compute emitted light if ray hit an area light source
L += isect.Le(wo);
// Evaluate BSDF at hit point
BSDF *bsdf = isect.GetBSDF(ray);
const Point &p = bsdf->dgShading.p;
const Normal &n = bsdf->dgShading.nn;
// Compute direct lighting for photon map integrator
if (directWithPhotons)
L += LPhoton(directMap, nDirectPaths, nLookup,
bsdf, isect, wo, maxDistSquared);
else
L += UniformSampleAllLights(scene, p, n,
wo, bsdf, sample,
lightSampleOffset, bsdfSampleOffset,
bsdfComponentOffset);
// Compute indirect lighting for photon map integrator
L += LPhoton(causticMap, nCausticPaths, nLookup, bsdf,
isect, wo, maxDistSquared);
if (finalGather) {
// Do one-bounce final gather for photon map
Spectrum Li(0.);
for (int i = 0; i < gatherSamples; ++i) {
// Sample random direction for final gather ray
Vector wi;
float u1 = sample->twoD[gatherSampleOffset][2*i];
float u2 = sample->twoD[gatherSampleOffset][2*i+1];
float u3 = sample->oneD[gatherComponentOffset][i];
float pdf;
Spectrum fr = bsdf->Sample_f(wo, &wi, u1, u2, u3,
&pdf, BxDFType(BSDF_ALL & (~BSDF_SPECULAR)));
if (fr.Black() || pdf == 0.f) continue;
RayDifferential bounceRay(p, wi);
static StatsCounter gatherRays("Photon Map", // NOBOOK
"Final gather rays traced"); // NOBOOK
++gatherRays; // NOBOOK
Intersection gatherIsect;
if (scene->Intersect(bounceRay, &gatherIsect)) {
// Compute exitant radiance at final gather intersection
BSDF *gatherBSDF = gatherIsect.GetBSDF(bounceRay);
Vector bounceWo = -bounceRay.d;
Spectrum Lindir =
LPhoton(directMap, nDirectPaths, nLookup,
gatherBSDF, gatherIsect, bounceWo, maxDistSquared) +
LPhoton(indirectMap, nIndirectPaths, nLookup,
gatherBSDF, gatherIsect, bounceWo, maxDistSquared) +
LPhoton(causticMap, nCausticPaths, nLookup,
gatherBSDF, gatherIsect, bounceWo, maxDistSquared);
Lindir *= scene->Transmittance(bounceRay);
Li += fr * Lindir * AbsDot(wi, n) / pdf;
}
}
L += Li / float(gatherSamples);
}
else
L += LPhoton(indirectMap, nIndirectPaths, nLookup,
bsdf, isect, wo, maxDistSquared);
if (specularDepth++ < maxSpecularDepth) {
Vector wi;
// Trace rays for specular reflection and refraction
Spectrum f = bsdf->Sample_f(wo, &wi,
BxDFType(BSDF_REFLECTION | BSDF_SPECULAR));
if (!f.Black()) {
// Compute ray differential _rd_ for specular reflection
RayDifferential rd(p, wi);
rd.hasDifferentials = true;
rd.rx.o = p + isect.dg.dpdx;
rd.ry.o = p + isect.dg.dpdy;
// Compute differential reflected directions
Normal dndx = bsdf->dgShading.dndu * bsdf->dgShading.dudx +
bsdf->dgShading.dndv * bsdf->dgShading.dvdx;
Normal dndy = bsdf->dgShading.dndu * bsdf->dgShading.dudy +
bsdf->dgShading.dndv * bsdf->dgShading.dvdy;
Vector dwodx = -ray.rx.d - wo, dwody = -ray.ry.d - wo;
float dDNdx = Dot(dwodx, n) + Dot(wo, dndx);
float dDNdy = Dot(dwody, n) + Dot(wo, dndy);
rd.rx.d = wi -
dwodx + 2 * Vector(Dot(wo, n) * dndx +
dDNdx * n);
rd.ry.d = wi -
dwody + 2 * Vector(Dot(wo, n) * dndy +
dDNdy * n);
L += scene->Li(rd, sample) * f * AbsDot(wi, n);
}
f = bsdf->Sample_f(wo, &wi,
BxDFType(BSDF_TRANSMISSION | BSDF_SPECULAR));
if (!f.Black()) {
// Compute ray differential _rd_ for specular transmission
RayDifferential rd(p, wi);
rd.hasDifferentials = true;
rd.rx.o = p + isect.dg.dpdx;
rd.ry.o = p + isect.dg.dpdy;
float eta = bsdf->eta;
Vector w = -wo;
if (Dot(wo, n) < 0) eta = 1.f / eta;
Normal dndx = bsdf->dgShading.dndu * bsdf->dgShading.dudx + bsdf->dgShading.dndv * bsdf->dgShading.dvdx;
Normal dndy = bsdf->dgShading.dndu * bsdf->dgShading.dudy + bsdf->dgShading.dndv * bsdf->dgShading.dvdy;
Vector dwodx = -ray.rx.d - wo, dwody = -ray.ry.d - wo;
float dDNdx = Dot(dwodx, n) + Dot(wo, dndx);
float dDNdy = Dot(dwody, n) + Dot(wo, dndy);
float mu = eta * Dot(w, n) - Dot(wi, n);
float dmudx = (eta - (eta*eta*Dot(w,n))/Dot(wi, n)) * dDNdx;
float dmudy = (eta - (eta*eta*Dot(w,n))/Dot(wi, n)) * dDNdy;
rd.rx.d = wi + eta * dwodx - Vector(mu * dndx + dmudx * n);
rd.ry.d = wi + eta * dwody - Vector(mu * dndy + dmudy * n);
L += scene->Li(rd, sample) * f * AbsDot(wi, n);
}
}
--specularDepth;
}
else {
// Handle ray with no intersection
if (alpha) *alpha = 0.;
for (u_int i = 0; i < scene->lights.size(); ++i)
L += scene->lights[i]->Le(ray);
if (alpha && !L.Black()) *alpha = 1.;
return L;
}
return L;
}
Spectrum DirectLighting::Li(const Scene *scene,
const RayDifferential &ray, const Sample *sample,
float *alpha) const {
Intersection isect;
Spectrum L(0.);
if (scene->Intersect(ray, &isect)) {
if (alpha) *alpha = 1.;
// Evaluate BSDF at hit point
BSDF *bsdf = isect.GetBSDF(ray);
Vector wo = -ray.d;
const Point &p = bsdf->dgShading.p;
const Normal &n = bsdf->dgShading.nn;
// Compute emitted light if ray hit an area light source
L += isect.Le(wo);
// Compute direct lighting for _DirectLighting_ integrator
if (scene->lights.size() > 0) {
// Apply direct lighting strategy
switch (strategy) {
case SAMPLE_ALL_UNIFORM:
L += UniformSampleAllLights(scene, p, n, wo, bsdf,
sample, lightSampleOffset, bsdfSampleOffset,
bsdfComponentOffset);
break;
case SAMPLE_ONE_UNIFORM:
L += UniformSampleOneLight(scene, p, n, wo, bsdf,
sample, lightSampleOffset[0], lightNumOffset,
bsdfSampleOffset[0], bsdfComponentOffset[0]);
break;
case SAMPLE_ONE_WEIGHTED:
L += WeightedSampleOneLight(scene, p, n, wo, bsdf,
sample, lightSampleOffset[0], lightNumOffset,
bsdfSampleOffset[0], bsdfComponentOffset[0], avgY,
avgYsample, cdf, overallAvgY);
break;
}
}
if (rayDepth++ < maxDepth) {
Vector wi;
// Trace rays for specular reflection and refraction
Spectrum f = bsdf->Sample_f(wo, &wi,
BxDFType(BSDF_REFLECTION | BSDF_SPECULAR));
if (!f.Black()) {
// Compute ray differential _rd_ for specular reflection
RayDifferential rd(p, wi);
rd.hasDifferentials = true;
rd.rx.o = p + isect.dg.dpdx;
rd.ry.o = p + isect.dg.dpdy;
// Compute differential reflected directions
Normal dndx = bsdf->dgShading.dndu * bsdf->dgShading.dudx +
bsdf->dgShading.dndv * bsdf->dgShading.dvdx;
Normal dndy = bsdf->dgShading.dndu * bsdf->dgShading.dudy +
bsdf->dgShading.dndv * bsdf->dgShading.dvdy;
Vector dwodx = -ray.rx.d - wo, dwody = -ray.ry.d - wo;
float dDNdx = Dot(dwodx, n) + Dot(wo, dndx);
float dDNdy = Dot(dwody, n) + Dot(wo, dndy);
rd.rx.d = wi -
dwodx + 2 * Vector(Dot(wo, n) * dndx +
dDNdx * n);
rd.ry.d = wi -
dwody + 2 * Vector(Dot(wo, n) * dndy +
dDNdy * n);
L += scene->Li(rd, sample) * f * AbsDot(wi, n);
}
f = bsdf->Sample_f(wo, &wi,
BxDFType(BSDF_TRANSMISSION | BSDF_SPECULAR));
if (!f.Black()) {
// Compute ray differential _rd_ for specular transmission
RayDifferential rd(p, wi);
rd.hasDifferentials = true;
rd.rx.o = p + isect.dg.dpdx;
rd.ry.o = p + isect.dg.dpdy;
float eta = bsdf->eta;
Vector w = -wo;
if (Dot(wo, n) < 0) eta = 1.f / eta;
Normal dndx = bsdf->dgShading.dndu * bsdf->dgShading.dudx + bsdf->dgShading.dndv * bsdf->dgShading.dvdx;
Normal dndy = bsdf->dgShading.dndu * bsdf->dgShading.dudy + bsdf->dgShading.dndv * bsdf->dgShading.dvdy;
Vector dwodx = -ray.rx.d - wo, dwody = -ray.ry.d - wo;
float dDNdx = Dot(dwodx, n) + Dot(wo, dndx);
float dDNdy = Dot(dwody, n) + Dot(wo, dndy);
float mu = eta * Dot(w, n) - Dot(wi, n);
float dmudx = (eta - (eta*eta*Dot(w,n))/Dot(wi, n)) * dDNdx;
float dmudy = (eta - (eta*eta*Dot(w,n))/Dot(wi, n)) * dDNdy;
rd.rx.d = wi + eta * dwodx - Vector(mu * dndx + dmudx * n);
rd.ry.d = wi + eta * dwody - Vector(mu * dndy + dmudy * n);
L += scene->Li(rd, sample) * f * AbsDot(wi, n);
}
}
--rayDepth;
}
else {
// Handle ray with no intersection
if (alpha) *alpha = 0.;
for (u_int i = 0; i < scene->lights.size(); ++i)
L += scene->lights[i]->Le(ray);
if (alpha && !L.Black()) *alpha = 1.;
return L;
}
return L;
}
void DistributedPath::LiInternal(const Scene &scene, const Sample &sample,
const Volume *volume, bool scattered, const Ray &ray,
vector<SWCSpectrum> &L, float *alpha, float *zdepth,
u_int rayDepth, bool includeEmit, u_int &nrContribs) const
{
Intersection isect;
BSDF *bsdf;
const float time = ray.time; // save time for motion blur
const SpectrumWavelengths &sw(sample.swl);
SWCSpectrum Lt(1.f);
float spdf;
if (scene.Intersect(sample, volume, scattered, ray,
sample.sampler->GetOneD(sample, scatterOffset, rayDepth),
&isect, &bsdf, &spdf, NULL, &Lt)) {
// Evaluate BSDF at hit point
Vector wo = -ray.d;
const Point &p = bsdf->dgShading.p;
const Normal &n = bsdf->dgShading.nn;
if (rayDepth == 0) {
// Set Zbuf depth
const Vector zv(p - ray.o);
*zdepth = zv.Length();
// Override alpha
if(bsdf->compParams->oA)
*alpha = bsdf->compParams->A;
// Compute emitted light if ray hit an area light source with Visibility check
if(bsdf->compParams->tVl && includeEmit) {
BSDF *ibsdf;
SWCSpectrum Le(1.f);
if (isect.Le(sample, ray, &ibsdf, NULL, NULL,
&Le)) {
L[isect.arealight->group] += Le;
++nrContribs;
}
}
// Visibility check
if(!bsdf->compParams->tVm) {
if (!bsdf->compParams->oA)
*alpha = 0.f;
return;
}
} else {
// Compute emitted light if ray hit an area light source with Visibility check
if(bsdf->compParams->tiVl && includeEmit) {
BSDF *ibsdf;
SWCSpectrum Le(1.f);
if (isect.Le(sample, ray, &ibsdf, NULL, NULL,
&Le)) {
L[isect.arealight->group] += Le;
++nrContribs;
}
}
// Visibility check
if(!bsdf->compParams->tiVm)
return;
}
// Compute direct lighting for _DistributedPath_ integrator
if (scene.lights.size() > 0) {
const u_int samples = rayDepth > 0 ? indirectSamples :
directSamples;
const float invsamples = 1.f / samples;
float lightSample[2], lightNum;
float bsdfSample[2], bsdfComponent;
for (u_int i = 0; i < samples; ++i) {
// get samples
if (rayDepth > 0) {
const u_int index = i * rayDepth;
sample.sampler->GetTwoD(sample,
indirectLightSampleOffset,
index, lightSample);
lightNum = sample.sampler->GetOneD(sample, indirectLightNumOffset, index);
sample.sampler->GetTwoD(sample,
indirectBsdfSampleOffset,
index, bsdfSample);
bsdfComponent = sample.sampler->GetOneD(sample, indirectBsdfComponentOffset, index);
} else {
sample.sampler->GetTwoD(sample,
lightSampleOffset, i,
lightSample);
lightNum = sample.sampler->GetOneD(sample, lightNumOffset, i);
sample.sampler->GetTwoD(sample,
bsdfSampleOffset, i,
bsdfSample);
bsdfComponent = sample.sampler->GetOneD(sample, bsdfComponentOffset, i);
}
// Apply direct lighting strategy
switch (lightStrategy) {
case SAMPLE_ALL_UNIFORM:
for (u_int i = 0; i < scene.lights.size(); ++i) {
const SWCSpectrum Ld(EstimateDirect(scene, *(scene.lights[i]), sample, p, n, wo, bsdf,
lightSample[0], lightSample[1], lightNum, bsdfSample[0], bsdfSample[1], bsdfComponent));
if (!Ld.Black()) {
L[scene.lights[i]->group] += invsamples * Ld;
++nrContribs;
}
// TODO add bsdf selection flags
}
break;
case SAMPLE_ONE_UNIFORM:
{
SWCSpectrum Ld;
u_int g = UniformSampleOneLight(scene, sample, p, n, wo, bsdf,
lightSample, &lightNum, bsdfSample, &bsdfComponent, &Ld);
if (!Ld.Black()) {
L[g] += invsamples * Ld;
++nrContribs;
}
break;
}
default:
break;
}
}
}
// trace Diffuse reflection & transmission rays
if (rayDepth < diffuseReflectDepth) {
ComputeEvent(scene, sample, bsdf, wo, diffuseReflectSamples,
indirectDiffuseReflectSampleOffset, indirectDiffuseReflectComponentOffset,
diffuseReflectSampleOffset, diffuseReflectComponentOffset,
BxDFType(BSDF_REFLECTION | BSDF_DIFFUSE),
diffuseReflectReject, diffuseReflectRejectThreshold,
L, alpha, zdepth, rayDepth, nrContribs);
}
if (rayDepth < diffuseRefractDepth) {
ComputeEvent(scene, sample, bsdf, wo, diffuseRefractSamples,
indirectDiffuseRefractSampleOffset, indirectDiffuseRefractComponentOffset,
diffuseRefractSampleOffset, diffuseRefractComponentOffset,
BxDFType(BSDF_TRANSMISSION | BSDF_DIFFUSE),
diffuseRefractReject, diffuseRefractRejectThreshold,
L, alpha, zdepth, rayDepth, nrContribs);
}
// trace Glossy reflection & transmission rays
if (rayDepth < glossyReflectDepth) {
ComputeEvent(scene, sample, bsdf, wo, glossyReflectSamples,
indirectGlossyReflectSampleOffset, indirectGlossyReflectComponentOffset,
glossyReflectSampleOffset, glossyReflectComponentOffset,
BxDFType(BSDF_REFLECTION | BSDF_GLOSSY),
glossyReflectReject, glossyReflectRejectThreshold,
L, alpha, zdepth, rayDepth, nrContribs);
}
if (rayDepth < glossyRefractDepth) {
ComputeEvent(scene, sample, bsdf, wo, glossyRefractSamples,
indirectGlossyRefractSampleOffset, indirectGlossyRefractComponentOffset,
glossyRefractSampleOffset, glossyRefractComponentOffset,
BxDFType(BSDF_TRANSMISSION | BSDF_GLOSSY),
glossyRefractReject, glossyRefractRejectThreshold,
L, alpha, zdepth, rayDepth, nrContribs);
}
// trace specular reflection & transmission rays
if (rayDepth < specularReflectDepth) {
float pdf;
Vector wi;
SWCSpectrum f;
if (bsdf->SampleF(sw, wo, &wi, .5f, .5f, .5f, &f, &pdf,
BxDFType(BSDF_REFLECTION | BSDF_SPECULAR),
NULL, NULL, true)) {
Ray rd(p, wi);
rd.time = time;
vector<SWCSpectrum> Ll(L.size(),
SWCSpectrum(0.f));
LiInternal(scene, sample, bsdf->GetVolume(wi),
bsdf->dgShading.scattered, rd, Ll,
alpha, zdepth, rayDepth + 1, true,
nrContribs);
for (u_int j = 0; j < L.size(); ++j)
L[j] += f * Ll[j];
}
}
if (rayDepth < specularRefractDepth) {
float pdf;
Vector wi;
SWCSpectrum f;
if (bsdf->SampleF(sw, wo, &wi, .5f, .5f, .5f, &f, &pdf,
BxDFType(BSDF_TRANSMISSION | BSDF_SPECULAR),
NULL, NULL, true)) {
Ray rd(p, wi);
rd.time = time;
vector<SWCSpectrum> Ll(L.size(),
SWCSpectrum(0.f));
LiInternal(scene, sample, bsdf->GetVolume(wi),
bsdf->dgShading.scattered, rd, Ll,
alpha, zdepth, rayDepth + 1, true,
nrContribs);
for (u_int j = 0; j < L.size(); ++j)
L[j] += f * Ll[j];
}
}
} else {
// Handle ray with no intersection
BSDF *ibsdf;
for (u_int i = 0; i < scene.lights.size(); ++i) {
SWCSpectrum Le(1.f);
if (scene.lights[i]->Le(scene, sample, ray, &ibsdf,
NULL, NULL, &Le)) {
L[scene.lights[i]->group] += Le;
++nrContribs;
}
}
if (rayDepth == 0)
*alpha = 0.f;
}
Lt /= spdf;
for (u_int i = 0; i < L.size(); ++i)
L[i] *= Lt;
SWCSpectrum Lv(0.f);
u_int g = scene.volumeIntegrator->Li(scene, ray, sample, &Lv, alpha);
L[g] += Lv;
}
void PreviewWorker::processIncoherent(const WorkUnit *workUnit, WorkResult *workResult,
const bool &stop) {
const RectangularWorkUnit *rect = static_cast<const RectangularWorkUnit *>(workUnit);
ImageBlock *block = static_cast<ImageBlock *>(workResult);
block->setOffset(rect->getOffset());
block->setSize(rect->getSize());
const int sx = rect->getOffset().x, sy = block->getOffset().y;
const int ex = sx + rect->getSize().x, ey = sy + rect->getSize().y;
/* Some local variables */
int pos = 0;
Intersection its;
Spectrum value, bsdfVal;
Vector toVPL;
Ray primary, secondary;
int numRays = 0;
float shutterOpen = m_scene->getCamera()->getShutterOpen();
for (int y=sy; y<ey; ++y) {
for (int x=sx; x<ex; ++x) {
/* Generate a camera ray without normalization */
primary = Ray(m_cameraO, m_cameraTL
+ m_cameraDx * (Float) x
+ m_cameraDy * (Float) y, shutterOpen);
++numRays;
if (!m_kdtree->rayIntersect(primary, its)) {
block->setPixel(pos++, m_scene->LeBackground(primary)*m_backgroundScale);
continue;
}
if (its.shape->isLuminaire())
value = its.Le(-primary.d);
else
value = Spectrum(0.0f);
toVPL = m_vpl.its.p - its.p;
secondary = Ray(its.p, toVPL, ShadowEpsilon, 1-ShadowEpsilon, shutterOpen);
++numRays;
if (m_kdtree->rayIntersect(secondary)) {
block->setPixel(pos++, value);
continue;
}
Float length = toVPL.length();
toVPL/=length;
BSDFQueryRecord rr(its, its.toLocal(toVPL));
rr.wi = normalize(rr.wi);
bsdfVal = its.shape->getBSDF()->eval(rr);
length = std::max(length, m_minDist);
if (m_vpl.type == ESurfaceVPL) {
BSDFQueryRecord bRec(m_vpl.its, -m_vpl.its.toLocal(toVPL));
bRec.quantity = EImportance;
value += m_vpl.P * bsdfVal * m_vpl.its.shape->getBSDF()->eval(bRec) / (length*length);
} else {
EmissionRecord eRec(m_vpl.luminaire,
ShapeSamplingRecord(m_vpl.its.p, m_vpl.its.shFrame.n), -toVPL);
eRec.type = EmissionRecord::EPreview;
value += m_vpl.P * bsdfVal * m_vpl.luminaire->evalDirection(eRec)
* ((m_vpl.luminaire->getType() & Luminaire::EOnSurface ?
dot(m_vpl.its.shFrame.n, -toVPL) : (Float) 1)
/ (length*length));
}
block->setPixel(pos++, value);
}
}
block->setExtra(numRays);
}
Spectrum UseRadianceProbes::Li(const Scene *scene, const Renderer *renderer,
const RayDifferential &ray, const Intersection &isect,
const Sample *sample, RNG &rng, MemoryArena &arena, int wavelength) const {
Spectrum L(0.);
Vector wo = -ray.d;
// Compute emitted light if ray hit an area light source
L += isect.Le(wo);
// Evaluate BSDF at hit point
BSDF *bsdf = isect.GetBSDF(ray, arena, wavelength);
const Point &p = bsdf->dgShading.p;
const Normal &n = bsdf->dgShading.nn;
// Compute reflection for radiance probes integrator
if (!includeDirectInProbes)
L += UniformSampleAllLights(scene, renderer, arena, p, n,
wo, isect.rayEpsilon, ray.time, bsdf, sample, rng,
lightSampleOffsets, bsdfSampleOffsets);
// Compute reflected lighting using radiance probes
// Compute probe coordinates and offsets for lookup point
Vector offset = bbox.Offset(p);
float voxx = (offset.x * nProbes[0]) - 0.5f;
float voxy = (offset.y * nProbes[1]) - 0.5f;
float voxz = (offset.z * nProbes[2]) - 0.5f;
int vx = Floor2Int(voxx), vy = Floor2Int(voxy), vz = Floor2Int(voxz);
float dx = voxx - vx, dy = voxy - vy, dz = voxz - vz;
// Get radiance probe coefficients around lookup point
const Spectrum *b000 = c_inXYZ(lmax, vx, vy, vz);
const Spectrum *b100 = c_inXYZ(lmax, vx+1, vy, vz);
const Spectrum *b010 = c_inXYZ(lmax, vx, vy+1, vz);
const Spectrum *b110 = c_inXYZ(lmax, vx+1, vy+1, vz);
const Spectrum *b001 = c_inXYZ(lmax, vx, vy, vz+1);
const Spectrum *b101 = c_inXYZ(lmax, vx+1, vy, vz+1);
const Spectrum *b011 = c_inXYZ(lmax, vx, vy+1, vz+1);
const Spectrum *b111 = c_inXYZ(lmax, vx+1, vy+1, vz+1);
// Compute incident radiance from radiance probe coefficients
Spectrum *c_inp = arena.Alloc<Spectrum>(SHTerms(lmax));
for (int i = 0; i < SHTerms(lmax); ++i) {
// Do trilinear interpolation to compute SH coefficients at point
Spectrum c00 = Lerp(dx, b000[i], b100[i]);
Spectrum c10 = Lerp(dx, b010[i], b110[i]);
Spectrum c01 = Lerp(dx, b001[i], b101[i]);
Spectrum c11 = Lerp(dx, b011[i], b111[i]);
Spectrum c0 = Lerp(dy, c00, c10);
Spectrum c1 = Lerp(dy, c01, c11);
c_inp[i] = Lerp(dz, c0, c1);
}
// Convolve incident radiance to compute irradiance function
Spectrum *c_E = arena.Alloc<Spectrum>(SHTerms(lmax));
SHConvolveCosTheta(lmax, c_inp, c_E);
// Evaluate irradiance function and accumulate reflection
Spectrum rho = bsdf->rho(wo, rng, BSDF_ALL_REFLECTION);
float *Ylm = ALLOCA(float, SHTerms(lmax));
SHEvaluate(Vector(Faceforward(n, wo)), lmax, Ylm);
Spectrum E = 0.f;
for (int i = 0; i < SHTerms(lmax); ++i)
E += c_E[i] * Ylm[i];
L += rho * INV_PI * E.Clamp();
return L;
}
// private method of li
Spectrum InstantRadiosity::_li( const Ray& r , bool ignoreLe , float* first_intersect_dist ) const
{
// return if it is larger than the maximum depth
if( r.m_Depth > max_recursive_depth )
return 0.0f;
// get intersection from camera ray
Intersection ip;
if( false == scene.GetIntersect( r , &ip ) )
return ignoreLe?0.0f:scene.Le( r );
// eavluate light path less than two vertices
Spectrum radiance = ignoreLe?0.0f:ip.Le( -r.m_Dir );
unsigned light_num = scene.LightNum();
for( unsigned i = 0 ; i < light_num ; ++i )
{
const Light* light = scene.GetLight(i);
radiance += EvaluateDirect( r , scene , light , ip , LightSample(true) , BsdfSample(true) , BXDF_TYPE( BXDF_ALL ) );
}
if( first_intersect_dist )
*first_intersect_dist = ip.t;
// pick a virtual light source randomly
const unsigned lps_id = min( m_nLightPathSet - 1 , (int)(sort_canonical() * m_nLightPathSet) );
list<VirtualLightSource> vps = m_pVirtualLightSources[lps_id];
Bsdf* bsdf = ip.primitive->GetMaterial()->GetBsdf(&ip);
// evaluate indirect illumination
Spectrum indirectIllum;
list<VirtualLightSource>::const_iterator it = vps.begin();
while( it != vps.end() )
{
if( r.m_Depth + it->depth > max_recursive_depth )
{
++it;
continue;
}
Vector delta = ip.intersect - it->intersect.intersect;
float sqrLen = delta.SquaredLength();
float len = sqrt( sqrLen );
Vector n_delta = delta / len;
Bsdf* bsdf1 = it->intersect.primitive->GetMaterial()->GetBsdf(&(it->intersect));
float gterm = AbsDot( n_delta , ip.normal ) * AbsDot( n_delta , it->intersect.normal ) / max( m_fMinSqrDist , sqrLen );
Spectrum f0 = bsdf->f( -r.m_Dir , -n_delta );
Spectrum f1 = bsdf1->f( n_delta , it->wi );
Spectrum contr = gterm * f0 * f1 * it->power;
if( !contr.IsBlack() )
{
Visibility vis(scene);
vis.ray = Ray( it->intersect.intersect , n_delta , 0 , 0.001f , len - 0.001f );
if( vis.IsVisible() )
indirectIllum += contr;
}
++it;
}
radiance += indirectIllum / (float)m_nLightPaths;
if( m_fMinDist > 0.0f )
{
Vector wi;
float bsdf_pdf;
Spectrum f = bsdf->sample_f( -r.m_Dir , wi , BsdfSample( true ) , &bsdf_pdf );
if( !f.IsBlack() && bsdf_pdf != 0.0f )
{
PixelSample ps;
float gather_dist;
Ray gather_ray( ip.intersect , wi , r.m_Depth + 1 , 0.001f , m_fMinDist - 0.001f );
Spectrum li = _li( gather_ray , true , &gather_dist );
if( !li.IsBlack() )
{
float dgterm = AbsDot( wi , ip.normal ) * max( 0.0f , 1.0f - gather_dist * gather_dist / m_fMinSqrDist );
radiance += f * li * dgterm / bsdf_pdf;
}
}
}
return radiance;
}
Spectrum IrradianceCache::Li(const Scene *scene, const RayDifferential &ray,
const Sample *sample, float *alpha) const {
Intersection isect;
Spectrum L(0.);
if (scene->Intersect(ray, &isect)) {
if (alpha) *alpha = 1.;
// Evaluate BSDF at hit point
BSDF *bsdf = isect.GetBSDF(ray);
Vector wo = -ray.d;
const Point &p = bsdf->dgShading.p;
const Normal &n = bsdf->dgShading.nn;
// Compute direct lighting for irradiance cache
L += isect.Le(wo);
L += UniformSampleAllLights(scene, p, n, wo, bsdf, sample,
lightSampleOffset, bsdfSampleOffset,
bsdfComponentOffset);
// Compute indirect lighting for irradiance cache
if (specularDepth++ < maxSpecularDepth) {
Vector wi;
// Trace rays for specular reflection and refraction
Spectrum f = bsdf->Sample_f(wo, &wi,
BxDFType(BSDF_REFLECTION | BSDF_SPECULAR));
if (!f.Black()) {
// Compute ray differential _rd_ for specular reflection
RayDifferential rd(p, wi);
rd.hasDifferentials = true;
rd.rx.o = p + isect.dg.dpdx;
rd.ry.o = p + isect.dg.dpdy;
// Compute differential reflected directions
Normal dndx = bsdf->dgShading.dndu * bsdf->dgShading.dudx +
bsdf->dgShading.dndv * bsdf->dgShading.dvdx;
Normal dndy = bsdf->dgShading.dndu * bsdf->dgShading.dudy +
bsdf->dgShading.dndv * bsdf->dgShading.dvdy;
Vector dwodx = -ray.rx.d - wo, dwody = -ray.ry.d - wo;
float dDNdx = Dot(dwodx, n) + Dot(wo, dndx);
float dDNdy = Dot(dwody, n) + Dot(wo, dndy);
rd.rx.d = wi -
dwodx + 2 * Vector(Dot(wo, n) * dndx +
dDNdx * n);
rd.ry.d = wi -
dwody + 2 * Vector(Dot(wo, n) * dndy +
dDNdy * n);
L += scene->Li(rd, sample) * f * AbsDot(wi, n);
}
f = bsdf->Sample_f(wo, &wi,
BxDFType(BSDF_TRANSMISSION | BSDF_SPECULAR));
if (!f.Black()) {
// Compute ray differential _rd_ for specular transmission
RayDifferential rd(p, wi);
rd.hasDifferentials = true;
rd.rx.o = p + isect.dg.dpdx;
rd.ry.o = p + isect.dg.dpdy;
float eta = bsdf->eta;
Vector w = -wo;
if (Dot(wo, n) < 0) eta = 1.f / eta;
Normal dndx = bsdf->dgShading.dndu * bsdf->dgShading.dudx + bsdf->dgShading.dndv * bsdf->dgShading.dvdx;
Normal dndy = bsdf->dgShading.dndu * bsdf->dgShading.dudy + bsdf->dgShading.dndv * bsdf->dgShading.dvdy;
Vector dwodx = -ray.rx.d - wo, dwody = -ray.ry.d - wo;
float dDNdx = Dot(dwodx, n) + Dot(wo, dndx);
float dDNdy = Dot(dwody, n) + Dot(wo, dndy);
float mu = eta * Dot(w, n) - Dot(wi, n);
float dmudx = (eta - (eta*eta*Dot(w,n))/Dot(wi, n)) * dDNdx;
float dmudy = (eta - (eta*eta*Dot(w,n))/Dot(wi, n)) * dDNdy;
rd.rx.d = wi + eta * dwodx - Vector(mu * dndx + dmudx * n);
rd.ry.d = wi + eta * dwody - Vector(mu * dndy + dmudy * n);
L += scene->Li(rd, sample) * f * AbsDot(wi, n);
}
}
--specularDepth;
// Estimate indirect lighting with irradiance cache
Normal ng = isect.dg.nn;
if (Dot(wo, ng) < 0.f) ng = -ng;
BxDFType flags = BxDFType(BSDF_REFLECTION |
BSDF_DIFFUSE |
BSDF_GLOSSY);
L += IndirectLo(p, ng, wo, bsdf, flags, sample, scene);
flags = BxDFType(BSDF_TRANSMISSION |
BSDF_DIFFUSE |
BSDF_GLOSSY);
L += IndirectLo(p, -ng, wo, bsdf, flags, sample, scene);
}
else {
// Handle ray with no intersection
if (alpha) *alpha = 0.;
for (u_int i = 0; i < scene->lights.size(); ++i)
L += scene->lights[i]->Le(ray);
if (alpha && !L.Black()) *alpha = 1.;
return L;
}
return L;
}
Spectrum ExPhotonIntegrator::Li(const Scene *scene,
const RayDifferential &ray, const Sample *sample,
float *alpha) const {
// Compute reflected radiance with photon map
Spectrum L(0.);
Intersection isect;
if (scene->Intersect(ray, &isect)) {
if (alpha) *alpha = 1.;
Vector wo = -ray.d;
// Compute emitted light if ray hit an area light source
L += isect.Le(wo);
// Evaluate BSDF at hit point
BSDF *bsdf = isect.GetBSDF(ray);
const Point &p = bsdf->dgShading.p;
const Normal &n = bsdf->dgShading.nn;
L += UniformSampleAllLights(scene, p, n,
wo, bsdf, sample,
lightSampleOffset, bsdfSampleOffset,
bsdfComponentOffset);
// Compute indirect lighting for photon map integrator
L += LPhoton(causticMap, nCausticPaths, nLookup, bsdf,
isect, wo, maxDistSquared);
if (finalGather) {
#if 1
// Do one-bounce final gather for photon map
BxDFType nonSpecular = BxDFType(BSDF_REFLECTION |
BSDF_TRANSMISSION | BSDF_DIFFUSE | BSDF_GLOSSY);
if (bsdf->NumComponents(nonSpecular) > 0) {
// Find indirect photons around point for importance sampling
u_int nIndirSamplePhotons = 50;
PhotonProcess proc(nIndirSamplePhotons, p);
proc.photons = (ClosePhoton *)alloca(nIndirSamplePhotons *
sizeof(ClosePhoton));
float searchDist2 = maxDistSquared;
while (proc.foundPhotons < nIndirSamplePhotons) {
float md2 = searchDist2;
proc.foundPhotons = 0;
indirectMap->Lookup(p, proc, md2);
searchDist2 *= 2.f;
}
// Copy photon directions to local array
Vector *photonDirs = (Vector *)alloca(nIndirSamplePhotons *
sizeof(Vector));
for (u_int i = 0; i < nIndirSamplePhotons; ++i)
photonDirs[i] = proc.photons[i].photon->wi;
// Use BSDF to do final gathering
Spectrum Li = 0.;
static StatsCounter gatherRays("Photon Map", // NOBOOK
"Final gather rays traced"); // NOBOOK
for (int i = 0; i < gatherSamples; ++i) {
// Sample random direction from BSDF for final gather ray
Vector wi;
float u1 = sample->twoD[gatherSampleOffset[0]][2*i];
float u2 = sample->twoD[gatherSampleOffset[0]][2*i+1];
float u3 = sample->oneD[gatherComponentOffset[0]][i];
float pdf;
Spectrum fr = bsdf->Sample_f(wo, &wi, u1, u2, u3,
&pdf, BxDFType(BSDF_ALL & (~BSDF_SPECULAR)));
if (fr.Black() || pdf == 0.f) continue;
// Trace BSDF final gather ray and accumulate radiance
RayDifferential bounceRay(p, wi);
++gatherRays; // NOBOOK
Intersection gatherIsect;
if (scene->Intersect(bounceRay, &gatherIsect)) {
// Compute exitant radiance using precomputed irradiance
Spectrum Lindir = 0.f;
Normal n = gatherIsect.dg.nn;
if (Dot(n, bounceRay.d) > 0) n = -n;
RadiancePhotonProcess proc(gatherIsect.dg.p, n);
float md2 = INFINITY;
radianceMap->Lookup(gatherIsect.dg.p, proc, md2);
if (proc.photon)
Lindir = proc.photon->Lo;
Lindir *= scene->Transmittance(bounceRay);
// Compute MIS weight for BSDF-sampled gather ray
// Compute PDF for photon-sampling of direction _wi_
float photonPdf = 0.f;
float conePdf = UniformConePdf(cosGatherAngle);
for (u_int j = 0; j < nIndirSamplePhotons; ++j)
if (Dot(photonDirs[j], wi) > .999f * cosGatherAngle)
photonPdf += conePdf;
photonPdf /= nIndirSamplePhotons;
float wt = PowerHeuristic(gatherSamples, pdf,
gatherSamples, photonPdf);
Li += fr * Lindir * AbsDot(wi, n) * wt / pdf;
}
}
L += Li / gatherSamples;
// Use nearby photons to do final gathering
Li = 0.;
for (int i = 0; i < gatherSamples; ++i) {
// Sample random direction using photons for final gather ray
float u1 = sample->oneD[gatherComponentOffset[1]][i];
float u2 = sample->twoD[gatherSampleOffset[1]][2*i];
float u3 = sample->twoD[gatherSampleOffset[1]][2*i+1];
int photonNum = min((int)nIndirSamplePhotons - 1,
Floor2Int(u1 * nIndirSamplePhotons));
// Sample gather ray direction from _photonNum_
Vector vx, vy;
CoordinateSystem(photonDirs[photonNum], &vx, &vy);
Vector wi = UniformSampleCone(u2, u3, cosGatherAngle, vx, vy,
photonDirs[photonNum]);
// Trace photon-sampled final gather ray and accumulate radiance
Spectrum fr = bsdf->f(wo, wi);
if (fr.Black()) continue;
// Compute PDF for photon-sampling of direction _wi_
float photonPdf = 0.f;
float conePdf = UniformConePdf(cosGatherAngle);
for (u_int j = 0; j < nIndirSamplePhotons; ++j)
if (Dot(photonDirs[j], wi) > .999f * cosGatherAngle)
photonPdf += conePdf;
photonPdf /= nIndirSamplePhotons;
RayDifferential bounceRay(p, wi);
++gatherRays; // NOBOOK
Intersection gatherIsect;
if (scene->Intersect(bounceRay, &gatherIsect)) {
// Compute exitant radiance using precomputed irradiance
Spectrum Lindir = 0.f;
Normal n = gatherIsect.dg.nn;
if (Dot(n, bounceRay.d) > 0) n = -n;
RadiancePhotonProcess proc(gatherIsect.dg.p, n);
float md2 = INFINITY;
radianceMap->Lookup(gatherIsect.dg.p, proc, md2);
if (proc.photon)
Lindir = proc.photon->Lo;
Lindir *= scene->Transmittance(bounceRay);
// Compute MIS weight for photon-sampled gather ray
float bsdfPdf = bsdf->Pdf(wo, wi);
float wt = PowerHeuristic(gatherSamples, photonPdf,
gatherSamples, bsdfPdf);
Li += fr * Lindir * AbsDot(wi, n) * wt / photonPdf;
}
}
L += Li / gatherSamples;
}
#else
// look at radiance map directly..
Normal nn = n;
if (Dot(nn, ray.d) > 0.) nn = -n;
RadiancePhotonProcess proc(p, nn);
float md2 = INFINITY;
radianceMap->Lookup(p, proc, md2);
if (proc.photon)
L += proc.photon->Lo;
#endif
}
else {
L += LPhoton(indirectMap, nIndirectPaths, nLookup,
bsdf, isect, wo, maxDistSquared);
}
if (specularDepth++ < maxSpecularDepth) {
Vector wi;
// Trace rays for specular reflection and refraction
Spectrum f = bsdf->Sample_f(wo, &wi,
BxDFType(BSDF_REFLECTION | BSDF_SPECULAR));
if (!f.Black()) {
// Compute ray differential _rd_ for specular reflection
RayDifferential rd(p, wi);
rd.hasDifferentials = true;
rd.rx.o = p + isect.dg.dpdx;
rd.ry.o = p + isect.dg.dpdy;
// Compute differential reflected directions
Normal dndx = bsdf->dgShading.dndu * bsdf->dgShading.dudx +
bsdf->dgShading.dndv * bsdf->dgShading.dvdx;
Normal dndy = bsdf->dgShading.dndu * bsdf->dgShading.dudy +
bsdf->dgShading.dndv * bsdf->dgShading.dvdy;
Vector dwodx = -ray.rx.d - wo, dwody = -ray.ry.d - wo;
float dDNdx = Dot(dwodx, n) + Dot(wo, dndx);
float dDNdy = Dot(dwody, n) + Dot(wo, dndy);
rd.rx.d = wi -
dwodx + 2 * Vector(Dot(wo, n) * dndx +
dDNdx * n);
rd.ry.d = wi -
dwody + 2 * Vector(Dot(wo, n) * dndy +
dDNdy * n);
L += scene->Li(rd, sample) * f * AbsDot(wi, n);
}
f = bsdf->Sample_f(wo, &wi,
BxDFType(BSDF_TRANSMISSION | BSDF_SPECULAR));
if (!f.Black()) {
// Compute ray differential _rd_ for specular transmission
RayDifferential rd(p, wi);
rd.hasDifferentials = true;
rd.rx.o = p + isect.dg.dpdx;
rd.ry.o = p + isect.dg.dpdy;
float eta = bsdf->eta;
Vector w = -wo;
if (Dot(wo, n) < 0) eta = 1.f / eta;
Normal dndx = bsdf->dgShading.dndu * bsdf->dgShading.dudx + bsdf->dgShading.dndv * bsdf->dgShading.dvdx;
Normal dndy = bsdf->dgShading.dndu * bsdf->dgShading.dudy + bsdf->dgShading.dndv * bsdf->dgShading.dvdy;
Vector dwodx = -ray.rx.d - wo, dwody = -ray.ry.d - wo;
float dDNdx = Dot(dwodx, n) + Dot(wo, dndx);
float dDNdy = Dot(dwody, n) + Dot(wo, dndy);
float mu = eta * Dot(w, n) - Dot(wi, n);
float dmudx = (eta - (eta*eta*Dot(w,n))/Dot(wi, n)) * dDNdx;
float dmudy = (eta - (eta*eta*Dot(w,n))/Dot(wi, n)) * dDNdy;
rd.rx.d = wi + eta * dwodx - Vector(mu * dndx + dmudx * n);
rd.ry.d = wi + eta * dwody - Vector(mu * dndy + dmudy * n);
L += scene->Li(rd, sample) * f * AbsDot(wi, n);
}
}
--specularDepth;
}
else {
// Handle ray with no intersection
if (alpha) *alpha = 0.;
for (u_int i = 0; i < scene->lights.size(); ++i)
L += scene->lights[i]->Le(ray);
if (alpha && !L.Black()) *alpha = 1.;
return L;
}
return L;
}
Spectrum IGIIntegrator::Li(const Scene *scene,
const RayDifferential &ray, const Sample *sample,
float *alpha) const {
Spectrum L(0.);
Intersection isect;
if (scene->Intersect(ray, &isect)) {
if (alpha) *alpha = 1.;
Vector wo = -ray.d;
// Compute emitted light if ray hit an area light source
L += isect.Le(wo);
// Evaluate BSDF at hit point
BSDF *bsdf = isect.GetBSDF(ray);
const Point &p = bsdf->dgShading.p;
const Normal &n = bsdf->dgShading.nn;
L += UniformSampleAllLights(scene, p, n,
wo, bsdf, sample,
lightSampleOffset, bsdfSampleOffset,
bsdfComponentOffset);
// Compute indirect illumination with virtual lights
u_int lSet = min(u_int(sample->oneD[vlSetOffset][0] * nLightSets),
nLightSets-1);
for (u_int i = 0; i < virtualLights[lSet].size(); ++i) {
const VirtualLight &vl = virtualLights[lSet][i];
// Add contribution from _VirtualLight_ _vl_
// Ignore light if it's too close to current point
float d2 = DistanceSquared(p, vl.p);
//if (d2 < .8 * minDist2) continue;
float distScale = SmoothStep(.8 * minDist2, 1.2 * minDist2, d2);
// Compute virtual light's tentative contribution _Llight_
Vector wi = Normalize(vl.p - p);
Spectrum f = distScale * bsdf->f(wo, wi);
if (f.Black()) continue;
float G = AbsDot(wi, n) * AbsDot(wi, vl.n) / d2;
Spectrum Llight = indirectScale * f * G * vl.Le /
virtualLights[lSet].size();
Llight *= scene->Transmittance(Ray(p, vl.p - p));
// Possibly skip shadow ray with Russian roulette
if (Llight.y() < rrThreshold) {
float continueProbability = .1f;
if (RandomFloat() > continueProbability)
continue;
Llight /= continueProbability;
}
static StatsCounter vlsr("IGI Integrator", "Shadow Rays to Virtual Lights"); //NOBOOK
++vlsr; //NOBOOK
if (!scene->IntersectP(Ray(p, vl.p - p, RAY_EPSILON,
1.f - RAY_EPSILON)))
L += Llight;
}
// Trace rays for specular reflection and refraction
if (specularDepth++ < maxSpecularDepth) {
Vector wi;
// Trace rays for specular reflection and refraction
Spectrum f = bsdf->Sample_f(wo, &wi,
BxDFType(BSDF_REFLECTION | BSDF_SPECULAR));
if (!f.Black()) {
// Compute ray differential _rd_ for specular reflection
RayDifferential rd(p, wi);
rd.hasDifferentials = true;
rd.rx.o = p + isect.dg.dpdx;
rd.ry.o = p + isect.dg.dpdy;
// Compute differential reflected directions
Normal dndx = bsdf->dgShading.dndu * bsdf->dgShading.dudx +
bsdf->dgShading.dndv * bsdf->dgShading.dvdx;
Normal dndy = bsdf->dgShading.dndu * bsdf->dgShading.dudy +
bsdf->dgShading.dndv * bsdf->dgShading.dvdy;
Vector dwodx = -ray.rx.d - wo, dwody = -ray.ry.d - wo;
float dDNdx = Dot(dwodx, n) + Dot(wo, dndx);
float dDNdy = Dot(dwody, n) + Dot(wo, dndy);
rd.rx.d = wi -
dwodx + 2 * Vector(Dot(wo, n) * dndx +
dDNdx * n);
rd.ry.d = wi -
dwody + 2 * Vector(Dot(wo, n) * dndy +
dDNdy * n);
L += scene->Li(rd, sample) * f * AbsDot(wi, n);
}
f = bsdf->Sample_f(wo, &wi,
BxDFType(BSDF_TRANSMISSION | BSDF_SPECULAR));
if (!f.Black()) {
// Compute ray differential _rd_ for specular transmission
RayDifferential rd(p, wi);
rd.hasDifferentials = true;
rd.rx.o = p + isect.dg.dpdx;
rd.ry.o = p + isect.dg.dpdy;
float eta = bsdf->eta;
Vector w = -wo;
if (Dot(wo, n) < 0) eta = 1.f / eta;
Normal dndx = bsdf->dgShading.dndu * bsdf->dgShading.dudx + bsdf->dgShading.dndv * bsdf->dgShading.dvdx;
Normal dndy = bsdf->dgShading.dndu * bsdf->dgShading.dudy + bsdf->dgShading.dndv * bsdf->dgShading.dvdy;
Vector dwodx = -ray.rx.d - wo, dwody = -ray.ry.d - wo;
float dDNdx = Dot(dwodx, n) + Dot(wo, dndx);
float dDNdy = Dot(dwody, n) + Dot(wo, dndy);
float mu = eta * Dot(w, n) - Dot(wi, n);
float dmudx = (eta - (eta*eta*Dot(w,n))/Dot(wi, n)) * dDNdx;
float dmudy = (eta - (eta*eta*Dot(w,n))/Dot(wi, n)) * dDNdy;
rd.rx.d = wi + eta * dwodx - Vector(mu * dndx + dmudx * n);
rd.ry.d = wi + eta * dwody - Vector(mu * dndy + dmudy * n);
L += scene->Li(rd, sample) * f * AbsDot(wi, n);
}
}
--specularDepth;
}
else {
// Handle ray with no intersection
if (alpha) *alpha = 0.;
for (u_int i = 0; i < scene->lights.size(); ++i)
L += scene->lights[i]->Le(ray);
if (alpha && !L.Black()) *alpha = 1.;
return L;
}
return L;
}
Spectrum IrradianceCache::IndirectLo(const Point &p,
const Normal &n, const Vector &wo, BSDF *bsdf,
BxDFType flags, const Sample *sample,
const Scene *scene) const {
if (bsdf->NumComponents(flags) == 0)
return Spectrum(0.);
Spectrum E;
if (!InterpolateIrradiance(scene, p, n, &E)) {
// Compute irradiance at current point
u_int scramble[2] = { RandomUInt(), RandomUInt() };
float sumInvDists = 0.;
for (int i = 0; i < nSamples; ++i) {
// Trace ray to sample radiance for irradiance estimate
// Update irradiance statistics for rays traced
static StatsCounter nIrradiancePaths("Irradiance Cache",
"Paths followed for irradiance estimates");
++nIrradiancePaths;
float u[2];
Sample02(i, scramble, u);
Vector w = CosineSampleHemisphere(u[0], u[1]);
RayDifferential r(p, bsdf->LocalToWorld(w));
if (Dot(r.d, n) < 0) r.d = -r.d;
Spectrum L(0.);
// Do path tracing to compute radiance along ray for estimate
{
// Declare common path integration variables
Spectrum pathThroughput = 1.;
RayDifferential ray(r);
bool specularBounce = false;
for (int pathLength = 0; ; ++pathLength) {
// Find next vertex of path
Intersection isect;
if (!scene->Intersect(ray, &isect))
break;
if (pathLength == 0)
r.maxt = ray.maxt;
pathThroughput *= scene->Transmittance(ray);
// Possibly add emitted light at path vertex
if (specularBounce)
L += pathThroughput * isect.Le(-ray.d);
// Evaluate BSDF at hit point
BSDF *bsdf = isect.GetBSDF(ray);
// Sample illumination from lights to find path contribution
const Point &p = bsdf->dgShading.p;
const Normal &n = bsdf->dgShading.nn;
Vector wo = -ray.d;
L += pathThroughput *
UniformSampleOneLight(scene, p, n, wo, bsdf, sample);
if (pathLength+1 == maxIndirectDepth) break;
// Sample BSDF to get new path direction
// Get random numbers for sampling new direction, \mono{bs1}, \mono{bs2}, and \mono{bcs}
float bs1 = RandomFloat(), bs2 = RandomFloat(), bcs = RandomFloat();
Vector wi;
float pdf;
BxDFType flags;
Spectrum f = bsdf->Sample_f(wo, &wi, bs1, bs2, bcs,
&pdf, BSDF_ALL, &flags);
if (f.Black() || pdf == 0.)
break;
specularBounce = (flags & BSDF_SPECULAR) != 0;
pathThroughput *= f * AbsDot(wi, n) / pdf;
ray = RayDifferential(p, wi);
// Possibly terminate the path
if (pathLength > 3) {
float continueProbability = .5f;
if (RandomFloat() > continueProbability)
break;
pathThroughput /= continueProbability;
}
}
}
E += L;
float dist = r.maxt * r.d.Length();
sumInvDists += 1.f / dist;
}
E *= M_PI / float(nSamples);
// Add computed irradiance value to cache
// Update statistics for new irradiance sample
static StatsCounter nSamplesComputed("Irradiance Cache",
"Irradiance estimates computed");
++nSamplesComputed;
// Compute bounding box of irradiance sample's contribution region
static float minMaxDist =
.001f * powf(scene->WorldBound().Volume(), 1.f/3.f);
static float maxMaxDist =
.125f * powf(scene->WorldBound().Volume(), 1.f/3.f);
float maxDist = nSamples / sumInvDists;
if (minMaxDist > 0.f)
maxDist = Clamp(maxDist, minMaxDist, maxMaxDist);
maxDist *= maxError;
BBox sampleExtent(p);
sampleExtent.Expand(maxDist);
octree->Add(IrradianceSample(E, p, n, maxDist),
sampleExtent);
}
return .5f * bsdf->rho(wo, flags) * E;
}
// return the radiance of a specific direction
// note : there are one factor makes the method biased.
// there is a limitation on the number of vertexes in the path
Spectrum PathTracing::Li( const Ray& ray , const PixelSample& ps ) const
{
Spectrum L = 0.0f;
Spectrum throughput = 1.0f;
int bounces = 0;
Ray r = ray;
while(true)
{
Intersection inter;
// get the intersection between the ray and the scene
// if it's a light , accumulate the radiance and break
if( false == scene.GetIntersect( r , &inter ) )
{
if( bounces == 0 )
return scene.Le( r );
break;
}
if( bounces == 0 ) L+=inter.Le(-r.m_Dir);
// make sure there is intersected primitive
Sort_Assert( inter.primitive != 0 );
// evaluate the light
Bsdf* bsdf = inter.primitive->GetMaterial()->GetBsdf(&inter);
float light_pdf = 0.0f;
LightSample light_sample = (bounces==0)?ps.light_sample[0]:LightSample(true);
BsdfSample bsdf_sample = (bounces==0)?ps.bsdf_sample[0]:BsdfSample(true);
const Light* light = scene.SampleLight( light_sample.t , &light_pdf );
if( light_pdf > 0.0f )
L += throughput * EvaluateDirect( r , scene , light , inter , light_sample ,
bsdf_sample , BXDF_TYPE(BXDF_ALL) ) / light_pdf;
// sample the next direction using bsdf
float path_pdf;
Vector wi;
BXDF_TYPE bxdf_type;
Spectrum f;
BsdfSample _bsdf_sample = (bounces==0)?ps.bsdf_sample[1]:BsdfSample(true);
f = bsdf->sample_f( -r.m_Dir , wi , _bsdf_sample , &path_pdf , BXDF_ALL , &bxdf_type );
if( f.IsBlack() || path_pdf == 0.0f )
break;
// update path weight
throughput *= f * AbsDot( wi , inter.normal ) / path_pdf;
if( throughput.GetIntensity() == 0.0f )
break;
if( bounces > 4 )
{
float continueProperbility = min( 0.5f , throughput.GetIntensity() );
if( sort_canonical() > continueProperbility )
break;
throughput /= continueProperbility;
}
r.m_Ori = inter.intersect;
r.m_Dir = wi;
r.m_fMin = 0.001f;
++bounces;
// note : the following code makes the method biased
// 'path_per_pixel' could be set very large to reduce the side-effect.
if( bounces >= max_recursive_depth )
break;
}
return L;
}
Spectrum IGIIntegrator::Li(const Scene *scene, const Renderer *renderer,
const RayDifferential &ray, const Intersection &isect,
const Sample *sample, RNG &rng, MemoryArena &arena) const {
Spectrum L(0.);
Vector wo = -ray.d;
// Compute emitted light if ray hit an area light source
L += isect.Le(wo);
// Evaluate BSDF at hit point
BSDF *bsdf = isect.GetBSDF(ray, arena);
const Point &p = bsdf->dgShading.p;
const Normal &n = bsdf->dgShading.nn;
L += UniformSampleAllLights(scene, renderer, arena, p, n,
wo, isect.rayEpsilon, ray.time, bsdf, sample, rng,
lightSampleOffsets, bsdfSampleOffsets);
// Compute indirect illumination with virtual lights
uint32_t lSet = min(uint32_t(sample->oneD[vlSetOffset][0] * nLightSets),
nLightSets-1);
for (uint32_t i = 0; i < virtualLights[lSet].size(); ++i) {
const VirtualLight &vl = virtualLights[lSet][i];
// Compute virtual light's tentative contribution _Llight_
float d2 = DistanceSquared(p, vl.p);
Vector wi = Normalize(vl.p - p);
float G = AbsDot(wi, n) * AbsDot(wi, vl.n) / d2;
G = min(G, gLimit);
Spectrum f = bsdf->f(wo, wi);
if (G == 0.f || f.IsBlack()) continue;
Spectrum Llight = f * G * vl.pathContrib / nLightPaths;
RayDifferential connectRay(p, wi, ray, isect.rayEpsilon,
sqrtf(d2) * (1.f - vl.rayEpsilon));
Llight *= renderer->Transmittance(scene, connectRay, NULL, rng, arena);
// Possibly skip virtual light shadow ray with Russian roulette
if (Llight.y() < rrThreshold) {
float continueProbability = .1f;
if (rng.RandomFloat() > continueProbability)
continue;
Llight /= continueProbability;
}
// Add contribution from _VirtualLight_ _vl_
if (!scene->IntersectP(connectRay))
L += Llight;
}
if (ray.depth < maxSpecularDepth) {
// Do bias compensation for bounding geometry term
int nSamples = (ray.depth == 0) ? nGatherSamples : 1;
for (int i = 0; i < nSamples; ++i) {
Vector wi;
float pdf;
BSDFSample bsdfSample = (ray.depth == 0) ?
BSDFSample(sample, gatherSampleOffset, i) : BSDFSample(rng);
Spectrum f = bsdf->Sample_f(wo, &wi, bsdfSample,
&pdf, BxDFType(BSDF_ALL & ~BSDF_SPECULAR));
if (!f.IsBlack() && pdf > 0.f) {
// Trace ray for bias compensation gather sample
float maxDist = sqrtf(AbsDot(wi, n) / gLimit);
RayDifferential gatherRay(p, wi, ray, isect.rayEpsilon, maxDist);
Intersection gatherIsect;
Spectrum Li = renderer->Li(scene, gatherRay, sample, rng, arena,
&gatherIsect);
if (Li.IsBlack()) continue;
// Add bias compensation ray contribution to radiance sum
float Ggather = AbsDot(wi, n) * AbsDot(-wi, gatherIsect.dg.nn) /
DistanceSquared(p, gatherIsect.dg.p);
if (Ggather - gLimit > 0.f && !isinf(Ggather)) {
float gs = (Ggather - gLimit) / Ggather;
L += f * Li * (AbsDot(wi, n) * gs / (nSamples * pdf));
}
}
}
}
if (ray.depth + 1 < maxSpecularDepth) {
Vector wi;
// Trace rays for specular reflection and refraction
L += SpecularReflect(ray, bsdf, rng, isect, renderer, scene, sample,
arena);
L += SpecularTransmit(ray, bsdf, rng, isect, renderer, scene, sample,
arena);
}
return L;
}
void HitPoints::TraceEyePath(HitPoint *hp, const Sample &sample, float const invPixelPdf)
{
HitPointEyePass *hpep = &hp->eyePass;
Scene &scene(*renderer->scene);
const bool includeEnvironment = renderer->sppmi->includeEnvironment;
const u_int maxDepth = renderer->sppmi->maxEyePathDepth;
//--------------------------------------------------------------------------
// Following code is, given or taken, a copy of path integrator Li() method
//--------------------------------------------------------------------------
// Declare common path integration variables
const SpectrumWavelengths &sw(sample.swl);
Ray ray;
const float rayWeight = sample.camera->GenerateRay(scene, sample, &ray, &(hp->imageX), &(hp->imageY));
const float nLights = scene.lights.size();
const u_int lightGroupCount = scene.lightGroups.size();
vector<SWCSpectrum> Ld(lightGroupCount, 0.f);
// Direct lighting samples variance
vector<float> Vd(lightGroupCount, 0.f);
SWCSpectrum pathThroughput(1.0f); // pathThroughput is normalised perpixel for the eyepass contribution, so no need for invPixelPdf normalisation;
vector<SWCSpectrum> L(lightGroupCount, 0.f);
vector<float> V(lightGroupCount, 0.f);
float VContrib = .1f;
bool scattered = false;
hpep->alpha = 1.f;
hpep->distance = INFINITY;
u_int vertexIndex = 0;
const Volume *volume = NULL;
bool specularBounce = true;
const bool enableDirectLightSampling = renderer->sppmi->directLightSampling;
for (u_int pathLength = 0; ; ++pathLength) {
const SWCSpectrum prevThroughput(pathThroughput);
float *data = eyeSampler->GetLazyValues(sample, 0, pathLength);
// Find next vertex of path
Intersection isect;
BSDF *bsdf;
float spdf;
sample.arena.Begin();
if (!scene.Intersect(sample, volume, scattered, ray, data[0],
&isect, &bsdf, &spdf, NULL, &pathThroughput)) {
pathThroughput /= spdf;
// Dade - now I know ray.maxt and I can call volumeIntegrator
SWCSpectrum Lv;
u_int g = scene.volumeIntegrator->Li(scene, ray, sample,
&Lv, &hpep->alpha);
if (!Lv.Black()) {
Lv *= prevThroughput;
L[g] += Lv;
}
// Stop path sampling since no intersection was found
// Possibly add horizon in render & reflections
if (!enableDirectLightSampling || (
(includeEnvironment || vertexIndex > 0) && specularBounce)) {
BSDF *ibsdf;
for (u_int i = 0; i < nLights; ++i) {
SWCSpectrum Le(pathThroughput);
if (scene.lights[i]->Le(scene, sample,
ray, &ibsdf, NULL, NULL, &Le))
L[scene.lights[i]->group] += Le;
}
}
// Set alpha channel
if (vertexIndex == 0)
hpep->alpha = 0.f;
hp->SetConstant();
break;
}
sample.arena.End();
scattered = bsdf->dgShading.scattered;
pathThroughput /= spdf;
if (vertexIndex == 0)
hpep->distance = ray.maxt * ray.d.Length();
SWCSpectrum Lv;
const u_int g = scene.volumeIntegrator->Li(scene, ray, sample,
&Lv, &hpep->alpha);
if (!Lv.Black()) {
Lv *= prevThroughput;
L[g] += Lv;
}
// Possibly add emitted light at path vertex
Vector wo(-ray.d);
if (specularBounce) {
BSDF *ibsdf;
SWCSpectrum Le(pathThroughput);
if (isect.Le(sample, ray, &ibsdf, NULL, NULL, &Le)) {
L[isect.arealight->group] += Le;
V[isect.arealight->group] += Le.Filter(sw) * VContrib;
}
}
const Point &p = bsdf->dgShading.p;
const Normal &n = bsdf->dgShading.nn;
// Estimate direct lighting
if (renderer->sppmi->directLightSampling && (nLights > 0)) {
for (u_int i = 0; i < lightGroupCount; ++i) {
Ld[i] = 0.f;
Vd[i] = 0.f;
}
renderer->sppmi->hints.SampleLights(scene, sample, p, n,
wo, bsdf, pathLength, pathThroughput, Ld, &Vd);
for (u_int i = 0; i < lightGroupCount; ++i) {
L[i] += Ld[i];
V[i] += Vd[i] * VContrib;
}
}
// Choose between storing or bouncing the hitpoint on the surface
bool const has_store_component = bsdf->NumComponents(store_component) > 0;
bool const has_bounce_component = bsdf->NumComponents(bounce_component) > 0;
float pdf_event;
bool store;
if (has_store_component && has_bounce_component)
{
// There is both bounce and store component, we choose with a
// random number
// TODO: do this by importance
store = data[4] < .5f;
pdf_event = 0.5;
}
else
{
// If there is only bounce/store component, we bounce/store
// accordingly
store = has_store_component;
pdf_event = 1.f;
}
if(store)
{
hp->SetSurface();
hpep->pathThroughput = pathThroughput * rayWeight / pdf_event * invPixelPdf;
hpep->wo = wo;
hpep->bsdf = bsdf;
hpep->single = sw.single;
sample.arena.Commit();
break;
}
// Sample BSDF to get new path direction
Vector wi;
float pdf;
BxDFType flags;
SWCSpectrum f;
if (pathLength == maxDepth || !bsdf->SampleF(sw, wo, &wi,
data[1], data[2], data[3], &f, &pdf, bounce_component, &flags,
NULL, true)) {
hp->SetConstant();
break;
}
if (flags != (BSDF_TRANSMISSION | BSDF_SPECULAR) ||
!(bsdf->Pdf(sw, wi, wo, BxDFType(BSDF_TRANSMISSION | BSDF_SPECULAR)) > 0.f))
{
++vertexIndex;
specularBounce = (flags & BSDF_SPECULAR) != 0;
}
pathThroughput *= f / pdf_event;
if (pathThroughput.Black()) {
hp->SetConstant();
break;
}
ray = Ray(p, wi);
ray.time = sample.realTime;
volume = bsdf->GetVolume(wi);
}
for(unsigned int i = 0; i < lightGroupCount; ++i)
{
if (!L[i].Black())
V[i] /= L[i].Filter(sw);
sample.AddContribution(hp->imageX, hp->imageY,
XYZColor(sw, L[i]) * rayWeight, hp->eyePass.alpha, hp->eyePass.distance,
0, renderer->sppmi->bufferEyeId, i);
}
}
Spectrum GlossyPRTIntegrator::Li(const Scene *scene, const Renderer *,
const RayDifferential &ray, const Intersection &isect,
const Sample *sample, RNG &rng, MemoryArena &arena) const {
Spectrum L = 0.f;
Vector wo = -ray.d;
// Compute emitted light if ray hit an area light source
L += isect.Le(wo);
// Evaluate BSDF at hit point
BSDF *bsdf = isect.GetBSDF(ray, arena);
const Point &p = bsdf->dgShading.p;
// Compute reflected radiance with glossy PRT at point
// Compute SH radiance transfer matrix at point and SH coefficients
Spectrum *c_t = arena.Alloc<Spectrum>(SHTerms(lmax));
Spectrum *T = arena.Alloc<Spectrum>(SHTerms(lmax)*SHTerms(lmax));
SHComputeTransferMatrix(p, isect.rayEpsilon, scene, rng, nSamples,
lmax, T);
SHMatrixVectorMultiply(T, c_in, c_t, lmax);
// Rotate incident SH lighting to local coordinate frame
Vector r1 = bsdf->LocalToWorld(Vector(1,0,0));
Vector r2 = bsdf->LocalToWorld(Vector(0,1,0));
Normal nl = Normal(bsdf->LocalToWorld(Vector(0,0,1)));
Matrix4x4 rot(r1.x, r2.x, nl.x, 0,
r1.y, r2.y, nl.y, 0,
r1.z, r2.z, nl.z, 0,
0, 0, 0, 1);
Spectrum *c_l = arena.Alloc<Spectrum>(SHTerms(lmax));
SHRotate(c_t, c_l, rot, lmax, arena);
#if 0
// Sample BSDF and integrate against direct SH coefficients
float *Ylm = ALLOCA(float, SHTerms(lmax));
int ns = 1024;
for (int i = 0; i < ns; ++i) {
Vector wi;
float pdf;
Spectrum f = bsdf->Sample_f(wo, &wi, BSDFSample(rng), &pdf);
if (pdf > 0.f && !f.IsBlack() && !scene->IntersectP(Ray(p, wi))) {
f *= fabsf(Dot(wi, n)) / (pdf * ns);
SHEvaluate(bsdf->WorldToLocal(wi), lmax, Ylm);
Spectrum Li = 0.f;
for (int j = 0; j < SHTerms(lmax); ++j)
Li += Ylm[j] * c_l[j] * f;
L += Li.Clamp();
}
}
#else
// Compute final coefficients _c\_o_ using BSDF matrix
Spectrum *c_o = arena.Alloc<Spectrum>(SHTerms(lmax));
SHMatrixVectorMultiply(B, c_l, c_o, lmax);
// Evaluate outgoing radiance function for $\wo$ and add to _L_
Vector woLocal = bsdf->WorldToLocal(wo);
float *Ylm = ALLOCA(float, SHTerms(lmax));
SHEvaluate(woLocal, lmax, Ylm);
Spectrum Li = 0.f;
for (int i = 0; i < SHTerms(lmax); ++i)
Li += Ylm[i] * c_o[i];
L += Li.Clamp();
#endif
return L;
}
Spectrum EstimateDirect(const Scene *scene,
const Light *light, const Point &p,
const Normal &n, const Vector &wo,
BSDF *bsdf, const Sample *sample, int lightSamp,
int bsdfSamp, int bsdfComponent, u_int sampleNum) {
Spectrum Ld(0.);
// Find light and BSDF sample values for direct lighting estimate
float ls1, ls2, bs1, bs2, bcs;
if (lightSamp != -1 && bsdfSamp != -1 &&
sampleNum < sample->n2D[lightSamp] &&
sampleNum < sample->n2D[bsdfSamp]) {
ls1 = sample->twoD[lightSamp][2*sampleNum];
ls2 = sample->twoD[lightSamp][2*sampleNum+1];
bs1 = sample->twoD[bsdfSamp][2*sampleNum];
bs2 = sample->twoD[bsdfSamp][2*sampleNum+1];
bcs = sample->oneD[bsdfComponent][sampleNum];
}
else {
ls1 = RandomFloat();
ls2 = RandomFloat();
bs1 = RandomFloat();
bs2 = RandomFloat();
bcs = RandomFloat();
}
// Sample light source with multiple importance sampling
Vector wi;
float lightPdf, bsdfPdf;
VisibilityTester visibility;
Spectrum Li = light->Sample_L(p, n,
ls1, ls2, &wi, &lightPdf, &visibility);
if (lightPdf > 0. && !Li.Black()) {
Spectrum f = bsdf->f(wo, wi);
if (!f.Black() && visibility.Unoccluded(scene)) {
// Add light's contribution to reflected radiance
Li *= visibility.Transmittance(scene);
if (light->IsDeltaLight())
Ld += f * Li * AbsDot(wi, n) / lightPdf;
else {
bsdfPdf = bsdf->Pdf(wo, wi);
float weight = PowerHeuristic(1, lightPdf, 1, bsdfPdf);
Ld += f * Li * AbsDot(wi, n) * weight / lightPdf;
}
}
}
// Sample BSDF with multiple importance sampling
if (!light->IsDeltaLight()) {
BxDFType flags = BxDFType(BSDF_ALL & ~BSDF_SPECULAR);
Spectrum f = bsdf->Sample_f(wo, &wi,
bs1, bs2, bcs, &bsdfPdf, flags);
if (!f.Black() && bsdfPdf > 0.) {
lightPdf = light->Pdf(p, n, wi);
if (lightPdf > 0.) {
// Add light contribution from BSDF sampling
float weight = PowerHeuristic(1, bsdfPdf, 1, lightPdf);
Intersection lightIsect;
Spectrum Li(0.f);
RayDifferential ray(p, wi);
if (scene->Intersect(ray, &lightIsect)) {
if (lightIsect.primitive->GetAreaLight() == light)
Li = lightIsect.Le(-wi);
}
else
Li = light->Le(ray);
if (!Li.Black()) {
Li *= scene->Transmittance(ray);
Ld += f * Li * AbsDot(wi, n) * weight / bsdfPdf;
}
}
}
}
return Ld;
}
