[an error occurred while processing this directive]
[an error occurred while processing this directive]
[an error occurred while processing this directive]
[an error occurred while processing this directive]
Projects
[an error occurred while processing this directive]
Publications
[an error occurred while processing this directive]
Resume
[an error occurred while processing this directive]
Ian Buck
Ian Buck
I have completed my Ph.D. at Stanford and currently work at NVIDIA
LinedIn Profile: http://www.linkedin.com/pub/ian-buck/15/13/192
Contact Info:
408-486-2000
2701 San Tomas Expressway
Santa Clara, CA 95050
BrookGPU is a compiler and runtime implementation of the Brook
stream programming language which provides an easy, C-like programming
environment for today's GPU. As the programmability and performance
of modern GPUs continues to increase, many researchers are looking to
graphics hardware to solve problems previously performed on general
purpose CPUs. In many cases, performing general purpose computation on
graphics hardware can provide a significant advantage over
implementations on traditional CPUs.
WireGL is a distributed network graphics driver for driving OpenGL
applications seamlessly across a PC rendering cluster. It allows for
unmodified graphics applications to render to large tiled display or
for a parallel graphics application to merge independent graphics
streams into a single output. Some of its other features include:
State and Geometry bucketing which is the ability to send only
primatives and state commands to servers which will render them;
Software context switching which allows for multiple graphics contexts
to share a single hardware context with the switching done in
software; Scalability up to 32 rendering nodes. This work is being
done with Pat Hanrahan, Greg Humphreys, and Matthew Eldridge.
My undergraduate thesis at Princeton University explored the
fesability of doing real-time teleconferencing with animated
characters instead of live video. Transmitting live video over the
web presents a host of problems given the limited bandwidth of the
internet. This project demonstrated that you can use a small
assortment of hand drawn images and which can be morphed to match the
user's expression in real-time. This required implemented a high
speed facial tracker, the development of a image morphing algorithm,
and a facial classifier to determine user expression. All of these
tasked were performed in 1/30 of a second. This work was done at
Princeton University with Alison Klein, Adam Finkelstein, David
Salesin, Richard Szeliski, and Chuck Jacobs.
My interests in hardware
design, especially in graphics, led me to do a semester of independent
work on graphics consoles. Hardware Nintendo was a project
which I designed and implemented a hardware design of a 1985 Nintendo
game console which included the MOS 6502 processor and Picture
Processing Unit. The image shown above of Nintendo Tennis was created
by letting the hardware simulation software run overnight executing
over one million instructions to generate the splash screen. The
project included all the steps of hardware design from
register-transfer to actual VHDL coding.
William J. Dally, Patrick Hanrahan, Mattan Erez, Timothy J. Knight, François Labonté,
Jung-Ho Ahn,
Nuwan Jayasena, Ujval J. Kapasi, Abhishek Das, Jayanth Gummaraju, and Ian Buck
[an error occurred while processing this directive]
[an error occurred while processing this directive]
[an error occurred while processing this directive]
[an error occurred while processing this directive]
[an error occurred while processing this directive]
Picts
BrookGPU is a compiler and
runtime implementation of the Brook stream programming language which
provides an easy, C-like programming environment for today's GPU.
As the programmability and performance of modern GPUs continues to
increase, many researchers are looking to graphics hardware to solve
problems previously performed on general purpose CPUs. In many cases,
performing general purpose computation on graphics hardware can
provide a significant advantage over implementations on traditional
CPUs.
WireGL is a distributed network graphics driver for driving OpenGL
applications seamlessly across a PC rendering cluster. It allows for
unmodified graphics applications to render to large tiled display or
for a parallel graphics application to merge independent graphics streams
into a single output. Some of its other features include: State and Geometry
bucketing which is the ability to send only primatives and state commands to
servers which will render them; Software context switching which allows for
multiple graphics contexts to share a single hardware context with the switching
done in software; Scalability up to 32 rendering nodes. This work is being done
with Pat Hanrahan, Greg Humphreys, and Matthew Eldridge. The WireGL home page.
Related publications:
My undergraduate thesis at
Princeton University explored the fesability of doing real-time teleconferencing
with animated characters instead of live video. Transmitting live video over the
web presents a host of problems given the limited bandwidth of the internet. This
project demonstrated that you can use a small assortment of hand drawn images and
which can be morphed to match the user's expression in real-time. This required
implemented a high speed facial tracker, the development of a image morphing
algorithm, and a facial classifier to determine user expression. All of these
tasked were performed in 1/30 of a second. This work was done at Princeton
University with Adam Finkelstein and David Salesin, Richard Szeliski, and Chuck Jacobs
at Microsoft Research.
Related publications:
If you have ever been to
SIGGRAPH or any other video technology demo, you will often see those motion
capture actors (booth bunnies, call them what you will...) wearing all black
with little silver balls taped to their wrists, elbows, legs and about
anywhere else. Cameras surrounding the actor will track the silver balls and
animate a character in real-time. Interactive Face was a project to
show that you don't need all the black suits and silver balls to track the
only thing moving in front of the camera, and you can do it without
overloading the CPU, still getting 30 frames per second results. This project
tracked the eyes, nose, mouth, and eyebrows and used that information to
compute head tilt, expression, and gestures all on an O2 workstation and only
using a third of the processor. Click here for the project report and a few
mpegs of it in action: Interactive
Face
My interests in hardware
design, especially in graphics, led me to do a semester of independent work on
graphics consoles. Hardware Nintendo was a project which I designed and
implemented a hardware design of a 1985 Nintendo game console which included
the MOS 6502 processor and Picture Processing Unit. The image shown above of
Nintendo Tennis was created by letting the hardware simulation software run
overnight executing over one million instructions to generate the splash
screen. The project included all the steps of hardware design from
register-transfer to actual VHDL coding. Click here for the final report and
some design diagrams: Hardware
Nintendo
For my independent work, I worked on developing an optimized
mathematical model for turbulent fluid simulation within a modeled voxel
environment. Work includes rotation dynamics and auditory analysis of
turbulent flow through musical instruments. Also it explores using graphics
hardware to accelerate the calculations of thermal gradients. Click here for
a copy of my paper: Turbulent Fluids Simulator
The goal of this project was to design and build a working
PDP-8 minicomputer which was popular in the 1970's and early 80's. Completed
for ELE 375 Computing Structures, a course I highly recommend, it was 100%
compatible and quite a bit faster than the original PDP since it use Xlinix
FPGA's and could operate up to 3Mhz. Project Partner: Amir Give'on '99. PDP-8
Minicomputer
NfsFtp is a special NFS server written for Windows 95 which
allows Unix users to mount FTP sites as if they were NFS directories. This
project alleviated the hassle of having to ftp files back and forth from remote
file systems with annoying gets and puts. Rather users could mount the FTP
server as a directory on their current machine and perform all the regular
shell commands, like "cp" or "ls" or even modify remote files with emacs
without a hitch. This was done with Joe Corkery '98 for Computer Science 461
Distributed Computing.
VRMud is a interactive modeling program that I worked on with
Ken Turnbill '98 and Tom Sanocki '98. It supported the molding of non-discrete
materials, like clay with tools (lathe, magnet, knife etc.) to simulate a real
workshop. The final result could be exported to a ray-traceable file. Features:
Dynamic mesh reallocation, multiple mud models, and a scene designer.
TheForce
is a term project for CS333, Advanced Programming Techniques. The goal is to
create a space fighter action game similar to XWing, by Lucas Arts. Using
OpenGL, Inventor, and written entirely in C++, the project six week schedule
included interactive sound and multiplayer networking option.
The group consists of 6 members, Drew Leamon '99, Tim Milliron '99, Philip
Nickolov '99, Eric Cheng '99, Trevor Sumner '98, and myself. Rob Jensen '98
did some really cool Star Wars models.
NetherRay
is a ray tracer I wrote with Rob Jensen '98 for a COS 426 assignment. It does
procedural shaders (with a shading language syntax modeled after RenderMan),
stochastic depth-of-field, soft shadows (give the light a radius), plus all
the usual reflections and refractions.
Drum was a
project done for COS 496 Simulations final project. The goal was to
accurately simulate the surface of a drum and study different waveform
and propagation properties. The drum was simulated with a mesh surface
and sound was synthesized by averaging vertex height. Some sound
bytes: A simple beat and an attempt at Yankey Doodle.