Features

Alpha Masking

on

off

Alpha masking lets us use cheap geometry (e.g. a quad) to represent more complex objects by enabling the ray to travel through transparent pixels of our texture. This is often used for foliage, leaves, or other objects where rendering a large quantity of complex geometry would otherwise be required. If the pixel is not fully transparent, we can even model semitransparency by using the alpha value as the probability that the ray passes through.

Renderer Modifications

First of all, I had to access the alpha channel of the albedo texture (if it exists). For this the following files were modified: image.hpp and texture.hpp in include/lightwave (glue code/ getters/ vector of alpha values), image.cpp in src/core such that it loads and stores the alpha channel, and image.cpp in src/texture to add a "GetAlpha(Point2 uv)" method that handles border behavior (similar to "Color evaluate(const Point2 &uv)" ). The more complex modifications happened in instance.cpp and scene.cpp (src/core), where I modified the "intersect()" and "transmittance()" methods. The basic idea of the modifications is: Just do not count a ray hit as a hit if the ray hit a transparent pixel of the texture. This had to be done recursively until the ray leaves the scene or hits a solid texture. Otherwise we would not be able to render multiple meshes with transparent textures behind each other, or even a single opaque mesh behind a transparent one correctly. Our transmittance function in scene.cpp had to be adjusted to support this as well. We also have to pay attention to how our shadow rays work, as a transparent texture will not obstruct the path to a light source, even when the ray hit the mesh. We do recursive checking here again because the ray can hit multiple transparent textured meshes and has to pass through all of them.

See how some leaves on the right image are clipped and the shadows are incorrect if we do not do this recursively:

working

broken

Challenges

The most frustrating part of implementing this feature was fighting the framework. I did not fully understand how to access/store the alpha values or images. I think my solution is overly convoluted, as I add "ref name="alpha" id="Image Texture_001" manually to the xml file instead of just using the alpha channel of the albedo texture/color directly if it has an alpha channel. There has to be a better way to do this, but I focused on making the feature work rather than making the code elegant (at least for this project) due to time constraints. Besides that, I was not really aware that the intersection logic had to be recursive at first, this created very weird renders where the pixels behind transparent parts were wrong (see images above). The feature was very easy to understand, but surprisingly complex to implement.

Post Processing: Bloom

with bloom

without bloom

Bloom is a surprisingly simple effect, that when not overdone, can create really nice soft glow around bright light sources. It is a post-processing effect that extracts the bright parts of the image, blurs them, then composits the blurred result back over the original image.

Renderer Modifications

This was probably the easiest feature to implement. I just had to create a new post-process very similar to the already implemented tonemap.cpp and operate on pixel color values. Find the brightest parts of the image using a threshold, then do a horizontal followed by a vertical gaussian blur on the isolated brightest parts, then add this to the original image. I also added the parameters "threshold", "intensity" and "radius" to tweak the effect.

Challenges

There was not really a big challenge here as I already knew the effect and just had to figure out how to implement it in the framework. The only challenge was to understand how to edit the xml file to actually apply it to my rendered image. After reading a helpful forum post and guessing the missing parts from error messages, it finally worked.

Normal Mapping

with normal map

without normal map

with normal map

without normal map

Normal mapping is also a very impactful effect that can make a mesh look much more detailed without having to add more geometry. This is much cheaper to render than if we added a million more triangles to add that detail. The idea is that we do not use the normals of the mesh geometry for rendering, but a dedicated normal texture instead. This way we can dictate how light bounces off the mesh and "fake" detail. This can be used with almost every texture and will make it look way more realistic without a significant performance drop.

Renderer Modifications

I added a new texture "m_normal" to instance.hpp and if that texture exists, I overwrite the geometry normals with the values stored in that texture (in instance.cpp). Note that the values have to be remapped from [0,1] range to [-1,1] range, otherwise the normals will be incorrect.

Challenges

At this point I was better at understanding how to deal with textures in lightwave and the xml file, so this was rather straightforward. But I still managed to introduce a mistake that made the normal map texture load correctly, but its reference was always null when I was overwriting the geometry normal. The annoying issue was in the xml file, my code expected the normalmap-tag to be declared at instance level and not next to baseColor or roughness... Shifting the line one line down so it was declared in the right scope fixed the issue. Otherwise this was a surprisingly easy feature to implement in comparison to the image quality improvement it enables. When I started working on my final render, I noticed that the normal map seemed very stretched on my meshes, there is probably still an issue with the way scaling works. I am not sure if the issue originates in my implementation or in the way I have set up my textures in blender...

Denoising

noisy input

denoised output

albedo map

normal map

Denoising is a post-process effect used to achieve high quality renders with low sample counts. It works by smoothing out detail where monte carlo sampling produces noise. We are using intels OIDN library for denoising and provide an additional albedo texture and normal texture (of the scene) to improve results.

Renderer Modifications

As denoising is just another post process, I just had to find out how to integrate the library in CMakefile.txt. After a few tries I got something that compiled, but adding dependencies was not an ejoyable experience in C++. Using the library was fairly straight forward, just a few conversions from lightwaves format to the libraries format were necessarry. To provide the albedo map, I had to modify many files and add methods that just simply return the albedo color without lighting and implement an integrator for it, similar to the normal integrator that already exists.

Challenges

CMakefile.txt is a place I do not want to spend much time at. I was very happy when the dependency worked and file paths were correct. Also adding the albedo integrator was slightly annoying as many files had to be adjusted with glue code and the "getAlbedo()" method. Besides these points, the OIDN library took care of the difficult parts. I am sure there are many ways the filters and settings of OIDN could be adjusted to achieve even better results, but as I was satisfied with the results I did not see the advantage of tweaking settings further.