Required Features Completed:

• Arbitrary camera placement, film resolution, and aspect ratio

• Arbitrary scenes with spheres, triangles (possible with vertex normals), and arbitrary background colors

• Arbitrary materials, including diffuse and specular shading, reflections, and refractions

• Point and directional lights

• Ambient lighting

• Shadows

• Recursion to a bounded depth

Additional Features:

(5) Spot lights

(5) Jittered supersampling

(5) Adaptive supersampling (must show a speedup over non-adaptive)

(5) User interface that shows the raytraced image being updated

(10) An acceleration structure: BVH (measure the performance impact on different scenes!)

(10) Parallelize the raytracer (and analyze the performance gains as you add more processors!)

<Added on March 21st>

(5) Boxes and Planes

(5) Constructive Solid Geometry (union, difference, and intersection of primitives)

Code:

• • https://github.com/CyberHolmes/CSCI5607/tree/main/Project3b

Team Member:

• Hailin Archer

Description

This ray tracer program takes a scene text file from commandline as input. It allows user to choose sample size and number of threads from commandline. It renders the scene on computer screen using openGL. It also saves the image on disk as specified by the scene file. It allows user to control the camera's position and view angle by keyboard input. It also allows user to view live pixel update of current camera view with space key.

I completed most required features plus spot light, super sampling and adaptive sampling together with 3a (sample results are also included here). I implemented triangle and vertex normal triangle, parallelization and BVH. The triangle implementation took me some time, because at that time I didn't quite understand the intersection equation and struggled a little with how to reconcile hitting opposite sides. Parallelization was surprisingly easy to implement using openMP. However, I later found that using dynamic threads allocation can make a big difference in performance. BVH took me the longest time to implement. A big part of it is finding hidden bugs. My BVH implementation did not show much gain at first due to those hidden bugs. Once the bugs are clear, BVH gives amazing performance gain, especially for scenes with lots of small vertex triangle.

I also implemented live ray trace image update. Currently this update is done without parallelization and openGL update is slow. To be able to render the image in a reasonable amount of time, I update the image n x n pixels at a time so that it won't take too long to render. This n is hard coded to be longest image dimension divided by 25.

I also improved my camera control dramatically from 3a. Camera position control is the same as 3a. Camera angle rotation control are now divided to be around x axis and around y axis with the arrow keys. Also worth noting is that the camera control keys can be pressed simultaneously and have a cumulative control effect.

Note: The amount camera moves with each key press is hard coded in camera.h file. The current setting is good for most of the provided scene files. However, the current step size is too big for dragon control. If you would like to navigate camera view in dragon scene, you should reduce the camera move step in the camera.h file.

< Added on March 21st>

I implemented planes, boxes and CSG. Planes were very simple to implement. It is defined by a point and a normal in my implementation. Boxes took a little time, because of the edges and the corners. My box primitive are axis aligned, defined by a center position and edge length. I created a scene file box_plane.txt for testing

With a good data structure, CSG is not hard to implement. Union and intersection didn't take any time. Difference is a bit tricky, but not very difficult either. My CSG takes two primitive objects (spheres and boxes right now) and a relationship type. I created csg.txt, outdoor_csg.txt, outdoor_csg1.txt for testing.

How to compile the code

$ make clean

$ make

How to run the program

$ ./ray ./Scenes/<FILENAME>.txt

$ ./ray ./Scenes/<FILENAME>.txt -samplesize <n> -numthreads <n>

• samplesize: optional, controls supersampling sample size per pixel, default 1 (no super sampling)

• numthreads: optional, controls number of threads for dynamic openmp commands, default 8

User Controls

3D Camera Control:

• 'w': positiveMovement.z

• 's': negativeMovement.z

• 'a': negativeMovement.x

• 'd': positiveMovement.x

• 'q': positiveMovement.y

• 'e': negativeMovement.y

• LEFT: negativeTurn.x

• RIGHT: positiveTurn.x

• UP: positiveTurn.y

• DOWN: negativeTurn.y

Live Pixel Update With Current Camera View

• 'space' key - Image will be updated with minimum 5 samples per pixel, up to the number of pixels from command input.

Save Current Rendering Result on Screen to a File

• 'o' - Save current rendering result on screen to a file with time stamp (won't delete the image saved at the beginning of the rendering)

Reset Camera to the Original Setting

• 'b' - Reset camera position

'escape' - quit program <implemented in starter code>

Video Demo of UI Controls

Camera control, live pixel update, reset

Sample Scene Rendering Results

BVH & Parallelization Benchmark

Render Time with The Fastest Configuration For All Scenes

(Dynamic Parallel Processing of 8 Threads + BVH)

Spot Light

Super Jittered Sampling + Adaptive Sampling

Adaptive Sampling Benchmark

Boxes, Planes and CSG (Added on March 21st)