Jeremy S. Smith
Asteroid Evasion
Developed using C# and Unity
Asteroid Evasion is a space-flight simulator built in Unity 5.5. The goal is to navigate the ship through an asteroid field while avoiding collisions for as long as possible. The player must steer using the mouse X and Y motions, which use the Unity Rigid-Body physics to apply force and torque to the ship. The longer the player survives, the higher their score will be.
Aracnescape
Developed using C# and Unity
Aracnescape is a game I created for my first Ludum Dare event. The game was built in 48 hours using Unity 5.4. The player takes on the role of a spider, who's goal is to navigate the bedroom and escape through the open window on the opposite side. The player must avoid being spotted by the human in the center of the room. As a spider, the player can use the furniture in the room to their advantage by crawling up any surface and even climbing upside-down.
Bump and Displacement Mapping
Developed using Java, OpenGL and GLSL
This application demonstrates how using different shaders on a 3D model can impact how the model is rendered. The user will cycle through the various states using the space bar. The first state features a displacement-mapping where the individual vertexes of the mesh are modified in the vertex shader to give the model a rough texture. The second state features a bump-mapping in which the normals of each pixel are modified in the fragment shader to give the model a textured look while still keeping the actual model completely spherical. The final state shows what the model looks like without any shader modifications.
Bezier Surface with Control Mesh
Developed using Java, OpenGL and GLSL
This application demonstrates how using a control mesh and Bezier interpolation can allow the user to create a smooth, curved surface. The user can move each control point in the control mesh by left-click and dragging it with the mouse, can cycle through the control points using the space bar, and can rotate the view by left-click and dragging the mouse. When a control point is modified, the vertex shader adjusts each vertex of the surface using a Bezier interpolation algorithm to create a smooth transition between control points. Specular lighting and a bump-mapping in the fragment shader are added to help the user visualize the surface.
Mandelbrot Fractal using Shaders
Developed using Java, OpenGL and GLSL
This application demonstrates how shaders can be used to handle complex algorithms in the GPU rather than taking up resources in the CPU. In this example, the application displays a Mandelbrot fractal which is built dynamically inside the GPU using a fragment shader. The user is given controls on the left side of the screen to allow them to adjust specific components used to generate the fractal. The user can modify the x and y start positions, the x and y end positions, and the number of fractal iterations.
Particle Effects with Kinematics
Developed using C++ and OpenGL
This application demonstrates how particle effects and kinematics can be combined to create an exciting fireworks display. The user can press the a, s, d, f, etc. keys to launch fireworks that takes off at a random angle. The fireworks fly in an arc and explodes into small particles when they reaches their apex. The particles fall and collide elastically with the ground, causing them to bounce a few times before disappearing. The principals shown in this application are commonly found in fire, explosions, smoke, and other common elements of video games. It was built from a basic particle application developed by the University of Pennsylvania (Copyright 2005).
Agent Group Behavior
Developed using C++ and OpenGL
This application demonstrates behaviors autonomous agents can perform in a simple world space. The user has many options on the right side of the screen to allow them to adjust the number of agents, how the agents move, and how they behave. The user sets a point in the world, then instructs the agent to seek, arrive, wander, flee, depart, or avoid obstacles to get to that point. The user can also instruct a group to separate, flock, align, follow a leader, or form a cohesion. It was built from a basic behavior application developed by the University of Pennsylvania (Copyright 2005).
Gesture Recognition using Neural Networks
Developed using Java
A gesture recognition method for body gestures is presented. Image recognition is accomplished by using a color tracking algorithm. Results of the image recognition process are then sent through a feed-forward neural network and trained using a backpropagation algorithm. Training is done over an ensemble using different randomized initial weights to reduce local minima error. Results of testing the trained network are then presented and compared to other methods.