engines outside of school (and before I ever took a graphics course!), the

first in Pascal, the second in C++. Both support lighting and reflection.

The Pascal engine had built-in support for planes, polys and fractals;

the C++ engine was built in a very organized fashion, and has support for

fractals, blobs, planes, and textures. It is built object-oriented in the way

it traces the ray and uses bounding boxes, so that, to add a new custom

mathematical object type (they can get funky, like the blobs & fractals)

you just write a bounding function and a ray-intersection function for it

and you're set.

All animations and stills copyright (c) 1993+ Ryan M. Geiss.

Some of the actual animations are not available right now, since I'm a cheapskate and am only paying for limited web space. Sorry!

FAT3.MOV - 4MB - 1999

THIS IS COOL - DOWNLOAD IT.

(just click the image)

This is a raytraced animation of a flythrough of a 3D Julia fractal.

It's cool because it's solving ray intersection with an arbitrary

3D function - as opposed to just rendering a big detailed polygon mesh.

That means you have perfect detail to the pixel level, and that you could

zoom in forever and ever and always get perfect detail. One drawback to

isosurfaces like this is that lighting computations are very difficult;

with polygons, it's easy to find the normal at vertices, then you can

just interpolate on a face for the normal at any point; but with

arbitrary isosurfaces like this, you have to write an approximator.

So, I finally got around to writing a good 3D normal-approximation

function, applied it to fractals, and produced this animation.

The algorithm goes around a circle in one plane

and finds the best surface normal by interval halving... then it

looks in a perpendicular arc (but aligned with the previously-found 2D

normal) and repeats the process (more or less) to find the full 3D normal.

This normal approximation is slow, but extremely accurate (16 iterations

gives you accuracy to 6.28/2^16, or 0.0001, radians), and it could be

used to find the normal on any binary 3d function (like a fractal),

where f(x,y,z) = { 0, 1 }. This animation took about 12 hours to

render on two Sun UltraSparc2's, using a total of 8 300-MHz processors.

In summary, the cool thing about this one is that it has true lighting, in

all 3 dimensions, and extensive use of that is made (gold, yellow and orange

directional lights add a nice touch). Also, the camera is moving *through*

the fractal - it took a little tweaking to find a path that wouldn't

intersect the fractal - but it adds a lot. Also, the fractal is subtly

morphing throughout the animation.

Another drawback to rendering isosurfaces is aliasing -

since you do have perfect detail, high-frequency components

in the model sometimes end up flickering, which you can see here.

9D.AVI - 10.3MB (sound) - 1997

I wrote this one in Pascal, believe it or not! This was one of the

very last things things I wrote in Pascal before switching to C.

It attempts to illustrate how a gradient 2D fractal can be turned into

an extruded, 3D solid volume; then it shows (very slowly) how the imaginary

constants in the fractal can be varied along the extrusion path, to make

the fractal warp (twist and morph) over time and/or space.

LIQUID.AVI - 7.3MB - 12/97

This one was made in C++. It is intended to recreate a particle

stream, somewhat like water. It demonstrates the versatility and

precision of the blob model, as well as the textures for the sky and

water. You can also see the shadow of the stream on the ocean behind it.

CANYON.AVI - 16MB - 12/97

This was also made with C++. It took a long time to choreograph -

many hours of my Christmas break for 97-98 were spent working on

it. It uses an inverted, extruded Julia fractal as a mountain. Notice

how all the different objects react to each other: the blobs' reflections

of shadows, mountains, sky and water; the shadows of the mountains on

the water; and the intersection of the first "sphere" with the water.

NEWBLB-S.AVI - 9.7MB - summer 1998

This one was rendered with the C++ engine while I was working at Tiburon.

It's very smooth. The blobs' transparency and color is gorgeous.

Definitely worth checking out.

GLASS.AVI - 6MB - 1999

This is an animation I made for our CIS 782 final project - Vince Scheib and I combined our raytracers and added distributed raytracing. This animation demonstrates soft shadows and soft refraction, as well as fully-functional phong normal interpolation for polygon objects. The animation is 30 frames long, and each frame was oversampled just 10 times, so you can see a little bit of roughness in some of the shadows. Notice where the glass shows properties of

RMAND6-S.AVI - 11MB - 1997

I wrote this in Pascal, in 1996, before I'd ever programmed anything 3D. The coolest

part of this animation is the looping method. Notice how the

core of it fades away at the end; underneath, you see the first 100 or so

frames of the animation again. Also notice that they zoom at different speeds

to create the illusion of depth.

BACK