Projects & Demos

Atmosphere Rendering

The atmosphere rendering is not designed to be perfectly realistic, but rather reacts in an interesting way with light sources. This is accomplished by implementing a post processing effect that reads the scene depth and direction of the light. The light is incrementally collected for each pixel. Refraction and scattering are both simulated. The wavelength of the light determines how much it is scattered, simulating this gives the sky a red color when the light arrives from a shallow angle, say during a sunrise or sunset.

PBR Materials

The native PBR rendering of Ripples.

Geometry Soup

This demo showcases the 2d physics and light mesh generation built into the engine. The collisions are fairly self explanatory. Collision detection, mtv calculation and overlap resolution are all written in-engine as a 2d physics library. The implementation of the light mesh generation can be outlined as follows:

• Find every mesh that is inside the lights area of effect
• Shoot two rays for each vertex of each object, the rays have a slight offset to either side of the vertex. When looking at an edge from a perpendicular angle this causes one ray to miss the edge ever so slightly while the other will hit. If the offset is very smal we get sharp shadows, just don't make it too smal or we will run into problems with floating point rounding errors
• For each ray hit we store a vertex location. If a ray does not hit any edge we store a vertex location at the end of the ray, ie at the perimeter of the light radius
• Every vertex can then be connected to form the light mesh.
• Run a shader on the mesh to "paint" it with a color that falls of in intensity as the distance from the source increases

Fast Multipole Method

This video shows an implementation of the Fast Multipole Method. Each object in the scene has its own gravitational potential, this would normaly grow in complexity very quickly as the number of objects increase. The FMM lets us calculate the gravitational potential much faster and for many more objects.

Even though the FMM allows for 10s or even 100s of thousands of objects to be simulated in real time, this application is bounded by the physics calculations and not the gravitational potential calculations.

Implicit Rendering

In this demo lots of objects were placed in a scene, each with their own position and mass. We let this mass potential decrease in a similar way to how the strength of gravity falls off. To render the scene we calculate the "potential", ie the sum of the influence of every object in the scene for each pixel.

If we let the strength fall off toward infinity we would need to calculate the potential for each object at every location, this would not be very fast. To avoid this issue we let the strength be zero at a distance relative to the size of the mass, like so:

This is obviously not how a graph of gravitational potential would look but that is ok, the goal is to make something visualy interesting.

To create some kind of gameplay we let the objects repell each other and if they collide with enough force they get combined into one bigger object. Finally the player can possess one of the objects and navigate through the landscape.