The raytacer implemented for this final project in CPE 473 includes the following:

• Direct lighting with ambient, diffuse, and specular lighting

This calculation is done using the Phong model of light.

• Reflections and refractions with a recusion depth of 6

Reflection rays are generated using the direction of the incoming ray and the normal of the surface that was struck:

Vector reflected_ray = d - n * (2 * d.dot(n));

Refraction rays are generated using the same vectors, as well as applying snell's law.

d.normalize();
float N;
if(inside)
N = s->ior;
else
N = 1.0f / s->ior;
float cos2T = -n.dot(d);
float sinT2 = N * N * (1.0f - cos2T * cos2T);
if(sinT2 > 1.0f)
{//total internal reflection
return Vector();
}
float cosT = sqrt(1.0f - sinT2);
return d * N + n * (N * cos2T - cosT);

• Soft shadows

Soft shadows require using area lights. This is done by accumulating the light from multiple point lights and dividing the result by the number of point lights used. In my implementation, I used a volume light (for more resolution) centered around the original point light location. I did this with a 3-level nested for loop that changed each dimention of the light's location by a small value and rendered the direct lighting for each iterated point light. This is very computation intensive and adds at least 4^3 times as many shadow calculations.

• Shadow Occlusion

This is where translucent objects cast a lighter shadow than opaque objects. However, an opaqe object and a translucent object might both be in the way of the light. In these cases, the smaller alpha (0 for opaque objects) takes priority in the shading.

• Quick intersections of complex scenes using both CUDA and Oct Trees

This quarter we teamed up with the parallel processing class to parallelize our raytracer. We used the CUDA environment, where masses of intersections can be ported to the graphics card to do hundreds of thousands of calculations at a time. In our CUDA implementation, we had the multiple threads in the graphics card each do intersections for one pixel, since the number of pixels will almost always beat the number of objects to intersect with.

In addition, we implemented an Oct Tree, which is a spatial subdivision method of dividing space into recursive volumes of 8 parts, 2 by 2 by 2. This improved our times dramatically.

• Texture mapping for spheres, meshes, triangles, and boxes

Texture mapping for spheres is very simple. Once an intersection is made, the object space point of intersection is used to create spherical coordinates relative to the center of the circle (in object space). These parameters are transformed into values between 1 and 0 for each x and y dimension pixels of an imported image for mapping.

For meshes, it is nearly the same. A *.m mesh is imported and the center of the mesh is calculated from the triangles. Each triangle is tagged as part of this union, given the center of the mesh, and connected with a texture. Then spherical coordinates as above are used with the center for the triangle being the center of its union mesh.

Triangle texture mapping uses barycentric coordinates. This is slightly complicated, but simply but, barycentric coordinates tells us how far we are from each corner of the triangle. These parameters are transformed into image coordinates (again 0 to 1) in both dimensions. In the POVray file, the image coordinates and be parameterized in a custom fashion (e.g. instead of including the whole image 0 to 1, include the middle half, 0.25 to 0.75).

Boxes are mapped exactly like spheres.

Complexity

(note - all of the bunny images shown are anti aliased 4 x)

bunny_jumbo.pov with Hard Shadows, No Anti Aliasing, 640 x 480

GPU: 1.26 sec

CPU: 21 min 56 sec

bunny_jumbo.pov with Soft Shadows, 4x Anti Aliasing, 1290 x 960

GPU: 14 min 35 sec

CPU: Don't even want to try.

bunny_jumbo_tris.pov with Hard Shadows, No Anti Aliasing, 640 x 480

GPU: 1.307 sec

CPU: 17 min 24 sec

bunny_jumbo_tris.pov with Hard Shadows, 2x Anti Aliasing, 640 x 480

GPU: 2.269 sec

CPU: 73 min 1 sec

bunny_jumbo_tris.pov with Soft Shadows, 4 x Anti Aliasing, 1290 x 960

GPU: 13 min 14 sec

CPU: Don't even want to try.

bunny_tasty.pov with Hard Shadows, no Anti Aliasing, 640 x 480

GPU: 1.667 sec

CPU: 24 min 18 sec