CIS565-Fall-2018 · ziedbha · Sep 29, 2018 · Sep 29, 2018 · Sep 29, 2018 · Sep 30, 2018
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -74,6 +74,7 @@ endif()
 include_directories(.)
 #add_subdirectory(stream_compaction)  # TODO: uncomment if using your stream compaction
 add_subdirectory(src)
+add_subdirectory(tinyobjloader)
 
 cuda_add_executable(${CMAKE_PROJECT_NAME}
     "src/main.h"
@@ -83,6 +84,7 @@ cuda_add_executable(${CMAKE_PROJECT_NAME}
 target_link_libraries(${CMAKE_PROJECT_NAME}
     src
     #stream_compaction  # TODO: uncomment if using your stream compaction
+	tinyobj
     ${CORELIBS}
     )
 

diff --git a/README.md b/README.md
@@ -3,11 +3,138 @@ CUDA Path Tracer
 
 **University of Pennsylvania, CIS 565: GPU Programming and Architecture, Project 3**
 
-* (TODO) YOUR NAME HERE
-* Tested on: (TODO) Windows 22, i7-2222 @ 2.22GHz 22GB, GTX 222 222MB (Moore 2222 Lab)
+* Ziad Ben Hadj-Alouane
+  * [LinkedIn](https://www.linkedin.com/in/ziadbha/), [personal website](https://www.seas.upenn.edu/~ziadb/)
+* Tested on: Windows 10, i7-8750H @ 2.20GHz, 16GB, GTX 1060
 
-### (TODO: Your README)
+# Project Goal
+<p align="center">
+  <img src="https://github.com/ziedbha/Project3-CUDA-Path-Tracer/blob/master/images/top.png"/>
+</p>
 
-*DO NOT* leave the README to the last minute! It is a crucial part of the
-project, and we will not be able to grade you without a good README.
+In this project, I implemented a Path Tracer using the CUDA parallel computing platform. Path Tracing is a computer graphics Monte Carlo method of rendering images of three-dimensional scenes such that the global illumination is faithful to reality. 
 
+# Path Tracing Intro
+<p align="center">
+  <img width="300" height="400" src="https://github.com/ziedbha/Project3-CUDA-Path-Tracer/blob/master/images/explanation.png"/>
+</p>
+In simple terms, a path tracer fires rays from each pixel, which would bounce off in many directions depending on the objects in the scene. If the ray is fortunate enough, it would hit an illuminating surface (lightbulb, sun, etc...), and would cause the first object it hit to be illuminated, much like how light travels towards our eyes.
+
+## Issues
+Path tracing is computationally expensive since for each pixel, our rays might hit numerous geometries along the way. Checking intersections with each geometry is expensive, which is why we employ optimization techniques (culling, caching, stream compaction, material sorting) as well as use a parallel computing platform (CUDA) to take advantage of the GPUs cores.
+
+## Stream Compaction, Caching, & Sorting Optimizations
+### Stream Compaction
+[Stream Compaction](https://github.com/ziedbha/Project2-Stream-Compaction) helps by ommitting rays that aren't used in an iteration anymore. This happens when a ray hits nothing, or runs out of bounces (e.g hits a light source). This allows for a fewer blocks to launch, and less divergence in threads. The effects are great in different types of open scenes (tall, numerous materials, high-poly count) as shown below:
+![](images/stream_compaction_scenes.png)
+
+However, the effects are less impressive when it comes to closed scenes, since stream compaction only comes in when rays hit a light source or natrually run out of permitted bounces. Overall, performance improves a lot with stream compaction.
+![](images/open_vs_closed_compact.png)
+
+### Caching
+Since in the beginning of every iteration we fire the exact same ray from the exact same pixel, then we cache the intersection results so that we do not repeat them in subsequent iterations. Note that this feature does not work when anti-aliasing is enabled since anti-aliasing adds noise to the first rays, making them probabilistically unequal in subsequent iterations.
+
+### Material Sorting
+
+| Without Sorting | With Sorting | 
+| ------------- | ----------- |
+| <p align="center"><img width="300" height="350" src="https://github.com/ziedbha/Project3-CUDA-Path-Tracer/blob/master/images/no_sort.png"/></p>| <p align="center"><img width="300" height="350" src="https://github.com/ziedbha/Project3-CUDA-Path-Tracer/blob/master/images/with_sort.png"/></p> |
+
+Before shading a ray, I performed an optimization that consisted in sorting the rays by the material type they hit. This allowed the CUDA warps (sets of threads) to diverge less in execution, saving more time. As the graphs above show, there are more branches in the unsorted case, and even more divergence as captured by the CUDA profiler.
+
+## 3D Model Importing (.obj)
+| Dedocahedron | Sword | 
+| ------------- | ----------- |
+| ![](images/deca.png) | ![](images/sword.png) |
+
+To import 3D .obj files, I used TinyObjLoader which is a good parser for this specific file format. .obj files contain vertex information (positions, normals, texture coordinates) as well as triangulation information. Implementing this feature meant that I needed to store separate triangles for one mesh, with each triangle containing the correct vertex data.
+
+As expected, high poly-count meshes take longer to render (see below)
+
+| Wahoo | [Spider](https://poly.google.com/view/cbFePDoI8yi) | 
+| ------------- | ----------- |
+| ![](images/wahoo.png) | ![](images/spider.png) |
+
+### Performance & Optimization
+Since GPUs aren't able to use resizable arrays, I couldn't store vectors of triangles for each mesh. Instead, I loaded my meshes this way:
+
+| Mesh 1 | Triangle 1-1 | Triangle 1-... | Triangle 1-n | ... | Mesh 2 | Triangle 2-1 | Triangle  2- ...| Triangle 2-m |
+| ------------- | ----------- | ----------- | ----------- | ----------- | ----------- | ----------- | ----------- | ----------- |
+| End Index of Triangle data | Vertex data | Vertex data | Vertex data | ... | End Index of Triangle data | Vertex data | Vertex data | Vertex data |
+
+So that when I tested intersections against a mesh, I would access the next index to find the first triangle, and I would access the end index to find the last triangle of the mesh.
+
+To test intersections against the mesh, I did two optimizations:
+1. *Bounding-Volume Culling*: I compute the bounds of the mesh and surround it by a bounding box. Using this bounding box, I can check if a ray can potentially hit the mesh. If it can't, then no intersection is possible, so we skip it. Else, we test intersections against all triangles.
+2. *Deferred Intersection Calculations*: I calculate intersections against triangles in a mesh in one giant batch. In other words, I only keep the closest triangle I intersected for a ray, and THEN perform all needed calculations. This significantly improves the performance of mesh intersection since for high poly-count meshes, simple calculations such as point retrieval become expensive.
+
+## Anti-Aliasing
+| Without Anti-Aliasing | With Anti-Aliasing | 
+| ------------- | ----------- |
+| ![](images/aa_none.png) | ![](images/aa.png) |
+
+In computer graphics, anti-aliasing is a software technique used to diminish stair-step like lines that should be smooth instead. This usually occurs when the resolution isn't high enough. In path tracing, we apply anti-aliasing by firing the ray with additional noise. If the ray is supposed to color pixel (x,y), we sample more colors around that pixel, and average them out to color pixel (x,y).
+
+The picture below explains the approach. My implementation is represented by the image on the right. A dot is a sample (ray), a square is a pixel.
+
+<p align="center">
+  <img width="300" height="100" src="https://github.com/ziedbha/Project3-CUDA-Path-Tracer/blob/master/images/aa_exp.png"/>
+</p>
+
+### Performance & Optimization
+Anti-Aliasing has no impact on performance since it is essentially 2 more lines of code per ray. All rays do the same anti-aliasing computation, which means that no warps diverge. No further optimization needed.
+
+## Depth of Field
+
+| Without Depth of Field | With Depth of Field | 
+| ------------- | ----------- |
+| ![](images/dof_none.png) | ![](images/dof.png) |
+
+In optics, depth of field is the distance about the plane of focus where objects appear acceptably sharp in an image. In path tracing, this is achieved by adding noise to the ray direction about the focal point, as explained in this [article](https://medium.com/@elope139/depth-of-field-in-path-tracing-e61180417027).
+
+### Performance & Optimization
+Depth of Field is just a few extra vector computations per ray, and much like anti-aliasing, it has no impact on performance. All rays do the same computation, which means that no warps diverge. No further optimization needed.
+
+
+## Materials Support
+<p align="center">
+  <img src="https://github.com/ziedbha/Project3-CUDA-Path-Tracer/blob/master/images/mix.png"/>
+</p>
+My implementation supports diffuse and specular materials. For specular materials, I support pure refractive, reflective, and transmissive materials. 
+
+### Diffuse
+<p align="center">
+  <img src="https://github.com/ziedbha/Project3-CUDA-Path-Tracer/blob/master/images/diffuse.png"/>
+</p>
+
+### Specular Reflective
+<p align="center">
+  <img src="https://github.com/ziedbha/Project3-CUDA-Path-Tracer/blob/master/images/reflect.png"/>
+</p>
+
+### Specular Refractive
+<p align="center">
+  <img src="https://github.com/ziedbha/Project3-CUDA-Path-Tracer/blob/master/images/refract.png"/>
+</p>
+
+### Transmissive using Schlick's Approximation
+<p align="center">
+  <img src="https://github.com/ziedbha/Project3-CUDA-Path-Tracer/blob/master/images/transmit.png"/>
+</p>
+
+# Bloopers & Bugs
+| Weak Seed for Randomly Generated Numbers | Incorrect Access of Path Index in a Thread | Missing Internal Total Reflection & Wrong Normals |
+| ------------- | ----------- | ------------- |
+| <p align="center"><img width="200" height="200" src="https://github.com/ziedbha/Project3-CUDA-Path-Tracer/blob/master/images/seed_bug.png"/></p> |  <p align="center"><img width="200" height="200" src="https://github.com/ziedbha/Project3-CUDA-Path-Tracer/blob/master/images/stream_compaction_bug.png"/></p> |  <p align="center"><img width="200" height="200" src="https://github.com/ziedbha/Project3-CUDA-Path-Tracer/blob/master/images/refraction_bug.png"/></p> |
+
+# Build Instructions
+1. Install [CMake](https://cmake.org/install/)
+2. Install [Visual Studio 2015](https://docs.microsoft.com/en-us/visualstudio/welcome-to-visual-studio-2015?view=vs-2015) with C++ compativility
+3. Install [CUDA 8](https://developer.nvidia.com/cuda-80-ga2-download-archive) (make sure your GPU supports this)
+4. Clone this Repo
+5. Create a folder named "build" in the root of the local repo
+6. Navigate to the build folder and run "cmake-gui .." in a CLI
+7. Configure the build with Visual Studio 14 2015 Win64, then generate the solution
+8. Run the solution using Visual Studio 2015
+10. Build cis_565_path_tracer and set it as Startup Project
+9. Run cis_565_path_tracer with command line arguments: ../scenes/name_of_scene.txt
diff --git a/images/aa.png b/images/aa.png
diff --git a/images/aa_exp.png b/images/aa_exp.png
diff --git a/images/aa_none.png b/images/aa_none.png
diff --git a/images/deca.png b/images/deca.png
diff --git a/images/diffuse.png b/images/diffuse.png
diff --git a/images/dof.png b/images/dof.png
diff --git a/images/dof_none.png b/images/dof_none.png
diff --git a/images/explanation.png b/images/explanation.png
diff --git a/images/mix.png b/images/mix.png
diff --git a/images/no_sort.png b/images/no_sort.png
diff --git a/images/open_vs_closed_compact.png b/images/open_vs_closed_compact.png
diff --git a/images/reflect.png b/images/reflect.png
diff --git a/images/refract.png b/images/refract.png
diff --git a/images/refraction_bug.png b/images/refraction_bug.png
diff --git a/images/seed_bug.png b/images/seed_bug.png
diff --git a/images/spider.png b/images/spider.png
diff --git a/images/stream_compaction_bug.png b/images/stream_compaction_bug.png
diff --git a/images/stream_compaction_scenes.png b/images/stream_compaction_scenes.png
diff --git a/images/sword.png b/images/sword.png
diff --git a/images/top.png b/images/top.png
diff --git a/images/transmit.png b/images/transmit.png
diff --git a/images/wahoo.png b/images/wahoo.png
diff --git a/images/with_sort.png b/images/with_sort.png
diff --git a/scenes/cornell.txt b/scenes/cornell.txt
@@ -38,12 +38,33 @@ REFR        0
 REFRIOR     0
 EMITTANCE   0
 
-// Specular white
+// Specular blue (refr + ref)
 MATERIAL 4
+RGB         .8 .98 .98
+SPECEX      0
+SPECRGB     .8 .98 .98
+REFL        0.5
+REFR        0.3
+REFRIOR     1.4
+EMITTANCE   0
+
+// Specular blue (ref only)
+MATERIAL 5
+RGB         .8 .98 .98
+SPECEX      0
+SPECRGB     .8 .98 .98
+REFL        1
+REFR        0
+REFRIOR     0
+EMITTANCE   0
+
+
+// Diffuse White
+MATERIAL 5
 RGB         .98 .98 .98
 SPECEX      0
 SPECRGB     .98 .98 .98
-REFL        1
+REFL        0
 REFR        0
 REFRIOR     0
 EMITTANCE   0
@@ -58,6 +79,8 @@ FILE        cornell
 EYE         0.0 5 10.5
 LOOKAT      0 5 0
 UP          0 1 0
+FOCAL		10
+LENSR		0.5
 
 
 // Ceiling light
@@ -115,3 +138,12 @@ material 4
 TRANS       -1 4 -1
 ROTAT       0 0 0
 SCALE       3 3 3
+
+// Sphere
+OBJECT 7
+sphere
+material 5
+TRANS       4 4 -1
+ROTAT       0 0 0
+SCALE       3 3 3
+
diff --git a/scenes/cube.txt b/scenes/cube.txt
@@ -0,0 +1,176 @@
+// Emissive material (light)
+MATERIAL 0
+RGB         1 1 1
+SPECEX      0
+SPECRGB     0 0 0
+REFL        0
+REFR        0
+REFRIOR     0
+EMITTANCE   4
+
+// Diffuse white
+MATERIAL 1
+RGB         .98 .98 .98
+SPECEX      0
+SPECRGB     0 0 0
+REFL        0
+REFR        0
+REFRIOR     0
+EMITTANCE   0
+
+// Diffuse red
+MATERIAL 2
+RGB         .85 .35 .35
+SPECEX      0
+SPECRGB     0 0 0
+REFL        0
+REFR        0
+REFRIOR     0
+EMITTANCE   0
+
+// Diffuse blue
+MATERIAL 3
+RGB         .35 .35 .85
+SPECEX      0
+SPECRGB     0 0 0
+REFL        0
+REFR        0
+REFRIOR     0
+EMITTANCE   0
+
+// neutral
+MATERIAL 4
+RGB         1 1 1
+SPECEX      0
+SPECRGB     1 1 1
+REFL        0
+REFR        0
+REFRIOR     0
+EMITTANCE   0
+
+// Diffuse 1
+MATERIAL 5
+RGB         .50 .98 .5
+SPECEX      0
+SPECRGB     .50 .98 .5
+REFL        0
+REFR        0
+REFRIOR     0
+EMITTANCE   0
+
+// Diffuse 1
+MATERIAL 6
+RGB         .2 .2 .98
+SPECEX      0
+SPECRGB     .2 .2 .98
+REFL        0.5
+REFR        0.6
+REFRIOR     1.3
+EMITTANCE   0
+
+// Diffuse red
+MATERIAL 7
+RGB         .8 .0 .0
+SPECEX      0
+SPECRGB     .98 .7 .8
+REFL        0
+REFR        0
+REFRIOR     0
+EMITTANCE   0
+
+// Diffuse yellow
+MATERIAL 8
+RGB         .8 .8 .3
+SPECEX      0
+SPECRGB     .98 .98 .0
+REFL        0
+REFR        0
+REFRIOR     0
+EMITTANCE   0
+
+// Camera
+CAMERA
+RES         800 800
+FOVY        45
+ITERATIONS  5000
+DEPTH       8
+FILE        cornell
+EYE         0.0 5 10.5
+LOOKAT      0 5 0
+UP          0 1 0
+FOCAL		10
+LENSR		0.5
+
+
+// Ceiling light
+OBJECT 0
+cube
+material 0
+TRANS       0 10 0
+ROTAT       0 0 0
+SCALE       6 .3 6
+
+// Floor
+OBJECT 1
+cube
+material 1
+TRANS       0 0 0
+ROTAT       0 0 0
+SCALE       10 .01 10
+
+// Ceiling
+OBJECT 2
+cube
+material 1
+TRANS       0 10 0
+ROTAT       0 0 90
+SCALE       .01 10 10
+
+// Back wall
+OBJECT 3
+cube
+material 1
+TRANS       0 5 -5
+ROTAT       0 90 0
+SCALE       .01 10 10
+
+// Left wall
+OBJECT 4
+cube
+material 2
+TRANS       -5 5 0
+ROTAT       0 0 0
+SCALE       .01 10 10
+
+// Right wall
+OBJECT 5
+cube
+material 3
+TRANS       5 5 0
+ROTAT       0 0 0
+SCALE       .01 10 10
+
+// Mesh
+OBJECT 6
+mesh	../models/cube.obj
+material 6
+TRANS       -4 6 -2
+ROTAT       0 45 45
+SCALE       1 1 1
+
+
+// Mesh
+OBJECT 7
+mesh	../models/cube.obj
+material 7
+TRANS       0 4 -2
+ROTAT       0 50 0
+SCALE       1 2 1
+
+// Mesh
+OBJECT 8
+mesh	../models/cube.obj
+material 8
+TRANS       -2 2 0
+ROTAT       0 30 0
+SCALE       1 1 2