These animations were created through programming. I've made two 3D
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

(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 total internal reflection due to the refraction of light. Also notice the ever-so-faint shadow of the glass on the ground (it's hardly visible) because the object is 90% transparent (most of its color is picked up from reflections and refraction). The fuzzy reflections on the ground are pretty sweet too.

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.