Foliage & Instancing

The canopy is what reads as a tree from a distance: the leafy mass, its density, its silhouette, the way light catches its edges. In Natsura the skeleton from Simulate is only the armature; foliage is placed onto it as a separate, fast-to-iterate layer, and it is placed as instances. A canopy can run to hundreds of thousands of leaves, so the unit you place is a reused, instanced piece rather than unique geometry, and Natsura is built to keep that instancing intact all the way through placement and posing. This page is the concept; it spins out into the workflows that actually produce foliage.

Visual pending.

What foliage is, in Natsura

Foliage is geometry attached to spawn points on the skeleton (tips, intersections, internodes, or custom groups) at a controllable density. The unit you attach matters, and Natsura gives you a few:

• Assemblies are pre-rigged hierarchies (a leaf cluster, a branch chunk, a fruit set) placed by the Assembly Decoration. This is the default and most mature path: instancing is preserved across placement, and because each piece is rigged it can be posed and deformed without breaking that instancing. See Assemblies.
• Clusters are flat meshes deformed to follow a branch, via the Cluster Decoration. The right tool when the input is a static mesh that should bend along a curve.
• Atlas cards are 2D leaf images turned into traced, lifted, embossed geometry by the atlas pipeline, which then feeds the decorations above.

Why instancing matters

A full canopy is far too much unique geometry to mesh leaf by leaf, so the same library piece is reused many times over. The trick is getting variety without giving that up. Two things make it work: trait matching picks which instanced piece goes where, so the canopy varies meaningfully across the tree rather than repeating one piece; and rig-level posing flattens, droops, and levels each placed piece by rotating it through its rig, which is a per-instance transform rather than new geometry. You keep the memory and render cost of instances while still getting a canopy that reads as grown. The same instancing carries through to export, where it becomes engine instances or Nanite-ready geometry.

Building a canopy

A canopy is more than scattered leaves; it is the distribution and variation that make the mass read as grown rather than sprinkled. The levers, all on the Assembly Decoration:

• Where it spawns. Tips for a sparse outer layer, internodes for fuller coverage, masked by any attribute on the tree.
• Which piece goes where. The Traits matches library pieces to spawn points by traits (angle, size, height, health), so the canopy varies meaningfully across the tree rather than repeating one piece.
• How each piece is posed. Rig-level effectors flatten leaves to the sky, droop branch ends, level tips up; see Shaping.
• Final density. A density-based removal pass thins over-crowded regions so the canopy has voids and breathing room. See Variation.

Visual pending.

Bigger pieces from smaller ones

A canopy doesn't have to be built from single leaves. You can grow a whole branch module (its own little simulation, decorated with leaves), then turn that module into a reusable assembly with Rig to Assembly and place it on the main tree. Larger prefabricated clusters mean fewer placements and a richer unit of foliage. The walkthrough in Your First Tree does exactly this.

Related

• Assemblies, the default foliage workflow.
• Atlases, turning 2D leaf images into foliage geometry.
• Traits, choosing which instanced piece goes where.
• Trunks & Meshing, the meshing layer foliage placement sits in.
• Materials, how the foliage is surfaced and shaded.
• Shaping, posing the placed foliage.