NoteBuilder


Methods

setStartTime (
startTime Int[]
)

When attached to spawnBuilder only.
Sets how far in the future a note should be played after it is activated.

setNoteLockToScale (
noteLockToScale Int[]
)

1: If a note value falls outside the scale assigned to the object, it will be rounded to the closest scale note. If setMapToScale = 1, it will be mapped to the scale’s range then rounded.
0: The note value will be without regard to the scale assigned to the object.

setNoteRelationship (
noteRelationship Int[]
)

For attached spawnBuilder Only.
Which note played by an instrumentBuilder that a spawnBuilder is attached to will cause an noteBuilder note attached to the spawnBuilder to activate.

setSequentialStart disables this feature.

-1: Every instrumentBuilder note.
0 – X: Related to the instrumentBuilder note with that index value.

setNoteColorSelection (
noteColorSelection Int[]
)

Allows a programmatic note (a note whose pitch is based on color) to use an alternate color, red green or blue, than the instrument it’s attached to.
-1: The the color of the parent instrumentBuilder.

setScale (
scale Int[]
)

Defaults to the document-level scale.
Allows an alternative scale array to be used for this noteBuilder.

setMapToScale (
mapToScale Int[]
)

When a note’s setLockToScale value = 1 (locked to scale), setMapToScale re-maps the note to the range of values in the scale rather than locking to the nearest scale note.

setLockPause (
lockPause Int[]
)

When a noteBuilder has multiple notes:
0: for an activated note that is locked, nothing will play causing a pause in the sequence with no sound.
1: for an activated note that is locked, the next consecutive note in the noteBuilder will play immediately with no pause.

setAllLockLength (
allLockLength Int[]
)

Locks the instrumentBuilder or spawnBuilder this noteBuilder is attached to from playing any notes for X amount of time after a note is activated.

setNoteArray (
notes Int[]
)

Sets a note MIDI value. setNoteRelative determines how the value is interpreted.

If setNoteRelative = 1, the setNoteArray is added to the attached instruments noteBase.
If setNoteRelative = 2, the setNoteArray is added to the programmatic (a note whose pitch is based on color) value.
If setNoteRelative = 3, the setNoteArray is defined value for the note.
If setNoteRelative = 4, the setNoteArray note is relative to the parent note (for spawn only).

setNoteLength (
lengthMin Int[] lengthMax Int[]
)

Sets the minimum and maximum length of a note.

If minimum = maximum, the length is defined as that value.
If a range, the length will be between the minimum and maximum based on the color intensity.

If minimum = -1, the length is a percentage of the maximum based on the color intensity, with shorter lengths more likely.
If minimum = -2, the length is a percentage of the maximum based on the color intensity, with longer lengths are more likely.

setNoteRelative (
noteRelative Int[]
)

Sets the way a notes pitch is calculated.

If setNoteRelative = 1, setNoteArray value is added to the attached instruments noteBase.
If setNoteRelative = 2, setNoteArray value is added to the programmatic (a note whose pitch is based on color) value.
If setNoteRelative = 3, setNoteArray value is defined value for the note.

If setNoteRelative = 4: Spawn only, relative to the parent note as follows:

setNoteRelative = 4 and parent’s played note noteRelative = 2:
setNoteArray = setNoteArray value is added to played note which is programmatic (a note whose pitch is based on color).

setNoteRelative = 4 and parent’s played note noteRelative = 1:
setNoteArray = setNoteArray value is added to played note + instrumentBuilder noteBase

setNoteRelative = 4 and parent’s played note noteRelative = else:
setNoteArray = setNoteArray value is added to played note which is defined.

If setNoteRelative = 5, the last note played by the instrument will play.

setNoteRange (
min Int[] max Int[]
)

Sets the range of pitches that a programmatic note (a note whose pitch is based on color) can use.

setVelocityRange (
velocityMin Int[] velocityMax Int[]
)

Allows the a note’s velocity to be set re-mapped between a minimum and maximum range.

setLockLength (
min Int[]
)

Sets how long a note will be locked after it is played.

When locked the note can not activate, however even if locked the note is evaluated and will cause the note progression to increment if the velocity is high enough. If that is not the desired effect, use setAllLockLength which will not increment the note progression.

-1: Lock for the duration of the note.
0 – X: Lock for X time.

setNoteSwing (
min Int[] max Int[]
)

Sets the minimum to maximum range a note can be offset from the time it is activated to the time it’s played based on the color intensity.

setVelocityGate (
velocityGateMin Int[] velocityGateMax Int[]
)

Set’s the minimum to maximum range of velocity what will allow the note to activate.

setCosineAffectsVelocity (
CosineAffectsVelocity Int
)

If set to 1, default, cosine changes the velocity of a note. If set to 0 it will not.

setLumaAffectsVelocity (
lumaAffectsVelocity Int
)

If set to 1, default, luma changes the velocity of a note. If set to 0 it will not.

setInvertVelocity (
invertVelocity Int
)

0: More color causes louder notes
1: More color causes quieter notes

setInvertLength (
invertLength Int
)

0: More color creates longer notes
1: More color creates shorter notes

setTickTockNoteLength (
lengths Int[]
)

Instead of using a defined note length, cycle through an array of values and repeat the array when the end is reached.

Each odd/even pair in the array correspond to minimum and maximum value for the noteLength.

setLockToMaxNoteLength (
lockToMaxNoteLength Int
)

Lock all notes for the maximum not length, not the length that was played, which could be shorter based on color.

setSteppedProgression (
steppedProgression Int
)

The noteBuilder will play in a descending stepped order: note 1, followed by 1 then 2, followed by 1 then 2 then 3 etc until the end of the list of note values.

Does not apply to spawnBuilder.

setClosestNote (
setClosestNote String[]
)
setLearnedNoteCount (
count Int[]
)

After X playbacks of the note, the average played note will be saved and used as the defined note when playing back on further activations.

setLearnedNoteResetCount (
count Int[]
)

After a learned note is set, how many times must it activate in order to be re-defined.

setClosestNoteGap (
closestNoteGap Int[]
)

The offset used by setClosestNote.