This reel is an overview of all of the tools that I've created during my time working at Frontier Developments. Please find a brief history and description of each tool in some detail below.
Around the end of every project, I found myself writing a series of reporting scripts to quickly track down animation hot-spots that were taking up too much memory, missing from overlays, weren't being used and anything else that would cause problems shipping the game.
I decided to consolidate all of these reports into a single tool that scanned a given directory for animations and displayed them in a searchable, filterable tree format.
As it scanned each animation, it extracted basic data such as the length and original creator but then it went on to search the game directory for any occurrences of that animation, how they were being built in the game resource structure and any files with related naming.
The resulting tool allowed us to track down a myriad of queries and potential errors quickly and efficiently without having to manually trawl through potentially hundreds of files.
Our team was presented with a scenario where we needed to generate flipped versions of our animations for cases where characters were holding hands. We wanted to be able to mirror the animations in a way that preserved the link between the two rigs.
The result was this simple Animation Mirroring tool. It works in two passes; in the first it stores all the attribute data for each controller in the rig, as well as any constraints in place. This data is then iterated over, inverting the relevant values, creating the mirrored animation curves. The pre-existing constraints are re-reacted on the mirrored controllers in the final pass.
On every game I've ever worked on there's always been parts of the pipeline that would benefit from being automated. I found myself making bespoke exporters over and over for all different kinds of assets and processes, eventually I decided to unify this into a single, adaptable tool.
Batch Exporter was developed from the ground up to be a completely dynamic vessel for any kind of process you wanted to automate.
The team's technical artist or tools programmer can create new actions for the Batch Exporter by creating a single class in the tool's file structure which defines the job's required attributes, pre-export, export and post-export methods.
Each attribute is supplied with a self-validation method and error-logging method with a set of base-checks inherited from the Attribute base class.
The structure of the tool is designed so that the UI is divorced from the underlying code, which allows you do create export jobs in code without running a GUI Maya session.
Details of the export are stored in the Maya scene in JSON format, making re-exporting easy for the next user to inherit the file.
Template Jobs can also be created, which can contain multiple steps in a pipeline - for instance; Export Model, Export Collision Mesh, Export Animation; Create Thumbnail; Append Item to Database; Generate Prefab File for Item...
This reduces many hours of manual wrangling into a one time set up, and then a single button press from then on.
Exporting assets for an in-game cinematic can create a lot of busy work for an animator when it comes to exporting to engine.
The manual process for this involved selecting the objects to export, adjusting the timeline to the required range, picking an export path, naming the file and finally exporting and checking the results. These steps would have to be repeated for every character and prop in the scene and every shot in the cinematic.
Making this into a wizard would make things rather more manageable and save a lot of wasted time that could be spent on animating or iteration.
The wizard detects all of the actors in the scene and creations selection sets from them, detects camera cuts and generates shot-ranges and then allows the user to pick a single path to export to and the naming is generated automatically to match a pre-defined convention.
At the end of the wizard, the user can edit the parameters before final export.
In the future, I'll make this a plugin for Batch Exporter so that the final data is stored in the generic animation format.
Maya does an excellent jobs of letting you see most things in the scene with the Outliner, but sometimes it can be difficult to find very deeply hidden nodes or to just quickly filter by a string.
Inspired by Spotlight-style search bars, I developed Find Nodes to solve this problem.
It's a simple interface that can be docked in Maya's interface and lets you quickly find and select any object in the scene, even the weird ones like "time1".
Sometimes animation needs to be very accurate, to the point of needing to know just what the G-Forces are being applied to an object in motion.
This tool lets you pick a point in a scene and by analysing it's positional delta across the duration of the animation, creates some lovely graphs displaying Acceleration, G-Forces, Height and Speed.
Grid UV Layout
Maya's UV editor lets you align UV's to columns, or rows, but not a whole selection of UV's at once! This is something our artists wanted to do.
Interpreting a selection of UV's as a grid turned out to be a little more difficult than I first anticipated. The solution involved getting the position of every selected vert and "drawing" a cone above them in turn, to see what other positions fall within that cone. From this you can sort the UV's into rows and columns and sort them positionally.
The average vertical and horizontal positions are used to arrange the UV's into a pleasing grid shape.
During the development of one of our projects we needed to be able to create icons for several hundred small building pieces and scenery items. Rendering each one in turn by hand wasn't practical, so I looked into automating the process.
The tool needed to open each Maya file in turn, create a default lighting setup position the camera and render a single square image.
The most difficult part of the tool was in creating a camera that correctly framed the object to be rendered. This was done by gathering information from the scene about what needed to be rendered (only mesh that will be exported for in-game) and then collecting the positions of all the verts in these models.
I then created a camera, rotated to a uniform angle, and using the positions I'd gathered and rather a lot of maths I triangulated the distance I'd need to move the camera back along it's Z axis to perfectly frame the item, plus a small percentage extra for margin. Why didn't I just use Maya's "frame selection"? It wasn't accurate enough, I needed the framing to be pixel perfect every single time so that the resulting icons would be perfectly uniform.
The tool gives the artist the option to create a single icon, or to traverse a whole folder of Maya scenes creating thumbnails.
Modern hardware rendering has come a long way in recent years and it's now common practice to use Direct X 11 shaders in Maya's Viewport 2.0 so that you can more closely see how your model is going to look in-game before you export.
The downside of this, is that when it comes to producing large renders for promotional purposes, all of your materials need to be remade with software-renderer-friendly shaders.
You can produce fairly large Hardware renders by default, but you soon reach a limit that your GPU cannot render above.
We needed to produce Hardware Renders that were in excess of 8k for large banners and so I needed to find a way of overcoming this limit.
I decided the best way was to find a way to break up the scene into small chunks, render them individually and then stitch them together in a final pass. The tool starts by working out how many rows and columns it will need to create all the pieces of the render and then goes about accurately panning the camera across, creating the renders. The camera itself doesn't move as this would cause distortion. Each frame is rendered at double resolution with only the middle 50% used, to prevent the SSAO vignette from creating visible borders.
The result is a tool that can create hardware renders at resolutions of 16k+, if that's what you want.
Switching from Max to Maya means leaving behind a few features that everyone knows and loves. Luckily for us we can remake our favourites in Maya!
Layer Browser is a copy of Max's scene browser, displaying the contents of Layers in a simple tree format. The options to hide, freeze and move objects between layers is made simple with buttons on the front end.
This way of viewing the contents of layers proved so useful, we extended it to Object Sets and Materials also.
Sometimes when you're building levels for a game, you just want to be able to quickly bring in objects from a library of separate models and piece them together in a new scene. This is why I made Layout Tool.
The tool is set up by scanning a folder of models, each one is loaded in turn and a uniform thumbnail is created. These thumbnails are presented to the user as a grid of buttons, which when clicked, immediately brings the object into the Maya scene for placement.
When building the interface, the tool also checks if the model's thumbnail is out of date or if there's a newer version of the model exists in version control. You're able to update both from the interface.
Creating LODs is an important part of game development, and being able to see how your LODs look when they switch models is important to a smooth transition.
For this reason I created LOD Viewer, a simple tool that allows the artist to scrub through all the available LODs in the Maya scene manually, or automatically pick a LOD based on the distance from the target model to the Maya perspective camera.
LOD distances can be imported form the engine's metadata format to ensure that the result matches that of the in-game effect.
Manisets are a simple proprietary file format that list all of the animations in a folder that need to be built by the engine's resource compiler, along with a bunch of flags inform how they get compiled.
Traditionally, these files are edited by hand but that presents a number of problems. Hand editing is slow, prone to errors and the user doesn't always have an encyclopaedic knowledge of the flags available to them and the syntax required to use them.
I made Maniset editor as a way to quickly generate and edit these files automatically, in an interface that felt as familiar as a text editor.
All of the available compiler flags are visible on the front end with pre-populated drop down boxes which intelligently suggest appropriate usages for these flags.
The tool supports multiple tabs, numerous formatting shortcuts (to keep it all tidy), undo/redo and a recently opened history menu.
This was a bespoke tool made for Planet Coaster.
It allows the artist to load a master character file (that contains all the mesh pieces that make up a crowd guest) and generates sliders to pick and choose which combination of meshes you want to make a character.
This was handy for making marketing materials, as well as looking for combinations of clothing that could cause problems when they went into game.
Pose Library was the result of a collaborative effort to create a tool that would allow the animators to store and share poses in a simple way. My main contribution to the tool was creating the matrix maths that allows for the pasting, mirroring and storage of poses as well as various expansions to the UI.
The animator can save any pose by selecting a single object in a character's rig and paste it back on another frame with a single click.
Various options are available for pasting, for instance you might want the pose exactly where it was previously in world space, or local to the position of the character now. You might even want to 'pin' part of the rig and paste the pose relative to that (like a foot in a walk cycle) or paste relative to another object.
The tool is capable of mirroring a pose in X, Y and Z (don't know why you'd ever mirror in Y) but rather than just flipping the rig's attributes, the tool does a complex comparison of the pose to the character's bind pose allowing for irregular and asymmetrical rigs to be mirrored.
All mirroring matrices are stored when the pose is saved, to reduce the time when the pose is pasted.
Version control integration allows poses to be quickly shared around a whole animation team.
When working with a large scene with multiple references, such as a cut-scene, it can be useful to see at a glance which of these references files are out of date and need updating.
This tool scans the scene for any file included in version control and retrieves their status. Any items in the scene that are out of date can be updated and reloaded from the interface, ensuring that you're always working with the most up to date materials.
This is another Max feature that we missed after we switched.
Snapshot tool simply combines a bunch of meshes and cleans up all the history and groups to leave you with a single, clean snapshot mesh of the selection.
Also, mostly for fun, I've added the "snapshot frames" functionality which will go along the timeline making a snapshot on each frame leaving you with a lovely 3D sculpt of your animation! Very useful for promotional materials or just nice desktop wallpaper.