|
|
|
This page documents projects that I have done outside of the my current work, typically because I want to investigate an algorithm/technique, or I have
seen something in a 3D demo/app/game and need to know how it works. Some projects
have been done at the request of people I know in the industry.
They are listed in no particular order. Some of these projects a on-going, some are never ending, while others have been completed.
|
| 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.
|
 |
| 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. |
 Real-time Heightmap Shadows |
| OpenSceneGraph |
For a project I am working on, I needed a full featured GEO Loader for OpenSceneGraph. The
loader needed to be able to load GEO files, including Text Nodes, Clip Regions, and Animation Behaviors.
This project involved developing this completely new loader for OSG.
Click Here to see more information about the project.
|
 GEO Loader for OpenSceneGraph. |
| 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.
|
 A rendering of the Ambient Occlusion term of a PLY file. |
| 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. |
 Turbine blade, 1.7 million polygons. |
| 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. |
 A portion of an automatically generated texture atlas. |
| 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.
It is an on-going project. 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 | |
|
Real-time Optimally Adapting Meshes
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%.) |
Buddha loaded from PLY, 1.1 million triangles. The left image is the shaded lit original file. The right image is the color coded display of the triangle strips (alternating colors to show the strips.) The stripping version resulted in an average of 4.6 triangles per strip, resulting in approximately 1.7 million less vertex transforms per render. |
| 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.
|
|
Unless otherwise noted, all of these projects were done using C++ and OpenGL. I will post more of my projects as I get the chance. glenn@raudins.com