Seth T Kelley
Massive Rendering
To achieve millions of objects on-screen with the player being able to move any of them, we used a heavily modified plugin for compute-accelerated instancing.
A clustered culling algorithm was introduced to pull unnecessary draw calls even before per-instance frustum culling is computed.
We strategically fallback to regular GameObject rendering for special objects to maintain the best tradeoff between fidelity and performance.
Seamless Animal Growth
Built on top of a custom burst-compatible virtualized transform system, and on top of fantastic artwork, Prehistoric Kingdom has seamless growth from infancy to adult!
Bespoke procedural runtime solutions were required to adapt bone lengths and maintain decent animation consistency.
Bypassing Unity's transform system allows us to update all the skeletons of 1000+ animals in realtime!
Human AI and Crowds
Humans use a multi-threaded AI architecture to allow each visitor or staff member to make individual decisions while maintaining high performance.
Crowd rendering is achieved with a heavily modified plugin that enables thousands of instances each with distinct animation control.
All animation is computed on the GPU. The pipeline has received serious optimization work, so that humans can use a wide variety of animations, and even use prop objects efficiently.
Efficient Bone-Capsule Selection
Maintaining classic colliders attached to bones has a serious performance cost.
To solve this, we start with a custom algorithm looks at the mesh skinning data and auto-generates capsule data for every bone.
Then at runtime, we check if the mouse ray is close to the dinosaur. If so, we perform direct ray-capsule intersection checks in Burst.
This provides robust and efficient selection, even with 1000+ dinosaurs present.
Unreal C++ Optimization
As a fun challenge to get more familiar with multi-threading in C++, I helped a fellow game developer optimize particle data conversions in his plugin.
He needed to be able to convert data for tens or even hundreds of thousands of particles. A hefty task for the CPU to be sure.
I was able to improve performance to 400% the original through careful lock-free multi-threading strategies!
Landmass Terrain System
This is a specialized node-based terrain system for Into The Fray. This enables the generation of large optimized land masses, complete with vegetation and procedurally generated settlements.
One of the main challenges was keeping this system fast, flexible, and maintainable. To that end I wrote the code to thread heavily from the beginning, keeping iteration times reasonable.
Additionally, a good amount of code went into custom inspectors to ensure a high degree of usability.
Optimized Dynamic Lighting
The main slow-down with real-time lighting is dynamic shadowing. Baked shadows are limiting, and the shadow settings in Unity don't help much here.
The solution was a script to efficiently pick the highest priority lights to shadow, while letting the sun shadow at a farther distance. This brought a 3-4x performance boost in lighting-heavy parts of my client's scene!
World Streaming Solution
Another solution built for Into The Fray! AssetBundles are used to store unique terrain and vegetation data on disk, compressed and unloaded.
With this streaming setup, parts of the world can be streamed in very efficiently without have to pre-load the entire world into RAM. This means RAM usage and load time are drastically improved.
Circle Pack Enhancer
A client approached me with a circle packing script and told me he wanted it to look less uniform and more natural.
I ended up writing a configurable post-process algorithm that procedurally modified the circles, moving and scaling some of them while removing others.
The next step to solve the overlapping circles was to write an optimized circle collision solver and a better visualization so the client could clearly see the result.
