Subsystem In

This function block provides an input channel for a subsystem scene. Use it to receive data from the parent (main) scene and make that data available inside the subsystem for further processing.

📥 Inputs

This function block does not have input sockets.

📤 Outputs

Generic This output forwards the data value provided by the parent scene into the subsystem. Each instance represents one input channel.

🕹️ Controls

Title Editable label shown on the block, usually set to a small index to identify the input channel.

Index The instance index (displayed as the block title) that indicates which input channel this block represents inside the subsystem.

Note: The block has minimal visible widgets—most configuration happens by arranging and indexing instances inside the subsystem and by wiring the parent scene.

🎯 Features

• Multiple input channels: You can add multiple instances of this block inside a subsystem to accept several separate inputs from the main scene.

• Automatic indexing: Each instance is automatically numbered so you can easily map parent inputs to their corresponding internal channels.

• Seamless data forwarding: At runtime the block provides the latest value from the parent scene for the corresponding channel so internal blocks can use it.

• Works with enabled/disabled subsystems: When a subsystem is controlled by an enabling mechanism, this block respects that control and provides the expected input values.

⚙️ Running mechanism

• At runtime the parent scene provides a list of input values for the subsystem.

• Each instance of this block represents one position in that list and outputs the value that corresponds to its index.

• Internal processing blocks read from the block's Generic output just like any other data source inside the subsystem.

• If the subsystem is disabled (via an enabling block), the input values can be delivered or bypassed depending on the subsystem configuration.

📝 Usage Instructions

1. In the main scene, provide input values to the subsystem (for example by connecting UI inputs or other data-producing blocks to the parent Subsystem block).

2. Inside the subsystem scene, add one or more instances of this block for each input channel you need. Each instance will be assigned a numeric index.

3. Use the block's Generic output to feed internal processing blocks with the incoming value from the parent scene.

4. To send results back to the parent, use matching output blocks inside the subsystem (for example Subsystem Out).

5. Use an enabling input in the parent scene (for example Subsystem Enabled) when you want to toggle subsystem execution.

💡 Tips and Tricks

• Pair this block with Subsystem Out inside the subsystem to create clear input/output interfaces between the main scene and the subsystem.

• Use Subsystem Enabled in the parent scene to control whether the subsystem runs, and let this block pass inputs only when desired.

• For user-driven values, feed the parent subsystem with Number Input, Logic Input, or String Input blocks; inside the subsystem, this block will expose those values via the Generic output.

• When you need to persist or cache incoming values inside the subsystem, combine with Data Memory so internal flows can reuse stable values.

• For global sharing between scenes, consider using Data Write Global and Data Read Global alongside subsystem inputs to coordinate values across multiple subsystems or the main scene.

🛠️ Troubleshooting

• No input appears inside the subsystem: Ensure the parent scene is providing inputs to the subsystem instance and that the number of provided values matches the number of Subsystem In instances.

• Values are mismatched (wrong channel): Check the index numbers shown on each block inside the subsystem—reorder or re-create instances so the indexing matches the parent input order.

• Subsystem not running or values not updating: Verify if an enabling control (Subsystem Enabled) is active in the parent scene and that connected enabling signals are correct.

• Need persistent input values between runs: Use Data Memory inside the subsystem to hold values when upstream inputs are intermittent.