3D Graphics Projects/Consulting/Investigations

Scene Graph

This project has gone through a number of revisions over the years, usually to add new technology to its architecture, to improve its implementation, etc. It currently consists of a scene graph which supports: Billboards, BSPs, LODs, various Geosets (some portions of the SceneGraph's design came from SGI's Performer product), switches, various traversal mechanisms, view frustum culling, viewports, terrain following, and loading from various formats (GEO, AC3D, PLY, Heightmaps and DEM.) It also includes libraries for animation behaviors and real-time communications via shared memory, TCP/IP, UDP, and data files.

Click Here to see the project page. This includes a comparison of results from a delauney triangulation and ROAM for terrain rendering in the scene graph.

Real-Time Modeling Tools

This project consists of multiple tools developed for a real-time modeler called GEO. The tools include automated polygon reduction, terrain loading (DEM, DTED, SRTM,) ambient occlusion, shadow texture generation, lofting, delaunay triangulation, curve generation, DXF loading, 3DStudio loading, polygon strip generator, tick mark tooks, and a complete stand-alone real-time animation tool.
Carbon Graphics, developer of GEO, ships one of these plug-ins as part of its base modeler.

Click Here to see more information about the plug-ins.

Virtual Welding Simulation

This project consists of a couple prototypes for a virtual welding simulation. One prototype uses OpenSceneGraph to simulate the welding bead in real-time, while the second prototype uses Unity3D to do the same task.

Click Here to see information about the virtual welding project.

OpenSceneGraph

This page documents some of my OpenSceneGraph projects. These projects include a welding simulation demo, and a replacement full featured GEO file loader for OpenSceneGraph.

Click Here to see more information about the GEO loader.
Click Here to see information about the virtual welding project.

Real-Time Heightmap Shadows

This project's goal was to develop accurate real-time shadows for height map based visualizations. It differed from terrain shadowing algorithms in the need for accurate shadows from multiple lighting angles. Heightmap visibility is computed using multi-threaded CPU based visibility solvers, or a CUDA solver. Generation of the shadows at run-time is done using texture mapping, or GLSL shaders.

Ambient Occlusion

This project investigated the ambient occlusion algorithm and developing a GPU accelerated version of the algorithm. The Ambient Occlusion algorithm has become popular in the last few years and it is easy to see why. The algorithm has the ability to give images the soft lighting of a global illumination solution without the expensive processing.

Click Here to see more information about the Ambient Occlusion project.

Large Model Visualization

This project involved developing technologies to allow interactive visualization of extremely large models. 3D scanners, and reverse engineering products generate model files that contain millions of polygons. As these models are manipulated, they must be visualized. This project's focus was technologies which required little or no precomputation, allowing the models to be updated repeatedly without delays for preprocessing.

Click Here to see more information about the project.

Progressive Meshing

If you look at some of the other projects on this page (triangle stripping, ROAM, scene graph), you will see that it is only natual that I would take the time to develop progressive meshing technology. Years ago, when I worked for Coryphaeus, Auto-LOD generation was our holy grail. Now, progressive meshing appears to offer a good solution to the problem.
This project involved two phases. Phase 1 was an implementation of a View Independent Progressive Meshing algorithm, working on large polygon count models. The Phase 1 algorithm would only consider the geometric impacts of the collapses in the metric. Phase 1 included a mesh generator which produced a progressive mesh file, and a progressive mesh file viewer.
Phase 2 involved developing an improved algorithm which included support for material attributes in the metric, loading models from 3D Studio and GEO files, and finally a plug-in for GEO.

Update: Project page updated with support for display on Nintendo DS.

Click Here to see the project page.

Texture Atlas Generation

The Texture Atlas Generation project involved developing an algorithm to automatically produce a texture atlas, by unwrapping a model and packing it into a single or multiple textures. The tool can load a model and produce a complete texture atlas of the model in a few seconds.

Click Here to see more information about the project.

Terrain Studio

The Terrain Studio project is the culmination of many other terrain projects. The goal of this project is to take technology developed in previous projects, and to develop a single terrain manipulation environment. Currently it supports loading terrain from DEM, DTED, and SRTM files. It supports the display of VPF (Vector Product Format) coastlines and political boundaries. It also features color height map displays and XML based colormap loading.
Click Here to see more information about the project.

Iterative TIN Generation

This project involved developing an iterative TIN generation algorithm for terrains read from DEM files. The ability to control the triangulation, limiting the error and polygon count made the algorithm worth investigating. The applicability to terrain simplification was another reason. The project also involved using the graphics board GPU to compute the error metric.

Click Here to see more information about the Iterative TIN project.

Vector Product Format (VPF)

Vector Product Format (VPF) from NIMA is a good source of global vector data. This project involved parsing the VPF format to extract vector data, and generating a vector feature library to support LOD, simplification, and rendering of the data.

Click Here to see more information about the VPF project.

Subdivision Surfaces

Subdivision surfaces have become a primitive which has generated quite a bit of interest in the industry. Much of this interest can be attributed to the fact that they are compact geometric representations of smooth surfaces. This project investigated implementing Loop's subdivision surface algorithm.

Click here to see the project page.

Real-Time Renderman / Renderman for Cg

This project involved mapping Renderman to a real-time architecture using OpenGL and Cg. The idea was to map as much of Renderman, specifically the shaders, to Cg shaders which can then run in a single pass in real-time. The project used the first release of Cg and early programmable graphics hardware.

Click Here to see the project page.

Active Surface Definition (ASD) / Continuous Active Terrain (CAT)

ASD is one of the first real-time continuous LOD techniques, made popular by the fact that it is included in SGI's Performer. One nice attribute of this technique, with regards to terrain, is that it doesn't require a regularly sampled height field to work. Instead TINs can be used as the source to generate the ASD LOD levels. This project included developing a ASD viewer, and building ASD LOD levels from terrain input.

Click here to see the project page, including an animation of the ASD morphing terrain.

Delaunay Triangulation

DEM terrains (and heightmaps) are a nice source of terrain data, but the regular sampling is not optimal if we aren't using a dynamic tessellation routine like the ROAM algorithm. To reduce the non-essential triangle count, this project put together an implementation of delaunay triangulation. Multiple simplification algorithms/metrics were also developed. One metric to simply reduce the number of vertices which added little or nothing to the terrain definition. Another metric to guarantee the preservation of features such as the coastline.

Click here to read more about this project and for more images.

ROAM Terrain Rendering

This project was a an implementation of the ROAM algorithm, originally published by Duchaineau, and made popular by a number of game engine folks. The goal is to reduce the number of triangles necessary to render the terrain.

This stand-alone implementation consists of a split-only implementation, which means the merge and split queues were not implemented. Instead the scene is re-tessellated every frame. The merge and split queues were planned but as many "side-projects" go, they haven't made it yet. Split-only implementations fall apart with dense terrain tessellations. Another limitation to ROAM is that it requires a regular grid terrain, so it can't support TINs.

This implementation was replaced with the implementation that was used in the Scene Graph. (Another split-only implementation.)

Horizon Mapping: Fast Terrain Lighting

This project was originally a quick lighting and shadow computation engine for DEM grids. With the advent of programmable graphics hardware, the project was extended to do horizon mapping in a fragment program, providing greatly improved shadow definition. Hard and soft shadows are supported at a minimal cost.

Click here to read more about this project and for more images.

Lofting/Skinning/Surface Reconstruction

This project involved developing a new version of a lofting (also known as skinning and/or surface reconstruction) algorithm. Lofting involves generating triangular meshes which connect contours of different size, shape, and location producing a skin stretched over those contours.

This project also involved developing a plug-in version of the algorithm for the vis-sim modeler Geo.

Click here to read more about this project and for more images.

Quad and Triangle Stripping

This project was to work on efficiently generating triangle and quad strips from a set of individual quads and triangles given to the stripping engine. The Stripping engine's purpose is to generate strips as fast as possible (so it can be done at load time), rather than taking the time to generate the theoretically optimal solution. It does a fairly effective job. The picture to the right is of a rather simple case, stripping a terrain file, but it shows what it can do.

Some may ask why waste the time, now that hardware can do 25 million triangles per second. To get the full throughput of a graphics chip, the less work it has to do, like transforming an extra million vertices or so, the better off you are. The less data you have to shuttle across the bus, the better also.

For most real world scenarios, it would be better to generate the strips off-line then load the models already stripped. The short-coming being that you can't support dynamic geometry scenarios this way.

PLY Loading - To test the stripping engine better, I wrote a PLY file loader so I could get access to nice big datasets, like Happy Buddha, that aren't as regular as terrain. As can be seen in the image to the right, and the statistics beneath it, the algorithm stands up to a more realistic dataset. I'm sure the dataset could be done with a more optimal set of strips, the algorithm performed quickly and reduced the vertex transform count by 1.7 million vertices (>50%.)

Inverse & Forward Kinematics

This project involved implementing an interactive Inverse Kinematics solver. The chosen algorithm was Cyclic-Coordinate Descent (CCD). It implements the CCD algorithm, dampens angle changes per iteration, and records them for forward kinematics. It provides different interpolation algorithms for the forward kinematics display.

Click here to read more about this project and for more images.

Real-Time Blob Visualization - Aka Lava Lamp

This project takes just about every kind of short cut to make blob rendering run at real-time. It only uses OpenGL for displaying the image in a GLUT window. The blob system is sampled, in a unique way, for each pixel (well, actually every other pixel, and alternates with each row, producing a checkerboard sampling), then shaded using a pseudo-depth gradient shading algorithm. The program is multi-threaded.

High Level Architecture / RTI

In a slight departure from all of the other 3D projects shown on this page, this project involves developing a simulation application framework for integrating with the DMSO HLA/RTI1.3-NG. For those not familiar with the HLA, it is an architecture for developing distributed simulations. A specific use is visual simulation. This project will be joined with the SceneGraph to drive visual simulations of on-going simulations.

For more information, on this project Click here.