void Light::SHProject(const PbrtPoint &p, float pEpsilon, int lmax,
const Scene *scene, bool computeLightVisibility, float time,
RNG &rng, Spectrum *coeffs) const {
for (int i = 0; i < SHTerms(lmax); ++i)
coeffs[i] = 0.f;
uint32_t ns = RoundUpPow2(nSamples);
uint32_t scramble1D = rng.RandomUInt();
uint32_t scramble2D[2] = { rng.RandomUInt(), rng.RandomUInt() };
float *Ylm = ALLOCA(float, SHTerms(lmax));
for (uint32_t i = 0; i < ns; ++i) {
// Compute incident radiance sample from _light_, update SH _coeffs_
float u[2], pdf;
Sample02(i, scramble2D, u);
LightSample lightSample(u[0], u[1], VanDerCorput(i, scramble1D));
Vector wi;
VisibilityTester vis;
Spectrum Li = Sample_L(p, pEpsilon, lightSample, time, &wi, &pdf, &vis);
if (!Li.IsBlack() && pdf > 0.f &&
(!computeLightVisibility || vis.Unoccluded(scene))) {
// Add light sample contribution to MC estimate of SH coefficients
SHEvaluate(wi, lmax, Ylm);
for (int j = 0; j < SHTerms(lmax); ++j)
coeffs[j] += Li * Ylm[j] / (pdf * ns);
}
}
}
Spectrum IrradianceCacheIntegrator::indirectLo(const Point &p,
const Normal &ng, float pixelSpacing, const Vector &wo,
float rayEpsilon, BSDF *bsdf, BxDFType flags, RNG &rng,
const Scene *scene, const Renderer *renderer,
MemoryArena &arena) const {
if (bsdf->NumComponents(flags) == 0)
return Spectrum(0.);
Spectrum E;
Vector wi;
// Get irradiance _E_ and average incident direction _wi_ at point _p_
if (!interpolateE(scene, p, ng, &E, &wi)) {
// Compute irradiance at current point
PBRT_IRRADIANCE_CACHE_STARTED_COMPUTING_IRRADIANCE(const_cast<Point *>(&p), const_cast<Normal *>(&ng));
uint32_t scramble[2] = { rng.RandomUInt(), rng.RandomUInt() };
float minHitDistance = INFINITY;
Vector wAvg(0,0,0);
Spectrum LiSum = 0.f;
for (int i = 0; i < nSamples; ++i) {
// Sample direction for irradiance estimate ray
float u[2];
Sample02(i, scramble, u);
Vector w = CosineSampleHemisphere(u[0], u[1]);
RayDifferential r(p, bsdf->LocalToWorld(w), rayEpsilon);
r.d = Faceforward(r.d, ng);
// Trace ray to sample radiance for irradiance estimate
PBRT_IRRADIANCE_CACHE_STARTED_RAY(&r);
Spectrum L = pathL(r, scene, renderer, rng, arena);
LiSum += L;
wAvg += r.d * L.y();
minHitDistance = min(minHitDistance, r.maxt);
PBRT_IRRADIANCE_CACHE_FINISHED_RAY(&r, r.maxt, &L);
}
E = (M_PI / float(nSamples)) * LiSum;
PBRT_IRRADIANCE_CACHE_FINISHED_COMPUTING_IRRADIANCE(const_cast<Point *>(&p), const_cast<Normal *>(&ng));
// Add computed irradiance value to cache
// Compute irradiance sample's contribution extent and bounding box
float maxDist = maxSamplePixelSpacing * pixelSpacing;
float minDist = minSamplePixelSpacing * pixelSpacing;
float contribExtent = Clamp(minHitDistance / 2.f, minDist, maxDist);
BBox sampleExtent(p);
sampleExtent.Expand(contribExtent);
PBRT_IRRADIANCE_CACHE_ADDED_NEW_SAMPLE(const_cast<Point *>(&p), const_cast<Normal *>(&ng), contribExtent, &E, &wAvg, pixelSpacing);
// Allocate _IrradianceSample_, get write lock, add to octree
IrradianceSample *sample = new IrradianceSample(E, p, ng, wAvg,
contribExtent);
RWMutexLock lock(*mutex, WRITE);
octree->Add(sample, sampleExtent);
wi = wAvg;
}
// Compute reflected radiance due to irradiance and BSDF
if (wi.LengthSquared() == 0.f) return Spectrum(0.);
return bsdf->f(wo, Normalize(wi), flags) * E;
}
// AmbientOcclusionIntegrator Method Definitions
Spectrum AmbientOcclusionIntegrator::Li(const Scene *scene, const Renderer *renderer,
const RayDifferential &ray, const Intersection &isect,
const Sample *sample, RNG &rng, MemoryArena &arena, int wavelength) const {
BSDF *bsdf = isect.GetBSDF(ray, arena, wavelength);
const Point &p = bsdf->dgShading.p;
Normal n = Faceforward(isect.dg.nn, -ray.d);
uint32_t scramble[2] = { rng.RandomUInt(), rng.RandomUInt() };
float u[2];
int nClear = 0;
for (int i = 0; i < nSamples; ++i) {
Sample02(i, scramble, u);
Vector w = UniformSampleSphere(u[0], u[1]);
if (Dot(w, n) < 0.) w = -w;
Ray r(p, w, .01f, maxDist);
if (!scene->IntersectP(r)) ++nClear;
}
return Spectrum(float(nClear) / float(nSamples));
}
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;
}
void DipoleSubsurfaceIntegrator::Preprocess(const Scene *scene,
const Camera *camera, const Renderer *renderer) {
if (scene->lights.size() == 0) return;
vector<SurfacePoint> pts;
// Get _SurfacePoint_s for translucent objects in scene
if (filename != "") {
// Initialize _SurfacePoint_s from file
vector<float> fpts;
if (ReadFloatFile(filename.c_str(), &fpts)) {
if ((fpts.size() % 8) != 0)
Error("Excess values (%d) in points file \"%s\"", int(fpts.size() % 8),
filename.c_str());
for (u_int i = 0; i < fpts.size(); i += 8)
pts.push_back(SurfacePoint(Point(fpts[i], fpts[i+1], fpts[i+2]),
Normal(fpts[i+3], fpts[i+4], fpts[i+5]),
fpts[i+6], fpts[i+7]));
}
}
if (pts.size() == 0) {
Point pCamera = camera->CameraToWorld(camera->shutterOpen,
Point(0, 0, 0));
FindPoissonPointDistribution(pCamera, camera->shutterOpen,
minSampleDist, scene, &pts);
}
// Compute irradiance values at sample points
RNG rng;
MemoryArena arena;
PBRT_SUBSURFACE_STARTED_COMPUTING_IRRADIANCE_VALUES();
ProgressReporter progress(pts.size(), "Computing Irradiances");
for (uint32_t i = 0; i < pts.size(); ++i) {
SurfacePoint &sp = pts[i];
Spectrum E(0.f);
for (uint32_t j = 0; j < scene->lights.size(); ++j) {
// Add irradiance from light at point
const Light *light = scene->lights[j];
Spectrum Elight = 0.f;
int nSamples = RoundUpPow2(light->nSamples);
uint32_t scramble[2] = { rng.RandomUInt(), rng.RandomUInt() };
uint32_t compScramble = rng.RandomUInt();
for (int s = 0; s < nSamples; ++s) {
float lpos[2];
Sample02(s, scramble, lpos);
float lcomp = VanDerCorput(s, compScramble);
LightSample ls(lpos[0], lpos[1], lcomp);
Vector wi;
float lightPdf;
VisibilityTester visibility;
Spectrum Li = light->Sample_L(sp.p, sp.rayEpsilon,
ls, camera->shutterOpen, &wi, &lightPdf, &visibility);
if (Dot(wi, sp.n) <= 0.) continue;
if (Li.IsBlack() || lightPdf == 0.f) continue;
Li *= visibility.Transmittance(scene, renderer, NULL, rng, arena);
if (visibility.Unoccluded(scene))
Elight += Li * AbsDot(wi, sp.n) / lightPdf;
}
E += Elight / nSamples;
}
if (E.y() > 0.f)
{
irradiancePoints.push_back(IrradiancePoint(sp, E));
PBRT_SUBSURFACE_COMPUTED_IRRADIANCE_AT_POINT(&sp, &E);
}
arena.FreeAll();
progress.Update();
}
progress.Done();
PBRT_SUBSURFACE_FINISHED_COMPUTING_IRRADIANCE_VALUES();
// Create octree of clustered irradiance samples
octree = octreeArena.Alloc<SubsurfaceOctreeNode>();
for (uint32_t i = 0; i < irradiancePoints.size(); ++i)
octreeBounds = Union(octreeBounds, irradiancePoints[i].p);
for (uint32_t i = 0; i < irradiancePoints.size(); ++i)
octree->Insert(octreeBounds, &irradiancePoints[i], octreeArena);
octree->InitHierarchy();
}
void MetropolisRenderer::Render(const Scene *scene) {
PBRT_MLT_STARTED_RENDERING();
if (scene->lights.size() > 0) {
int x0, x1, y0, y1;
camera->film->GetPixelExtent(&x0, &x1, &y0, &y1);
float t0 = camera->shutterOpen, t1 = camera->shutterClose;
Distribution1D *lightDistribution = ComputeLightSamplingCDF(scene);
if (directLighting != NULL) {
PBRT_MLT_STARTED_DIRECTLIGHTING();
// Compute direct lighting before Metropolis light transport
if (nDirectPixelSamples > 0) {
LDSampler sampler(x0, x1, y0, y1, nDirectPixelSamples, t0, t1);
Sample *sample = new Sample(&sampler, directLighting, NULL, scene);
vector<Task *> directTasks;
int nDirectTasks = max(32 * NumSystemCores(),
(camera->film->xResolution * camera->film->yResolution) / (16*16));
nDirectTasks = RoundUpPow2(nDirectTasks);
ProgressReporter directProgress(nDirectTasks, "Direct Lighting");
for (int i = 0; i < nDirectTasks; ++i)
directTasks.push_back(new SamplerRendererTask(scene, this, camera, directProgress,
&sampler, sample, false, i, nDirectTasks));
std::reverse(directTasks.begin(), directTasks.end());
EnqueueTasks(directTasks);
WaitForAllTasks();
for (uint32_t i = 0; i < directTasks.size(); ++i)
delete directTasks[i];
delete sample;
directProgress.Done();
}
camera->film->WriteImage();
PBRT_MLT_FINISHED_DIRECTLIGHTING();
}
// Take initial set of samples to compute $b$
PBRT_MLT_STARTED_BOOTSTRAPPING(nBootstrap);
RNG rng(0);
MemoryArena arena;
vector<float> bootstrapI;
vector<PathVertex> cameraPath(maxDepth, PathVertex());
vector<PathVertex> lightPath(maxDepth, PathVertex());
float sumI = 0.f;
bootstrapI.reserve(nBootstrap);
MLTSample sample(maxDepth);
for (uint32_t i = 0; i < nBootstrap; ++i) {
// Generate random sample and path radiance for MLT bootstrapping
float x = Lerp(rng.RandomFloat(), x0, x1);
float y = Lerp(rng.RandomFloat(), y0, y1);
LargeStep(rng, &sample, maxDepth, x, y, t0, t1, bidirectional);
Spectrum L = PathL(sample, scene, arena, camera, lightDistribution,
&cameraPath[0], &lightPath[0], rng);
// Compute contribution for random sample for MLT bootstrapping
float I = ::I(L);
sumI += I;
bootstrapI.push_back(I);
arena.FreeAll();
}
float b = sumI / nBootstrap;
PBRT_MLT_FINISHED_BOOTSTRAPPING(b);
Info("MLT computed b = %f", b);
// Select initial sample from bootstrap samples
float contribOffset = rng.RandomFloat() * sumI;
rng.Seed(0);
sumI = 0.f;
MLTSample initialSample(maxDepth);
for (uint32_t i = 0; i < nBootstrap; ++i) {
float x = Lerp(rng.RandomFloat(), x0, x1);
float y = Lerp(rng.RandomFloat(), y0, y1);
LargeStep(rng, &initialSample, maxDepth, x, y, t0, t1,
bidirectional);
sumI += bootstrapI[i];
if (sumI > contribOffset)
break;
}
// Launch tasks to generate Metropolis samples
uint32_t nTasks = largeStepsPerPixel;
uint32_t largeStepRate = nPixelSamples / largeStepsPerPixel;
Info("MLT running %d tasks, large step rate %d", nTasks, largeStepRate);
ProgressReporter progress(nTasks * largeStepRate, "Metropolis");
vector<Task *> tasks;
Mutex *filmMutex = Mutex::Create();
Assert(IsPowerOf2(nTasks));
uint32_t scramble[2] = { rng.RandomUInt(), rng.RandomUInt() };
uint32_t pfreq = (x1-x0) * (y1-y0);
for (uint32_t i = 0; i < nTasks; ++i) {
float d[2];
Sample02(i, scramble, d);
tasks.push_back(new MLTTask(progress, pfreq, i,
d[0], d[1], x0, x1, y0, y1, t0, t1, b, initialSample,
scene, camera, this, filmMutex, lightDistribution));
}
EnqueueTasks(tasks);
WaitForAllTasks();
for (uint32_t i = 0; i < tasks.size(); ++i)
delete tasks[i];
progress.Done();
Mutex::Destroy(filmMutex);
delete lightDistribution;
}
camera->film->WriteImage();
PBRT_MLT_FINISHED_RENDERING();
}
