#live brief

[beverleygraphics]

Check this out !

[snabshot99]

Final Outcomes from the Live Turner Duckworth Sink or Swim brief. I am really proud of my final logo and web designs they turned out better than I initially thought, this was a great experience working in a professional environment and putting myself to the limit getting this task done in a short amount of time. The main thing I will take away from this task is that it has made me a much more confident speaker when talking or pitching ideas. This has lead me to have confidence in my ability to be a class rep for this year which is amazing.

[yvonnejohnstonhnd2-blog]

Live Brief

See the story

Planning, images and evaluation for the live brief.

[gaurav-bhave]

Post 8: Unreal Engine 5.6 Integration – The Final Renders

Day 25 of the Bit Reactor live brief. This is it. The final stretch.

After weeks of wrestling with nodes, booleans, and procedural math in Houdini, it was time to actually prove that this tool works in a game engine. A generator is useless if it only looks good inside Houdini. The ultimate test for this Technical Environment assignment was bringing the Houdini Digital Asset (HDA) into Unreal Engine 5.6, setting up the materials, and getting the final beauty renders.

The Houdini Engine Magic

I exported the final .hdanc file and imported it straight into my Unreal Engine Content Browser. Because I have the Houdini Engine plugin installed, Unreal natively understands the asset.

Dragging the HDA into my level was a massive moment of relief. It didn't just import as a static mesh; the entire parameter interface I built in Post 7—the sliders for the Destruction Zone, the toggles for the metal armature, and the seed randomisers—all populated directly inside the Unreal Details panel.

I spent a good hour just playing with the sliders, watching the engine pause for a second, communicate with Houdini in the background, and dynamically generate completely new, perfectly UV'd ruined pillars right before my eyes. No modelling required.

The Material Bridge

A procedural mesh still needs textures. Earlier in the pipeline, I added an unreal_material attribute to the geometry streams. Here in UE5, that preparation paid off instantly.

I set up the master materials: a peeling, blueish-grey painted concrete for the outer shell; a rough, earthy brown aggregate for the damaged inner core; and a heavily corroded metal for the rebar. Because I tagged the geometry in Houdini with the exact file paths to these materials, Unreal automatically assigned them the second the pillar generated, perfectly separating the pristine outer walls from the chaotic internal damage.

The Photoroom Setup

When it came to presenting the final tool, I decided against building a full diorama environment. If you put an asset in a busy scene, you can hide bad modelling behind props and heavy fog. I wanted these pillars to stand on their own.

Instead, I set up a clean, dark "photoroom" lookdev environment. By using a pure black backdrop and a crisp, neutral studio lighting setup, there is absolutely nowhere for bad topology or messy booleans to hide. The lighting catches the sharp, procedural edges of the Voronoi fractures and highlights the thick, chunky stylised read of the silhouette perfectly.

To give a sense of scale, I dropped the standard Unreal Engine mannequin into the lineup. Seeing the character next to the generated assets really drives home how massive and imposing these dark fantasy pillars are supposed to feel.

Expanding the Horizon: Procedural Inspirations

Completing this asset has completely shifted my perspective on what it means to be an environment artist today. Relying purely on traditional, manual modelling limits how fast you can iterate on world-building. To push my stylised, SOP-driven workflows further, I’ve been researching some of the best technical artists in the industry who specialise in this exact intersection of Houdini and game environments. If you are learning proceduralism, you need to study these artists:

Simon Verstraete: A senior tech artist famous for his work on LEGO Horizon Adventures and the Project Titan toolset. His ArtStation (artstation.com/siver) is a goldmine for game-ready procedural architecture. He is an absolute master at building incredibly complex, stylised tools (like castle walls, sci-fi panels, and ruins) using highly logical, SOP-focused networks that perfectly bridge into Unreal Engine.

Anastasia Opara: Known for her groundbreaking work at Embark Studios, her approach to proceduralism is incredibly inspiring. She focuses heavily on the underlying logic of how environments naturally form—like her famous Procedural Lake Houses. Her work proves that procedural generation can feel deeply organic, painterly, and art-directed rather than strictly mathematical. You can find her portfolio and resources at anopara.gumroad.com and across 80 Level breakdowns.

Radu Cius: Obviously, the primary inspiration for this specific brief. His ability to break down heavy, stylised destruction into digestible, non-destructive node logic is what made this entire pillar generator possible. (artstation.com/raducius)

The Final Results

The workflow is officially a success. What started as a terrifying blank node graph is now a robust, adaptable tool. In just a few clicks, I was able to generate four completely distinct pillar variations—ranging from mildly chipped to completely hollowed out—ready to be populated across a game level.

[gaurav-bhave]

Post 7: Building the Tool – The Houdini Digital Asset (HDA)

Day 22 of the Bit Reactor live brief. We are at the very end of the project timeline, and today is all about shifting mindsets.

Up until now, I’ve been thinking like a 3D modeller—focused on silhouettes, booleans, and UVs. But this is a Technical Environment assignment. The goal isn't just to make one cool pillar; it’s to deliver a fully functional, user-friendly tool that another environment artist can drop into their scene and use without ever looking at a node graph.

To do that, I needed to package my massive, sprawling network into a clean Houdini Digital Asset (HDA).

The Engine Room: The Switch Nodes

Before I could build a pretty interface, I needed to set up the logic that would actually respond to the buttons an artist pushes.

In my network graph, I built a dedicated purple block for the interface controls. The absolute backbone of this section is the Switch node. A Switch node is basically a procedural fork in the road: if its input is set to 0, it passes stream A; if it's set to 1, it passes stream B.

I wired up a series of these switches to control the heavy operations. For example, calculating the massive boolean for the destruction zones or generating the high-poly wire armature takes processing power. By wiring these through switches, I created "gates" that can entirely bypass those heavy calculations if the user just wants a simple, undamaged blockout pillar.

Exposing the Parameters

With the switch logic in place, I officially collapsed my entire pillar network into a subnet and converted it into an HDA (.hdanc since I'm on the Education Edition).

This opened up the Type Properties window, which is where the real UI design happens. Instead of making an artist dig through 80 different nodes to change the damage scale, I went through my graph and dragged the most important parameters right to the top level.

I focused on giving the user the exact controls they need to hit the stylised art direction from the Radu Cius references:

The Sliders: I exposed the Seed, Size, and Location parameters for the Destruction Zone. These link directly back to the Scatter and Mountain nodes deep in the graph.

The Toggles: I set up simple checkboxes linked to my Switch nodes. Want the metal rebar sticking out? Just check "Add Armature". Want a clean pillar? Uncheck "Add Damage".

A good tool shouldn't let the user break it. One thing I really focused on in the parameter setup was the "Disable When" logic.

If an artist unchecks the "Add Destruction Zone" toggle, there is no reason for them to be tweaking the "Seed" or "Size" sliders—it would just be confusing. In the Type Properties, I added a simple line of logic ({ newparameter4 == 0 }) so that whenever the main destruction toggle is off, all the related sliders automatically grey out and disable. It’s a small UX detail, but it makes the tool feel incredibly professional.

Ready for Unreal Engine 5.6

Looking at the final, clean parameter window floating in my viewport is a massive relief.

This isn't just a Houdini interface; this exact menu is what will populate in Unreal Engine 5.6. Because we are using the Houdini Engine plugin, I will be able to drag this .hdanc file straight into my Unreal Content Browser. When I drop it in a level, I’ll get this exact set of sliders and toggles in the UE5 Details panel, allowing me to generate infinite variations of stylised, ancient pillars live in the engine, perfectly UV'd and automatically tagged with rust and stone materials.

The Houdini pipeline is officially complete!

[gaurav-bhave]

Post 6: The Final Assembly – Cleaning the Graph

Day 20 of the Bit Reactor live brief. We are deep into Week 3, and the heavy lifting is finally done.

Over the last few weeks, I’ve built a jagged internal core, a warped outer shell, perfectly stacked procedural stones, and a twisted metal armature. But right now, it’s just a massive web of disconnected Houdini nodes. Before I can even think about turning this into a usable tool, I need to unify the geometry, optimize it, and make sure the UVs are locked in.

Following the final cleanup stages of the workflow, it was time to dive into the final assembly block.

The Grand Integration

Bringing all these complex procedural pieces together is where a graph either succeeds or completely breaks.

I routed my "Inside Pieces", my "First Level of Detail", and my "Stones" into a massive final Boolean operation. This forced the perfect stones to break and conform exactly to the jagged inner core.

Because procedural booleans can sometimes generate microscopic, useless geometry that ruins game performance, I dropped a Delete Small Parts node right after the boolean. This is a crucial optimisation step for a game-ready asset. It sweeps through the mesh and deletes any floating poly-islands or microscopic slivers of stone, keeping the vertex count clean and deliberate.

UVs and Material Tags

With the geometry unified, I used a Split node to separate the outer stones from the interior core faces. I needed to process their UVs and material tags separately.

Keeping to my native SOPs rule, I ran both streams through UVunwrap to flatten the islands and UVlayout to pack them efficiently.

Even though I plan to handle the final texturing natively in Unreal Engine 5.6, the engine still needs to know how to assign those shaders. On both streams, I used a Attribute Create node to generate a unreal_material string. By tagging these streams with the exact paths to my UE5 shaders now, I am ensuring that when this tool eventually talks to Unreal, the engine will automatically assign the correct materials to the right faces.

The Pivot Point

I merged the two UV'd stone streams back together; added a final subtle Bend to make the pillar feel top-heavy and ancient; and merged it with the twisted metal armature we built last week.

Before finishing the graph, I ran a final gauntlet of optimization nodes: Fuse (to weld any overlapping vertices), Clean, and Soften Normals.

The absolute most important node in this chain, though, was the final Match Size. In game development, an asset's pivot point is everything. I set this node to justify the Y-axis to "Min", guaranteeing that the very bottom of the pillar sits exactly at the 0,0,0 origin. When an environment artist eventually drops this pillar into a level, it will snap perfectly to the floor.

The Backup Plan: ROP FBX

At the very bottom of the network, I added a ROP FBX Output node.

To be clear, exporting a static FBX isn't the final goal here—that defeats the purpose of a procedural generator! However, it’s a necessary backup. Having the ability to click a button and spit out a baked FBX means I have a clean mesh ready to go if I ever decide I want to take this asset into Substance Painter for a bespoke hero-prop texturing pass.

Next up: The node graph is 100% complete and optimised. But an artist can't use a web of 100 nodes. In the next post, I’ll be wrapping this entire system up into a Houdini Digital Asset (HDA), building a clean user interface, and bringing it live into Unreal Engine via the Houdini Engine plugin.

[gaurav-bhave]

Post 5: The Armature – Building the Metal Skeleton

Day 14 of the Bit Reactor live brief. We are closing out Week 2, and the pillar is really starting to come together.

I have the beautifully warped outer stones and the jagged inner core, but there is still a massive piece missing. When ancient pillars crumble, they don't just break into clean rocks; they reveal the internal structure holding them together. To really sell the stylised, heavy destruction from Radu Cius's references, I needed to build the internal metal armature—the exposed rebar.

Step 1: The Base Armature (Setting the Height)

Before generating any dense wire meshes, I had to build the main structural frame. This is the backbone of the armature system.

Bringing in a reference to my base mesh, I used a combination of Line and Tube primitives. The Line nodes are critical here—they act as the master controllers for the height of the metal skeleton. By using Match Size and Copy to Points, I instanced the tubes along these lines to create the thick outer brackets of the cage.

Because the lines dynamically reference the height of the overall pillar blockout, this ensures that if I make the pillar 20 feet taller, the metal skeleton scales up perfectly with it.

Step 2: The Inner Armature (The Wire Mesh)

Once the main structural frame and height were locked in, I needed to fill the void inside it with a dense, intersecting wire grid.

Building this by hand would take hours. Procedurally, using native Houdini SOPs, it took a handful of nodes. I generated a bounding box based on the structural space, then used a Divide node to slice that box into a 3D grid of lines.

Instead of manually extruding cylinders along all those intersecting lines, I dropped down a pair of Wire nodes. Instantly, every single line in that grid was given a physical thickness, turning a basic wireframe into a solid metal mesh.

Step 3: Procedural UVs

With the inner mesh and base armature merged together into one solid cage, I needed to ensure it was ready for texturing. Doing UVs procedurally sounds intimidating, but I wanted to keep the tool logic as clean as possible without relying on black-box tools.

I set up my UVs using Houdini's native UV Flatten and UV Layout nodes. By flattening the geometry and packing it procedurally, I ensure that no matter how much the initial pillar dimensions change, the rebar UVs will automatically repack themselves perfectly every single time.

Step 4: Deforming the Metal

A perfectly straight metal grid sticking out of a ruined pillar looks completely fake. If the stone around it exploded, that metal needs to be warped and twisted.

To achieve this non-destructively, I used a combination of a Point Jitter and a Lattice node.

First, I created a bounding box around the armature and used the Point Jitter to randomly scramble the points of that box.

Then, I plugged that scrambled box into a Lattice node alongside my metal armature.

The Lattice node forced the perfect metal grid to warp and bend to match the scrambled box. A final Bend node gave it some macro-level bowing. The result is jagged, chaotic rebar that looks like it has survived a siege.

Prepping for Unreal Engine 5

The final and most important step of the day was getting this ready for the engine. This is a Technical Environment brief, meaning the asset needs to be plug-and-play.

At the very end of the armature setup, I dropped down a Attribute Create node specifically to set up the unreal_material string. By tagging this metal geometry with the exact path to my rust material in UE 5.6, I am guaranteeing that when I eventually export this digital asset, Unreal Engine will automatically recognise the metal bits and assign the correct shader.

Next up: We have all the physical pieces—the stones, the core, and the metal. Next week, it’s time to clean up the geometry, combine everything, and get this asset ready for the bridge into Unreal Engine.

[gaurav-bhave]

Post 4: Procedural Masonry – Slicing the Stones

Day 10 of the Bit Reactor live brief. We are officially into Week 2, and the project is really starting to look like an environment asset.

Last week, we successfully created a macro-level, warped outer shell for the pillar. It has that great, organic silhouette, but there is one glaring issue: it’s still just one giant, solid chunk of geometry. If this is going to look like an ancient, ruined structure, it needs to be built out of individual, stackable stones.

Following the Radu Cius workflow, the next phase involves generating the "Stones Base" and the "Stones." This part of the process completely blew my mind because of how beautifully non-destructive it is.

The "Stones Base" Logic

My initial thought was that I would need to somehow procedurally model a single brick and then use some complex math to copy and stack it hundreds of times. But since I am strictly relying on SOPs and avoiding VEX coding, that approach sounded like a nightmare.

Houdini offers a much smarter way: fracturing a bounding volume. Instead of building from the bottom up, I used the Voronoi Fracture technique again. By generating a bounding box that encompasses the entire pillar and scattering points through it in a somewhat grid-like pattern, the Voronoi node instantly shatters the volume into perfectly stacked, blocky "bricks".

To make them actually read as individual stones rather than a cracked solid, I applied a slight procedural Transform to scale each individual fractured piece down by a fraction of a percent. Instantly, visible "mortar" gaps appeared between every single stone.

The Magic Step: Boolean Intersect

So, I had a perfect grid of stacked bricks, but my actual pillar shell from Week 1 is beautifully warped, bowed, and uneven. How do I get the perfect bricks to follow the warped silhouette?

This is where the true magic of procedural booleans comes in.

Instead of using a Boolean to subtract (like we did to take bites out of the mesh earlier), I brought my deformed outer shell and my perfect brick grid together and set the Boolean operation to Intersect.

Houdini calculated the overlapping volumes and essentially "carved" the brick grid to perfectly match the warped, organic boundaries of the outer shell. The result was incredible. The perfectly straight bricks were instantly sheared off and shaped to follow the bowed, ancient silhouette of the pillar.

Micro-Detailing the Surface

After the boolean intersection, the stones fit perfectly, but their surfaces were a bit too flat and clean.

To fix this, I unpacked the individual stone geometry, ran a quick Remesh to ensure good topology, and dropped down my favourite node: Attribute Noise (Mountain SOP). Unlike the Mountain node from last week (which altered the macro shape of the entire pillar), I dialled the element size way down. This applied micro-level noise, giving the individual bricks subtle surface chipping, wear, and a rocky texture.

By the end of today, the generator is producing a fully stacked, warped, and textured stone pillar. The visual target is getting incredibly close.

Next up: The outside looks great, but we need to integrate the jagged internal core we built on Day 2 and introduce the metal rebar (the armature) to really sell that destroyed look.