Parametric blocks

How to use parametric blocks in Rayon.

Here is all you need to know about using and creating parametric blocks.

What is a parametric block?

Parametric blocks make blocks in Rayon adaptable. Instead of creating multiple versions of the same object (different lengths, sizes, or repetitions), you can define a single block that adjusts automatically by editing it manually, or by editing its parameters numerically.

Interacting with a parametric block

We explain in this section where to find, and how to work with parametric blocks.

Working with existing parametric blocks

Existing parametric blocks can be found in side Rayon's libraries. Spotting them is easy as they have a gear icon, indicating their parametric nature.

Once inserted on the canvas, you will be able to work with any parametric block by interacting with its grips. Let's dive in, step by step...

• Click on a parametric block instance on canvas to select it.

• The block will now display grips , which are small handles corresponding to each parameter.

• Drag a grip along the parameter axis to adjust the block’s geometry.

• As you drag, the geometry updates in real time, based on to the actions and parameters that are set up on inside the block definition. The dragging motion will be affected by other settings too: minimum and maximum of the dragging distance, incremental or continuous dragging motion, etc.

Another way to interact with a parametric block, is through the values of its parameters, located in the properties panel...

• Select a Parametric block instance to input a numeric value directly in the right panel.

• Rayon immediately updates the parameter and all linked actions.

• When an incremental value is defined, entering a custom value rounds automatically to the closest valid increment.

Creating a new parametric block

Parametric can also be created; this requires a slightly more in-depth understanding of how parametric blocks work. This section will offer a deeper dive into parametric blocks.

Some definitions

We need to start by laying down a useful definitions. A parametric block combines five elements that work together:

• An action transforms geometry,

• A parameter drives that transformation,

• A parameter points mark how and where the parameter is anchored on the canvas,

• A selection set decides what is impacted,

• An active area defines where the transformation applies within the selection set.

Element	What it does	Example
Action	Defines how geometry changes when the parameter updates.	Stretch : moves parts of geometry. Array : repeats geometry along a direction.
Parameter	Provides the numeric and directional input for the action.	A segment parameter between two points controlling distance or spacing.
Parameter Points	Define the start and end of a parameter. They anchor its axis and can be moved or snapped to geometry.	The two grips controlling a block’s stretch direction.
Selection Set	Defines which geometry is included in the transformation.	The elements that will move or repeat.
Active Area	Refines the selection set by specifying which control points or portions of geometry are affected.	In a Stretch action, entities with control points inside the area stretch proportionally. Entities without any inside are translated entirely along the parameter axis.

So far Rayon supports, a handful of parameters and actions that we detail here.

Type	Description	Used by..
Segment Parameter	Measures a distance between two points and provides both length and direction.	Stretch, Array
Stretch Action	Moves geometry inside a defined selection set when the parameter value changes.	Segment Parameter
Array Action	Repeats selected geometry at a defined increment along the parameter axis.	Segment Parameter

Creating your first parametric block

Let's go through a few steps to create a first block, and learn a few concepts along the way...

1

Enter edit in isolation mode

• Create a block definition. More about blocks.

• Edit the block with Edit in Isolation. (Right Click > Edit in Isolation or Ctrl+Alt+E).

2

Choose an action

• In the block toolbar, choose an action you'd like to use.

• Pick the transformation you want: Stretch or Array.

3

Create or select a parameter

After selecting an action, Rayon prompts you to choose a parameter.

• Create Parameter : pick two points to define a Linear axis.

• Use existing Parameter : reuse one defined earlier in the same block by selecting it.

Once the parameter is selected or created:

• For Stretch actions, Rayon asks which Parameter Point should be assigned to the action — the start or the end point. This determines which side of the parameter acts as the fixed point and which side drives the transformation.

• For Array actions, this step is skipped — the action uses the entire parameter direction and doesn’t depend on a specific point.

The parameter appears as a purple guideline with draggable grips.

4

Define the selection set & active area

For Stretch actions

Stretch action uses two definitions:

• Selection Set — which entities are eligible to move;

• Active Area — where deformation is detected. • If selected entities have control points inside the Active Area, only those points move (deformation). • If selected entities have no control points inside the Active Area, the entire entity translates by the stretch delta. • Entities not in the selection set do not move.

For Array actions

• Select the geometry to repeat.

• Define the spacing or increment distance (e.g., 600 mm).

5

Save the definition

Exit edit in isolation to save the block definition. All instances of this block now include interactive grips that control the parameter.

Example scenarios

As it turns out, parameters and actions can de combined in many different ways to create various types of parametric blocks; we provide you here with a few examples...

Use Case	Setup	Result
Adjustable bench	Segment Parameter + Stretch Action	Drag to make the bench longer.
Row of chairs	Segment Parameter + Array Action	Drag to add or remove chairs at fixed spacing.
Modular shelf	Segment Parameter + Array Action	Extend to automatically add shelf units.

Going deeper: parameters & actions

Let's complete our understanding of parametric blocks by getting more familiar with parameters and actions.

Segment Parameter

The segment parameter defines a linear distance and direction that actions can use to transform geometry. It’s the core driver behind Stretch or Array actions — providing both the value (length) and axis (orientation).

Each Segment Parameter has two Parameter Points : a start and an end. They appear directly on the canvas and can be moved, snapped, or edited numerically in the right panel. When the distance between these two points changes, every linked action updates automatically.

Parameter Entity Panel

Field	Description
Name	The name of the parameter (e.g., Length, Spacing, Distance). This helps identify it when linking actions.
Length	Displays the current measured distance between the two parameter points. You can also type a specific value to set it precisely.
Type	Defines how the parameter behaves. You can select between None/Incremental/List.
Minimum / Maximum	Optional constraints for the parameter value. Use these to prevent the user from stretching or arraying beyond desired limits.
Chain actions	Determines whether linked actions are triggered continuously when the parameter changes: • On : actions run in series (chained or cumulative). • Off : actions run in parallel (non-destructive).

Parameter Behaviour

• The Segment Parameter establishes a direction (from its start to end point) and a length.

• When its value changes (by dragging the grip or editing numerically), all linked actions recalculate their transformation.

• You can reuse the same parameter across multiple actions to synchronize behaviour (e.g., stretching and arraying in the same direction).

• Constraints (minimum / maximum) are enforced visually in the canvas : the parameter grip stops at the limit.

• When a list of incremental values is defined for the parameter, any value entered outside edit mode is automatically adjusted to the closest valid increment based on that list, ensuring consistent, precise behaviour across all instances.

Parameter Example

Imagine a shelf module with a Stretch and an Array action:

1. You create one strech action with a segment Parameter called ModuleLength.

2. You create another and Array action linked to that same parameter.

3. Dragging one grip increases the shelf’s total length : stretching the side panels and adding extra shelves in between automatically.

This allows complex adaptive behaviours to remain easy to control with a single distance handle.

Actions

So far, Rayon only supports stretch and array actions; let's discover both of them.

Stretch action

When you select a Stretch Action in the right panel, you can configure how the action behaves. This panel defines what will move and how it will move when the linked parameter changes.

Stretch action panel

Field	Description
Name	The name of the action, automatically set to “Stretch”. You can rename it if you have multiple actions in the same block.
Area	Opens the editor to define the Active Area : the crossing zone that determines which parts of the geometry will deform when the parameter changes. Geometry with control points inside this area will stretch; geometry without any inside will move as a whole along the parameter axis.
Selection Set	Opens the editor to define the Selection Set : the geometry affected by this action. Only selected entities react to the stretch (either by deforming or moving). You can add geometry by clicking on it, or remove part of the geometry with Alt/Option.
Angular offset	Rotates the stretch direction relative to the parameter axis, allowing for angled transformations. For most cases, this stays at 0°.
Dist. mult.	Defines a distance multiplier for the stretch effect. For example, ×1 applies the parameter value as-is; higher values amplify the displacement.
Insertion	Controls whether the block’s insertion point is affected by the stretch: • Include : insertion point moves with the stretch. • Exclude : insertion point remains fixed in place.

Stretch action behaviour

• The Stretch Action is linked to a Parameter.

• The parameter’s distance and direction drive how far and in which direction the geometry moves, this can include regular geometry and other parameters, allowing multiple parameters to move together.

• The Selection Set defines which objects respond to the stretch.

• The Active Area defines which parts of those objects are deformed versus translated.

Stretch action example

If you create a Stretch action on a table block:

1. The Selection Set includes the table top and one leg.

2. The Active Area crosses the right side of the table.

3. When you drag the parameter grip, the right leg and that part of the top move, while the rest of the table stays fixed.

If the table had an object (like a decorative line) fully outside the Active Area but inside the Selection Set, it would translate as a whole rather than deform.

Array action

The Array Action creates repeated copies of selected geometry along a parameter’s direction. It’s used to distribute identical elements (like chairs, panels, or shelves) evenly along a distance that can be adjusted on the canvas.

The number of copies depends on the parameter’s total length and the column offset value. As you drag the parameter grip, Rayon automatically recalculates how many instances fit along the axis and updates the geometry in real time.

Array action panel

Field	Description
Name	The name of the action, automatically set to “Array.” You can rename it to distinguish multiple array actions in the same block.
Selection Set	Opens the editor to define the Selection Set : the geometry that will be repeated along the parameter’s axis. Only the selected entities will be duplicated.
Column offset	The column offset defines the distance between each copy. It can be expressed in any supported unit (e.g., 0.6 m). The total number of copies is calculated automatically based on this offset and the current parameter length.

Array action behaviour

• The Array Action is linked to a Parameter, which defines both the axis and the total distance available for repetition.

• As the parameter length increases, Rayon fills the space with copies spaced by the column offset.

• The first copy is always placed at the parameter’s start point; subsequent copies extend along the axis until the parameter’s end point.

• The array updates dynamically as you drag grips on the canvas or modify the parameter value in the inspector.

• The array never overlaps or extrapolates past the parameter’s total distance : when the space becomes too small to fit another copy, Rayon automatically removes the extra instance.

Array action example

Imagine a row of chairs block:

• You define an Array Action associated to a Segment Parameter along the row direction.

• You select one chair as the geometry to repeat.

• You set the Column offset to 0.6 m.

• As you drag the parameter grip, Rayon automatically adds or removes chairs so they fill the distance evenly at 0.6 m intervals.

Array action Tips

• Use logical increments for the column offset (e.g., module widths, seat spacing, tile size).

• You can combine an Array and a Stretch on the same parameter, for example, stretch the base plane and array the elements on top of it.

Tutorial

For more step-by-step information, watch our tutorial about how to use and create blocks in Rayon:

---

We are always available

Book a demo with our team, right here. To get some support, reach out to us through our in-app support chat. More about our support policy right here.