Parameter Creation and Layout

gain := CreateParam('Gain', ptDataFader, pioBoth);
gain.Min(-24); gain.Max(6); gain.Format('%.1f dB');

Parameters represent inlets, outlets, and internal controls. Define them in Init and configure them with the methods below to mimic module UI.

CreateParam

function CreateParam (caption: string; typ: TParamType, ioTyp : TParamIOType ):TParameter;

Creates a parameter and returns its handle. Choose the caption, visual type, and IO role to expose in the patch.

gain := CreateParam('Gain', ptDataFader, pioInput);
mix := CreateParam('Mix', ptDataFader, pioBoth);
audioOut := CreateParam('Output', ptAudio, pioOutput);

TParamType

Define the visual style and data semantics for parameters created through CreateParam. Pick the variant that matches the hardware control or data you need to expose.

TParamIOType Control whether a parameter shows up as an inlet, outlet, both, or only within the script.

TParameter.IsInput

procedure TParameter.IsInput (val: boolean);

Overrides the IO direction after creation.

buffer := CreateParam('Buffer', ptArray, pioNone);
buffer.IsInput(true);

TParameter.IsOutput

procedure TParameter.IsOutput (val: boolean);

Turns a parameter into an outlet even if it was created as internal.

diagnostic := CreateParam('Log', ptDataField, pioNone);
diagnostic.IsOutput(true);

TParameter.Scale

Sets exponential, logarithmic, or linear scaling for faders so they mirror BrainModular gain or filter modules.

frequency.Scale(lsExp);

TScale

procedure TParameter.Scale (val: TScale);

Available scaling curves for fader-style parameters.

TParameter.Color

TParameter.Color(val: TAlphaColor)

Set the foreground color of the parameter.

transient.Color($FF1ABC9C);

TParameter.OffColor

TParameter.OffColor(val: TAlphaColor)

Defines the inactive color on switch-style parameters.

bypass.OffColor($FF303030);

TParameter.Visible

TParameter.Visible (val: Boolean);

Hides the parameter in the module while keeping them addressable from scripts or snapshots.

advanced.Visible(false);

TParameter.Min

TParameter.Min(val: Single)

Sets the minimum numerical value and clamps incoming automation. By default the min value is 0.

feedback.Min(0.0);

TParameter.Max

TParameter.Max(val: Single)

Sets the maximum permissible value. By default the min value is 1.

feedback.Max(0.95);

TParameter.MinMaxNoLimit

TParameter.MinMaxNoLimit(val: Boolean)

Allows a data field to exceed the standard min/max, ideal when mirroring Array modules.

offset.MinMaxNoLimit(true);

TParameter.DefaultValue

TParameter.DefaultValue(val: Single)

Defines default value for the parameter

rate.DefaultValue(1.0);

TParameter.Caption

TParameter.Caption(val: String)

Renames the label shown in the control panel without rebuilding the parameter.

spread.Caption('Stereo Spread');

TParameter.Symbol

TParameter.Symbol(val: String)

Displays a unit suffix.

delay.Symbol('ms');

TParameter.Format

TParameter.Format(val: String)

Controls numeric rendering using Pascal format strings.

delay.Format('%.1f');

example 1

with an input number = 12345.678

• Decimal : %d (12345)
• Exponent : %e (1.23456780000000E+004)
• Fixed 2 digits : %.2f (12345.68)
• General : %g (12345.678)
• 12 width fixed 2 digits : %12.2f ( 12345.68)

example 2

  // Just 1 data item
  Trace(Format('%s', ['Hello']));

  // A mix of literal text and a data item
  Trace(Format('String = %s', ['Hello']));
  Trace('');

  // Examples of each of the data types
  Trace(Format('Decimal          = %d', [-123]));
  Trace(Format('Exponent         = %e', [12345.678]));
  Trace(Format('Fixed            = %f', [12345.678]));
  Trace(Format('General          = %g', [12345.678]));
  Trace(Format('Number           = %n', [12345.678]));
  Trace(Format('Money            = %m', [12345.678]));
  Trace(Format('Pointer          = %p', [addr(text)]));
  Trace(Format('String           = %s', ['Hello']));
  Trace(Format('Unsigned decimal = %u', [123]));
  Trace(Format('Hexadecimal      = %x', [140]));

output

Hello
String = Hello

Decimal = -123
Exponent = 1.23456780000000E+004
Fixed = 12345.68
General = 12345.678
Number = 12,345.68
Money = ¤12,345.68
Pointer = 0069FC90
String = Hello
Unsigned decimal = 123
Hexadecimal = 8C

example 3

  // The width value dictates the output size
  // with blank padding to the left
  // Note the <> characters are added to show formatting
  Trace(Format('Padded decimal    = <%7d>', [1234]));

  // With the '-' operator, the data is left justified
  Trace(Format('Justified decimal = <%-7d>', [1234]));

  // The precision value forces 0 padding to the desired size
  Trace(Format('0 padded decimal  = <%.6d>', [1234]));

  // A combination of width and precision
  // Note that width value precedes the precision value
  Trace(Format('Width + precision = <%8.6d>', [1234]));

  // The index value allows the next value in the data array
  // to be changed
  Trace(Format('Reposition after 3 strings = %s %s %s %1:s %s',
               ['Zero', 'One', 'Two', 'Three']));

  // One or more of the values may be provided by the
  // data array itself.
  Trace(Format('In line           = <%10.4d>', [1234]));
  Trace(Format('Part data driven  = <%*.4d>', [10, 1234]));
  Trace(Format('Data driven       = <%*.*d>', [10, 4, 1234]));

output

Padded decimal    = <   1234>
Justified decimal = <1234   >
0 padded decimal  = <001234>
Width + precision = <  001234>
Reposition after 3 strings = Zero One Two One Two
In line           = <      1234>
Part data driven  = <      1234>
Data driven       = <      1234>

TParameter.ListBoxString

TParameter.ListboxString(val: String)

Populates combo boxes with comma-text options.

mode.ListBoxString('"Round Robin","Ascending","Random"');

TParameter.ReadOnly

TParameter.ReadOnly(val: Boolean)

Locks a parameter from user edits while still allowing script updates.

status.ReadOnly(true);

TParameter.FastCallback

TParameter.FastCallback(val: Boolean)

Enables the immediate callback path for tactile controls.

gate.CallbackMode(cbImmediate);

TParameter.CallbackMode

TParameter.CallbackMode(mode: TCallbackMode)

Selects the exact thread on which the parameter's Callback will execute. Available modes are : cbMainThread, cbImmediate, cbAsync, cbVideo, cbRealTime, cbGraphic, cbNetwork.

TCallbackMode

procedure Init;
begin
  trigger := CreateParam('Trigger', ptButton, pioInput);
  trigger.CallbackMode(cbImmediate);

  display := CreateParam('Display', ptTextField, pioNone);
  display.CallbackMode(cbGraphic);

  sender := CreateParam('OSC Out', ptDataFader, pioBoth);
  sender.CallbackMode(cbNetwork);
end;

TParameter.DontSave

TParameter.DontSave(val: Boolean)

Marks transient parameters that should not persist in patches or workspaces.

runtimeId.DontSave(true);

TParameter.SavedName

TParameter.SavedName(val: String)

Overrides the storage key used in the workspace. By default the saved name is the caption. Can be useful if several inlets have the same caption.

transpose.SavedName('transposeSemitones');

TParameter.IsSeparator

TParameter.IsSeparator(val: Boolean)

Inserts a blank line before the control inside the module inspector.

sectionBreak.IsSeparator(true);

Parameter Value Access

TParameter.asFloat

procedure TParameter.asFloat(val : single);
function TParameter.asFloat: single;

Reads or writes a single-precision value, the primary way to control faders and numeric inlets.

procedure Process;
begin
  lfo := depth.asFloat * sin(phase);
  output.asFloat(lfo);
end;

TParameter.asInteger

procedure TParameter.asInteger(val : integer);
function TParameter.asInteger: integer;

Handles discrete values for switches, list boxes, and counters.

if voiceCount.asInteger = 0 then
  voiceCount.asInteger(1);

TParameter.asString

procedure TParameter.asString(val : string);
function TParameter.asString: string;

Stores formatted text in captions, log outputs, or TCP/IP helpers.

status.asString(Format('Active voices: %d', [voiceCount.asInteger]));

TParameter.asMidi

procedure TParameter.asMidi(index : integer; val : TMIDI);
function TParameter.asMidi(index : integer): TMIDI;

Reads and writes MIDI events indexed per block. Combine with Length to iterate polyphonic buffers.

msg := noteIn.asMidi(i);
msg.data1 := msg.data1 + transpose.asInteger;
noteOut.asMidi(i, msg);

TParameter.asArray

procedure TParameter.asArray(index : integer; val : single);
function TParameter.asArray(index : integer): single;

Accesses array parameters element by element, matching Array modules or bus buffers.

for i := 0 to shapeIn.Length - 1 do
begin
  shapeOut.asArray(i, shapeIn.asArray(i) * gain.asFloat);
end;
shapeOut.Length(shapeIn.Length);

TParameter.asColor

procedure TParameter.asColor(val : TAlphaColor);
function TParameter.asColor: TAlphaColor;

Gets or sets ARGB colors using TAlphaColor, enabling palette manipulation alongside XY Draw or LED grid modules.

var col: TAlphaColor;
begin
  col := colorIn.asColor;
  col := col xor $00FFFFFF;
  colorOut.asColor(col);
end;

TParameter.asBoolean

procedure TParameter.asBoolean(val : boolean);
function TParameter.asBoolean: boolean;

Reads or writes a boolean value. The getter returns True when the parameter's rounded value equals 1, False otherwise. Convenient for switches and toggles.

if bypass.asBoolean then
  output.asFloat(input.asFloat)
else
  output.asFloat(input.asFloat * gain.asFloat);

TParameter.asBitWise

procedure TParameter.asBitWise(val : uInt32);
function TParameter.asBitWise: uInt32;

Reads or writes bit masks used by logic or OSC modules.

flags.asBitWise(flags.asBitWise or $00000010);

TParameter.Length

procedure TParameter.Length(l : integer);
function TParameter.Length: integer;

Defines the number of elements for array and MIDI parameters.

noteOut.Length(activeCount);

TParameter.equal1

function TParameter.equal1: boolean;

Return TRUE if the parameter's value is equal to 1.

TParameter.equal0

function TParameter.equal0: boolean;

Return TRUE if the parameter's value is equal to 0.

TParameter.CopyFromModule

function TParameter.CopyFromModule(AModuleName, AModuleTletName: string):boolean;

Copy the value from a specified module terminal (inlet or outlet) into the current parameter. See dynamic-patching. Returns TRUE if the operation succeed FALSE otherwise.

TParameter.CopyToModule

function TParameter.CopyToModule(AModuleName, AModuleTletName: string): boolean;

Copy the current parameter value to a specified module terminal (inlet or outlet). See dynamic-patching. Returns TRUE if the operation succeed FALSE otherwise.

TParameter.ReadFromChunk

procedure TParameter.ReadFromChunk(ChunkName, ItemName: string);

Read a parameter value from a specified chunk and item. See chunks.

TParameter.WriteToChunk

procedure TParameter.WriteToChunk(ChunkName, ItemName: string);

Write a parameter value to a specified chunk and item. See chunks.

more about scripts

• Scripts Reference
• Files
• Scripts Reference Summary
• Dynamic Patching
• Usine Objects
• Strings
• Buses
• IML Messages
• JSON
• Global Array
• Date & Time
• Windows Registry
• Script Overview
• Parameter Creation and Layout
• Chunks
• Dynamic Array
• Color
• Math and Randomization
• Variants
• Script Editor Panel
• Script