PROCEDURAL TREES WITH NATSURA - TSUKUDA
He is passionate about using Houdini to create procedural content for cinematics and videogames and is working focused on Environmental design.
He graduated from IGAD (International Games Architecture & Design) in Breda and interned at SideFX‘s game dev team in Los Angeles in 2018/2019.
This is PART 3 out of 4 from the Procedural Island Tsukuda presentation given for Houdini 22's launch event in Shenzhen, China, the Houdini Hive on October 15th in Tokyo, Japan and IGDC (India Game Developers Conference) on October 28th in Chennai, India!
More than a tutorial, below you can see my thought proces and workflow in creating a 3-week project that can be used as a demo, slide by slide.
Here I will go over the procedural foliage with Natsura which was a collaboration with Feike and George, but if you want to see the entire project, you can check out the full presentation on my ArtStation!
In this project, I created this island in about 3 weeks. The image above is the start of the project.
On the following slides, you can see the progress of the procedural trees I made for this demo.
For any project, I start off with finding reference. This can be a simple as a screenshot from GoogleMaps, but I decided to take many pictures of what I think is interesting and can be helpful later on in this project.
So about Natsura! This is a new toolset being released in 2026/2027 for Houdini that focusses on procedural foliage generation, fully parametric based in real life values.
Like with everything in this project, we start off with the OSM data, and we generate points with roughly a 10 to 15m radius, placed where the trees in the reference are also planted.
I make sure that those point are moved to the height of the heightfield using a simple ray node, and then use the building blocks to double check that no trees spawn inside of them. Setting this up from the start will allow artists later on to change the buildings and even the terrain and still have all the trees generate and placed correctly.
This gives us a base pointcloud, which we can reference for instancing in both Houdini and Unreal.
We give each point a random rotation, scale, colour and some other attributes like object collision, ambient occlusion and more. All these attributes can be used to grow individual trees.
For the Houdini/Natsura part, I worked closely with Feike and George from Natsura, so the coming slides, including this one, are a collaboration.
Natsura works from the trunk of the tree upwards, and the nodes are placed like a growing tree as well. We can set our initial values for the tree to grow each step, use simple attributes for the rotation and angle of the tree using simulate and grow nodes. What makes Natsura really unique are its settings based in real life variables like gravitropism or crown shyness. Really cool!
The way natsura works is a little bit like a shadergraph. There are a lot of attributes living on the skeleton of the tree while it grows like height, amount of light, direction to nearby objects. And these can be used to map behaviors.
From each generation of the base trunk, we can decide on the generation of the branches. We can first set up how the growth starts and ends for the branches, and then from there on we can use those branches again for placing smaller and smaller branches, all the way up to leaves.
And since we have attributes that we can visualise with color, it’s easy to assign variables such as age or distance. On the right we can see the ambient occlusion visualised, showing the awareness of object proximity. The blue shows there is no room for growth in that general direction, which the tree then tries to avoid.
Natsura provides a Simple Tree Example that comes built in, and i decided to continue on that, as it will totally be sufficient as a base for what we’re trying to set up today.
Natsura can deal with leaves in the shape of atlas textures. From the incoming atlas texture I selected the leaves I liked by drawing their skeleton. I wired this into a cluster decoration which Natsura uses to place the leaves.
The trees will exist out of a skinned mesh for the trunk and out of instances for the remaining clusters. Here I did a small setup to get a cluster of branches in the shape that I liked.
Natsura provides tooling to further work with the cluster I just made. I divided up the cluster in smaller sub instances which I will use in the main tree after this.
The big reason to do this is because nanite foliage has a major limitation regarding instance/bone count so controlling the amount of instances was very important. Assemblies are rigged automatically as you can see with the wind animation here. I think it’s cool to see everything jiggle.
And then we generate our last Natsura simulation to create the final tree. In this example, we are driving the growth percentage, width scale, gravitropic response and branch amount according to a per-point "age" attribute
This behaviour can be driven directly by the attributes on an incoming pointcloud, and could be extended to include light level, tree health, object proximity etc.
Now, after our generation in Houdini, all we have to do is use our point cloud in Unreal. We’re placing the trees with PCG, and as you saw in the first slides, each point has already some variation in scale and rotation, but we can also slightly offset each tree’s basecolor in the material!
What’s really cool is that using this setup with Nanite assemblies, Natsura instances run quite fast. And it doesn’t stop there.
Since we have UE’s custom wind plugin, we can now easily change the direction and gusts of the wind to match any weather behaviour we want. Isn’t that cool?
Now this project consists out of 4 different procedural workflows, and this is procedural buildings, procedural boulevards, procedural trees and procedural bridges all combined.
Running through the demo in UE really gets the project vibe, and since everything is procedurally generated, the project can be optimized and adjusted where needed in a constant iterative cycle. Pretty neat!
We get great atmospheric shots that look natural from up close...
..as well as realistic overal scale and scope for this demo from a more bird's-eye view.
As you can see, not bad for a 3-week-project! We have a nice combination of all these different assets working in tangent to create a fast, iterative and playable demo in UE, that looks great!
If anything, I hope you got inspired by this short demo and procedural workflow, and are excited to start something using Houdini as well. Cheers!
CREATED BY
