Basic Ray Tracer

 

Basic Ray Tracer

Welcome to the development blog of my ray tracer developed throughout the course CENG795 SPECIAL TOPICS: ADVANCED RAY TRACING
The ray tracer program is developed in C++ and works on the CPU. In this version of the program, core ray tracing functionalities are present with shading models of ambient, diffuse, specular(Blinn-Phong) and ideal specular(mirror) reflectance along with dielectrics(transparency). The image outputs are in png format and I am using LodePNG library for encoding.

Implementation Details

Parser

As input, the ray tracer expects an xml file that defines the camera and scene properties. Thus, the first task at hand is to parse this file and store the information in some class. For parsing the elements of the xml, I have used tinyxml2 library. Some important notes about parsing step are as follows:

• Triangle normals are computed for efficiency
• All the information is stored in an object of class Scene
• XML file uses 1-based indexing for faces, indices and ids

Now that we are done with parsing, we can move onto more interesting stuff about ray tracing.

Geometry

Geometry in basic ray tracing consists of vectors, rays and intersection routines. During development, I have followed Peter Shirley and R. Keith Morley. 2003. Realistic Ray Tracing (2 ed.). A. K. Peters, Ltd., Natick, MA, USA.
Although there exists some mistakes in the source code presented after the chapters, it still guides you in terms of good practice and low level efficiency. The chapters themselves are concise thus you can learn quickly and use it in practice. My class Vec3 is basically the same as in the book, consisting of floats. Floats are chosen over doubles for performance. Also inlining is used often for simple vector operations.  
class Ray is also how you would expect, only important note would be that we add an epsilon to shadow rays to eliminate self shadowing.
The intersection routines are all about geometry and the derivation for their formulas can be found in the book. For triangle intersections, using barycentric is a plus on performance.

Shape Primitives and Object Oriented 

A ray tracer usually consists of several modules(Or does it?) and gets complicated very fast with many operations. An appropriate approach is to take advantage of an object oriented design.

(Simplified) Class Diagram of Ray Tracer

As can be seen from the class diagram above, there is an abstract base class called Shape and Triangle, MeshTriangle and Sphere are derived from it. hit and shadowHit methods are virtual and need to be implemented in the derived classes. This class structure makes it extremely elegant and easy when writing the "main" routine.

The important points to note are that normal is pre-computed and stored in triangle primitives. For Triangles, vertices are stored directly, whereas for MeshTriangles indices to vertex_data are stored along with a pointer to its parent mesh. Parent mesh is just a container for vertex_data(actually it also stores a pointer to vertex_data for memory efficiency reasons). I have actually tested it both ways, storing vertices directly and storing indices. I found out that, storing the vertices directly uses almost double the amount of memory used by index one. Performance wise, direct storage is faster about a double. I chose to stick with indices in the end.

Shading Models 

For shading, I have mainly followed Peter Shirley and Steve Marschner. 2009. Fundamentals of Computer Graphics (3rd ed.). A. K. Peters, Ltd., Natick, MA, USA.
Ambient, diffuse, specular shading and mirror reflections are not too challenging. However one mistake that I made while working with reflections was that, when points were in shadow, I wasn't adding the light coming from reflections.
Refractions on the other hand were a bit more challenging. At first I was needlessly adding the light contributions(ambient, diffuse and specular) to the transmitted rays which were inside the dielectric object. This caused the images to appear brighter than they should be.

After I changed the code, I was able to get dimmer outputs, which look more similar to the reference image. I intend on looking into this at a later point as well in order to match the image better.

Multithreading

I added multithreading as well. It definitely helps with execution time. An important feature of ray tracing is that calculation of one pixel is independent from the calculation of another pixel. Thus, the calculations can be parallelized. The first method I thought was to divide the image into number of threads and make them individually work on mutually exclusive parts of the image. This method isn't particularly smart, because some part of the image might be empty and the thread responsible for that part would complete its job much faster than the others. To overcome this, I wrote a simple concurrent stack structure that allows the threads to pop a pixel and work on it. The access to the stack is made thread safe by use of locks. Since most of the work is calculations, the access is negligable. 

Outputs and Some Timing Experiments

simple.xml

0,142s (8 threads) 

0,134s (4 threads)

0,091s (1 thread)

spheres.xml

0,159s (8 threads)

0,174s (4 threads) 

0,236s (1 thread)

bunny.xml

4,493s (8 threads)

6,488s (4 threads) 

23,050s (1 thread)

cornellbox.xml

0,222s (8 threads)

0,195s (4 threads)

0,330s (1 thread)

cornellbox_glass.xml

0,250s (8 threads) 

0,252s (4 threads)

0,428s (1 thread)

scienceTree.xml

18,329s (8 threads)

25,403s (4 threads)

1m31,986s (1 thread)

Machine specs:
OS: Ubuntu 18.04.02 LTS 64-bit

Processor: Intel® Core™ i7-4770S CPU @ 3.10GHz × 8
Memory: 7,5 GiB