The Monte Carlo pathtracer is a recent project of mine that I worked on for my Advanced Rendering class. Since I already wrote some detailed posts on how it functions on my  3D specialised Instagram page, I shall leave a link to that page for further details including progress shots, but nevertheless, I will still summarise how I developed the pathtracer from a simple Naive integrator to the full blown Monte Carlo pathtracer using development upon the Light Transport Equation.

Github code (including comments from commits).

Link to 3D Instagram account where I post updates to my pathtracer and other projects.

To the left are some renders that I created with the pathtracer by constructing custom JSON files and then rendering them with the pathtracer. Attached below are more catalogues of my personal favourites, some from the assignment that we had to turn in, and others of my own creation. In the next section, I still wanted to discuss the theory on implementation and how I tackled it, because I find the subject matter quite fascinating. In the future, I want to see if I can optimise the code to be able to take in metallic textures or perhaps more complicated polygon meshes, since the meshes and textures used for these renders are quite basic, in the sense that only normal maps and bump maps are used to render most of these images. 

The image that you see on the right is one of the very first renders that I got from my pathtracer using the Naive Integration method. To summarise briefly, in a scene with a few objects and a light source, one would cast an infinite amount of rays from the camera into the scene, and bounce it in a random direction if a hit is registered on an object. We would then keep the ray bouncing until the bounce hits the light source (which has a colour value >= 1.f), and return the accumulated colour from the other bounces. However, a major issue with this method is that the casting of multiple rays and bouncing them until it hits the light source is way too inefficient, and during rendering, it would take a lot of runtime to generate. This is why the next method, the direct lighting method, was introduced. 

Unlike the Naive Integrator, the Direct Light pathtracer did not use a loop to continuously bounce a ray until it hit the light; rather, while we still generate a ray from the camera (which I will call out ray since this is the ray that we will be seeing), once said ray hits an object's surface, we cast a ray directly to a point on the light source and return the colour value of that singular point on the surface. This is also why in this case, because we are no longer casting rays in multiple bounces to the surrounding area which makes us not pick up the colour of other influences, we only see one colour on the objects in the scene. Comparatively though, the runtime of the Direct Lighting is the fastest since it requires no iteration to output a colour. 

The final step for my Monte Carlo pathtracer was to combine global illumination, but also reintroduce the ray bounce concept all the way from the Naive Integrator. With the global illumination calculation, I was able to add environment maps for my renders, and by putting MIS into a for loop which terminates upon hitting the light meant that the render would be very precise, which is a far cry from the somewhat pixelated renders from the Naive Integrator.