Creating a Scaffolding Generator for Unreal Engine in Houdini

Akio Inagaki has shared a comprehensive breakdown, detailing the working process behind the Houdini-powered procedural scaffolding generator, explaining how instancing was used, and revealing how procedural materials were integrated.

In case you missed it

You may find these articles interesting


Greetings! My name is Akio Inagaki, a passionate 20-year-old student, currently immersed in my second year of studying Game Graphics Production at Howest Digital Arts & Entertainment, with a particular focus on the captivating world of technical art. It all began when I embarked on a Procedural Introduction course last year, where I was challenged to create a procedural vintage skyscraper using Houdini. This experience ignited my fascination with Houdini's procedural approach, propelling me into a world of endless exploration and learning.

Before diving into the exciting journey of developing the scaffolding generator, I had the privilege of contributing to several projects that allowed me to refine my skills. Collaborating on game prototypes and engaging in small-scale procedural art experiments were pivotal moments that paved the way for the complexities and challenges of the scaffolding generator project.

Moreover, I am excited to share that I am actively seeking an internship opportunity for the upcoming first semester of 2024. This period presents a valuable chance for me to apply my Houdini expertise and expand my horizons under the guidance of experienced professionals.

Studying Houdini

I made the decision to learn Houdini last year, captivated by its power and potential for procedural workflows.

During my learning journey, I relied on a variety of resources to master the software. I extensively followed Houdini breakdown videos and talks available on platforms like YouTube. Additionally, the JoyOfVex blog on CGWiki proved to be an invaluable resource for diving into Houdini's VEX language. My advice to students interested in learning Houdini is not only to watch tutorials, but also to actively replicate and experiment with the concepts they learn. Houdini has its own unique way of thinking, which can be challenging at first but immensely rewarding once grasped.

Getting Started With the Scaffolding Generator

The inspiration for the scaffolding generator came from the awe-inspiring Project Titan demo created by SideFX, showcasing the benefits of a procedural workflow. Intrigued by the scaffolding tool featured in the demo, I searched for tutorials or resources to understand its construction, but found none. Determined to create my own version, I embarked on the project.

My goal was to develop a real-time, efficient, and flexible scaffolding tool that could be used to construct large-scale environments with ease and interact with the environment. I wanted to enable users to effortlessly modify meshes, materials, and overall aesthetics, all within the Unreal Engine environment.

The Workflow

The setup of the scaffolding generator involved a meticulous process, blending various tools within Houdini to achieve the desired outcome. One of the critical components was leveraging Houdini's point instancing functionality for optimal performance.

To begin, I created point clouds in Houdini and assigned each point a path to an Unreal-ready mesh. These meshes were then seamlessly instanced onto the designated points within the Unreal Engine environment, resulting in the desired scaffolding structure. Some of the additional features I incorporated included stairs, nets, and ground interaction, elevating the overall functionality and flexibility of the generator.

Main Structure Breakdown:

  • Cleaning up the meshes: Initially, I had to clean up the meshes provided by Unreal Engine to ensure optimal geometry for further processing.
  • Adding points to top primitives: I used the top primitives of the meshes to add points, which would later serve as the basis for creating the vertical ledges and the foot of the scaffolding.
  • Projecting points to the ground: Since I wanted the tool to interact with the ground, I projected the newly created points onto the ground mesh. This ensured that the scaffolding maintained a realistic connection to the environment.
  • Calculating height parameters: By calculating the distance between a top point and its projected point, I could determine the number of floors that could fit within the scaffolding. Additionally, this calculation provided essential information, such as the offset distance for the first floor and the height of each floor parcel.
  • Creating floors: Armed with the precise floor parameters, I proceeded to generate a correctly oriented points cloud representing one floor. Using this floor as a template, I duplicated and adjusted the points cloud by the number of floors required, taking into account their individual heights.

Stairs Breakdown:

  • Reusing network elements: To streamline the workflow, I leveraged parts of the existing network used to create the points cloud for the vertical ledges and the feet of the scaffolding. This allowed for efficient reuse of resources and a cohesive overall structure.
  • Creating stair platforms: The stairs required alternating platforms on each floor. To achieve this, I utilized the base floors, which were initially created as planes. By removing unnecessary primitives using the Blast SOP and a Group by Range node, I obtained the desired platforms.
  • Establishing connections between platforms: The challenge arose when connecting the platforms with lines, where only one line was permitted per floor, and the lines needed to alternate sides. As the Add SOP couldn't be relied upon due to point order constraints, I resorted to writing custom VEX script. This script enabled me to create connections between specific points (e.g., 0-2, 3-5, 4-6, 7-9, etc.) within the platforms.
  • Resampling and orienting points: With the polylines representing the connections established, the next step involved resampling the lines and orienting the points appropriately. This preparation ensured that the points were ready for instancing the stairs' steps.
  • Creating the stairs support: The final step in the process entailed constructing the stairs support. Using a sweep node and a custom curve, I followed the polylines to generate the mesh. This approach allowed users to easily manipulate the shape of the stairs support, providing greater customization options.

Rosette Rings Breakdown (a rosette is a circular component that connects different parts of a scaffolding structure together, providing stability and support):

  • Modeling the Rosette Rings: I created four distinct Rosette Rings to be instanced in Unreal Engine. These included a corner Rosette Ring, a straight Rosette Ring, a 3-intersections Rosette Ring, and a 4-intersections Rosette Ring.
  • Determining point assignments: The first step in the setup involved determining which points would need to instance each specific type of Rosette Ring. To achieve this, I utilized groups, group promotions, and group combines. These tools allowed me to categorize and combine points based on their intended Rosette Ring type.
  • Orienting the Rosette Rings: The most challenging aspect of this process was correctly orienting all the Rosette Rings. To accomplish this, I employed a technique where I looped over the floor primitives and temporarily moved them to the center of the scene. This centralization step enabled me to assign the points to the appropriate orientation based on their world positions. Once the orientations were determined, the points were moved back to their initial positions.
  • Applying instancing: The final step involved adding instancing to the assigned points, effectively placing and replicating the corresponding Rosette Rings throughout the scaffolding. This instancing feature provided efficiency and allowed for consistent placement and distribution of the Rosette Rings.

Leveraging Houdini's Instancing

Houdini's instancing capabilities played a crucial role in the success of the scaffolding generator. As one of my primary goals was real-time performance and scalability, object instancing alone was insufficient. To address this, I utilized point instancing within Houdini.

Point instancing and object instancing are two methods used in computer graphics to efficiently duplicate and render multiple instances of an object. Here's a simple explanation of both concepts and a comparison between them:

  • Point instancing involves duplicating an object at specific points in a scene. Instead of creating individual copies of the object, a single instance is created and referenced at multiple points. Each instance maintains its unique position, scale, and orientation, allowing for variation in the placement and appearance of the duplicated objects. Point instancing is often used when you need precise control over the location and attributes of each instance, such as when scattering objects across a terrain or distributing trees in a forest.
  • Object instancing, on the other hand, involves duplicating an entire object or geometry. It creates multiple independent copies of the original object, each with its own position, scale, and orientation. 
    The point instancing approach not only facilitated real-time rendering but also enabled easy modification and scalability for large-scale environments.

Integrating Procedural Materials

To provide users with flexibility in material customization, I integrated procedural materials created in Substance 3D Designer. These materials were designed with exposed parameters, allowing users to tweak and experiment with different variations and styles. You could, for example, change the name written on the kickboard, the condition of the scaffolding, the colors, or you could just swap the default meshes with your custom-made assets to match your desired aesthetic. By empowering users to adjust material properties within the Unreal Engine environment, the scaffolding generator becomes a versatile tool that adapts to their creative vision and aesthetic preferences.


While creating the points to instance Unreal meshes was a relatively straightforward process, the real challenge lay in correctly orienting and assigning specific meshes to each point. One of the most difficult aspects of the project was the placement and orientation of the rosette rings. To tackle this, I had to meticulously determine which points should instance which rosette ring type and then orient those point groups accordingly. To achieve this, I moved each primitive to the center of the world and used their positions to assign them to the desired rosette ring type group. Quaternion transformations were then utilized to precisely orient the points in the required direction. This complex process ensured that the scaffolding generator achieved the desired level of accuracy and visual fidelity, despite the inherent challenges involved.

Developing the scaffolding generator was a challenging endeavour, especially while balancing it with my other coursework. Although I had initially intended to allocate more time, my commitment to maintaining high grades in my other courses limited the available development time.

Consequently, I had to rework various aspects of the tool and incorporate unfinished features that I had envisioned, such as stairs, nets, and additional point instances. Despite these challenges, I persevered and managed to bring the project to fruition.

Thank you for investing your time in reading my breakdown. I sincerely hope that you have found the information valuable and gained some intriguing tips from it. It has been a pleasure for me to share my insights and experiences. If there are any additional questions or if you would like to delve deeper into any specific aspects, please do not hesitate to reach out!

Akio Inagaki, Houdini Artist

Interview conducted by Theodore McKenzie

Join discussion

Comments 0

    You might also like

    We need your consent

    We use cookies on this website to make your browsing experience better. By using the site you agree to our use of cookies.Learn more