Introduction to Ray Tracing

Before the break we started talking about ray tracing. Let's briefly review what we had said...
Ray tracing represents a different approach to rendering than the standard OpenGL pipeline.

We can think of the OpenGL rasterization-based rendering as a form of the following algorithm:

initialize z-buffer
for all triangles
   for all pixels covered by the triangle
       compute color and z
       if z is closer than what is already in the z-buffer
           update the color and z of the pixel

This algorithm is fast because each triangle in the scene is touched only once and in a predictable order.
Even Pixar uses this algorithm it is offline program Renderman.
Another property is that during the processing of a triangle, setup computation is done only once can can be amortized over all of the pixels in it.
We can soup up this basic model using fancy shading computations and by using multipass algorithms like shadow mapping.

In basic ray-tracing, we reverse the loop orders to obtain:

for all pixels on the screen
   for all objects seen in this pixel
     if this is the closest object seen at the pixel
         compute color and z
         set the color of the pixel

Advantages of Ray Tracing

We never waste computation calculating the color of an occluded object
Transparency is easier.
We can directly render smooth objects without first having to dice them into triangles.
It is also easier to render solid objects described by volumetric set operations, such as union or intersection.
It is easier to handle reflections and shadows.

Intersection Testing

The geometry of a scene for ray tracing purposes.

To figure out whether an object is seen in a pixel, we need to be able to determine if a ray shot out from the eye through a pixel in the film plane intersects the object. (See the picture above.)
A salutory effect of being able to carry out such intersection tests is we will also be able to further trace light through the scene. For example, we can figure out how directly illuminated that point on an object is by a light source, or how much light it is receiving that was reflected off of other objects.

Intersection Testing -- Plane

Suppose we wish to compute the intersection of the ray with starting point `tilde p` and direction `vec d` (we'll denote this ray `(tilde p, vec d)`) with a plane described by the equation `Ax + By + Cz + D = 0`.
To start we represent points along the ray using the parameter `lambda` via the equation:
`[[x],[y],[z]] = [[p_x],[p_y],[p_z]] + lambda [[d_x],[d_y],[d_z]]`
Plugging into the plane equation, we get:
`0 = A(p_x + lambda_x) + B(p_y + lambda_y) + C(p_z + lambda_z) + D`
`= lambda(Ad_x + Bd_y + Cd_z) + Ap_x + Bp_y + Cp_z + D`.
Solving for `lambda` yields
`lambda = -(Ap_x + Bp_y + Cp_z + D)/(Ad_x + Bd_y + Cd_z)`

Example

Suppose the eye was on the z-axis at 2. We are shooting a ray from this position through `[-1, 1, 0]^t` (top left of our normalized coordinates). Suppose we are interested in where this hits the plane with normal `[0, -1, 0]^t` and where the point `[0, 2, 0]^t` is on the plane.
`tilde p` is
`[[0],[0],[2]]`.
`vec d` is
`[[-1],[1],[0]] - [[0],[0],[2]] = [[-1],[1],[-2]]`
The equation of the plane will be `0x + (-1)y + 0z + 2 = -y + 2 = 0`.
The formula of the last slide gives
`lambda = -( 2 )/ (-1) = 2`.
Substituting this back in give the intersection point as:
`[[x],[y],[z]] = [[0],[0],[2]] + 2 [[-1],[1],[-2]] = [[-2],[2],[-2]]`

Intersection Testing -- Triangle Take 1

We split the task of intersecting a ray with a triangle into two steps.
First, we compute the `A`, `B`, `C`, `D` of the plane supporting the triangle and compute the ray-plane intersection as above. (We can use the three points to determine a normal, then sub one of the points into the plane equation to get `D`.)
Next, we need a test to determine if the intersection point is inside or outside of the triangle.
To do the second step, recall when we were discussing backface culling last semester, we wanted to figure out if a triangle with vertices counter-clockwise ordered as `tilde p_1`, `tilde p_2`, `tilde p_3` was a forward-facing or back-facing triangle.
This involved computing the cross product `(tilde p_3 - tilde p_2) times (tilde p_1 - tilde p_2)` which would be negative if the vertices are arranged counterclockwise in the forward-facing plane and positive otherwise.
So to check if we have a front face (counterclockwise), we checked that:
`(x_n^3 - x_n^2)(y_n^1 - y_n^2) - (y_n^3 - y_n^2)(x_n^1 - x_n^2)`
is positive.
On the next slide, we use this clockwise/counter-clockwise test to determine if a point `tilde q` is inside or outside a triangle `Delta(tilde p_1, tilde p_2, tilde p_3)` where the vertices are arranged in a counter-clockwise order

Intersection Testing -- Triangle Take 2

To do our test we consider the three triangles, `Delta(tilde p_1, tilde p_2, tilde q)`, `Delta(tilde p_1, tilde q, tilde p_3)`, and `Delta(tilde q, tilde p_2, tilde p_3)`
When `tilde q` is inside of `Delta(tilde p_1, tilde p_2, tilde p_3)`, then all three sub-triangles will agree on their clockwisedness. When `tilde q`, they will disagree.

Intersection Testing -- Sphere

We can adapt the idea behind ray-plane intersections to calculate ray-sphere intersections.
Model a sphere by a radius `R` and a center `vec c`, as the set of points `[x, y, z]^t` that satisfy the equation `(x-c_x)^2 + (y-c_y)^2 + (z-c_z)^2 - r^2 = 0`.
Plugging this in the equation for the points on a ray gives:
`0 = (p_x + lambda d_x - c_x)^2 + (p_y + lambda d_y - c_y)^2 + (p_z + lambda d_z - c_z)^2 - r^2`
`= (d_x^2 + d_y^2 + d_z^2)lambda^2 + [2d_x(p_x - c_x) + 2d_y(p_y - c_y) + 2d_z(p_z - c_z)] lambda `
`qquad + (p_x -c_x)^2 + (p_y -c_y)^2 + (p_z -c_z)^2 - r^2`
Only `lambda` is not known. So we can find `lambda` by using the quadratic formula after substituting in the known values above.
If there are two real roots then there are two intersections. If there is one real root (of degree 2), the intersection is tangential. Otherwise, the ray misses the sphere.

Early Rejection

Instead of testing every scene object for intersection with the ray, we may use auxiliary data structures to quickly determine that some set of objects is entirely missed by the ray.
For example, one can use a simple shape (a sphere or a box) that encloses some subset of the objects
Given a ray, one first calculates if the ray intersects the volume.
If it does not, then clearly, this ray misses all of the objects in the bounded set and so no more intersection testing is needed,
This idea can be generalized into hierarchical spatial data structures such as BSP trees or k-d trees.

Ray-tracing

Outline

Introduction to Ray Tracing

Advantages of Ray Tracing

Intersection Testing

Intersection Testing -- Plane

Example

Intersection Testing -- Triangle Take 1

Intersection Testing -- Triangle Take 2

Intersection Testing -- Sphere

Early Rejection