Core Nodes

Core nodes are the fundamental verbs of Natsura.
They form the low-level procedural grammar from which higher-level wrappers (like Grow) are assembled.

If wrappers are the cockpit — bundling useful defaults, sockets, and a streamlined UI — core nodes are the wires and circuits underneath.
They are minimal, explicit, and flexible, exposing the raw mechanics of growth without abstraction.

Why Core Nodes?

• Wrappers
  • Artist-facing.
  • Bundle multiple core nodes into one tool.
  • Prioritize usability and reduced graph complexity.
• Core nodes
  • Technical, single-purpose, and granular.
  • Useful for debugging, custom logic, or extending workflows.
  • The place to go when wrappers don’t expose enough control.

📌 Most artists won’t need core nodes day to day. They’re invaluable for advanced users, pipeline developers, and those who want to look under the hood.

Core Node Index

Growth

• Grow Core
  Creates a single internode (branch segment).
  • Applies transforms: length, width, pitch, roll, yaw.
  • Emits attributes like id, parent_id, generation, u, age.
  • The fundamental building block used inside Grow.

Iteration

• Repeat Core
  Loops a child graph for N iterations.
  • Produces normalized index u [0..1] for mappings.
  • Supports fractional step limiting (fraction).
  • Backbone of recursive and iterative growth.

Branching

• Split Core
  Forks the graph into parallel children.
  • Assigns inter_node_id for sibling indexing.
  • Used in Grow for fork logic and multiplicity.

Gating

• Switch Core
  Chooses between inputs at runtime.
  • Gated by conditions, mappings, or attributes.
  • Enables state-driven transitions (e.g. bud → leaf → flower).
  • Evaluated when the graph is run by Simulate.

Termination

• Kill Core
  Removes internodes or entire branches based on rules.
  • Conditions can include age, u, or environmental attributes.
  • Useful for pruning, death, or seasonal effects.
  • Lets you model lifecycles, thinning, and stochastic die-off.

Custom Logic

• Wrangle Core
  Raw VEX hook for power users.
  • Create or modify attributes.
  • Prototype behaviors not yet covered by other nodes.
  • Bridge to Houdini: use objects, fields, or volumes to drive growth.

Support Systems

Not “core nodes” themselves, but deeply integrated:

• Mapping — attribute-driven modulation of sockets (ramps, noise, blending).
• Effectors — inject world-space influences like light, gravity, collisions.
• Decorations — attach leaves, bark, clusters; run post-simulation.

When to Use Core Nodes

• To build custom wrappers or experimental operators.
• To debug and understand how wrappers like Grow are built internally.
• To gain absolute control over attributes, iteration, and branching logic.
• To extend Natsura in production pipelines.

Example: Grow vs grow_core

• Grow (Wrapper)
  • Provides repeats, forks, sockets, and conditions in one node.
  • Easy for artists to get results with minimal wiring.
  • Hides technical complexity behind a cockpit UI.
• grow_core (Core)
  • Only makes a single internode.
  • To repeat, split, or switch, you must explicitly wire other cores.
  • More work, but maximum transparency and flexibility.

See also

• Grow – wrapper built from core nodes
• Simulate – executes the Apex graph and resolves mappings/effectors
• Overview – high-level introduction to Natsura