Last week, we were going over a basic lighting model suitable for ray-tracing
We define radiant flux as the amount of light coming in from a wedge W through a a sensor surface `X`.
We defined irradiance in terms of a normal `vec n` and the limit as `X` shrinks to a point `tilde x`.
We defined outgoing radiance as a further limit as the wedge shrinks to a direction `vec w`.
Using these concepts we introduced the idea of a Bidirectional Reflection Distribution Function which was
the ratio of the outgoing radiance to the incoming irradiance.
This was used to come up with the reflection equation.
We said how this had to be modified when dealing with mirrors and refraction.
Finally, we started talking about light simulation where we want to compute an approximation of the outgoing radiance `L^1(tilde x, vec v)` in some direction (say towards the eye) without having to compute integrals.
For a point light we got the equation
`L^1(tilde x, vec v) =f_(tilde x, vec n)(-vec l,vec v)E_(vec n)^e(H, tilde x)`
Direct Area Lights
Suppose our light source has a finite area.
This forces us to do the integral in the reflection equation:
`L^1(tilde x, vec v) = int_H dw f_(tilde x, vec n)(vec w, vec v) L^e(vec w, tilde x) cos (theta)`.
The integrand over `H` is only non-zero for incoming diections `vec w` that "see" light.
If we approximate the integral using some finite number of incoming directions `vec w_i`, we can use ray tracing to calculate `L^e(vec w_i, tilde x)` values.
If we use randomness to select these directions, this is called distribution ray tracing.
If the light source is partially occluded by other geometry, this integration will produce shadows that have soft boundaries.
Two Bounces
The superscript `1` in `L^1` refers to the number of photon bounces we are calculating
We can compute the `L^2` light distribution, by using the reflection equation but replacing `L^e` with `L^1`:
`L^2(tilde x, vec v) = int_H dw f_(tilde x, vec n)(vec w, vec v) cos (theta) L^1(vec w, tilde x) `
`= int_H dw f_(tilde x, vec n)(vec w, vec v) cos (theta) int_(H') dw' f_(tilde x', vec n')(vec w', vec w) cos (theta') L^e(vec w', tilde x')`
` = int_H dw int_(H') dw' f_(tilde x, vec n)(vec w, vec v) cos (theta)f_(tilde x', vec n')(vec w', vec w) cos (theta') L^e(vec w', tilde x')`
Here `tilde x'` is the point first hit along the ray `(tilde x, - vec w)`.
At the intersecting point, `vec n'` is the normal, `H'` is the upper hemisphere and `vec w'` is an incoming direction making angle `theta'` with `vec n'`
Computing with the Two Bounce Equation
The second equation of the last slide, suggests computing `L^2` by recursively evaluating these nested integrals using distribution ray tracing.
That is, an outer loop integrates the hemisphere above `tilde x`.
For each sampled direction `vec w`, we hits some point `tilde x'`.
We then use a recursive distribution ray tracing call to integrate the hemisphere above it.
The third equation gives an alternative was to compute the integral.
Let `tilde x''` be the first point hit along the ray `(tilde x', vec w')`.
Then in the integral, each setting of `(vec w, vec w')` corresponds to a geometric path of length two `(tilde x, tilde x', tilde x'')`.
We can think of this integrand as calculating the light emitted at `tilde x''`,
reflected at `tilde x'`, and then reflected at `tilde x` out toward `vec v`.
So rather than an integral over two hemispheres we can think of this as an integral over a space of paths. This is the basis for path tracing variants of ray tracing.
Important of the Second Bounce
The second bounce `L^2` is less important than direct lighting, but it is needed to properly simulate blurry reflections of the the surrounding environment.
It also produces the less visible effect called color bleeding where the color of a surface is influenced by the color of nearby surfaces.
In the first picture above, you can see the blurry reflection of the light panel off the wall onto the sphere, and color bleeding from the walls to the ceiling.
In the second picture above, you can see caustic effects caused by light bouncing off a mirrored or refracted surface and creating a bright spot on diffuse surfaces.
Quiz
Which of the following statements is true?
Radiant flux is the limiting value of irradiance as we let the wedge `W` shrink to a point.
Last week, we used the same reflection equation for general materials as for mirrors.
The BRDF for a diffuse material is the constant `1`.
And So On
In the real world light can bounce many times.
The total observed light, `L^t`, is thus the sum
`L^t = L^e + L^1 + L^2 + L^3 + ...`
Higher bounces account for the overall distribution of lightness and darkness in an image.
In software rendering, higher bounces are often computed using sampling and summing either via distribution ray tracing, path tracing, "radiance" algorithm, or photon mapping.
In OpenGL, these effects are often simply hacked using a combination of multiple pass rendering, and precomputed textures.
The Rendering Equation
Instead of thinking of `L^t` as an infinite sum of `L^i`, we can also think of `L^t` as the solution of the rendering equation.
We start off with the following shorthand
`L^1 = BL^e` where `B` is the bounce operator mapping light distribution to light distributions.
In General `L^(i+1) = BL^i`.
Putting this together we get
`L^t = L^e + L^1 + L^2 + L^3 + ...`
`= L^e + B(L^e + L^1 + L^2 + L^3 + ...)`
`= L^e + BL^t`
This expresses an equation that must hold for the total equilibrium distribution `L^t`.
At a surface point, this can be expanded as
`L^t(tilde x, vec v) = L^e(tilde x, vec v) + int_H dw f_(tilde x, vec n)(vec w, vec v) L^t(vec w, tilde x) cos (theta)`
This is called the rendering equation and we'll look at ways to solve it next day. Our solution so far is the sum we have been considering.
Notice that `L^t` occurs on both sides of this equation, so it is an integral equation, (similar to a differential equation, which would involve derivatives rather than integrals).
Code examples
I'd like to switch topics for a moment and discuss how to set up a project for Hw4.
I have created some starter code (sorry, doesn't have the GLSL 1.2 shaders) which I'd like to briefly go over.
The code shows how the idea of using arrays to send geometry and lighting data to the fragment shader, it shows how to set up the rectangle on which drawing will be done in the fragment shader, and it illustrates how to "fake" the recursion sufficiently to do a fixed number of bounces. (Shaders don't support recursion.)
