Shaping

Shaping is the heart of working in Natsura: taking a structure that grows and bending it toward the form you have in mind. You do that through three levers that compose: Mapping to drive any parameter from an attribute, Effectors to apply directional forces, and rig posing to deform placed foliage without breaking instancing. This page is about how those levers map to the things a tree actually does in nature, and how you reach in by hand when you want to.

Trees are shaped by the forces around and within them: they grow up against gravity, echo the rhythm of their own branching, avoid crowding themselves, and respond to the environment they're planted in. Natsura models these as effectors, per-point direction vectors that a Grow (or an Assembly Decoration) reads through a chosen response mode (attract, repel, flatten, align-up, level-up, orbit).

Visual pending.

This page gives the artist-facing, advanced take on mapping and effectors. For the deeper technical reference on either, see the Mapping and Effectors feature pages.

Mapping is the master control

Before any specific force: mapping is the primary mechanism for driving anything in Natsura. Pitch, roll, yaw, width, fork probability, step length, and the strength of every effector can all be driven by a Map chain reading an attribute. "Make branches near the surface respond more to light", "make the trunk thicker lower down", "spread the branch angle from base to tip": these are all mapping. Effectors supply the direction; mapping decides how much of it applies, and where. Keep this in mind through everything below: every force has a strength, and every strength can be a map.

Gravity

Gravity is the most important shaping force, used on both the grow and the assembly decoration. The Gravity Effector writes a uniform up-vector across the whole tree; the response mode decides what the growth does with it:

• Repel pushes growth away from gravity, the typical case, producing upward-tending trunks and shoots.
• Attract pulls growth toward gravity, for hanging and weeping forms.
• Flatten holds growth at a plane to gravity, the right mode for lateral branches, which sit out level rather than reaching up.
• Align (up) twists the local up vector toward gravity, influencing phyllotaxy.

A young upward-tending tree typically uses repel on the trunk and flatten on the lateral branches. Drive the strength with a map to vary it (stronger lower down, looser near the crown).

Visual pending.

Ancestor, self-similar rhythm

One of the most expressive effectors, and worth reaching for early. The Ancestor Effector reads a direction from a point's ancestor (parent, grandparent, further back) rather than computing one from outside. A twig can echo the direction of its parent bough, which echoes the trunk: the visible coherence real trees have between scales. It can copy the parent's own shape, and also copy the influences that shaped the parent. Combine it with another effector on the parent for the inheritance to mean something.

Magnets, the artist's hand

The Magnet Effector is a user-placed sphere of influence in the viewport: place spheres in the scene and branches within their radius are pulled or pushed to steer growth in a direction you choose. It's the most directly artist-controlled effector. Reach for it to pull a hero branch toward a window, push a branch out of a silhouette, or do local shaping the ambient field won't produce. See Interactive tools below for placing and editing magnets in the viewport.

Awareness of the tree's own shape

The Deflection Effector makes branches aware of the tree's own shape so they avoid overcrowding: a crown that doesn't grow back through its own lower branches. It reacts to the tree's own geometry, not to the surrounding terrain or scene; response to the environment a tree grows in is handled separately (see Situation and environment below). Use repel as the response mode.

Noise

The Noise Effector is a spatially-varying vector field. Most directional effectors produce too-uniform results on their own; layering a low-amplitude noise effector on top gives the natural irregularity real trees have. Because it's coherent in space, neighbouring points drift in similar directions (organic), unlike per-point random mapping (jittery).

Rig posing the foliage

Shaping isn't only the skeleton. On the Assembly Decoration, the same effectors apply as rigid rotations through each assembly's rig: flattening leaf clusters to the sky, drooping branch ends, levelling tips up, without breaking instancing, because the deformation is posed on the rig rather than per-vertex. This is where a placed canopy gets its final shaping. Drive these with maps on the assembly's own u to affect, say, only the leafy ends of each piece.

Visual pending.

Combining forces

Multiple effectors can be added to the same Grow; they stack in the order added. A common combination:

• Gravity (repel) for the dominant upward tendency.
• Ancestor for self-similar rhythm between scales.
• Noise (low amplitude) for organic irregularity.
• Magnet layered last for local, hand-placed shaping.

Give each one a Map-driven strength so its influence varies across the tree.

Situation and environment

A tree is a form shaped by where it lives. An open-grown oak in parkland is a different tree from the same species packed into a closed forest; a windward pine on a ridge is different from a sheltered one. Usually in computer graphics we grow trees in isolation, and it stops the artist thinking about making something the world has clearly acted on. Because Natsura is a simulation, you set up a recipe in response to an environment and watch how it grows into that environment, rather than hand-tweaking the result. This is the other half of variation: variation drives difference between trees from attributes you author; situation drives difference from the environment the tree is planted in.

Two mechanisms do the work:

• The environment input on Simulate. Plug in scene geometry and Natsura bakes it into an optimised format carrying occlusion and lighting information, and exposes a phototropism vector the plant can grow with respect to. This is how light-aware growth happens today; there is no separate light effector. The plant can grow toward light and around occluders because that information is baked into something the simulation reads cheaply.
• Mapping by proximity. Drive parameters by how close a point is to scene objects, or whether it's in shade. For example: where there's a lot of geometry nearby, map the tree to grow taller (reaching for light); where it's open, let it spread. Proximity and shade become inputs to Mapping like any other attribute.

Visual pending.

The situations below are approaches, not one-click presets. Natsura doesn't yet ship example scenes for each, and they're as much a guide for the kind of content we want to build as a recipe to follow. The underlying mechanism is always the same: per-point attributes and an environment encode the situation, mapping consumes them, the recipe responds.

• Specimen (open-grown). Nothing to compete with: a wide, symmetric crown with low limbs retained. The default recipe (no environment) approximates this. Exaggerate it with more fork spread and by holding lower-branch retention through mapping.
• Forest (closed canopy). Neighbours on all sides drive the crown narrow and tall, lower limbs lost to shade. Reach this by plugging neighbour geometry into the environment so light competition is felt, mapping growth taller in crowded areas, and pruning lower-generation branches by age.
• Hedgerow. Spreads sideways, asymmetric from one-sided competition. Encode the adjacent hedge in the environment so the lit side grows out; reduce gravity's hold so the tree leans further than it otherwise would.
• Windswept (exposed). A crown that streams downwind in a wedge. Approximate with a Direction Effector in the prevailing-wind direction plus mapping that biases the effect higher up the tree, and prune windward branches via a Wrangle-written exposure attribute.
• Slope. The trunk bows to find vertical; uphill and downhill sides differ. Carry slope direction and steepness as per-point attributes and consume them through mapping.
• Mixed. Real scenes blend these. A glade in a forest has open-grown trees in the middle and closed-canopy trees at the edge. Because the situation is just per-point attributes plus an environment, mixed cases need no special handling: the same recipe responds to whatever each point encodes.

Visual pending.

Interactive tools

Most of Natsura is procedural: you author rules and the simulation runs them. But several nodes carry interactive viewport states, real-time controls you step into to manipulate the result directly, with feedback no parameter could give you. They're the artist's hand inside the pipeline. The pattern is consistent: press Enter on the node (or click the state button on its parameter panel) to enter the state, Escape or click away to exit. Each state's parameter detail lives on its node page.

Stepping into the simulation (the grow state). The most powerful interactive state lives on the simulation itself. Natsura grows step by step, and the grow state lets you get in between the steps: pose the structure between step one and step two, then let the simulation carry on from your edit and take a different path. It turns a black-box solve into something you can reach into and direct, and the simulation can also respond to objects you place interactively in the scene. This is an area that will keep expanding. The Grow Drawer, a tool for sketching branches by hand and letting the simulator fill in the rest, is coming soon.

Classifying foliage (the classify gizmo). Press Enter on an Assembly Decoration while a tree is displayed to enter the classify state. The viewport shows the tree alongside a graph where each library assembly is a draggable point; drag an assembly along a trait axis and its placement on the tree redistributes in close to real time. Because decorations run in the post-process, these gizmos can be very fast, close to real time. The same gizmo is available as a standalone Classify node. For the model behind it, see the Traits.

Magnets. The Magnet Effector places a sphere of influence in the viewport: click to place, drag to position, set radius and strength, and branches inside the radius respond. It's one of several interactive controls, useful for local, hand-placed shaping the ambient effector field doesn't produce. Curve-based guides and other placeable controls are planned; studios who know what they're doing can already build their own with custom effectors.

Assembly and import states. The assembly workflow and the import tools carry their own interactive states: Edit Pivots (Assembly Resource / Pivot Edit) to drag pivots to the base of branches or leaves when auto-rigging needs help; Edit Assembly (Assembly Edit) to rotate, deform, and fix connectivity on the rigged result; and the Import Highpoly wizard (Import Highpoly) for a guided walk through loading scanned geometry.

Related

• Effectors and Mapping, the technical reference behind the forces above.
• Simulation, the engine these forces shape, and where variation comes from.
• Traits, the model behind the classify gizmo.
• Simulate, where the environment input and per-point attributes enter.