Project3: Nicholas Liu

.gitignore

@@ -23,7 +23,8 @@ build
 .LSOverride
 
 # Icon must end with two \r
-Icon
+Icon
+
 
 # Thumbnails
 ._*
@@ -558,3 +559,4 @@ xcuserdata
 *.xccheckout
 *.moved-aside
 *.xcuserstate
+.vscode/*

.vscode/launch.json

@@ -0,0 +1,16 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "CUDA C++: Launch",
+            "type": "cuda-gdb",
+            "request": "launch",
+            "program": "${workspaceFolder}/build/bin/cis565_path_tracer",
+            "args": ["scenes/cornell.json"],
+            "cwd": "${workspaceFolder}"
+        },
+    ]
+}

CMakeLists.txt

@@ -56,6 +56,7 @@ set(headers
     src/interactions.h
     src/intersections.h
     src/glslUtility.hpp
+    src/guiDataContainer.h
     src/pathtrace.h
     src/scene.h
     src/sceneStructs.h
@@ -68,12 +69,14 @@ set(sources
     src/stb.cpp
     src/image.cpp
     src/glslUtility.cpp
+    src/guiDataContainer.cpp
     src/pathtrace.cu
     src/intersections.cu
     src/interactions.cu
     src/scene.cpp
     src/preview.cpp
     src/utilities.cpp
+    src/tiny_gltf.cpp
 )
 
 set(imgui_headers
@@ -109,7 +112,6 @@ source_group("ImGui\\Headers" FILES ${imgui_headers})
 source_group("ImGui\\Sources" FILES ${imgui_sources})
 
 #add_subdirectory(src/ImGui)
-#add_subdirectory(stream_compaction)  # TODO: uncomment if using your stream compaction
 
 add_executable(${CMAKE_PROJECT_NAME} ${sources} ${headers} ${imgui_sources} ${imgui_headers})
 set_target_properties(${CMAKE_PROJECT_NAME} PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
@@ -123,7 +125,6 @@ endif()
 target_link_libraries(${CMAKE_PROJECT_NAME}
     ${LIBRARIES}
     cudadevrt
-    #stream_compaction  # TODO: uncomment if using your stream compaction
     )
 target_compile_options(${CMAKE_PROJECT_NAME} PRIVATE "$<$<AND:$<CONFIG:Debug,RelWithDebInfo>,$<COMPILE_LANGUAGE:CUDA>>:-G;-src-in-ptx>")
 target_compile_options(${CMAKE_PROJECT_NAME} PRIVATE "$<$<AND:$<CONFIG:Release>,$<COMPILE_LANGUAGE:CUDA>>:-lineinfo;-src-in-ptx>")

README.md

@@ -2,12 +2,53 @@ CUDA Path Tracer
 ================
 
 **University of Pennsylvania, CIS 565: GPU Programming and Architecture, Project 3**
+* Nicholas Liu
+* [Linkedin](https://www.linkedin.com/in/liunicholas6/)
+* Tested on: Linux Mint 22 Wilma, AMD Ryzen 7 5800X @ 2.512GHz, 32GB RAM, GeForce GTX 1660 Ti
+
+### Background
+This project is a path tracer, written in CUDA. It functions by physically simulating the paths of light rays in a scene in order to render objects. For each pixel, many simulated light rays are fired from the camera. The rays intersection with geometry is calculated, bounced probabalistically in a direction dependent on the material hit, and picks up color from the surface hit.
+
+Note that rays are fired from the camera instead of from light sources, as the vast majority of actual photons emitted from an arbitrary light source would not hit the camera and would be wasted computation -- hence tracing the paths in reverse.
+
+### Features
+## Material surfaces
+The project currently features 4 different types of surfaces: diffuse, reflective, transmissive, and glassy.
+
+Diffuse surfaces disperses light equally in all directions, and give a flat color.
+
+Reflective and transmissive surfaces disperse rays in one particular output direction for a given input direction, following the laws of reflectance and Snell's laws respectively. Reflective surfaces appear as mirrors, while transmissive are see-through with some distortion.
+
+Finally, glassy surfaces reflect some light rays and transmit others, with probability dependent on the incident angle of the incoming light ray.
+
+![](img/Refraction.png)
+A glossy reflection
+
+## Depth of field
+A thin-lens approximation of a camera is used to generate depth of field, which blurs out objects depending on how close they are to a focal plane a set distance from the camera. 
+
+![](img/nodof.png)
+![](img/dof.png)
+
+## Direct Lighting
+Many rays in the path tracing algorithm will miss light sources. The more rays miss their light sources, the longer it takes for the final image to converge. Another rendering technique, direct lighting, can yield a faster convergence time -- it works by, instead of scattering a ray randomly, picking an arbitrary point on a light source and scattering it in said direction.
+
+Direct lighting notably does not yield correct-looking results for reflective and transmissive materials, but generally gives a usable image faster, especially in cases with small light sources.
+
+The following show a 20 sample image with regular lighting and direct lighting compared and a fairly normal-sized light source
+
+![](img/simple20samp.png)
+![](img/direct20samp.png)
+
+The code for direct lighting also lays the groundwork for multiple importance sampling, which functions well in both the scenarios that naive and direct lighting path tracing methods work well for -- I'll be sure to come back to this project with some materials and scenes where direct lighting really shines!
+
+## GLTF loading and texturing
+To be able to render more visually interesting scenes without hand-specifying them through code, loading of arbitrary mesh data is supported. Materials that utilize textures for their albedo and emmission maps are supported as well, in order to allow for geometry that isn't just uniform in color.
+![](img/AvocadoCornell.png)
+
+
+
 
-* (TODO) YOUR NAME HERE
-* Tested on: (TODO) Windows 22, i7-2222 @ 2.22GHz 22GB, GTX 222 222MB (Moore 2222 Lab)
 
-### (TODO: Your README)
 
-*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.