Trees were the most technically challenging part of our project. In order to model a forest, we needed to create an infinitely repeating random collection of tree objects. Thanks to a quirk of ray marching, calculating an infinite amount of trees is actually the same computation as calculating a single tree! 

Here is how this work.

Repetition was attained by first creating a simple grid of objects in our scene. To do this, we used the fract function, which takes in a float and returns only its decimal part. This is useful because we can use this to determine the distance from a position onto its closest point on a grid. 

Here is an example of how fract provides the distance to the closest grid point:

With some simple transformations, we can scale this to any grid size, as well as change it to get the distance to the center of each grid rather than in the corner. 

Now, the ray which originally had its position variable P, will instead have a variable Q that transforms P into a value between 0 and 1 that constantly repeats. If we generate a signed distance field for an object (such as a sphere) centered at vec2(0.5, 0.5), this object will appear at every 1 distance apart. 

Basic grid generated using fract

Code for above image

Next, we implemented two things: random jittering of the tree positions on the grid, and offsetting the height to be the same as the terrain. This part was relatively simple, we can use a random function and pass in the floored coordinate as input.

Added jitter to grid as well as terrain offet

Code for above image

We modeled the shape of a tree by generating three overlapping cone objects, applying noise to each, and taking the union of them to construct a cohesive ‘foliage’ appearance. Next we added an inner ‘cone’ which serves to provide visual volume to the trees, as well as having the effect of color variation within the foliage itself. 

Image of trees built using cones and noise

Then, we modified the material to have a random color between dark and light green using noise.

The two components of rendering the sky were creating clouds and the sun. Starting with clouds, we used fractional brownian motion (FBM) to generate noise. Brownian motion is the random change in position of particles suspended in liquid or gas, and FBM is an extension of this function with an extra parameter that provides a property of persistence such that movement in one direction will continue to tend in that direction. For the purpose of creating realistic clouds, FBM serves as a noise function with smooth transitions between sky and clouds to create a hazy look. The final FBM function starts out with a basic noise function and iteratively adds more detailed noise at each step by increasing the frequency by a factor of two and layering that on top of the previously calculated noise.

Fractional Brownian Motion code

For the sun, we used a technique similar to view direction dependent specular reflection of the blinn-phong shading model. We first defined a point in space where the sun is centered at, used that to determine the direction of the light ray, and took the dot product of that light direction and the ray being traversed. The larger that dot product value is, the closer the traversed ray is to the center of the sun, and the brighter the output pixel is. 

To render bodies of water, we create a static plane of blue and applied time-dependent noise to create the effect of small undulations, aka waves. To create the reflection of the trees and sky, we used the normal vector of the water and the direction of the viewing ray to calculate the direction of the reflected ray using the reflection function:

output ray direction = ray_input - 2 * N (ray_input * N)

This output ray’s resultant color is either the trees’ reflection or determined by the sky generation function.

Water reflections without land

Water reflections with land

The goal of fog was to create a greater sense of depth in our scene. To simulate fog, we use our ray distance in an exponent so that further objects will be colored more like the fog color. The fog equation is:

1.0 - exp(-fog_intensity * distance * distance)

No fog

Blue fog with intensity 0.0000005

White fog with intensity 0.000003

Artifacts were common throughout our project, stemming from one issue: high frequency displacement mapping. This issue comes from the simple fact that signed distance functions are inaccurate when certain displacement operations are made, because rays might step over objects. 

Here are a couple of cases we encountered, and how we solved the issue:

Issue 1: Overstepping into terrain

Occasionally, the ray marching algorithm would step into the terrain. To fix this,we added an absolute value to our ray marching end condition, so that our code will backtrack if it steps into an object (originally it would stop immediately if it stepped into an object). 

Anti-aliasing disabled

Anti-aliasing enabled