PBRT_V2 总结记录 <106> SingleScatteringIntegrator

SingleScatteringIntegrator

class SingleScatteringIntegrator : public VolumeIntegrator {
public:
    // SingleScatteringIntegrator Public Methods
    SingleScatteringIntegrator(float ss) { stepSize = ss; }
    Spectrum Transmittance(const Scene *, const Renderer *,
        const RayDifferential &ray, const Sample *sample, RNG &rng,
        MemoryArena &arena) const;
    void RequestSamples(Sampler *sampler, Sample *sample,
        const Scene *scene);
    Spectrum Li(const Scene *, const Renderer *, const RayDifferential &ray,
         const Sample *sample, RNG &rng, Spectrum *T, MemoryArena &arena) const;
private:
    // SingleScatteringIntegrator Private Data
    float stepSize;
    int tauSampleOffset, scatterSampleOffset;
};

作用：

（SingleScatteringIntegrator 中，ray中每一个点除了有 emission 的效果之外，还有 直接光照的效果，只考虑直接光照，那么对应的下面的公式，就是  participating media 的 emission and in-scattered 的部分）

In addition to accounting for the emission at each point along the ray, the Single
ScatteringIntegrator also considers the incident radiance due to direct illumination
but ignores incident radiance due to multiple scattering. Thus, its Li() method estimates
the integral

where Ld only includes radiance from direct lighting. This radiance may be blocked
by geometry in the scene and may itself be attenuated by participating media between
the light and the point p‘ along the ray (Figure 16.6).

 

Figure 16.6: When the direct lighting contribution is evaluated at some point t along a ray passing
through participating media, it’s necessary to compute the attenuation of the radiance from the light
passing through the volume to the scattering point as well as the attenuation from that point back to
the ray origin.

 

 

1. 

Spectrum SingleScatteringIntegrator::Li(const Scene *scene, const Renderer *renderer,
        const RayDifferential &ray, const Sample *sample, RNG &rng,
        Spectrum *T, MemoryArena &arena) const {
    VolumeRegion *vr = scene->volumeRegion;
    float t0, t1;
    if (!vr || !vr->IntersectP(ray, &t0, &t1) || (t1-t0) == 0.f) {
        *T = 1.f;
        return 0.f;
    }
    // Do single scattering volume integration in _vr_
    Spectrum Lv(0.);

    // Prepare for volume integration stepping
    int nSamples = Ceil2Int((t1-t0) / stepSize);
    float step = (t1 - t0) / nSamples;
    Spectrum Tr(1.f);
    Point p = ray(t0), pPrev;
    Vector w = -ray.d;
    t0 += sample->oneD[scatterSampleOffset][0] * step;

    // Compute sample patterns for single scattering samples
    float *lightNum = arena.Alloc<float>(nSamples);
    LDShuffleScrambled1D(1, nSamples, lightNum, rng);
    float *lightComp = arena.Alloc<float>(nSamples);
    LDShuffleScrambled1D(1, nSamples, lightComp, rng);
    float *lightPos = arena.Alloc<float>(2*nSamples);
    LDShuffleScrambled2D(1, nSamples, lightPos, rng);
    uint32_t sampOffset = 0;
    for (int i = 0; i < nSamples; ++i, t0 += step) {
        // Advance to sample at _t0_ and update _T_
        pPrev = p;
        p = ray(t0);
        Ray tauRay(pPrev, p - pPrev, 0.f, 1.f, ray.time, ray.depth);
        Spectrum stepTau = vr->tau(tauRay,
                                   .5f * stepSize, rng.RandomFloat());
        Tr *= Exp(-stepTau);

        // Possibly terminate ray marching if transmittance is small
        if (Tr.y() < 1e-3) {
            const float continueProb = .5f;
            if (rng.RandomFloat() > continueProb) {
                Tr = 0.f;
                break;
            }
            Tr /= continueProb;
        }

        // Compute single-scattering source term at _p_
        Lv += Tr * vr->Lve(p, w, ray.time);
        Spectrum ss = vr->sigma_s(p, w, ray.time);
        if (!ss.IsBlack() && scene->lights.size() > 0) {
            int nLights = scene->lights.size();
            int ln = min(Floor2Int(lightNum[sampOffset] * nLights),
                         nLights-1);
            Light *light = scene->lights[ln];
            // Add contribution of _light_ due to scattering at _p_
            float pdf;
            VisibilityTester vis;
            Vector wo;
            LightSample ls(lightComp[sampOffset], lightPos[2*sampOffset],
                           lightPos[2*sampOffset+1]);
            Spectrum L = light->Sample_L(p, 0.f, ls, ray.time, &wo, &pdf, &vis);
            
            if (!L.IsBlack() && pdf > 0.f && vis.Unoccluded(scene)) {
                Spectrum Ld = L * vis.Transmittance(scene, renderer, NULL, rng, arena);
                Lv += Tr * ss * vr->p(p, w, -wo, ray.time) * Ld * float(nLights) /
                        pdf;
            }
        }
        ++sampOffset;
    }
    *T = Tr;
    return Lv * step;
}

作用：

（这里的Li函数，大部分代码都是和 EmissionIntegrator 比较类似，可以参考《PBRT_V2 总结记录 <105> EmissionIntegrator》，这个Li 函数，最主要的就是计算 直接光照的效果。）

This integrator’s Li() method uses the same general ray-marching approach to evaluate
the equation of transfer as the EmissionIntegrator.

 

细节

a.

    // Compute sample patterns for single scattering samples
    float *lightNum = arena.Alloc<float>(nSamples);
    LDShuffleScrambled1D(1, nSamples, lightNum, rng);
    float *lightComp = arena.Alloc<float>(nSamples);
    LDShuffleScrambled1D(1, nSamples, lightComp, rng);
    float *lightPos = arena.Alloc<float>(2*nSamples);
    LDShuffleScrambled2D(1, nSamples, lightPos, rng);

作用：

（先获得采样 光源的 采样点）

One difference is that this one computes
sample values for light source sampling before it enters the for loop over sample
positions. Because it isn’t known how many samples will be necessary until Li() is called

(since this number depends on the length of the ray segment over which integration is being
done), it’s not possible to have the Sampler generate samples and pass them into Li()
via the Sample. Therefore, the samples are generated here. Two one-dimensional patterns
are used for selecting which light to sample and which light component to sample, and a
two-dimensional pattern is used for selecting points on area light sources.

 

 

b.

        // Compute single-scattering source term at _p_
        Lv += Tr * vr->Lve(p, w, ray.time);
        Spectrum ss = vr->sigma_s(p, w, ray.time);
        if (!ss.IsBlack() && scene->lights.size() > 0) {
            int nLights = scene->lights.size();
            int ln = min(Floor2Int(lightNum[sampOffset] * nLights),
                         nLights-1);
            Light *light = scene->lights[ln];
            // Add contribution of _light_ due to scattering at _p_
            float pdf;
            VisibilityTester vis;
            Vector wo;
            LightSample ls(lightComp[sampOffset], lightPos[2*sampOffset],
                           lightPos[2*sampOffset+1]);
            Spectrum L = light->Sample_L(p, 0.f, ls, ray.time, &wo, &pdf, &vis);
            
            if (!L.IsBlack() && pdf > 0.f && vis.Unoccluded(scene)) {
                Spectrum Ld = L * vis.Transmittance(scene, renderer, NULL, rng, arena);
                Lv += Tr * ss * vr->p(p, w, -wo, ray.time) * Ld * float(nLights) /
                        pdf;
            }
        }
        ++sampOffset;

作用：

（参考公式：  , 上面主要就是计算这个公式，而且，在计算第二个积分的时候，采用了 UniformSampleOneLight 的思路（参考《PBRT_V2 总结记录 <97> DirectLightingIntegrator》），所以最后的

Lv += Tr * vr->Lve(p, w, ray.time) + Tr * ss * vr->p(p, w, -wo, ray.time) * Ld * float(nLights) / pdf;

最后累积完Lv 之后，再进行 Lv * step，这两个步骤就是直接执行公式：

）

After including volume emission in
the same way that the EmissionIntegrator does, it finds the value of σs at the point,
selects a light to sample, and computes its contribution to scattering at the point. Because
the source term is generally evaluated at many points along the ray, only a single light is
sampled at each one, and its contribution is scaled by the number of lights, similar to the
direct lighting integrator’s “sample one light” strategy.

Computing the estimate of the direct lighting contribution at a point p involves estimating
the integral

Rather than sampling both the phase function and the light source and applyingmultiple
importance sampling, the implementation here always lets the light choose a sample
position on the light source and then computes the estimator directly. For media that
aren’t extremely anisotropic, this approach works well.