Natsura Simulate

The solver node. Traverses the Apex graph, executes growth logic, resolves mappings, and generates the final geometry.

The Simulate node is the engine of Natsura. It takes the abstract graph recipe and executes it to generate geometry.

  • Execution: Traverses the graph, running the logic defined by Grow, Split, Repeat, etc.
  • Resolution: Evaluates all mappings, effectors, and conditions.
  • Generation: Produces the final skeleton and decoration geometry.

== Concept ==

=== Build vs. Run ===

In Natsura, you first build a graph (using Grow, Split, etc.) and then run it with Simulate. The graph defines the "DNA" of the plant; Simulate grows the plant.

=== Solver Loop ===

Simulate runs a feedback loop. In each step:

Active tips grow (Grow nodes).

Conditions are checked (Switch, Prune).

Attributes are updated (Wrangle, Repeat).

New tips are spawned (Split, Fork).

Inputs

Input 0 -- Graph: The Apex graph to simulate.

Input 1 -- Parms (Optional): Global parameter dictionary.

Input 2 -- Points (Optional): Source points for "Grow from Points" mode.

Outputs

Output -- Geometry: The generated skeleton and/or decoration geometry.

Parameters

Overview

Concept

Build vs. Run

Solver Loop

Simulate runs a feedback loop. In each step : # Active tips grow (Grow nodes).

Conditions are checked (Switch, Prune).

Attributes are updated (Wrangle, Repeat).

New tips are spawned (Split, Fork).

Parameters

Globals

Generation : By default, the current frame number will be used. The frame number can be set using the Playbar at the bottom of the interface.

Max Steps : Safety limit for the simulation loop. Prevents runaway growth.

Seed : Global random seed for the simulation.

Output

Output Skeleton : Generates the line graph representing the branch structure.

Output Decorations : Generates instanced geometry (leaves, flowers, etc.) attached via decoration sockets.

Point Attributes : Specify which attributes (e.g., N, width, Cd) to retain for points.

Primitive Attributes : Specify which attributes to retain for primitives.

keep_dead_stuff : Enable this option to preserve parts of the geometry marked as inactive.

Related

  • Grow Node — Defines the growth logic that Simulate executes.
  • Split Node — Creates explicit parallel branches in the graph topology.
  • Repeat Node — Reevaluates Grow over multiple iterations to generate branching hierarchies.
  • Signal Node — Guides plant growth using external data such as vector fields or collision geometry.
  • Switch Node — Enables transitions between different growth behaviors based on attribute-driven thresholds.
  • Prune Node — Removes components of the plant structure to simulate natural shedding or manual trimming.
  • Wrangle Node — Allows users to write custom VEX code for advanced procedural control.

@attributes

== Attributes ==

Simulate outputs standard attributes on the generated geometry:

  • id -- Unique identifier for each internode.
  • parent_id -- ID of the parent internode.
  • generation -- Recursive depth from the root.
  • u -- Normalized progress along the growth section.
  • age -- Time/step counter.
  • width -- Branch thickness.
  • radius -- Branch radius (derived from width).
  • orient -- Orientation quaternion (on decorations).
  • scale -- Scale factor (on decorations).
  • variant -- Variant index (on decorations).

@workflow

== Workflow ==

  1. Construct your graph using Grow and other nodes inside the Simulate network.
  2. Connect the end of the graph to the Simulate's internal output.
  3. (Optional) Connect scatter points to Input 2 to grow many instances from different root positions.
  4. Adjust Generation (or use the timeline) to control growth progression.
  5. Toggle Output Skeleton and Output Decorations to control what geometry is produced.
  6. Visualize the output using the three display modes: Output, Preview, or Skeleton.

@applications

== Applications ==

  • Full Plant Generation: Execute a complete growth graph to produce ready-to-render vegetation.
  • Multi-Instance Scattering: Feed scatter points into Input 2 to grow forests, hedgerows, or ground cover.
  • Iterative Design: Use the Generation parameter to scrub through growth stages and refine the recipe.
  • Decoration Pipeline: Automatically instance leaves, flowers, and fruit based on decoration sockets defined in Grow nodes.

@notes

  • Display Modes: Use Skeleton mode for fast iteration, Preview for lightweight shading, and Output for final decorated geometry.
  • Performance: Reduce Max Steps or use simpler graphs when iterating. Full decoration output is the most expensive mode.
  • Integration: Works with all Natsura graph nodes. The Simulate is the mandatory final step -- no geometry is produced without it.

Natsura Signal

Integrates environmental signals, such as proximity or vector fields, to guide plant growth dynamically.

Natsura Split

Creates explicit parallel branches in the growth graph. Distinct from innate forking, Split allows you to fork the topology into separate, distinct logical paths.