Kevin Parker's Portfolio

VR Physics-based Animation - Spring 2019

Interactive physics

As seen in several projects below, I have been curious about how physics works. Working in a team for the final project of my Physics-based Animation class, we were able to create an experience that allows a person to interact in VR with simulations from our previous projects in the class (a cloth animation is shown here) as well as an added finite-element method simulation that was based upon projective dynamics.

A video with more details is available Here

Ray Tracer - Fall 2017

Realistic graphics through ray tracing

I elected to have a class in Ray Tracing in Fall 2017, and this project is from that class. I was able to implement a ray tracer (a computer simulation of physical light) with support for Blinn-Phong shading of triangle meshes and spheres. It supports global illumination through Monte-Carlo sampling, path tracing (shown in this example), or photon mapping. Other features that are not shown include texturing, depth of field, and reflective/refractive surfaces.

Specifically in this image, I am showing the "Utah Teapot" sitting on top of a floor. Both the floor and the teapot are the exact same color, but lighting (global illumination) is calculated by virtually tracing the paths that photons would take in this scene. This process gives accurate shading around the details of the teapot.

3D Asteroids - Spring 2017

The game of Asteroids, but best with a swivel chair!

I'd had previous experience in iOS development, but given the field's rate of change, I elected to take a class to update my knowledge and learn best practices. This game was my final project for that class. Similar to the reasons I took this class, a big part of this game was actually experimentation: I wanted to know if motion controls would be good for a game of Asteroids. I wanted to know how a phone UI would feel if it remained upright, even when the phone was held at an angle (This is why the text is not perfectly upright on this screenshot; I was holding the phone a couple degrees off of vertical). And of course, I wanted to make something fun that included things such as particle effects, wireframe meshes, and shooting.

This app was written purely in Swift, using OpenGL ES 2; particle effects were almost entirely offloaded to the GPU via vertex shaders.

AudioLab - Summer 2016

An FFT-based assistant for tuning audio equalizers

After buying a new stereo and speakers for my car, I was unsatisfied with the way it sounded with a flat equalizer. After trying to tune it by-ear and never initially finding something truly satisfactory, I wrote a quick iOS app that would send out pulses of sound at the peak of each of the EQ's ten bands (31 Hz, 62 Hz, 127 Hz, etc), record the sound produced and then perform real-time Fourier analysis on the signals to determine frequency response, distortion, and other information about the system at various sound levels.

My car's audio sounded so much better after tuning it with information provided by this app.

Perlin noise - Spring 2016

A smoothed isosurface in 3D octaved noise

This is a small chunk of 3D octaved noise. I meshed the surface using marching cubes and then smoothed the mesh using one of my algorithms. This is still a work in progress. Because marching cubes has a couple of ambiguous cases, there are some potential issues when these occur.

Pseudorandom Planets - Fall 2015

Simple spherical planets generated algorithmically

Quick map creation is a helpful thing for game developers, however most maps created are generally flat instead of spherical. This is very much a work in progress, but it demonstrates that nice planets can be created pseudorandomly.

Rtyuio - Fall 2013

A turn-based battle game

This was a game I wrote for a 3-day game creation challenge (the Ludum Jam). I wrote an AI, pathfinding, random map generation and resource management.

Marbletracks - Fall 2012

A physics marble game

I wrote Marbletracks a few years ago after being fascinated with large marble machines that are commonly found at the airport. You can draw lines on an infinite canvas and watch as groups of marbles travel around the lines you drew, perhaps in a perpetual motion machine. The original version is implemented using OpenGL ES 1 and Box2D within Objective-C. I have considered porting this over to a new physics and graphics engine, such as iOS's SpriteKit.

Sudoku Solver - Fall 2010

A program that solves any (solvable) Sudoku board

This Java program first tries to solve the Sudoku puzzle using similar logic to what a human would use. If that fails, it resorts to a brute-force method to ensure that every possible square is filled with something.

This board took my software 11 milliseconds to solve on my 2010 MacBook Pro, and most human-solvable Sudoku boards will solve near this amount of time on similar hardware.

Wiimote-controlled Robot - Spring 2010

A robot controlled by just moving your arm

For a 8th grade science fair project, I decided to make a robot. A couple of years later, I learned how to connect to Wii Remotes using Bluetooth so I decided to use them to control the robot I already had. At the time, the Wii remotes were both a cheap source of accelerometers (one is used for each of the arm joints) and joysticks (which are used to control the claw and wheels).

A video demonstrating this robot is available Here

3D Mandelbrot Set - Fall 2009

The Mandelbrot set put into 3D; then ray-traced

The Mandelbrot set is a shape defined by a recursive function in the complex plane. Images are often generated by repeating this function and then counting how many iterations needed to be executed. These images often use different colors as the number of iterations increases, however this image shows both depth and color changing alongside iterations. The final image is ray traced (using the SunFlow renderer).

Ping-pong physics simulation - Fall 2009

A simulation of a thousand ping-pong balls colliding

Starting several years ago, I was fascinated by physics engines and ray tracing. I decided to merge the two in a simulation of a thousand ping pong balls being hit by a large steel marble. I think that this kind of simulation blurs the line between science and art.

A brief video is available Here