2. Basic Ray Tracing Principles

There exists a wide range of methods for rendering 3D scenes such as the ones I used. Among them, the ray tracing algorithm is a popular choice for its ability to produce realistic images.

Ray tracing simulates the propagation of light rays within a 3D scene. Instead of casting rays from the light source, we trace them from the camera (the Helmholtz principle). For each pixel of the final image, we compute the intersection between the ray and the objects in the scene, then apply a lighting model to determine the visible color. In this project, the lighting model is primarily Blinn-Phong.

The basic algorithm proceeds as follows:

1. Cast a ray from the camera for each pixel.
2. Check for intersections with objects (triangles, spheres, etc.).
3. Compute the color at the intersection point using the Blinn-Phong model or an equivalent approach.
4. Handle reflection and refraction based on a maximum ray depth (ray_depth).
   1. For reflection, cast a new ray in the reflected direction.
   2. For refraction, cast a new ray in the refracted direction (e.g., using Snell’s law).

In this project, the main extension is accounting for a participating medium along the ray’s path, in order to compute absorption and scattering within this volume.

3. Participating Media

The participating medium implemented here can be considered as smoke, represented in a cube subdivided into a grid of voxels. Each voxel has a density that can be generated in various ways: constant density, linear or exponential gradient, Perlin noise, etc. Depending on the density value, the amount of light passing through that voxel is attenuated more or less strongly.

3.1 Cube-Ray Intersection

To determine if a ray enters the volume (and where), we calculate its intersection with the cube’s faces (x=0, x=1, y=0, y=1, z=0, z=1). The parameter values t that correspond to these faces let us identify the entry point (tMin) and the exit point (tMax) of the ray within the cube.

In some cases, we get particular edge case we have to handle:

• Ray origin inside the volume: in this situation, there is no entry point (or tMin is negative). We start from inside the volume directly.
• Zero direction component: division by zero. Fortunately for us, in C++, division by zero is defined as infinity, so we can handle this case. However, thanks to the bit representation of floating points, it is possible to get -0.0. Other than having a negative sign, C++ treats the value as 0 notheless. However, division by -0.0 will not give the same value as division by 0.0 because of the negative sign.

4. Traversing the Participating Medium

Once the volume is intersected, we need to sample it to compute absorption and scattering. In order to sample it, we need to traverse the grid. In order to do so, two approaches were implemented:

• DDA (Digital Differential Analyzer)
  This method advances through the volume by moving from one voxel-plane intersection to the next. It guarantees that no voxel in the path of the ray is skipped, even if the ray barely touches a corner of the voxel. However, it also means that we will sample each voxel only once.
• Ray Marching
  Here, we move forward using a constant step size. The samples are thus regularly spaced along the ray, sometimes with a slight jitter to reduce repeating artifacts. Unlike the DDA approach, with a small enough step size, we can sample individual voxels multiple times. However, this method can be slower than the DDA methods (especially when the step size is small) and we are not guaranteed to sample every voxel in the path of the ray.

In both cases, at each sample (or step), we compute the density and model the interaction with light.

5. Light Attenuation

Light attenuation in a medium is primarily based on the Beer-Lambert law:

To make the results more realistic, we also account for:

• Absorption (σa): part of the light is absorbed and transformed (e.g., into heat).
• Out-Scattering (σs): light is scattered out of the original ray direction.
• In-Scattering (σs): light coming from other directions is scattered towards the camera.
• Emission: not implemented here (e.g., fire or flames) but could be added in a future version.

The attenuation formula thus becomes T = exp(-d · (σa + σs) · density), where density is the volumetric density at the sampled point. A phase function is used to model the direction of scattering. The simplest type of phase function is the isotropic one. These functions scatter light in all directions equally. The formula for the isotropic phase function is

where piso is the probability of scattering in a given direction.

The other type of phase functions are the anisotropic functions. These functions scatter light in a prefered direction. The function used in this project was the Henyey-Greenstein phase function. The formula for the Henyey-Greenstein phase function is

where phg is the probability of scattering in a given direction, g is the asymmetry factor and can take any value between -1 and 1, and θ is the angle between the camera ray and light ray.

5.1 Computing Light Inside the Volume

At each step along the ray, we must evaluate the amount of light from the various sources. To do this, we cast a light ray toward each light and compute the transmittance (lightTransmittance) at the considered point. We then apply the phase function to determine how much of that light is redirected towards the eye.

Russian Roulette can be used to stop computations when transmittance becomes very low, avoiding wasted time in nearly opaque regions. If the random test fails, we multiply the remaining transmittance to compensate and continue.

6. shade() Function

Previously, the shade() function handled illumination in a binary fashion (an object either blocked the light or not). With the participating medium, we now weight the light contribution by the transmittance measured along the shadow ray in the volume. Thus, the light source contribution can range between 0 and 1, reflecting partial absorption within the medium.

Once we've computed the shading at our intersection point, the final colour that get displayed is evaluated as: