|
Automated Stencils and Gobos from 3D Models
Developed as an interactive program, the stencil utilities toolkit
allows the user to turn an arbitrary 3D mesh into a guideline for
a printed stencil. Users can adjust line thickness, lighting, and
camera angles to achieve the desired result. Hardware Acceleration
is used to obtain the artistic style and a unique algorithm joins
disconnected regions. These generated stencils can be used to fabricate
hand usable stencils or sent to factory for Gobo production for use
in theatrical stage lighting.
|
|
PAWS (Pipes And WaveS)
Developed in Java with JOGL (OpenGL Bindings for Java). Users can connect to local or remote databases to query data. 3D graphs are generated and can be interactively explored. Interaction through wave-based motion allows a deep understanding of the relationships throughout the graph. Nodes can be selected, highlighted, labeled, flagged, recolored and moved around in any way the user sees fit.
. |
|
Real-Time Caustics on Deformable Meshes
The goal of this project was to combine two techniques, Shah et al.'s "Caustics Mapping:
An Image-space Technique for Real-time Caustics" and Oliveria et al.'s "Real-Time Refraction Through Deformable
Objects." The caustics paper mentions how easily it can use Chris Wyman's Image-space refraction, but
this newer technique requires no precomputation. Banking off our recent familiarization with XNA, we
implemented both algorithms using the framework and developed a small world to test in. The caustics algorithm
works efficiently by avoiding any explicit intersection calculations. Instead, the world positions of the scene are
rendered to cubemap from the perspective of the translucent object. Refraction is then computed from the view of
the lightsource and instead of looking up environment color, the environment positions are taken. These positions
are then used to render point sprites using Vertex Texture Fetch.
|
|
XNA Development
The goal of this project was to become familiar with the Microsoft's
new XNA framework. The XNA framework is built around DirectX with only a small subset
of the API exposed. The great feature about XNA is that if created carefully, the
application or game will run on both Windows and XBox 360 platforms. I chose to implement
a simple projectile based game that I had originally created in OpenSceneGraph. Porting this
project to XNA was relatively simple and the final implementation was much cleaner code.
Multitexturing and normal mapping shaders all written in HLSL.
|
|
Mixing Procedural Shading
The goal of this project was to mimic a real world object, in this
case a piece of granite rock, and then add an other worldly feel to it. To create this
effect I combined procedural techniques with explicit texturing. The model itself
was created to mirror the original rock, using Wings 3D. Procedural normal mapping
is achieved using a 3D noise texture and a novel normal blending technique. The view
dependent rune markings are texture mapped and blended into the procedural shader and
varied with time to achieve a pulsing glow.
|
|
Two Surface Refraction Shader
Implemented a multipass refraction shader using GLSL in OpenGL. The refraction algorithm used
is based off Chris Wyman's 2005 SIGGRAPH paper entitled, "An Approximate Image-Space Approach for Interactive Refraction."
In this method, depth information is used to approximate an exit point of the refracted ray and apply the
second refraction to find the final exit direction.
|
|
BSP Culling
Implemented using OpenGL/C++. Input at runtime controls
the dimensions of the maze. Once generated the user is placed inside
the maze and can find his way through. Features include Texturing, Collision Detection,
and BSP culling. |
|
General RayTracer
A basic implementation of a RayTracing Engine. Images are rendered from
models obtained from the Standard Procedural Database or other NFF input files. Features
include specular highlights, casted shadows, and anti-aliasing. |
|
Renderman and Procedural Shading
As an exercise to introduce renderers, a simple scene of objects
was entered programmatically, textured, and lit from several angles to provide a
compelling image. Afterwards, several shaders were written in the Renderman Shading
Language to model real-world surfaces. Included in the project were shaders for water,
ice, concrete, snow, and marble tile.
|