Simulation

Simulation is the engine that brings Natsura’s graphs to life.
Where wrappers and core nodes define rules, the simulation pass evaluates those rules over time, creating the final structures and geometry.

Deferred Evaluation

Natsura doesn’t model step by step like traditional Houdini networks.
Instead, it uses deferred evaluation:

• When you build a graph with Grow, Split, Repeat, etc., you’re describing rules, not immediately generating geometry.
• These rules are stored in an Apex graph of internodes, attributes, and sockets.
• Only when you run Simulate does the system resolve those rules, iterate growth, and produce geometry.

This separation keeps graphs lightweight, editable, and flexible, while the heavy lifting happens only at simulation time.

How It Differs from Procedural Modeling

Traditional procedural modeling in Houdini is immediate: every node creates geometry, which flows downstream.
In Natsura:

• Nodes describe growth steps and relationships, not meshes.
• Geometry is deferred until simulation, so you can change mappings or effectors globally without constantly rebuilding.
• You can iterate designs faster, because editing the “recipe” is cheaper than editing baked geometry.

How Simulation Works

When a Simulate executes, it:

1. Evaluates the Apex graph built from Grow, Repeat, Split, Switch, etc.
2. Applies mappings — parameter remaps and procedural variations chained through Map, Map If, or Map Blend.
3. Evaluates effectors — environmental influences like light, gravity, or collisions.
4. Resolves conditions — gating logic from Switch, Prune, or Wrangle.
5. Generates internodes — producing the plant skeleton.
6. Applies decorations — Surface, Cluster, Trunk, and Select Decorations to turn the skeleton into full geometry.

The result: a hierarchy of branches, leaves, and meshes ready for rendering or export.

Putting It All Together

• Wrappers (Grow, Split, Repeat, Switch, Prune, Wrangle) describe what should happen.
• Core nodes are the minimal verbs underneath them.
• Mappings let attributes drive parameters over space or time.
• Effectors make the system responsive to the environment.
• Decorations add final detail.
• Simulate is the stage where all of these layers converge into geometry.

Notes

• Because evaluation is deferred, the same graph can be simulated multiple times with different seeds, parameters, or effectors — producing endless variation.
• Deferred evaluation also means debugging often involves inspecting attributes, not geometry.
• Some features (like pruning over time) are still evolving, and may require Wrangle for now.