Building procedural game assets with Houdini

PDG (Procedural Dependency Graph) is a recently added feature in Houdini. It is meant for building networks (not just chains) of tasks, where each task might have some sort of dependency on others and Houdini then knows how to execute the graph in an optimal way – by executing some operations in parallel or distributing them on multiple machines. It works by processing “work items“. Each work item is passed down the network from node to node and can hold attributes (similar to geometry attributes – strings, numbers etc.). A task in a PDG network can be, for example – cooking a Houdini network and getting it’s result or doing some Houdini unrelated tasks – like executing Python scripts, running  command line applications or even spawning even more work items or modifying their attributes.

In order to create any pipeline with PDG, you must have a way to generate work items and each work item must hold all necessary information. Your PDG pipeline can be just a chain of dependant operations, but the real magic happens if you can execute several things in parallel  – like generating a bunch of game assets or simulating 50 different explosions. If that is the case, you must build your projects in a specific – PDG friendly way.
When executing PDG network, separate Houdini instance gets spawned for processing each work item. Imagine opening HIP file and just having access to attributes stored in one work item.  Based on these attributes, your HIP file should be able to do just that one part of whole work independantly, without doing anything extra – for example generate just one specific asset and nothing more. You do that by referencing PDG work item attributes in your setup. For example, if your pipeline should generate different rocks for a game engine, your node setup must be able to generate any single rock just by receving some PDG work item attributes – like random seed, rock type, size. You can reference work item attributes with @attribname syntax in almost any node parameter. There are also built in work item attributes – such as index, frame, input, output and name.  They are automatically generated. You can access them by writing @pdg_attribname.

Speaking about interacting with Houdini from PDG – you actually can’t just tell it to execute some Houdini network. What you can do is three things:

1. Cook an exported HDA (Houdini Digital Asset) and get the resulting geometry which you can save or pass (as intermediate file or keep in memory) to other PDG operation along the work item.
2. Execute (Invoke) Compiled Block inside a HIP file and get it’s resulting geometry like in the first case.
3. Execute a ROP node (Usually a render operation or geometry export operation). In this case, depending on which ROP node it is executing and how it is set up, it might cook entire Houdini network if it is fed into the ROP node.

In my case I chose to use option number 3 to keep things a bit simpler.

After extracting one rock piece to work with, you can forget about PDG. You have just one rock piece with it’s name and that’s it – the rest of your SOP network is built for processing just this one thing. This way, PDG can effectively execute as many parallel work items as your computer memory allows or even among multiple computers if they are available and are configured properly.

Last step of the pipeline is the baking of substance textures.

For that to happen, we first need to generate all the geometry, bake all the utility textures and save them to disk. Then we can use PDG Python Script node and go through all work items and generate command line parameters for the sbsrender utility, which will take input textures from given paths and generate a bunch of output textures in given paths. We do all that just by knowing the work item name attribute – form that we can generate all the input and output names based on our naming convention.

Then we just execute the sbsrender and wait for it to finish.

import hou
import os, sys
import subprocess

sbsRender = r"C:\Program Files\Allegorithmic\Substance Automation Toolkit\sbsrender.exe"
hip_path = hou.hscriptExpandString("$HIP")
os.chdir(hip_path)

substance_name = r"substance\cave_rocks_B.sbsar"
output_path = r"demo2\substance"

piece_name = pdg.strData(work_item, "name")
piece_path_name = piece_name.replace("/","_").lower()
if '.' in piece_path_name:
    out_path_name = piece_path_name.replace(".","_")
else:
    out_path_name = piece_path_name

out_rez = 10

if "wall_block" in piece_path_name:
    out_rez = 12
elif "top_block" in piece_path_name:
    out_rez = 11
elif "boulder" in piece_path_name:
    out_rez = 10

output_size_param = "\$outputsize@{0},{0}".format(out_rez)
tex_base = r"unity\textures"

commandArgs = ('--engine d3d10pc ' + 
               '--input "{0}" '.format(substance_name) +
               'render ' +
               '--output-path "{0}" '.format(output_path) + 
               '--output-name {0}'.format(out_path_name) + '_{outputNodeName} ' +
               '--set-value "{0}" '.format(output_size_param) + 
               '--set-entry Normal@"{0}" '.format(tex_base + "\\\\" + piece_path_name + "_normal.png") +               
               '--set-entry Bentnormal@"{0}" '.format(tex_base + "\\\\" + piece_path_name + "_bentnormal.png") +               
               '--set-entry Position@"{0}" '.format(tex_base + "\\\\" + piece_path_name + "_position.exr") +
               '--set-entry WorldNormal@"{0}" '.format(tex_base + "\\\\" + piece_path_name + "_worldnormal.png") +
               '--set-entry AO@"{0}" '.format(tex_base + "\\\\" + piece_path_name + "_ao.png") +
               '--set-entry Curvature@"{0}"'.format(tex_base + "\\\\" + piece_path_name + "_curvature.png"))
               
result = subprocess.check_output('"{0}" {1}'.format(sbsRender, commandArgs))

That’s it. PDG will wait until this python script finishes for each work item.

As I mentioned earlier, I’m also generating the stalagmites on the ground – each as a separate unique object. Here my setup is very similar – I have another TOP network for that, which is almost exactly the same as one for generating rocks. Only In this case I’m creating my work items by iterating over stalagmite seed points and use different naming convention for everything.

For the Collector demo I used Houdini to generate other assets too – like ground sand mesh, destroyed columns and vector fields for particle effects. But because these are single objects, there was no point in using PDG for that and I used simple manual approach where I bake and export everything manually.

Last thing I wanted to add is that because Houdini is so awesome, I can have everything inside a single HIP file – all my subnetworks that do different things. It’s very very handy to have everything together.

This is unrelated to Houdini, but importing everything in Unity and setting up all the materials and mesh parameters, can also be a tedious task – especially if your pipeline is generating large amount of assets. What you can do is to write a custom asset import script called AssetPostprocessor
that gets executed in Unity Editor whenever an asset is being imported or re-imported. In this script, you can easily add your custom asset processing logic – for example, I added automatic material generation based on imported objects name and automatic texture assignment to that material. I also added a feature that checks if texture name contains the string “_normal” and if it does, marks the texture types as normal map. For fbx models, I disable loading animation and creating a rig component for all the static assets.
This way you an create fully automated import pipeline as long as you stick to a predefined naming convention.

CaveAssetPostprocess.cs (Unity editor script file sample):

using System.IO;
using UnityEditor;
using UnityEditor.Presets;
using UnityEngine;

public class CaveAssetPostprocess : AssetPostprocessor
{
    void OnPreprocessModel() 		
    {
       if(assetPath.Contains("Cave/Cave_") || assetPath.Contains("Cave/stalagmite_"))
       {
            ModelImporter importer = assetImporter as ModelImporter;
            importer.generateSecondaryUV = true;
            importer.animationType = ModelImporterAnimationType.None;
		    importer.importAnimation = false;
       } 
    }

    void OnPreprocessTexture()
    {
        if (assetPath.ToLower().Contains("_normal.") || assetPath.ToLower().Contains("_bentnormal."))
        {
            TextureImporter textureImporter = (TextureImporter)assetImporter;
            textureImporter.textureType = TextureImporterType.NormalMap;
            textureImporter.convertToNormalmap = false;
            textureImporter.maxTextureSize = 4096;
        }

    }

    Material OnAssignMaterialModel(Material material, Renderer renderer)
    {
        //Automatic material creation of cave pieces
        if (assetPath.Contains("Cave/Cave_") && assetPath.Contains(".fbx"))
        {
            string pieceName = assetPath.Substring(assetPath.LastIndexOf("/") + 1);
            pieceName = pieceName.Substring(0, pieceName.Length - 4);
            //Debug.Log("Importing cave piece!! " + pieceName);

            string mtlName = pieceName + ".mat";
            string[] mtls = AssetDatabase.FindAssets("mtlName", new[] { "Assets/_SCENE/Props/Cave/Materials" });

            Material pieceMtl = null;
            if (mtls.Length == 0)
            {
                pieceMtl = new Material(Shader.Find("HDRP/LitTessellation"));
                pieceMtl.name = pieceName;
                AssetDatabase.CreateAsset(pieceMtl, "Assets/_SCENE/Props/Cave/Materials/" + pieceName + ".mat");
            }
            else
                pieceMtl = (Material)AssetDatabase.LoadAssetAtPath(mtls[0], typeof(Material));

            if (pieceMtl != null)
            {
                Texture2D baseColor = (Texture2D)AssetDatabase.LoadAssetAtPath("Assets/_SCENE/Props/Cave/Textures/" + pieceName + "_basecolor.png", typeof(Texture2D));
                Texture2D normalMap = (Texture2D)AssetDatabase.LoadAssetAtPath("Assets/_SCENE/Props/Cave/Textures/" + pieceName + "_normal.png", typeof(Texture2D));
                Texture2D bentNormal = (Texture2D)AssetDatabase.LoadAssetAtPath("Assets/_SCENE/Props/Cave/Textures/" + pieceName + "_Bentnormal.png", typeof(Texture2D));
                Texture2D masks = (Texture2D)AssetDatabase.LoadAssetAtPath("Assets/_SCENE/Props/Cave/Textures/" + pieceName + "_masks.png", typeof(Texture2D));

                pieceMtl.SetTexture("_BaseColorMap", baseColor);
                pieceMtl.SetTexture("_NormalMap", normalMap);
                pieceMtl.SetTexture("_BentNormalMap", bentNormal);
                pieceMtl.SetTexture("_MaskMap", masks);

                pieceMtl.EnableKeyword("_NORMALMAP_TANGENT_SPACE");
                pieceMtl.EnableKeyword("_NORMALMAP");
                pieceMtl.EnableKeyword("_BENTNORMALMAP");
                pieceMtl.EnableKeyword("_MASKMAP");

                pieceMtl.shader = Shader.Find("HDRP/Lit");

                return pieceMtl;
            }
            else return material;
        }

        if (assetPath.Contains("Cave/stalagmite_") && assetPath.Contains(".fbx"))
        {
            string pieceName = assetPath.Substring(assetPath.LastIndexOf("/") + 1);
            pieceName = pieceName.Substring(0, pieceName.Length - 4);

            string mtlName = pieceName + ".mat";
            string[] mtls = AssetDatabase.FindAssets("mtlName", new[] { "Assets/_SCENE/Props/Cave/Materials" });

            Material pieceMtl = null;
            if (mtls.Length == 0)
            {
                pieceMtl = new Material(Shader.Find("HDRP/LitTessellation"));
                pieceMtl.name = pieceName;
                AssetDatabase.CreateAsset(pieceMtl, "Assets/_SCENE/Props/Cave/Materials/" + pieceName + ".mat");
            }
            else
                pieceMtl = (Material)AssetDatabase.LoadAssetAtPath(mtls[0], typeof(Material));

            if (pieceMtl != null)
            {
                Texture2D baseColor = (Texture2D)AssetDatabase.LoadAssetAtPath("Assets/_SCENE/Props/Cave/Textures/stalagmites/" + pieceName + "_basecolor.png", typeof(Texture2D));
                Texture2D normalMap = (Texture2D)AssetDatabase.LoadAssetAtPath("Assets/_SCENE/Props/Cave/Textures/stalagmites/" + pieceName + "_normal.png", typeof(Texture2D));
                Texture2D masks = (Texture2D)AssetDatabase.LoadAssetAtPath("Assets/_SCENE/Props/Cave/Textures/stalagmites/" + pieceName + "_masks.png", typeof(Texture2D));

                pieceMtl.SetTexture("_BaseColorMap", baseColor);
                pieceMtl.SetTexture("_NormalMap", normalMap);
                pieceMtl.SetTexture("_MaskMap", masks);

                pieceMtl.EnableKeyword("_NORMALMAP_TANGENT_SPACE");
                pieceMtl.EnableKeyword("_NORMALMAP");
                pieceMtl.EnableKeyword("_MASKMAP");

                pieceMtl.shader = Shader.Find("HDRP/Lit");

                return pieceMtl;
            }

        }

        return material;

    }

}

I hope this was useful to someone. This was not meant as an exact step-by-step tutorial on how to create something, but more like general overview about all the different steps  required to put together a pipeline like that and reasoning behind those decisions. I spent a lot of time going through all of this by trial and error. I hope this allows for you to save some time.

Don’t hesistate if you have some questions or suggestions – I would be happy to answer them.