A pulp fiction adventure of turn based tactics and real time stealth.

This was the primary studio project being worked on during my time at Harebrained Schemes and, while I was technically on the Core Tech team, I worked directly on it for art pipeline programming, along with helping with design and implementation of studio-wide tooling and libraries.

The Environment Art Pipeline⌗

The biggest thing I did directly on the Lamplighters League project was rebuilding and extending the game’s environment art asset pipeline, which was responsible for getting raw assets out of Maya and Blender and into the game in a usable state for level design. There were two steps to this that I was involved with: a Python postprocessing utility called automatically during export from the artist’s software and the import pipeline actually within Unity.

The Python Postprocessor⌗

The bulk of the work was in the Python tool. When I was given ownership of it, it was a very basic, ad-hoc Python script that did some metadata scraping on assets to merge meshes (eg: grouping things like walls, gameplay specifiers, etc). It worked for the purpose, but was very clunky and hard to extend, used the system Python installation, and required significant manual setup with a special local Blender installation. The main task at hand was to add an additional step that automatically generated tuned LODs (level of detail meshes) for assets using the Simplygon library.

Because the existing code wasn’t much to build on, and because making clean, reusable tooling is sort of the thing Core Tech did, I got to work completely rebuilding everything. This led to the discovery that we had very little in the way of existing Python tooling and libraries, which led to a very large amount of rework there that I talk about in the Core Tech project page.

Ultimately, I ended up building this tool into a fully featured CLI application that could be used both as a drop in replacement for the existing script and as a batch utility to reprocess thousands of existing art assets. It was developed to be as modular as possible so that more steps could be added if needed, and so any individual part could easily be extracted out into a separate library. The tool was a full Python package that could be uploaded to an index server and deployed with no additional local dependencies.

The Unity Importer⌗

The other major area of the pipeline was within the Unity project itself, which handled final processing of assets during import. This included things like separating out gameplay metadata and collision, asset organization and tagging, and prefab generation/linking. I ended up reworking large sections of the pipeline to allow support for LODs, which introduced many edge cases, especially with existing, legacy assets.

Core Tech Library Integration⌗

While I didn’t normally work directly on the game, I was involved with the integration of several Core Tech libraries into the project, including tools for debug drawing, procedural flowmap generation, and video playback. This typically involved either implementing the bridging logic myself or working with engineers and tech artists to adapt things to meet their specific needs.