OpenGL GPU Path-Tracer
Credits: Artist , Source
Here’s a short summary of things I’ve worked on:
Blender Exporter and Importer
The first thing I did is to write my own exporter that can export blender scenes to a custom 3D file format. Instead of using existing standard 3D file formats with import-libraries like assimp, I chose to write my own exporter and define a custom format since that would give me more direct control over the materials and the mesh data. For now, all the meshes are automatically triangulated and the vertex data is transformed to World-Space before storing it in a file. Two files are created, a Json and a binary file. the Json file contains the location to the binary file and a list of all materials that’s assigned to the triangles, the binary file on the other hand contains the vertex and triangle data. The exporter creates these two files and makes a copy of all the textures next to the binary file for easy access.
Acceleration Structure (used: BVH tree)
The triangle data are then packed into an array and then given to the BVH-tree class for tree generation. The BVH-tree then orders and partitions the given list of triangles equally into a fixed number of ‘bins’. Then the SAH (Surface Area Heuristics) is used to determine the best split axis and split position or decide if we should split the node at all. This step is repeated as long as the splitting cost is lesser than making a leaf-node or if the number of triangles per leaf-node exceeds the given amount. The below video show’s the tree built using the above algorithm. (number of bins: 8, max number of nodes per triangle=1 (i.e) each leaf-node has exactly one triangle in it):
Then next step, make the BVH traversable with a given ray! The Demo of which is shown below:
Port the BVH tree to our OpenGL compute Shader:
This step is easy, just have to flatten the BVH tree into an array then write it to an SSBO. I then create separate SSBOs for triangle data, material data and triangle index list. And the real question now is, how does it fairs? Well see it for yourself!
The heatmap for the Stanford Bunny:
| BVH params | heatmap |
|---|---|
|
Number of Bins: 20 Max Number of Triangles Per Node: 3 |
Blue: 1 triangle/AABB hit. Green: 100 triangle/AABB hit. Red: 200+ triangle/AABB hit. |
Not bad, not excellent either.
There are other better Alternatives like NVIDIA’s SBVH which avoids overlapping bounds. Here’s the comparison of my attempt at BVH and SBVH:
The SBVH implementation performs a little better, but it could be a lot more better than what it currently is. I’ve decided not to integrated the current implementation of SBVH as it is into my path-tracer since I felt like it’s incomplete and wanted to dedicate more time slowly experimenting and optimizing it in the future. And also my hands were itching to complete the core features first!
Actual Path-tracing
At the time of writing, the path-tracer uses a naive uniform hemisphere sampling approach.
Here are some of the renders from my path-tracer:
Credits: Artist , Source
Credits: Artist , Source