Josh Barczak

jbarcz1@gmail.com
http://www.joshbarczak.com

My first game credit.  I implemented the rendering framework which drives the diplomacy screens.  This is a cut-scene renderer with quite a lot of bullet points:

• Texture-space subsurface scattering.
• Post-process bloom and depth-of-field.
• Planar reflections.
• Screen-space refraction.
• Fur fins and shells.
• Quite a few lighting models.

For DX11-class hardware, we used a proprietary variable-bit-rate compression scheme for the leader textures, which you can read about in our EGSR 2011 paper (see publication list above).

Besides the leader system, I also built a procedural ice-floe generator for the polar regions.  If you're playing the game and happen to go close enough to the poles, you'll notice that each and every ice chunk is unique.

A collection of generic implementations of common raytracing data structures.  (BVH, QBVH, KDTree, Uniform Grid).  Available here. 

TRT's goals are:

- To provide a flexible reference codebase for research, prototyping, and hobbyist experimentation
- To provide baseline components which may be modified for use in a production renderer
- To provide a ready-made solution for 'lightweight' raytracing applications (such as picking, line-of-sight testing, and the like).
 

This demo used a GPU-based continuum crowd simulation to create a rich world filled with interactive "Froblin" characters.  It also showcased the use of hardware tessellation to add details adaptively to the characters.  Since we simulated our characters on the GPU, we had to find ways to do key frame interpolation, LOD selection and character culling on the GPU via shaders.

My main technical contributions to the demo were the terrain system, character culling and LOD, and a vertex compression scheme which enables fast multi-pass animation.  You can read more in the SIGGRAPH 2008 course notes (here).

I designed and built a scalable parallel physics engine that was used in this demo to simulate thousands of bouncing ping pong balls.  I also helped implement and optimize several of the rendering effects used in this demo (MSAA imposter rendering, bloom effects, ambient occlusion).  Go get the demo here.

I shamelessly stole this screenshot from Chris Oat.

As a member of the ATI 3D Application Research Group, I played a significant role in the development of Ruby: Whiteout.  I implemented a sizable portion of the demo engine, and developed a variety of rendering effects for the demo (motion blur, depth of field, dynamic SH lighting, shadow map filtering).  Go get the demo here.

Pet Raytracer

This started out as a homework assignment in my intro to graphics course, but quickly grew into a personal hobby.  After spending a few years expanding on my homework assignment, I recently re-wrote the entire thing from scratch.  My pet renderer is now a fast, full-featured system which I use to produce artwork to hang on my walls.

Click here to go to the JRT page.

MS Thesis:  Interactive Illumination Using Large Sets of Point Lights

I presented several optimization techniques which could be used to render shadowed illumination from hundreds of point lights using a commodity GPU.  This allows for interactive rendering of soft shadows by point sampling an area light, and also allows for approximate indirect illumination using Instant Radiosity.  For more information, read my thesis.

Interactive Caustics Using Hierarchical Light Volumes

As an independent research project, I developed a variation on the classic light shaft technique for rendering water caustics. Shadows are implemented by detecting and culling light volumes from occluded areas of the water surface, which not only improves the realism of the image, but can also speed up the rendering.  You can download the (unpublished) paper here.

DirectX Runtime Environment for Ashli

As a summer intern at ATI Research, I developed a runtime system to support high level shading using DirectX and the Ashli compiler.  The runtime provided a transparent framework for multi-pass rendering, which allowed the application to use arbitrarily complex shaders without worrying about exceeding hardware resource limits. 

The screenshot on the left is from a sample application developed with the DirectX runtime environment.  The walls and surfaces are rendered with HLSL shaders, the objects are rendered using GLSL shaders.

SLODSIM

As a research assistant at UMBC, I designed and implemented a software simulator for executing procedural shaders and collecting performance statistics.  The goal was to produce a simulation environment for profiling the shading workload in 3D scenes and evaluating the effectiveness of procedural shading optimizations.  The system contains a modular, user-programmable virtual machine, and a software rasterizer which uses the VM to perform per-vertex and per-pixel computation. 

FireFighter

This was a group project I did as part of a UMBC special topics course: CS691E: Graphics for Games

The game was built using a scene graph library called WildMagic, which came bundled with our textbook.  Click here to go to the FireFighter page.

My Asteroids Clone

Way back during my junior year at UMBC, I made a little Asteroids clone in order to teach myself DirectDraw programming.  You can download it here.  The game was developed using DirectDraw 7.0 for the graphics, and the Windows API for the sound.  I make no guarantees as to how well it works.

My Tetris Clone

One of my earliest self-motivated programming projects, this is a simple Tetris clone written in Visual Basic 6.0.  I make no guarantees as to how well it works, but you can play with it if you want.  You will need the VB6 runtime, which you can probably download from somewhere on Microsoft’s website.  Get it here.