Presented by SideFX
With game developers under the gun to produce larger worlds, more engaging realism, and higher quality gameplay, it’s never been more challenging to bring games to life - under crushingly tight deadlines. That’s why it’s more important than ever to have smooth, efficient pipelines - using the most up-to-date software technology - so game producers know their teams’ efforts are focused on the highest value creative contribution, and are able to iterate quickly to achieve high-quality art direction.
Procedural automation, used by Houdini tech artists, can accelerate tasks that would traditionally take a much longer time. Just a few of the tasks that can benefit from a procedural approach include Asset Validation to make sure assets work properly in-game, process review using Shotgun in support of a collaborative environment, data generation that would require the participation of a tech artist, and last but not least an efficient photogrammetry pipeline.
I am a tech artist at SideFX Software working to provide tools for Game Developers looking to take advantage of procedural workflows in Houdini. These workflows are published on SideFX Labs, a testing ground for over 150 tools and assets that wrap up common workflows and create tight integrations with software you use everyday. These tools are developed outside the regular Houdini development cycle which makes them more accessible for testing and feedback and some of them will be used in the following examples.
Automated Asset Validation
Having assets with proper manifold geometry, UVs, vertex color and potentially even collision geometry and many other attributes such as Vertex Colors are important. Since we’re all human and can make mistakes, it can easily happen that someone forgets to add the required additional UV channels our shader artist desperately needs. It might also just have been deleted by accident when exporting these out of Houdini, Maya, 3dsMax, Blender etc.
So how do you find these kinds of problematic assets? Well, you could either wait until someone complains (potentially after releasing the game!), or search for them proactively and spend a lot of time. My preference is doing this proactively, especially since it can be fully automated.
With Houdini’s Procedural Dependency Graph (PDG) technology, you can very easily automate many of these mundane tasks using a simple network of nodes describing the steps you would usually do by hand. These tasks can then be processed on your local machine or distributed to a larger compute farm or even greater efficiency. In this first example, we will look at how to check for the presence of specific attributes on an entire asset library of data. This is just a simple example you could extend to any project-specific requirements you might have.
The above node network shows the entire process of checking for the existence of the following properties on the geometry: UV, UV2 (lightmaps / blend), vertex colors (incl alpha) and vertex normals. The attributes being checked are controlled by a parameter that can be easily changed by anyone on the team. You may have done something similar using a Python script, but that: (a) requires you to know Python, (b) doesn’t give you multithreading out of the box for parallelized processing, and (c) doesn't have the nice visual way of accessing and using a massive library of geometry processing tools that Houdini has.
Once the tool has run, you get a log similar to the one below, describing all the issues found. You could even have this automatically sent to the respective artist in charge of these assets.
(Cd in Houdini means vertexcolors)
The above shows which files have been tested and what their issues are - making it easy to find problematic files and fix them.
Automated Asset Reviews with Shotgun
The next thing we will be looking at is the automation of rendering, uploading & updating asset thumbnails on Shotgun, once again using PDG. Assets can (and will) change a lot during development - and each asset’s thumbnails should also change so you can easily find which is the right asset using the latest information. A popular and frequently used tool to manage and review assets at a large scale is Shotgun. From their website: “Shotgun is software that simplifies creative project management and unifies visual effects (VFX), animation, and games teams of all sizes.”
Artists make many small fixes and tweaks to data whenever some issue or new requirement arises during development, and when on tight deadlines they might not always take the time to update the status on Shotgun or other similar platforms. So, similar to the Asset Validation covered earlier, this process needs to be automated as much as possible.
Thankfully Paul Lemeshko did a talk at the Houdini 18.5 HIVE about PDG interfacing with Shotgun using the “Publisher Tool” to render CG assets with multiple light rigs and publish them immediately.
In his talk, he shows a spaceship being rendered using several different light rigs. This leaves artists with two approaches for automating this process: (1) Running the Shotgun publishing tool manually with highly art-directable settings (be able to tweak lights and camera placement specific to the current asset), or (2) Generating thumbnails / turntables automatically for an asset database similar like the Asset Validation example.
Example of the results achieved with the free publishing tool on the SideFX Content Library.
Being able to do this automatically will once again massively improve the iteration speed of the artists, since they do not need to spend a lot of time on mundane tasks such as updating asset status.
To get a game to run smoothly you need LODs! Level Of Detail (LOD) for 3D models means decreasing the complexity of a mesh as it moves away from the camera (or other metrics). A mesh needs a lot of detail when being inspected from nearby, but does not need as much detail when being looked at from a distance to maintain its look.
Making LODs can be quite tedious, especially if they are for geometry that aren’t considered “hero objects”, such as characters or key objects in gameplay. Nobody likes making LODs for small props that are scattered around and only really function as filler objects. So why don’t we all collectively agree to generate these semi-automatically?
To get proper LODs, we need to first have a piece of geometry that functions as our LOD0. The goal is to generate copies in decreasing levels of complexity based on that input. While doing so, we need to preserve the UVs or regenerate them to consolidate the materials.
As an example we’ll be running this mesh from Quixel Megascans through the LOD Create tool from SideFXLabs. By default it will generate polyreduced versions of it, and all the artist needs to do is specify how much each LOD should be reduced by.
By clicking the “Debug all LODs” checkbox, we can see the total chain of generated meshes. As expected, each LOD is reduced in complexity and even has an impostor as the last LOD. Impostors are basically just an orthographic 2D render of the geometry, that gets assigned to a billboard mesh in the distance (very useful for rendering a forest of trees cheaply).
Once you tweak the values to your liking, you hit export and import it to your engine of choice. That’s it. The tool even has a preset system so you can import your own pre-made configurations for easy processing of many assets. The nice thing about this is that you could once again use PDG to process a whole library of assets at once, and tweak the results. Another benefit of using this tool is that it is fully open source, meaning you can dive inside and change any of the steps used to generate the LODs. Don’t like how it polyreduces? Change the approach to use your own.
Data Driven Development
Generating large worlds can be very time consuming and expensive. But what if you didn't have to create everything from scratch, and were able to use real-world data that apps such as Google Maps use? Well you’re in luck! Using OpenStreetMap data you can import things such as road curves, building profiles, lakes, rivers and much more (including large amounts of metadata).
Similarly, wouldn’t it be great to import pre-existing Digital Elevation Maps (DEM) and satellite data for real world locations? That’s what MapBox can help with.
Using the SideFXLabs OSM node, an artist can simply import any area of the world from Open Street Map and get it as curves and primitives in Houdini. It really is as easy as browsing to your preferred location and hitting download. The resulting file gets loaded with the tool - and voila.
A nice example of this workflow in action is Insomniac Games’ Spiderman. In that game, the building blockouts are most likely made by hand by artists (or generated), but data-wise they are very similar. They are data-driven with a set of metadata affecting how the buildings and roads are generated.
Mapbox is a location-data platform that powers the maps and location services used in many popular apps. Mapbox also provides enterprise-grade location, traffic, and movement data, and APIs for routing, navigation, and delivery matrixing. So the data is very rich and perfect for driving procedural world generation.
Browse to the location anywhere on earth you’re interested in with the map browser, select a map style (satellite scan, custom style, etc) and hit download. You get a native Houdini Heightfield/Terrain, with all the maps correctly assigned. Artists and worldbuilders are now able to use this data as reference or a starting point for their environments. So what is it you could do with it? Generate amazing worlds for use in Unreal Engine for example.
Check out this amazing block showcasing the progress on “Flak Jack”, a project by Sandy Sutherlands using Houdini, Unreal and the SideFXLabs MapBox tool.
“Flak Jack” by Sandy Sutherland http://lippykid.com/blog
Houdini as a Tech Art Toolbox
Houdini is all about the attributes. As people building shaders will know, debugging them can be nearly impossible. How do certain output values get to where they ended up being? With a visual node graph you can easily follow the flow of data and see what happens during that process. The more data points you have access to during debugging, the more likely you’ll be able to find why something is either working or not working.
Prototyping and Debugging Shaders
Valentine Kozin from Rare did a really excellent talk at the SideFX Hive at GDC2019, where he talks about prototyping a raymarching shader for Sea of Thieves in Houdini before building the equivalent in Unreal Engine. Since Houdini is attribute-driven, and points can be used for any purpose, you can have a pointwrangle, with some simple VEX, simulate what a pixel (point) on a screen returns in a shader context. In the image below the results from the intersection tests done in a raymarching shader gets visualized as vertex colors, allowing you to see the results of what it would look like in the engine.
Thanks once again to attributes, you can also even visualize what each ray is doing while bouncing around inside the geometry - something you cannot do while debugging a shader using more conventional means. This makes Houdini an excellent prototyping tool for tech artists, even if the result generated does not directly end up in the game.
Automation leaves time for Artists to Shine
The different examples of procedural automation at work have shown you the benefits of building a gamedev pipeline that supports your artists while tackling critical issues such as validating assets, updating asset information for Shotgun, generating content using sources such as OSM and Mapbox, and providing a general tech artist toolbox. Houdini is being used more and more in gamedev pipelines and here we have only discussed a few of the many ways procedural automation can free up your artists to make better games.
The Next Step: Houdini Engine for Unity and Unreal Engine
Houdini’s procedural workflows, such as those you just learned about, are built using networks of nodes that can be wrapped up into assets that can be shared with other Houdini artists. Through the power of Houdini Engine, these procedural assets built in Houdini with custom-tailored interfaces can be brought into UE4 and Unity, and used by game artists whether they know Houdini or not. Houdini Engine does the processing work on the assets, and delivers the results back to the editor. These procedural assets work within the editor for content creation and are baked out before going to runtime.
SideFX is pleased to announce that Houdini Engine for UE4 and Houdini Engine for Unity are now available for commercial customers for free. Previously free for artists using Houdini Indie, this now gives commercial artists and studios the ability to widely deploy procedural assets created in Houdini to the UE4 and Unity real-time 3D platforms for use in game and XR development, virtual production and design visualizations.
You can learn more at: