Your First Tree

This is the written companion to the Natsura 101 video series. It builds one tree in Houdini from a fresh scene: grow a trunk, mesh it, decorate it with rigged foliage, build a custom branch cluster, and refine the silhouette into a finished, decorated tree.

Work through it in order the first time; afterwards each section stands on its own. Where a step touches a system in depth, there's a link to the reference page for it. When your tree is ready, Take Your Tree to Unreal continues the walkthrough into the engine.

1. Grow your first trunk

Natsura ships with 180+ nodes. Most are under-the-hood machinery; the ones you'll use day to day live on the toolbar. The fundamental tools, left to right, are Simulate, Grow, Split, Switch, Mapping, Effectors, Decorate, with the newer Assembly and Scans workflows alongside them.

Place a Simulate

In Houdini you work inside contexts. The default is the object context. Click Simulate on the toolbar and drop it down, and Natsura creates a geometry container called Natsura and moves you inside it. You can step back out by clicking obj in the network path. You'll spend most of your Natsura time inside this geometry context.

Simulate is the engine. It has three inputs (graph (leftmost), optional points, optional environment) and two outputs: geometry and rig. The points input is for spawning many trees at once or a field of grass; the environment input lets the plant react to what it's growing in. On its own, with nothing wired in, Simulate produces no geometry.

For its full parameter surface, see Simulate.

Visual pending.

Add a Grow

With the Simulate selected, click Grow on the toolbar. The first Grow you place takes a moment (extra first-time cooks). Because Simulate was selected, the Grow auto-wires into Simulate's first input. (If Simulate wasn't selected, place the Grow and wire it by hand.)

Select the Grow and set Max Growth Steps to about 10, then press F to frame. You've got a single trunk or bole.

Visual pending.

Shape the trunk

Bring the Start Width Scale down a little to taper the base. Dragging sliders feels slow because the viewport is recomputing live.

Two width controls do most of the shaping:

• Start Width Scale, scales the base of the trunk.
• Width Scale / Step, how fast thickness drops off as it grows.

Visual pending.

2. Add secondary branches

With the trunk Grow selected, go back to the toolbar. Grow, Split, and Switch now show a small dropdown caret; clicking presents options. The Grow dropdown asks where to continue growth from:

• Graph Terminal, from the terminal (tip) shoot.
• Graph Lateral, from the lateral shoots.

Pick Graph Lateral. A new Grow is created and wired into the second input of the first Grow. This second Grow describes the branches that emerge from the trunk; they inherit the parent's width.

On the secondary Grow:

• Start Pitch, set the branch angle.
• Start Width Scale, bring down to a fraction of the parent width.
• Max Growth Steps, 7 to 8.

Visual pending.

Drive pitch with a Map

A constant pitch looks mechanical. Click the small icon next to the Pitch value. You get options: promote it to an external node, set it random, map it, or open the dropdown (mapping with more options). Choose Map from Attribute.

Pick u, the local 0→1 position along an axis (0 at the base of the branch, 1 at the tip), and specifically parent u, the u value of the parent trunk each branch is attached to. A new Map node is created and selected; it runs from min 0 to ~60°.

The spread is going the wrong way (wider at the top). Flip it (change the driver, flip the ramp, or swap the min/max values) until the angle spreads nicely from the base of the tree toward the top.

For the full mapping framework, see Mapping.

Visual pending.

Add organic forking

For quick bifurcation, turn on the Fork helper on the Grow rather than building your own repeat/grow recipe.

• Fork toggle, on.
• Steps, reduce to see the structure with less bifurcation.
• Probability, lower it to reduce how much forking occurs.

Tweak the pitch Map's min angle a little more once forking is in. The skeleton is now in good shape; time to think about meshing.

Visual pending.

3. Mesh the trunk with a Surface Decoration

Meshing in Natsura is handled by the decoration system. Decorations are standalone meshing processes you assign to a Grow, instead of building a SOP graph downstream of the Simulate to post-process the result. See Decorations for the model.

The Simulate output already looks somewhat meshed; that's because each Grow ships with a Trunk Preview meshing decoration assigned by default. It's a placeholder.

Now set up real meshing:

1. Select both Grows and remove the Trunk Preview decoration from each.
2. Open the Decorate panel and, with both Grows still selected, click Surface Decoration. A new node is added and assigned to both Grows.
3. On the Surface Decoration, tune subdivision and interpolation settings.

Assign a material

Use a Surface Resource to give the tree its material. Drop a Surface Resource from the Import group into the graph and assign it. Surface resources are how Natsura handles tree materials, and will do more over time.

To see it properly in the viewport:

• On the display toolbar, set colour to Show Geometry Color (raw geometry with materials/colour).
• Click the small blue orb and turn on Smooth Shaded to drop the wireframe shading.

You now have a textured trunk and branches.

Visual pending.

4. Add foliage with an Assembly Decoration

In Natsura 0.7, branches and clusters are handled by the new assembly framework: prefabricated, rigged tree/branch models that can be deformed and assigned to the tree. There's a dedicated assembly learning series; this is the quick version. See Assemblies (overview).

From the Decorate panel, pick an Assembly Decoration and drop it into the graph. Unlike the Surface Decoration, leave it unassigned for now and work on it in isolation.

Select it. You'll see a skeleton of a tree in the viewport, one of the built-in preview meshes. At the top of the display view you can switch between preview-mesh types. The simulate preview is greyed out because this decoration isn't yet assigned to any Grow.

Pick parts on the trait graph

The little branch pieces come from the decoration's own preview geometry. Click Launch (or press Enter), then hold Alt and move in the viewport, and a graph loads with two axes, angle and size (the default trait dimensions; you don't have to use these).

At the bottom, all the available pieces sit in an unclassified region. Left-click-drag a piece up onto the graph to use it. Drag a second piece to a different corner. To control which part goes where, set what size and angle mean on the source skeleton: under the Distribution panel click the axis symbol and choose, e.g., size. Drag a weight toward 0 or 1 and the part selection shifts to whichever piece is closer to that value. Set the mode to Auto Update here; in this view it's fast and interactive.

Visual pending.

Assign to the tree and map by height

Mapping directly on the isolated decoration warns, because the preview isn't a real simulation; it's a prefab. So assign the decoration to the actual tree first:

1. Select both Grows and drag-drop the Assembly Decoration onto them. Branches appear immediately. Because the decoration is operating on Tips only, you get branches at the tips.
2. Now Map from Attribute works against the tree's real attributes. Pick Map by Height, and use the tree's own height (roughly 14 m here) to set the range. With output mapped 0→1 you get a selection of different parts from base to top.

The variation reads more clearly with more varied decorations, and you can set up as many mappings as you want. Once assigned, you can also map against attributes that already exist on the tree.

Visual pending.

Densify and spawn along the branches

• Increase Probability to add more branches to the main structure.
• Decrease Length Scale / Step to contract the tree toward the main trunk; do the same with Width Scale to taper faster.

To spawn foliage at variable distances along each branch instead of only at the tips, switch the Assembly Decoration from Tips to Internodes, and branches now appear at the simulation's internodes. If that isn't dense enough, click Extra and subdivide, or set a distance between branches (also mappable).

Then shape the branches a little: on the Assembly Decoration, play with Pitch to pull the branch clusters more upright.

To flatten leaves to a plane against gravity (taking advantage of the fact that these are rigged assemblies) open the Effectors popup and add a Gravity Effector. (Effectors are the next section.)

Visual pending.

5. Shape with Effectors

Effectors are how you build your own controls to drive the shaping of the tree. Natsura ships a preset library (ancestor, deflection, gravity, magnet, noise, direction) and you can author your own. They're being rolled out across the whole toolset; right now they can be assigned to the Assembly Decoration (to deform rigged pieces) and to the Grow. See Effectors.

Gravity on the Grow

At the very bottom of the Grow's parameter interface is the same effector button used on the Assembly Decoration. Add a Gravity Effector here too; it pulls the tree upright. That's the opposite of what we want, so flip the direction. It's a bit strong, so get granular with mapping:

• Click the button again → Map from Attribute → u, this time self (your own u: a gradient from the base of the branch to its tip). You get a nice arcing shape.
• In the Map, increase the strength. Set one output negative to pull branches up near the base.

Because you're back in the simulation (slower), switch back to On Mouse Up while playing with the graph.

Visual pending.

Build a mapping graph

A parameter isn't limited to one Map; you can build a whole mapping graph. With a Map selected, go to the toolbar Map dropdown:

• Append Left, places the new Map before the selected one.
• Insert Right / Splice, splices it into the graph after the current Map.

Splice in a new Map (e.g. map 3 → map 4). The Grow's reference updates to the new tail Map automatically.

Set the new Map's blend mode from Replace to Add so you get the combined effect of both Maps. Set it to operate on parent u rather than local u. Now you have two kinds of gravity control: a local one shaping each branch, and one that varies the shape according to where you are on the parent trunk. Combining Maps and blend modes gives a wide range of shaping.

Visual pending.

Refine the clusters on the Assembly Decoration

Back on the Assembly Decoration, change the gravity effector's behaviour to Flatten so the leaves sit on a plane to the sky (push it above 1 to force it stronger). Right now it's uniform across the whole assembly. Because assemblies are rigged, they carry a u value across the skeleton; use it to affect different parts of each piece without breaking instancing:

• Map → Map from Attribute → u (self). Now the effector only flattens the ends of the branches (where u is high), not the whole cluster.
• Set the value at u = 0 higher to flatten the whole branch again, or leave it at 0 so only the leafy tips flatten, a nice result.

Visual pending.

6. Build a bigger branch cluster

The canopy looks sparse. Build a separate, larger branch module out of the same assemblies, then use that to decorate the tree. Splitting work across multiple parts keeps the workflow clean.

1. Drop a new Simulate in the network, then click Grow.
   Placement bug (at time of recording). The new Grow may land in a weird spot. May be fixed by the time you watch.
2. On the new Grow: Start Pitch = 90° (grow horizontally), Max Growth Steps ≈ 10. Decrease Start Length Scale and Start Width Scale so it reads as a branch.
3. Add a little Fork; if it's too much, drop Fork Probability right down. Decrease Width Scale so it tapers off.
4. Rather than a fresh decoration, copy-paste the Assembly Decoration you already tuned, and drag-drop it onto this Grow (into the black field below the Trunk Preview). You get a load of branches/leaves.
5. That copied decoration's size is driven by your height Map (map 2), which is meaningless here; unlink that map and set selection to Random to pick randomly from the available parts.

Visual pending.

Lay parts out and avoid the overlay trap

To pick from a wider range, press Launch (or the enter-state icon → Edit on Geometry) to enter the state.

In the state, Shift + left-click-drag to select all parts, then middle-mouse-drag to lay them out; a rough diagonal/random spread is fine.

Control where branches appear, and shape them

Use masking or pruning to control where branches start on the parent module. Pruning removes over-dense areas; for a branch, near the base makes sense. Then switch back to the Simulate to see it in context and play with the Assembly Decoration:

• Scale the branches (this affects pruning, which runs after placement).
• Try a gravity attract or repel effector. If it's too strong, unlink the shared map and map it yourself with u (self). A negative value droops the leaves; or pull up near the base and droop at the ends.
• Add a Noise Effector to break things up, and ease off the pruning.

Playing across the Grow and the Assembly Decoration settings lets you generate a wide variety of branch types fast. (Later you can plug seed points into the Simulate to spawn many branches at once.)

Visual pending.

7. Turn the cluster into an assembly (Rig to Assembly)

You've built a branch module from procedural geometry plus prefab instances. Now convert it into an assembly you can use to decorate the main tree, with Rig to Assembly.

Wire both outputs of the new Simulate (geometry and rig) into Rig to Assembly. It shows a breakdown:

• The instances that make up the assembly.
• A new instance, the procedural geometry that was created.
• The rigged output geometry.

Toggle display rig, turn on pivots, or turn geometry off to inspect just pivots + rig. View the u value (encoded into the geometry, like a simulation); this is how deformation works in the Assembly Decoration with respect to the hierarchy. You can also see the unique assemblies (each becomes a reusable assembly) and the individual instances, with shared colour lining up instances by their location in the assembly.

Press play on the timeline to watch them animate. If they animate correctly, the assemblies are configured properly and will respond well to deformation in the Assembly Decoration and to wind in Unreal.

Use it on the main tree

Go to the final tree (the first cook takes a while). Wire Rig to Assembly's output into the main tree's Assembly Decoration. You'll see the small components again, because you still need to pick which modules go where:

1. On the Assembly Decoration, click Reset to snap everything back to the origin.
2. Place only the large module you built.
3. The view is still on prototype geometry; on the display toolbar switch to Simulate 1 (the real tree).

Because the new clusters are larger, the tree now looks over-dense; decrease the scale. Then refine with the gravity effector map: flatten sooner, or dial in a bit of droop toward the ends with a touch of inverse droop near the base. For more nuance, duplicate the effector and set it to Level Up (strong) so branch up-vectors point skyward; duplicate again to mix in Flatten. Mixing gravitational influences gives you the canopy shape.

Visual pending.

8. Refine the silhouette (Switch + terminal shoot)

Back on the main simulation, control where growth happens. To keep branches off the lower trunk, place a Switch node and wire it so the secondary Grow only takes effect above ~2 m.

When you do, the lower branches disappear, but they've been replaced by assemblies, because Grow 1 still has the Assembly Decoration assigned and is spawning on all unused internodes. Keep it if you like it; otherwise select Grow 1 and Remove the decoration.

Also make sure Grow 2 extends off the terminal shoot of the trunk, so the trunk doesn't terminate in an ugly stub.

That's your first tree: grown, meshed, decorated, shaped, and refined, a finished Natsura tree in Houdini.

Visual pending.

Take it to Unreal

Ready to see it in a game engine? Take Your Tree to Unreal continues the 101 walkthrough: export the tree as a Nanite Skeletal Assembly, import it, and set up layered wind in Houdini.

Where to go next

• Go deeper on assemblies. Assemblies (overview) and Assembly Decoration.
• Shape it deliberately. Shaping, gravity, self-similar rhythm, magnets, and the response modes that bend growth.
• Make a stand of trees, all different. Variation, and feed seed points into the Simulate.
• Use a real scanned trunk as the base. Trunk Extension.
• Take it into Unreal. Take Your Tree to Unreal.