Download my 1-page resume.
This page is a work in progress as I dig up old screenshots and photos.
Team-based projects where I played an integral part.
C#, MSSQL, Web-services
Integrated Twitter and Facebook conversations into MSNBC's live TV show productions. It involved some Microsoft-stack, some Linux rendering machines, some sweet code. Ever push to production with 400k concurrent users? But more importantly, I once bumped into Jimmy Fallon outside the cafeteria! He was really nice. I was too starstruck to say anything witty. And I shared an elevator ride with Jason Sudeikis. No big deal.
This social-media lower-third first premiered on MSNBC's NOW with Alex Wagner show.
Before parallax scrolling became a prerequisite for long-form startup sales-pages, Disney and Microsoft approached us to create a rich comic-book experience using HTML5, heavy parallax effects, sweet Daft Punk tunes, and make it all run at 60fps on the yet-unreleased IE9 in time for it's own public launch event!
I put this together with a highly distributed multi-timezone team in record time.
Check out our behind-the-scenes at the windows.com blog.
What did it take to build a highly interactive virtual newspaper?
Inventing an entire touch-based UI framework. Everything from coming up with original interactions to layout and position rendering. Basically building your own jQuery/Ember.js from scratch, and supporting not one mouse-cursor but a dozen fingers.
Besides building out the MVC architecture and custom controls, I went out of my way to make the interface silky smooth.
See that sweet rotating flip animation at 0m47s? You are welcome. The silky smooth page-resize and text-reflow at 1m13s? Why, thank you for noticing.
C#, WPF, HPC
A multi-user multi-touch game for the Microsoft Surface with beautiful graphics and sounds. Playing by yourself? Connect to a Microsoft High Performance Cluster for a serious challenge.
One of my favorite contributions was thread-safety, deadlock-detection, and automatic event-marshalling that guaranteed callbacks ended up in the proper UI thread. This eventually became it's own library and was used for other projects.
This game sat (and perhaps still sits) in the lobby of one of the Microsoft campus buildings.
C#, RESTful Web Services, RS232
We built the networking infrastructure and a small app ecosystem for the Chrysler 200C EV Concept Car. With it we could remotely control many of the car's functions including the heating and the power windows from an iPhone. You could use your tablet to push a map-route to the car's dashboard and DJ out to the car's speakers at the same time. The car's interior had no buttons. All controls were via touch-screen and wireless.
- Interfacing with the capacitive grid of the curved touch-panel film via RS232
- Dewarping touch coordinates to match the projected-space of the dashboard HUD
- Generating fast and high-quality gestures from raw and noisy data (the really fun part!)
- RESTful web-services enabling communication between an iPhone app, a Windows tablet, and the car's hardware (eg: starting the car, tweaking air conditioning, playing music, rolling down windows)
An exhibitor told me in 15 years he has never seen such a fully functioning concept-car, drive-train and all :)
The car was unveiled to an excited audience at Detroit's 2009 Autoshow.
C#, C++, Microsoft Surface
An award winning multi-touch car-configuration app that uses object recognition to modify a rendered scene. I overhauled the rendering system to dramatically boost performance and enhance the user experience.
- Created a realtime out-of-core compositor that took advantage of Vista's WDDM technology to squeeze every ounce of computing power out of the Surface.
- Developed a custom image format optimized for super fast decoding, custom tailored to the HDD/RAM/CPU performance of the machine, eliminating inefficiencies and tackling the major bottlenecks (filesystem caching, texture uploading, hdd seek times). Allowed the app to render huge amounts of data in realtime.
- Reverse-engineered and bypassed WPF's image-handling bottlenecks using a DX9 proxy-dll to rewrite managed-mode calls, reducing the video-memory footprint by half, significantly reducing memory-thrashing and improving the frame-rate resulting in silky smooth interactions.
Hobby and Freelance Projects
Written entirely by me. Mostly from scratch. Minimal use of third-party libraries. Optimized for learning and performance.
Built a 3D game-engine from scratch in C# + XNA + HLSL shaders focusing on real-time indirect lighting. All the math was based on hard work by researchers like Sebastien Lagarde from his excellent article-series on physically based shading and prefiltered cubemaps and Tri-Ace's generous papers and presentations. I've been obsessed with this new mathematical model since sitting through Tri-Ace's lecture @ GDC 2012. I combined their work into an uber-shader that generates realistic ambient-diffuse and ambient-specular lighting for various material (rough and smooth, metal and plastic). It was hard and fun :)
Playing around with multi-layer materials as per Weidlich. Layers attempt to simulate transmission, absorption, and view-dependent effects. This BRDF-layering works in a physically-based deferred shading engine. I can render plastics, glass, and metals with the same code path by tweaking a few simple parameters for each layer and it's BRDF: roughness, complex IOR for metals and simple IOR for dielectrics, diffuse reflectance, and layer thickness.
Experimented with various Specular BRDFs: Cook Torrance, KSK, and TriAce's neat ambient specular formula; plugged in various distributions and geometry terms (Gaussian, Phong, TrGgx/SmithG1, and Beckmann). A few Diffuse BRDFs including Oren Nayar (original and a Tri-Ace simplification).
Settled on a combination of the microfaceted KSK (using the Tr/GGX distribution) for specular and Oren Nayar for diffuse.
For Fresnel I used LSK's formulas for both complex and regular IORs. It's really satisfying to plug in an IOR and see the resulting copper, aluminum, or gold tint appear across the bright shaded surface.
Below: shiny metal, rough metal, shiny acrylic material over plastic, rough acrylic over plastic.
Semitransparent smooth reflective acrylic over: smooth gold, rough gold, and a weird deeply absorbing plastic.
My mech wearing a complex 2-layer material. Looking good!
2003 - 2006
An easy-to-deploy tournament administration system with many skins and innovative features (at the time):
- Demo/Replay uploading with push to remote-storage. Allowed viewers around the world to rewatch famous matches, even in countries where international-bandwidth was expensive (eg: Iceland).
- Image resizing for screenshots
- Professional seeding algorithm (as used in major league sports) now available for everyone in eSports
- Single and Double-Knockout Brackets rendering
- Multiple CSS themes
Used for years in video-game tournaments around the world. Allowed me to meet gamers from places I've never visited like Iceland, Bulgaria, South Africa, New Zealand, and New Jersey! A few people forked my code (before it was cool to do it on GitHub) and put their name on it and pretended it was theirs, I considered it a compliment.
C++, OpenGL, SDL, Register Combiners
A 3D game-engine built from scratch supporting the hotness of the time:
- Quake3 Model Support with animation (MD3)
- Milkshake3D and Maya scene importing
- Register Combiner based lighting and decals
- CTF Game Mechanics with Flag Capping, Weapon Pickups, and good old Jump pads
- Collision Detection using a capsule (cylinder + two spheres) around the Actor; test done against static triangle geometry optimized by an Octree
- Decals could span multiple polygons (better than Q3 did at the time)
Just a software rasterizer with perspectively-corrected bilerp texture filtering, Cohen-Sutherland line rasterization, and a simple matrix-camera. Rendered scenes exported out of Maya.
Modeled in Maya (remember version 6.0? crash-tastic!)
Proof-of-concept pure-JS 3D model rendering in your browser before Canvas/WebGL came along. No Flash or any other external plugins.
Wrote a plugin for Maya to output JS-friendly meshes. The rasterizer worked in IE6SP1 and other browsers that supported the XBM-image format and the base64 dataURI encoding hack. Realtime rendering here meant 0.5 frames/second :)
Assembles x86 intel-syntax asm code into machine-code and wraps it in a MZ header. Uses base64 data-uri method to send the newly generated executable to the user, bypassing the server. The generated executable runs within a Windows command shell. Yeah, scary.
C++, MCI, VFW, AVI
Win32 screen-scrapping using BitBlt/GetDIBits, async I/O audio capture, real-time XVID+MP3 encoding into an AVI container. Fancy event registration, beautiful debug logging, bilinear image resizing.
C++, IOCP, MySQL, Perl
A GameSpy and AllSeeingEye clone and a stab at the C10K problem.
Uses a Windows NT Async I/O with Completiong Ports based event system that deliveres high throughput and scales easily with more CPU cores. Thousands of queries per second with minimal CPU usage over consumer-grade internet connections. Fast geo-coding using a MySQL Heap Engine with GeoIP data.
Built and published game-server statistics using Perl+MySQL.
C#, ASP.NET 2.0, GDI+, MSSQL 2000/2005
A database-driven chart-building web-app. Dynamic server-side chart generation with an Ajax front-end. WMI event-monitoring and dll-imports for high-resolution performance timing using PerfMon and DebugView. Dynamic label-fitting, number-formatting, and image-compression. Includes a test-harness for TDD-style building of new chart-renderers and my own version of "shaders".
3D pie charts, pretty bar-graphs, and gauges (which were all the rage in 2004).
C++, OpenGL, CG (PS3.0)
A completely out-of-core generation and rendering of terrain using the GPU (async from the CPU). Vertex Buffers and Indices generated on the GPU using a fragment-shader with a PBO attached to a FBO which was then reinterpreted as a VBO for the next shader which rendered and shaded the GPU generated geometry.
This technique bypassed the vertex-texture-fetch bottleneck of existing terrain renderers. It generated camera-space vertices, kept a static index-buffer, all rendered geometry was by definition within the perspective view-frustum.
Witty optimization: free bilinear-interpolation of heightfield data through Texcoord units made the geometry-building pass as cheap as a passthrough fragment-shader!
C++, CPU and PPU Emulation, Meta-Programming, Disassembly
An emulator with CPU, PPU, and input support. Win32 GDI-based rendering. Cycle-accurate emulation, multiple PPU-CPU sync modes. Ran multiple games (like Super Mario and Donkey Kong).
Development was straightforward thanks to the many freely available and detailed 6502 and RP2A03 CPU references.
I love beautiful debugging like this colorful console output with reflection-fueled file:line and class::method source data.
The way horizontal scrolling works is pretty neat. Super Mario Bros uses it:
C++, OpenGL, SDL, GLUT, FMOD, Register Combiners/Fixed Pipeline, Cg (PS2.0, a little 3.0), Linux and Windows, Nvidia-specific OpenGL Extensions
Built multiple game-engines from scratch, trying to learn everything I could from books like the Game Programming Gems, Morgan Kaufmann series, and online tutorials from gamedev.net, flipcode, and awesome authors like nehe and humus.
- Various netcode server-client architectures (over UDP)
- Cross-platform blocking multi-threaded
- Linux event-based
- Windows IOCP with thread-pools
- Windowing and input wrappers for Win32 and Linux (X, Win32, DirectInput)
- OpenGL based GUIs (input boxes, scrolling textareas, buttons) inspired by deep-hierarchical OO popular at the time
- Custom reflection support for various compilers (even GCC3.3 and MSVC6) to generate Visual Studio clickable output (file:line class::method() - output text)
- CPU specific optimized versions of STL classes like lists, stacks, string manipulation and formatting.
- Very fast printf, strlen and strcpy implementations optimized for block-copy, SIMD, and fast int/float parsing
- Shader-based variable-width and monospace bitmap font rendering; optimized in various ways: display lists and VBOs
- Static mesh importing: .3DS, .MD3, and written from scratch: .OBJ .BSP
- Image importing (written from scratch): .TGA, .BMP
- Convex-hull optimized geometry for fast physics
- Frame-rate independent physics using variable-length ticks (like Unreal), multiple-ticks (like Quake)
- Optimized math libraries (Matrix and Vector classes with the usual operations, including determinants, inverse, and orthonormalization)
- Skyboxes, demo/replay support, texture/asset management, actor/model management, high-resolution and high-granularity performance timing, and sweet visual-debugging tools.
- In-game event system with both Edge and Level triggers
- Early 2000s style OO and design-patterns usage: deep hierarchies, lots of interfaces, factories, singletons, visitors, and the curiously-recurring-template pattern (CRTP was my favorite, I miss it so much!)
- Spatial Partitioning with a polygon-cutting Octree for faster occlusion culling, frustum culling, and collision detection.
- Various point-in-polygon and sphere-vs-triangle tests; Various constraint resolution approaches.
- Vertex-based animation. Wasn't up to skeletal skinning just yet.
I modeled, textured, rigged, skinned, and animated my own characters. They weren't pretty, but got the job done. Baked animations. Made plugins to export generated data out of Maya into my own custom 3D model formats.
A clone of my favorite childhood 2D platformer: Jetpack.
- Interactive level components, items pickups.
- 2D collision detection and response with a capsule around the actor
- Frame-rate independent physics
- A particle system that worked on NVidia and Intel graphics chipsets
- Some sweet 2D pixel-artwork by yours truly
Wrote a system to allow for the Sony Aibo AI code to talk to a simulated robot instead of a real physical one. This enabled rapid prototyping by bypassing the slow firmware-uploading process and long reboot cycles. It also enabled safe testing without risking wearing out and damaging joints due to bad walk cycles and physical collisions.
- Built a reflection-engine to analyze and reconstruct the packet structures of a closed-source remote-processing robotics framework. Used C++, Perl, and packet sniffing.
- Created a service to intercept network-based robotic joint commands and sensing requests, simulated them in a virtual environment, and responded back using the reverse-engineered protocol discovered in the previous step.
- For the physical simulation of PID joints and collision response against the ground, along with feeding a simulated video of the environment back to the machine-vision segment of the AI, I started off with a UT2004 mod (from university students in Italy), and then built my own solution.
- My own physics-simulating environment provided rigid-body dynamics through a variety of engines: ODE, Bullet, Newton Dynamics, Havok, and eventually settling on PhysX (before it was even bought by Nvidia, good call!)
- Integrated a Convex Decomposition library to build optimal meshes for accurate collision detection. The resulting simulation reliably predicted drifts in the robot's locomotion code that was observable in real life.
C++, OpenGL, PortAudio, Speex, Networking
A simple proof-of-concept VOIP app using port-audio for low-latency audio capture and playback, and speex codec for low-bitrate realtime audio encoding. Fancy circle-buffer graphs for debugging buffering.
Photoshop, HTML, CSS, MySQL, Apache, PHP, JS
Helped maintain this long-running old-school competitive eSports site. Created new designs and re-implemented the site from scratch. Learned a lot about social-media and online communities.
And I built beautiful looking schemas:
Added deferred tile-based lighting to my game engine. You use 2D projections of light volumes to match lights to their screen-space tiles, then render one tile at a time, looping over the . This gets rid of wasteful full-screen passes and maximizes shader throughput and concurrency.
Below: muzzle-flash with an animated point-light attached, spanning multiple tiles.
Wrote a Skeletal Retargeting demo for the Kinect with Microsoft's official public beta drivers.
- Generating orientation matrices from Kinect's position-only data. Why a beta-level API would be missing something as critical as joint-orientations, I don't know.
- Matching up Kinect's skeleton to the skeletal rig of my 3D game asset.
C++, C#, HLSL
Built complete content pipelines to export data out of Maya (and previous 3DS Max).
- Maya exporter plugins and custom model/mesh formats
- Export textures and non-mesh game-elements (e.g. locators as spawn-points)
- Export custom Material attributes as material data (surface roughness, IOR, etc)
- Export skeletons with weight-painted skin bindings and skeletal animation
- Created a consistent process for getting perfect T-pose binds (2011)
- Game importers:
- Animation framerate resampling with slerped joint rotations
- Generated VBOs and IBOs for efficient memory usage
- Baked joint xforms into normals for fast accurate object-space shading
- Split animation-tracks into loopable game-triggerable animations
- Automatically generated simple convex geometry for collision detection around otherwise high-poly meshes
- Tagging-support to properly position weapon meshes within hands of actor models
When not importing my own model formats, I've written importers for various common model formats, and most recently an FBX-SDK importer that could reload a model in real-time upon detecting a change on disk, to aid in fast design iteration and in-game testing.
Written various animation systems, from completely CPU driven vertex-animations to optimized GPU based skinning. Including model instancing and Deferred Shading compatible G-Buffer output with motion vectors and material data.
I'm a big fan of visual debugging. Here's a simple skeleton. For pretty joint orientation visualization, find my Kinect Avateering debugger screenshot.
Animation, weapon-tags, muzzle position and direction, in the GIworld.
HD and low-detail data, treated by the same processing pipeline. Guess which one was a free 3D scan and which a paid game-asset!
When a t-pose bind fails:
They say the camera adds 10 pounds. But incorrect absolute transform hierarchies add a 100 pounds:
Implemented and tried to understand techniques by awesome people like @marcosalvi, @AndrewLauritzen, @iryoku1, and @aras_p
- PCF, VSM, ESM, and EVSM shadow filters
- Parallel split cascades with circular and square distance metrics
- Automatic near/far/partition-split distances using: geometry intersection tests and DX9-style histogram building (involves downsampling and pulling down depth-buffer from the GPU -- pretty slow) inspired by SDSM (one day I'll do it the DX11 way!)
- Precision-enhancing and compression tricks (16bit normals, Crytek's best-fit normals, linear and non-linear z-depth)
Nice shadows with IBL ambient
Contact Shadows via bent-normals
Parallax-Corrected Cubemap Reflections
Implemented an effect used in cutting-edge AAA games like Battlefield 3.
A Deferred 3D Particle Shading Engine based on a wonderful presentation by Nicholas Francis. It would blend Normal Maps of otherwise 2D billboards creating a puffy 3D-looking cloud that responds to complex world lighting.
I got my name out there for a chart filled article. I gathered and dusted the data using the Twitter API, a lot of regular expressions, a database, and the wonderful R graph-building language.
Before XMLHttpRequest was standardized, I built an AJAXy realtime wiki that looked like a real world message board. You could zoom in and out, organize ideas visually with colors and by grouping things together on a large canvas. There was a sweet minimap on the bottom-left corner.
Some fancy features required a lot of work for cross-browser support, including manual event binding for movable windows, AJAX polling, and resizable windows with PNG drop-shadows (anyone remember PNG-fix? or cutting up images into 9-tiles to let them stretch-repeat?)
You could even build custom gradients in IE, back when that browser had the most amount of cutting-edge features :)
What's the most challenging error to catch in an elegant way in PHP? Parse errors! Well I found a way to make that work!
My error handler would dump out a nice stacktrace, find and print out the line of code that caused the problem and it's surrounding code-block. You could figure out the error in 2 seconds without ever leaving the browser!
I strive for immediate feedback and beauty in everything, even error handlers:
I aim for this level of responsiveness from every system I work on, from web to desktop applications, to embedded devices.