Pegaria

Pegaria is a short film that has not yet been finished. It tells a 5 minute story of a magical being (pegaria) that is menaced and hunted by a dark cloud (parto). The film-let Pegaria was planned to be the next year short film project after ExKloration. In contrast to Exkloration it would contain 100% rendered scenes using the the rendering engine Light++, which is a custom ray-tracer.
This page shows several pictures that were created during the production process. A few words describe the process itself and comment the pictures.

The concept of the short film was build upon the features of Light++. Light++ itself is build to run on parallel distributed systems (MPI) and provides procedural and physically based features, that are not often found in other render-engines (back in 1999). These include for example: fractal height field mountain shaping, dispersion (glass and atmospheric objects), fractal volume clouds with accurate scattering models (including forward scattering) and astronomically correct starry skies. Although Light++ supports these features it lacks some standard basic features like efficient rendering of polygons, texture mapping, texture formats, or supporting standard 3d file formats.
So there were a lot of things to do for our short film project: development of missing features of Light++, development of some data exchange between Maya and Light++, creation of the scenery in Light++, creation of a scenery (mainly the animated actors) in Maya and of course storyboard, design and music.

First we developed a story for the film that could be told in 5 minutes. Then we described the film scene by scene and finally created an animated pre-visualization of Pegaria. The pre-visualization contains locations, objects and scenes that would show 'the muscles' of Light++. A mystic place in the sky, a character made out of glass, a character made out of clouds and particles, a mountainside containing a lake and finally a sunset. It was important to keep the duration of the film short to prevent too high rendering times. Especially ray-marching through volumetric clouds is a very expensive operation.
The story itself is very linear. The unicorn Pegaria is threadened be a dark cloud (parto) that appears in the home world of Pegaria. All the clouds turn dark when Parto appears. Pegaria flees over the mountains to a magic tree that grows on an island in a mountain lake. There she awaits parto and defeats it with the help of the magic tree.

We wanted a classical soundtrack beginning with the mystic sound of a harp. The music was composed by Raimund Kennerth based on the pre-visualizations we did at the beginning of the project. The orchestra score was finished and the recording took place. But because we ran out of time tremendously during this phase, the recording did not achieve the best quality. Especially the timings in the music were far away from the timings in the video. Also, the small orchestra (~23 people) would have needed more strings.

As already mentioned we imported a grid of the mountain structure into Maya. In Maya we designed and created the polygon objects for the unicorn, the tree, the island and other objects. We created an animation rig for pegaria and experimented with particles and 'particle characters'. Also we wanted to create a magical object out of seethe cloth and created several tests.
To bring the neccessary data into Light++ we wrote MEL scripts that exported camera information, polygon objects and particles in files on a per frame basis.

First we began to create a mountain and cloud environment in Light++. At that time we run Light++ under Linux. The ray-tracer consists of several c++ classes. The scene description itself is also done in c++. After compilation the scene description can be rendered by execution of the binary. It is an almost impossible task to get something good looking out of those hundreds of parameters from scratch. It takes quiet a long time and several test renderings to get a parameter experience. We extended the existing c++ classes by our own needs for materials and shaping of the clouds. Here are some pictures of the mountain process.

As mentioned above, Light++ was not capable of rendering polygon objects. Well, actually it already contained the intersection test for one polygon. But we had to developed a hierachical algorithm for speeding up the intersection process. Here a tree-structure based on bounding spheres is used. The first level of spheres contain some polygons. The next level of spheres contain again spheres and so on. The the uppermost level is the bounding sphere of the polygonal object. With this technique an intersection point of a 100.000 polygon object and a ray can be found by just 4 sphere and 2 polygonal intersection test.

Finally we developed some interpolation and import classes to get the functionality for animated cameras and objects (motion blur). At the end we still had some problems to find a good method to estimate the integration distance in the volumetric clouds which lead to annoying artifacts. We also had problems with rays that had very tangential intersections at the horizon and clouds. A testanimation produced some very nice results with the procedural mountainside, though. A crazy picture was created be giving each pixelcolumn a different time. That way the whole camera flight can be seen in one picture.

Introduction

Fractal Cloud

Team

Sunset

Story

The Music

The Maya Side

Development on the Light++ Side

Mountain Regions

Rockish Material

Mountain Greens

Mountaintops

Cirrus Clouds

Stratocumulus

Density Cuts

Mountain Cuts

Both Layers

Fractal and Cut

Close Up

Mountains and Atmosphere

Added Cloud Layers

Marbled Checker

Falloff Material

Dispersion

Marble Forming

Checker Material

Material Self-Anitaliasing

Mesh Maya

Mesh Light++

Smooth Mesh Maya

Smooth Mesh Light++

Moutain Grid Maya

Mountain Lake

Time Flow

Some Final Words