Additional Projects

A further selection of my technical work - please visit GitHub to see more!

1. Rigidly-bound USD Prim Instancing

2. WebGL Tiny Planet

3. Shader Fun - Various Vertex and Fragment Shaders

4. Unreal Engine Collaborative VR Game

5. Unreal Engine 2-Player First Person Shooter

6. Unity Physics Invaders Game

7. Real-Time Motion Blur and Lens Flare

8. Micro Minecraft

9. Particle Systems

10. Toys We R Short Film

Rigidly-bound USD Prim Instancing

Utilizing the USD Python API, created a LOP node that allows for the Instancing of rigidly-bound objects in the scene. Memory concerns are one of our largest challenges, and this tooling allows any objects that are rigidly bound such as hats, props, shoes, costume elements and more to be loaded into memory only once regardless of how frequently they appear in the shot. In a large crowd, this can result in very significant savings on the memory footprint. The tooling pairs with a setup in Katana to ensure that these objects as they exist in the USD shot bundle are successfully instanced at render time. The tooling is proprietary to LAIKA Studios and is not publicly viewable.

WebGL Tiny Planet

A real-time, interactive planet whose God (You!) can modify things at will. Change the terrain, the size of the mountains, the color of the ocean, and more! It can also animate to music of your choice! Implemented using WebGL and coded in TypeScript and GLSL using Visual Studio Code. It utilizes Node.js and the user interface is implemented using npm’s dat.GUI. The project uses a variety of noise functions, most prominently 3D Fractal Brownian Motion. It uses a vertex shader to modify a subdivided icosphere to create mountains, oceans, and plains. It then uses a fragment shader to color the terrain in a natural-looking way according to the elevation and latitude.

Code: https://github.com/ndevlin/noisy-planet

Live WebGL Demo!: https://ndevlin.github.io/noisy-planet/

Shader Fun

Implemented various vertex and fragment shaders as part of an interactive GUI. The shaders are written in GLSL using the OpenGL API and all run in realtime on the GPU. There are both surface shaders and post-processing shaders.

Surface shaders: Toon Shader, Matcap, Color Gradient, Spherical Rainbow Vertex Deformation, Shrinking Red Vertex Deformation, Blin-Phong, TV Surface Noise

Post-Processing Shaders: GreyScale Vignette, Gaussian Blur, Sobel, Bloom, Worley Noise, Pointillism, RGB Warp, Outline, Motion Blur, Lens Flare

Code: https://github.com/ndevlin/ShaderPlayground/tree/master/project_package/glsl

Unreal Collaborative VR Game

“Robbing The Bird’s Nest” - Did you ever see yourself in Mission Impossible or Ocean’s 11, working as a team to break into a vault to nab the valuables before you get caught? Now you’ll have the opportunity to see if you have what it takes! One player will strap on the VR headset and infiltrate the vault to steal the treasure, the other will observe from above, helping them navigate through the vault, solve puzzles, and avoid being detected.

Players must interact in real time and work together to get in and get out safely. The player with the VR Headset, the "Worm", will move through the space, avoid obstacles, look for clues, and avoid being seen. The player at the computer, the "Bird," can see the whole scene from above, modify the lighting in real time to help the Worm, and manipulate the environment in other ways. The Worm will see these changes live and can interact with the virtual world accordingly.

This game was implemented using Unreal Engine, Steam VR, and the HTC Vive Pro. Blueprints were used extensively to handle the game logic, input from the computer and the VR headset, and more.

Code: https://github.com/ndevlin/RobbingTheBirdsNest

Unreal Engine 2-Player FPS Game

A unique take on the traditional First Person Shooter. The game uses networking through Steam to allow 2 players to face off over the internet. In the first round, players map out their path and acquire ammunition. Then, in the second round, players retrace their steps from the first round, moving forward or backwards in time, and trying to eliminate their opponent before they themselves are eliminated.

Created using Unreal Engine and C++; Visual Studio and Steam were also used.

Code: https://github.com/anthonymansur/TimeWarp

Unity Physics Invaders Game

A 1-Player Desktop game created using Unity and C#. The game is modeled on the classic Space Invaders game, but there is a twist; Enemy ships, when hit, will fall onto the playing surface, and you must clear the debris away while playing. The logic of the game is implemented using an Object Oriented structure in C# within the Unity Engine. Visual Studio was utilized for the C# portions of the project.

View the GitHub below to view the code or try out the executable:

Code: https://github.com/ndevlin/PhysicsInvaders

Real-Time Motion Blur and Lens Flare

Created at Analytical Graphics Incorporated (AGI). Added real-time post-processing effects that simulate motion blur and lens flare to the pre-existing, massive rendering engine of AGI’s flagship software, Systems Tool Kit (STK). The project was implemented in C++ using GLSL and OpenGL, in Visual Studio. At the beginning of the project, I created a prototype version of each effect for testing purposes before implementing the algorithms into STK. As the actual code is proprietary, the below code represents the shader code from these prototypes.

Code: https://github.com/ndevlin/ShaderPlayground/blob/master/project_package/glsl/post/gaussian_copy.frag.glsl

Micro Minecraft

Led a team to create, from scratch, a simplified version of Minecraft playable in real time, including player physics and advanced lighting and texturing. The game is capable of infinite expansion like real Minecraft, using a Fractal Brownian Motion 3D noise function. It also features animated textures with mipmapping, realistic lighting and shading, and transparency sorting. The project was implemented in C++ using Qt Creator and the OpenGL API. Please note that the below project is private and thus you will need to contact me to access the code.

Code: Please contact me to see the code for this project, as it is set to private on GitHub

Particle Systems

A particle systems simulator that creates a 2-dimensional, physically accurate fireworks simulation. The project was implemented in C++ using Visual Studio. Forces are calculated on the rockets and on each particle to accurately simulate their movement and interaction.

Code: Please contact me to see the code for this project, as it is set to private on GitHub

Toys We R Short Film

Created a 1-minute avant-garde animated short film using Blender. Wrote, modeled, animated, and lit each shot of the film over the course of 4 months.