CIS681 Lab 4

Winter MMXI
due Monday, February 21

FINALIZED
NOTE: I've added that you have to implement simple near-far (hither-yon) clipping limits to your ray tracer.

Below, a transformed sphere and a transformed cube - one with a solid texture and one with a surface texture

Non uniform scaling of sphere and cube	Simple near cutting plane

Textured objects with reflection	Textured objects with reflection and refraction.	More complex near cutting plane

Objective

To modify lab3 to include solid and surface texture mapping, ellipses and cuboids (as non-uniformly scaled spheres and cubes), with simple near-far clipping.

Assignment

Modify your ray tracer to incorporate new effects. Call your program lab4. As with previous labs, your program should take an argument of a scene description filename, read it in, and output a .ppm file.

Your raytracer should:

allow for non-uniform scaling by computing intersections in object space.
```
scale <x> <y> <z>
```
handle transformed cubes. Calculate ray-axis-aligned-unit-cube intersections in object space. The cube command is similar to the sphere command:
```
cube <r> <g> <b> <texture-name_s> <kd> <ks> <n_i> <kr> <gl> <kt> <n1> <tr>
```
display at least one type of solid texture and one type of surface texture. Solid or surface texture should be on a sphere while the other type of texture should be on a cuboid - your choice which way to do it. You can use either procedural textures or table-based textures.
use the <texture-name_s> (make up your own texture names) to specify what objects are to be textured and what kind of texture to apply. For example, a sphere might get a stripe solid texture ; a cube might get a sinusoidal 2D texture on each face. For example,
```
cube 0.8 0.2 0.2 sines 0.7 0.6 3   0.6 0.0     0.5 1.05 0.0
sphere 0.3 0.6 0.2 stripes 0.7 0.6 3   0.0 0.0     0.0 0.0 0.0
```
Include simple near-far (aka hither-yon) clipping by ignoring any intersections that are outside of the clipping range.
Include with your submission a sample scene file which contains a scene with:
- a camera,
- at least two lights, and
- approximately 5 objects, including at least:
  - one transformed (including non-uniform scale) textured ellipse,
  - one transformed (including non-uniform scale) textured cuboid
- include at least one solid texture and one surface texture (one on an ellipse and the other on a cuboid)
Include a README.txt file with your submission explaining the solid and surface texture functions you used.

Notes

As with previous labs, the lab will be graded on UNIX using your submitted makefile and input files that produce .ppm files that can be converted to .jpg and viewed using display. The grader should be able to do the following on the Department's UNIX system, assuming your input file is called input.txt and it outputs an image in output.ppm:
```
make
lab4 input.txt
convert output.ppm output.jpg
display output.jpg
```
You do not need to include any reflection or refraction, but you should still have shadows

You need to do the inverse transform back into object space of intersection points. Incrementally build up the inverse transformation matrix as you incrementally build the current transform matrix. Pseudo-code for display procedure looks like (skipping over some details):

  for each pixel
    form ray
    for each object
      inverse transform ray (source point and direction) into object space
      if (intersection of ray and object exists)
        if (closest intersection so far)   // compare in world space
          transform point and normal back into world space
          // besides intersection info, enough info to retrieve texture colors is also needed
          record object, object space point, world point, world normal  
    if closest object is textured
      get texture color from object, texture and object space point
    do illumination model using color, world point, world normal
    record pixel color

For non-uniform scale as well as textures, you need to inverse transform rays back into object space for the intersection computation.
For the solid texture, just take the intersection point x,y,z through some procedure or table look-up (with interpolation) to get the new color.
For the surface texture:
- If the surface texture is on the sphere, then you need the inverse tangent function to map an x,y,z intersection location to u,v coordinates
- If the surface texture is on the cube, then you find the last entering face and map the x-y, y-z, or x-z coordinates (depending on which plane its on) to u,v simply by adding 0.5 to each.

Extra Credit

Include in your README.txt file an explanation of any extra credit work that you do together with example input files that demonstrate that work.

Generate a nice-looking wood texture
Generate a multiple frequency marble texture
Do some kind of interesting 2D table-based texturing
Genrate an interesting and/or complex scene including reflection and refraction
Handle cutting into a non-uniformly scaled sphere so that it appears solid

Last updated 2/11/2011

class home page