CIS565-Fall-2017 · rickyrajani · Sep 21, 2017 · Sep 21, 2017 · Sep 21, 2017 · Sep 21, 2017
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -72,7 +72,7 @@ if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
 endif()
 
 include_directories(.)
-#add_subdirectory(stream_compaction)  # TODO: uncomment if using your stream compaction
+add_subdirectory(stream_compaction)  # TODO: uncomment if using your stream compaction
 add_subdirectory(src)
 
 cuda_add_executable(${CMAKE_PROJECT_NAME}
@@ -82,7 +82,7 @@ cuda_add_executable(${CMAKE_PROJECT_NAME}
 
 target_link_libraries(${CMAKE_PROJECT_NAME}
     src
-    #stream_compaction  # TODO: uncomment if using your stream compaction
+    stream_compaction  # TODO: uncomment if using your stream compaction
     ${CORELIBS}
     )
 

diff --git a/README.md b/README.md
@@ -3,11 +3,76 @@ 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)
+* Ricky Rajani
+* Tested on: Windows 7, i7-6700 @ 3.40GHz 16GB, NVIDIA Quadro K620 (Moore 100C Lab)
 
-### (TODO: Your README)
+This project implements a CUDA-based path tracer capable of rendering globally-illuminated images very quickly. Base code was provided; however, the core renderer was implemented by the author.
 
-*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.
+### Core Features:
+- A shading kernel with BSDF evaluation for Ideal Diffuse surfaces [PBRT 8.3] and perfectly specular-reflective (mirrored) surfaces
+- Path continuation/termination using Stream Compaction
+- Path segments and intersections are contiguous in memory by material type before shading
+- First bounce intersections are cached for re-use across all subsequent iterations
 
+### Extra Features:
+- Refraction [PBRT 8.2] with Frensel effects using Schlick's approximation
+- Physically-based depth-of-field (by jittering rays within an aperture) [PBRT 6.2.3]
+- Stochastic Sampled Antialiasing
+- Motion blur through averaging samples at different times during the animation
+
+*All features are easily toggleable
+
+# Samples - 5000 iterations
+
+Open scene with anti-aliasing
+
+![](img/samples/open-basic.PNG)
+
+Closed scene with anti-aliasing (only one light)
+
+![](img/samples/closed-basic.PNG)
+
+Open scene with depth-of-field
+
+![](img/samples/dof2.PNG)
+
+![](img/samples/dof.PNG)
+
+Open scene with motion blur
+
+![](img/samples/motion2.PNG)
+
+Open scene with refraction (index of refraction is 1.5)
+
+![](img/samples/refract2.png)
+
+Open scene with reflection
+
+![](img/samples/refract.PNG)
+
+# Performance Analysis
+
+![](img/optimizations-open.PNG)
+
+![](img/optimizations-closed-graph.PNG)
+
+![](img/active-paths-graph.PNG)
+
+### Stream Compaction:
+
+Stream compaction helps most after a few bounces. It reduces the number of active paths during an iteration. The plot above shows the reduction in paths for open and closed scenes during one iteration. The thrust implementation (remove-if) was used for stream compaction as it was significantly faster than the work-efficient compaction.
+
+Using compaction reduces time spent on computing intersection of rays on object considerably. However, the drawback with stream compaction is time spent removing inactive paths. Thrust takes a significant amount of time with compaction which decreases its benefits.
+
+Examining the data, it is also evident that stream compaction is beneficial only for open scenes as the number of paths terminating in a closed scene is significantly less than in an open scene. 
+
+### Caching First Bounce:
+
+Caching the first bounce during an iteration reduces the time complexity significantly. However, this optimization can't be used under certain circumstances where the scene is not static, such as depth of field or motion blur. 
+
+### Sorting Path Segments and Intersections:
+
+Sorting path segments and intersections seems to not be beneficial for the scene (cornell) used as there are not that many materials used. In this scenario, sorting actually increases the time complexity and is not an optimization. In the open scene, it is more efficient to remove inactive paths rather than making them contiguous in memory. In the closed scene, since memory doesn't decrease significantly, sorting will take longer. In both cases, there still are not enough materials in the scene to balance the cost of sorting.
+
+## References
+- [PBRT] Physically Based Rendering, Second Edition: From Theory to Implementation. Pharr, Matt and Humphreys, Greg. 2010.
diff --git a/img/active-paths-graph.PNG b/img/active-paths-graph.PNG
diff --git a/img/optimizations-closed-graph.PNG b/img/optimizations-closed-graph.PNG
diff --git a/img/optimizations-open.PNG b/img/optimizations-open.PNG
diff --git a/img/samples/closed-basic.PNG b/img/samples/closed-basic.PNG
diff --git a/img/samples/dof.PNG b/img/samples/dof.PNG
diff --git a/img/samples/dof2.PNG b/img/samples/dof2.PNG
diff --git a/img/samples/motion.PNG b/img/samples/motion.PNG
diff --git a/img/samples/motion2.PNG b/img/samples/motion2.PNG
diff --git a/img/samples/open-basic.PNG b/img/samples/open-basic.PNG
diff --git a/img/samples/refract.PNG b/img/samples/refract.PNG
diff --git a/img/samples/refract2.png b/img/samples/refract2.png
diff --git a/scenes/cornell.txt b/scenes/cornell.txt
@@ -48,6 +48,26 @@ REFR        0
 REFRIOR     0
 EMITTANCE   0
 
+// Emissive material (light two)
+MATERIAL 5
+RGB         1 0.5 1
+SPECEX      0
+SPECRGB     0 0 0
+REFL        0
+REFR        0
+REFRIOR     0
+EMITTANCE   2
+
+// Refractive white
+MATERIAL 6
+RGB         .98 .98 .98
+SPECEX      0
+SPECRGB     0 0 0
+REFL        0
+REFR        1
+REFRIOR     1.5
+EMITTANCE   0
+
 // Camera
 CAMERA
 RES         800 800
@@ -59,7 +79,6 @@ EYE         0.0 5 10.5
 LOOKAT      0 5 0
 UP          0 1 0
 
-
 // Ceiling light
 OBJECT 0
 cube
@@ -71,7 +90,7 @@ SCALE       3 .3 3
 // Floor
 OBJECT 1
 cube
-material 1
+material 6
 TRANS       0 0 0
 ROTAT       0 0 0
 SCALE       10 .01 10
@@ -115,3 +134,30 @@ material 4
 TRANS       -1 4 -1
 ROTAT       0 0 0
 SCALE       3 3 3
+MOTION	    -1 1 0
+
+// Cube
+OBJECT 7
+cube
+material 6
+TRANS       2 6 -1
+ROTAT       45 45 0
+SCALE       2.5 2 3
+MOTION	    1 -1 0
+
+// Sphere
+OBJECT 8
+sphere
+material 3
+TRANS       -3 2 2
+ROTAT       0 0 0
+SCALE       1 4 1
+MOTION	    1 1 0
+
+// Floor light
+OBJECT 9
+cube
+material 5
+TRANS       0 0 0
+ROTAT       0 0 0
+SCALE       5 .3 4
diff --git a/src/interactions.h b/src/interactions.h
@@ -73,7 +73,41 @@ void scatterRay(
         glm::vec3 normal,
         const Material &m,
         thrust::default_random_engine &rng) {
-    // TODO: implement this.
-    // A basic implementation of pure-diffuse shading will just call the
-    // calculateRandomDirectionInHemisphere defined above.
+  // TODO: implement this.
+  // A basic implementation of pure-diffuse shading will just call the
+  // calculateRandomDirectionInHemisphere defined above.
+
+	if (m.hasReflective > 0) {
+		pathSegment.ray.direction = glm::reflect(pathSegment.ray.direction, normal);
+		pathSegment.color *= m.specular.color;
+	}
+	else if (m.hasRefractive > 0) {
+		// Schlick's Approximation implementation
+		thrust::uniform_real_distribution<float>urefract(0, 1);
+		float R_0 = std::pow((1.0f - m.indexOfRefraction) / (1.0f + m.indexOfRefraction), 2.0f);
+		float dot = fabs(glm::dot(normal, pathSegment.ray.direction)); // use fabs not abs for precise calculation
+		float fresnel = R_0 + (1.0f - R_0) * std::pow(1.0f - dot, 5.0f);
+
+		if (urefract(rng) < fresnel) {
+			pathSegment.ray.direction = glm::reflect(pathSegment.ray.direction, normal);
+		}
+		else {
+			float refractNum = 0.0f;
+			if (pathSegment.isRefract) {
+				refractNum = m.indexOfRefraction;
+			}
+			else {
+				refractNum = 1.0f / m.indexOfRefraction;
+			}
+			// Snell's law
+			pathSegment.ray.direction = glm::refract(pathSegment.ray.direction, normal, refractNum);
+			pathSegment.isRefract = urefract(rng) > 0.5;
+		}
+	}
+	else {
+		pathSegment.ray.direction = calculateRandomDirectionInHemisphere(normal, rng);
+	}
+
+  pathSegment.color *= m.color;
+  pathSegment.ray.origin = EPSILON * pathSegment.ray.direction + intersect;
 }