OpenGL Demos and Online Resumé

by Bernie Freidin © 1999-2000

I am seeking employment in the game industry as a programmer. I have experience with (and a passion for) 3D graphics programming. Ideally I would like to work on a cutting-edge game engine. Below are some of my recent OpenGL demos. To download them all as a single .zip file, click here. In addition, here is a little more information about me:
Contact Information Traditional Resumé A Little Bit About Me Personal Photos
Instructions for compiling these demos.

Get demo! (417k)
View Source Code
View Technical Paper

Flythrough Demo

This is a solid boolean modeler, which parses scene descriptions and produces polygonal output suitable for rendering. The screen shot to the left is from a test scene that is included with the demo. Notice that the textures are applied randomly; the point of this demo is the conversion of scene descriptions to polygons, not the visual appearance.

Scene descriptions consist of polygon (shape) definitions, extrusion, transformations, boolean operations, scene hierarchy specification, loops, and function calls - all of which are implemented in my own scene description language. Here is a sample scene description. The modeler parses such a description to produce a hierarchical polyhedral representation of the scene, and then performs solid modeling (a.k.a. CSG) operations to produce a polygonal b-rep (boundary representation) suitable for rendering in OpenGL. This allows complex geometry and architecture to be constructed without the use of CAD programs such as 3D Studio Max.

In addition to the scene description parsing and solid modeling, this program also demonstrates my smooth flying-camera physics and collision-detection. Collision-detection is trivially easy (at least with respect to a single moving object), but collision-response is hard. The reason for this is that a moving object can, and almost always does, collide against multiple surfaces simultaneously, and the resultant sliding movements must be carefully handled with respect to near-parallel surfaces to avoid numerical instabilities, etc, etc..

This project was my senior thesis for my undergraduate degree. In addition to writing the program, I also wrote a technical paper describing how it operated and introducing the field of solid modeling.

Get demo! (276k)
View Source Code
Visit my Hyperbolic Tiling Gallery

Hyperbolic Maze Demo

This is one of those demos that it is best to try first, and ask questions about later. It is a simple maze game, and the goal is to visit the entire maze. Being in hyperbolic space, however, makes things rather interesting. The maze itself, for instance, consists of a regular "grid" in which five squares meet at each corner, not four. Yet the geometry is very consistent. Navigation is also interesting: one explores new territory while apparently moving around in circles.

Hyperbolic space can be thought of as "the opposite of spherical space". It has been studied mostly by mathematicians and physicists during the past century, and recently is being explored as a means of visually representing large hierarchies. Hyperbolic space has many interesting geometrical properties: a good introduction to the subject is Geometry of Surfaces by John Stilwell.

My inspiration for this project came largely from a math video called Not Knot, which includes a rendered flythrough in hyperbolic space. My reaction was: why not put this kind of space in a game? Surely, people eventually tire of seeing the same old dungeons, forests, cities and space stations. Something profoundly new could be a very good thing. Now, the question of course is; what is it like to run around and interact in a hyperbolic environment?

The maze demo here is more of a "proof of concept" than anything else. It shows that hyperbolic space can be successfully used in an explorable environment, with interesting results. Here is my idea for how to incorporate hyperbolic space in a real game. Starting with a Quake3-style (sci-fi) shooter, there would be these "portals" into an alternate hyperbolic universe. A player could pass through one of these portals, and find him/herself floating in a crystal-like (see Not Knot, you'll know what I mean here) environment. Flying through this environment would lead to other portals back into the normal universe. Essentially, the hyperbolic space would function as a very real representation of the "alternate dimensions" often referred to in science fiction.

Visit my Hyperbolic Tiling Gallery for some other examples of hyperbolic tilings.

Get demo! (59k)
View Source Code
View Technical Paper

Zoom! Fractal Circle-Packing Demo

This is a project I did for a graduate class in computer graphics at the University of Massachusetts, although it bears little resemblance to the original simple assignment. It displays a well-known fractal circle-packing in which all circles have integer curvature. The curvature of a circle is the reciprocal of the circle's radius. The demo allows the user to zoom into the fractal, and more detail is generated as needed. The program is intended to demonstrate adaptive LOD (level-of-detail) concepts, as both the hierarchical structure of the fractal and the circles themselves are displayed in this way. Further performance is gained by hierarchical rejection of offscreen nodes.

The hierarchy itself is rather interesting. Unlike more traditional hierarchies such as BSP trees, this demo makes use of a "ternary" tree in which each node has three children as well as three parents. Nodes are added to the hierarchy in realtime as the view is zoomed in. Another interesting aspect of the demo is the equations used to generate new circle positions. While the computation of new circle curvatures is trivial (solved in the first line of the following code), the positions are much more complicated:

	double dz = az + bz + cz + 2.0*sqrt(az*bz + bz*cz + cz*az);
	double vx = ax*bz - az*bx;
	double vy = ay*bz - az*by;
	double mx = az*(ax*(1.0 - bx*bx + by*by) - 2.0*ay*(bx*by)) +
	            bz*(bx*(1.0 - ax*ax + ay*ay) - 2.0*by*(ax*ay)) ;
	double my = az*(ay*(1.0 + bx*bx - by*by) - 2.0*ax*(bx*by)) +
	            bz*(by*(1.0 + ax*ax - ay*ay) - 2.0*bx*(ax*ay)) ;
	double ex = mx*dz + 2.0*vx*(az-bz);
	double ey = my*dz + 2.0*vy*(az-bz);
	double fx = az*az*az*bx*(1.0 - bx*bx - by*by) +
	            bz*bz*bz*ax*(1.0 - ax*ax - ay*ay) ;
	double fy = az*az*az*by*(1.0 - bx*bx - by*by) +
	            bz*bz*bz*ay*(1.0 - ax*ax - ay*ay) ;
	double nx = az*bz*ex - dz*fx;
	double ny = az*bz*ey - dz*fy;
	double s  = 4.0*az*bz*sqrt(az*bz + bz*dz + dz*az);
	double nz = 2.0*az*bz*(az+bz)*(az+bz);
	double dx = (nx - vy*s)/nz;
	double dy = (ny + vx*s)/nz;

The computed circle has radius 1/dz and is positioned at {dx/dz, dy/dz}. It is worth noting that all computations here have integer results, even the square-root on the first line and the divides on the last two lines. I use double-precision floating point arithmetic to allow for a greater representable range; this allows the fractal to be zoomed in further before numerical instabilities mess things up.

Get demo! (77k)
View Source Code
View Technical Paper
Visit my Fractal Image Gallery

Mandelbrot Explorer Demo

This is another project I did for the graduate class I took. It is a Mandelbrot/Julia fractal renderer with a rich set of features. This demo uses the same zooming interface as the Zoom! demo above, but the rendering to proceeds asynchronously without regard to the user's interaction with the zoom box. Also, the rendering is progressive; the initial pass provides near-instant feedback and then additional passes provide increasing detail. The last pass uses supersampling to achieve professional-quality results.

I experimented heavily with variations on the traditional Mandelbrot/Julia rendering algorithms, which produced some very interesting results. Some of the fractal images rendered by this program don't appear to be related to the Mandelbrot set, but they are. One of the alternative rendering algorithms which I discovered produces tiny bubbles, rings, and wispy tentacle-like objects around the fractal, organized into coherent layers that seem to interact three-dimensionally. I have since learned that this technique is already known, it is called "orbit traps".

Because the feature-set of this demo is so large, I strongly suggest to anyone interested in running it that they first read the technical documentation, as it describes each feature in detail.

Visit my Fractal Image Gallery for examples of what this program can do.

Get demo! (30k)
View Source Code

RTIN MeshToy Demo

Right-triangular irregular networks, or RTINs, are used to represent data with non-uniform detail. A typical example is in realtime terrain rendering, where rocky regions need many polygons to be represented accurately while flatter regions can be rendered using less polygons without causing noticeable artifacts. Two very nice properties of RTINs are: 1) They form a binary tree which makes searching and culling extremely fast, and 2) Every edge is adjacent to exactly two triangles, hence no "cracks" appear during rendering.

A lot of people have created realtime adaptive-LOD terrain systems using RTINs. One well-known example is the ROAM algorithm. Here is another good reference on RTINs. My demo, however, is not a terrain system. It is simply a program that allows someone to interactively subdivide an RTIN mesh. Since splitting triangles in an RTIN mesh can recursively cause other triangles to split (in order to preserve mesh connectivity), there is some degree of non-intuitiveness to the splitting process. It is useful to be able to experiment with the splitting process directly, as from doing so one gains a better understanding of RTIN geometry.

This page © Bernie Freidin, 2000.
Last updated April 4th, 2000.