UGC - Map Editor

Introduction

I was contracted by Scattershot as Senior Tech Artist to work on the User Generated Content (UGC) Tools for their competitive FPS title Project Athena. The UGC Tools were supposed to be a set of tools that would allow players to create maps, game modes and skins for characters and weapons directly in game.

I have worked on the tools together with an engineer colleague of mine, Giulio Auriemma, and our responsibility were roughly split this way:

• Giulio was responsible for the overall code architecture, data serialization, server communication and game runtime
• I was responsilbe for the runtime mesh modeling and rendering

We started working on the map editor, which would then set the foundations for all other UGC tools.

Here is a quick video of me demostrating the mesh modeling tools we have implemented.

Technical Details

Building a map editor, or UGC tools in general, is quite an undertaking, and this was my first professional experience with the Unreal Engine and C++. So I’ve started my task by researching what the engine source code had to offer.

After a couple of days of research and exploration I found two internal modules that became the foundation of our UGC implementation, namely the Mesh Modeling Toolset and the Interactive Tools Framework. These modules are used by the Unreal Engine Editor to enable all of their modeling modes and tools.

These modules are internal to the engine, are supposed to be used within the editor, but luckily they are not editor module. That means that we could use them at runtime, but we had to figure out what classes and functionalities we needed to code to make the modules work at runtime, from within the game.

I ended up writing a non trivial amount of C++ code to expose all the needed modeling tools and to create an implementation of the Interactive Tool Framework runtime within which all the tools were managed. The framework in particular exposed functionalities like managing the active tools, gizmos, actors interactions like selection and transform, and the undo/redo system.

Finally, all the mesh modeling and tools interactions I wrote were rendered into a separate editor window (as you can see from the timelapse above). My colleague Giulio was responsible for this part of the work. This specific functionality (running the map editor into a separate window) proved to be one of the most complicated to implement, since we were not allowed to make engine modifications. This added quite a degree of complexity to our task, but allowed us to implement features, like Docking UI, that are really useful to a user workflow working with our tools.

Here is another quick video showcasing the Docking UI.