Grow

The Grow node builds a procedural growth graph using Natsura’s core operations.

• One step of development. Execute once, loop with an embedded repeat, or fork into new branches.
• Parameters are exposed as sockets. Left constant they act like standard parameters; connected to mapping chains, they vary in space and time.
• Grow does not simulate. Use Simulate to traverse the graph, resolve mappings/effectors, apply decorations, and output geometry.

Related:
Overview · Core Nodes · Repeat · Switch · Mapping · Effectors · Decorations

Concept

One step, optionally looped and forked

• Single step — Max Growth Steps = 1 emits one internode.
• Looped — higher step counts invoke the embedded repeat. u (normalized repeat index) resets per repeat. fraction gates realized steps but does not renormalize u.
• Forked — optional children can spawn per-iteration during the repeat.
• Chaining — multiple Grows connected under one Simulate form complete recipes.

🎥 /videos/natsura_grow_step_to_structure.mp4 — One step → repeat → fork → simulated result

What’s inside Grow

Grow is a wrapper around core nodes (“verbs”):

• grow_core — build an internode + transforms
• repeat_core — loop the step and form u
• split_core — create children
• switch_core — gate paths on/off

You can wire cores directly for low-level control. See Core Nodes.

Why sockets

• Constants evaluate once.
• Mapped sockets consume attributes every step — varying with position (fields, collisions) or time (age, iteration).

Examples:

• Taper: map Per-Step Width by u or distance-from-root.
• Light-seeking: drive bend weights with a phototropism effector.
• Age gating: raise Fork Probability after a few iterations.

🎥 /videos/natsura_grow_mapping_intro.mp4 — Phototropism strength driven by parent.u

Inputs / Outputs

• Input 0 — Graph
  Existing growth graph (empty for first Grow). This node appends.
• Input 1 — Parms
  Geometry with a parms detail dictionary. Feed external constants or mapping data into sockets.
• Input 2 — Second Graph
  Secondary graph merged each repeat iteration. Interleave other recipes.
• Output — Graph
  An Apex graph fragment (internodes, attributes, queued decorations). Pass to Simulate.

📷 /images/natsura/grow_inputs.png — Graph (0), Parms (1), Second Graph (2).

Parameters

Sockets may be left constant (fixed behavior) or connected to a mapping chain (variable behavior).

Initialization

• Interval (interval) — spawn cadence for this child.
• Interval Offset (interval_offset) — phase shift.
• Offset (offset) — position offset before orientation.
• Multiplicity (multiplicity) — children created at init (different from Fork).
• Init Pitch / Roll / Yaw — one-time orientation.
• Start Length Scale / Width Scale — multipliers for the first segment.

📷 /images/natsura/grow_init_compare.png — Multiplicity 1 vs 3.

Growth (embedded repeat)

• Max Growth Steps — repeat bound (compile-time).
• Fraction — realized steps = floor(fraction × max_steps) (does not renormalize u).
• Per-Step Length / Width — multipliers each iteration. Width recomputed every step.
• Spiral Pitch / Roll / Yaw — incremental bends per step.

🎥 /videos/natsura_grow_repeat_spiral.mp4 — Spiral over 12 steps.

Fork

• Enable Fork — allow branching during repeat.
• Branches / Probability / Spread — spawn count, gate, and angular distribution.

📷 /images/natsura/grow_fork_probability.png — Probability sweep.

Sockets

• Mappings — connect mapping chains.
• Effectors — connect effectors (world-space vectors, mappable strengths).
• Decorations — queue leaves, bark, clusters. Run after simulation.

Conditions (experimental)

• Start / Stop / Fork conditions declared here, evaluated by Simulate.

Attributes

📷 /images/natsura/grow_attributes_overlay.png — Overlay of u, generation, width.

Workflow

1. Initialize — orientation, multiplicity, offsets.
2. Grow — steps, fraction, per-step multipliers, spirals.
3. Fork — branches, probability, spread.
4. Sockets — attach mappings, effectors, decorations.
5. Simulate — evaluate with Simulate.

🎥 /videos/natsura_grow_workflow_overview.mp4 — Init → growth → fork → mapping → simulate.

Mapping quick-reference

• Chains evaluate left → right; downstream blends own the result.
• Clamp inputs only; outputs are not clamped.
• Access ancestry as self, parent, parent+N.
• u is set pre-Strands and pre-Decorations. Use parent.u for child-launch logic.

See Mapping.

How-tos

• Taper with u — map Per-Step Width ramp u: 0→1 → 1.0→0.3.
• Bend toward light — phototropism effector; map Spiral Pitch rising after u > 0.3.
• Irregular forking by age — map Fork Probability from noise seeded by id, gated by age > 2.

Applications

• Species templates — chain multiple Grows; swap mapping chains for species variation.
• Variation libraries — duplicate a Grow, adjust mappings only.
• Responsive growth — map sockets from effectors.
• Decorations — queue leaves, bark, clusters (post-sim).
• Hybrid recipes — combine with Split, Switch, Repeat.

Examples

• Straight stem — 5 steps, no fork.
• Branching sapling — forked branches, ~50% probability.
• Light-seeking shoot — phototropism effector.
• Climbing vine — spiral yaw, low fork, collisions reduce pitch.
• Grass tuft — high multiplicity, truncated fraction, strong taper.

Notes

• Grow builds, Simulate runs.
• u from repeat, not renormalized by fraction.
• Forking can explode counts; gate with age/conditions.
• Recursive Yaw exists (hidden in compact UI).
• Conditions are declared in Grow, evaluated in Simulate.

Troubleshooting

• Branch count explodes → lower fork branches/probability; create a mapping limit with split_depth.
• u looks wrong → u is for max growth steps. it is not renormalized if using a lower growth % yet.
• Unable to map growth steps → max_growth_steps is compile-time; use growth % instead.

See also

Simulate · Repeat · Switch · Core Nodes · Mapping · Effectors · Decorations