Projects

Ray - My Doom Engine:
Inspired by the first of the ID Software's Doom series, I wrote the following engine on my junky i386. It is a 2D BSP renderer, not a raycaster. (Images may need some gamma correction). 

QR - My Quake Engine: 
After spending some time with Quake (professionally of course :) ), I wrote a Quake Renderer (QR). This is another 3D BSP renderer. It reads Quake I .bsp files and lets you walk around ala Quake. All the texturemapping stuff is implemented in low level assembly. Despite many people, I think writing low level assembly for fast texturemapping and math stuff is quite fun (or at least was fun. It's been 5-6 years since I wrote this one. Since then graphics capabilities on PC's increased so much that everybody takes high quality bi-tri-linear texturemapping for granted). In order to use this one, you need the real Quake (you need real Quake data files for viewing). I also included a tool to extract the .bsp file from the .pack files. Maybe you can use this to find secrets in the game :).

Pixie - RenderMan Renderer:
Pixie is a renderer that I've been working on for some time. It has its own web page at:

http://pixie.sourceforge.net

The RenderMan (R) Interface Procedures and RIB Protocol are:
Copyright 1988, 1989, Pixar. All rights reserved.
RenderMan (R) is a registered trademark of Pixar.

View Dependent Refinement of Progressive Meshes:
This is an X Windows based program for the view dependent refinement of progressive meshes. In this program, I implemented the refinement thru edge collapses only. So I start with the original mesh and perform edge collapses so that the detail level is adjusted to the desired level. Detail level is dictated by the view frustum, surface orientation and screen space error. For example, the portions of the mesh outside the viewing frustum or the parts that look away from you are refined to a lower detail level. The refinement step also takes the screen space error into account, i.e.: distant parts are fined more, flat areas refined more whereas silhouettes are refined less. Since I performed edge collapses only, the refinement step is lightning fast. I don't have to go through all the topology checks. Because I start from the original mesh. this also simplifies the ecol structure. So I don't need an outrageous disk space requirements. This also enables topology comprising refinement. For example, during the refinement, unconnected parts of the mesh can merge together (of course this depends on the underlying edge decimator. I used Garland's Simplification by Quadric Error Metrics). Here're some pictures:

Here're some more images on frustum refinement:

The surface orientation refinement: The objective of this criterion is to decrease the number of triangles that look away from you without compromising the triangles that you actually see (that look towards you).

The screen space error refinement: The objective here is to decrease the number of triangles as long as we attain a fixed quality of the mesh as seen from the current camera. Note that the silhouettes are refined relatively less due to the bigger impact of edge collapses on  the visual quality.

Here're more images for screen space error refinement:

Of course, the ultimate objective of the method is to decrease the number of triangles so that we don't pay for what we don't see.

Delaunay Triangulator: 
This is my class project for cs294 #5 - Triangulation & Meshing.  I implemented 4 different Delaunay triangulation algorithms:

• Guibas & Stolfi's divide and conquer with vertical splits
• Guibas & Stolfi's divide and conquer with alternating splits
• Incremental delaunay triangulation (randomized)
• Gift wrapping

You can download the source code here.

Here's my rigid body simulator that I call rbody. It is available with the source code here.