Pattern < ValueType >

  • ValueType: [object Object]

Pattern arpeggiates between the given notes in a number of patterns.


import { Pattern } from "tone";
const pattern = new Pattern((time, note) => {
	// the order of the notes passed in depends on the pattern
}, ["C2", "D4", "E5", "A6"], "upDown");

Hierarchy

Constructor

new Pattern (
callback?:ToneEventCallback<ValueType > ,

The callback to invoke with the event.

values?:ValueType [] ,

The values to arpeggiate over.

pattern?:PatternName

The name of the pattern

) => Pattern
new Pattern (
options?:Partial<PatternOptions<ValueType > >
) => Pattern

Properties

blockTime #

readonly Seconds

The number of seconds of 1 processing block (128 samples)

callback #

(time,value) => void

The callback to be invoked at a regular interval

context #

BaseContext

The context belonging to the node.

debug #

boolean

Set this debug flag to log all events that happen in this class.

disposed #

readonly boolean

Indicates if the instance was disposed. 'Disposing' an instance means that all of the Web Audio nodes that were created for the instance are disconnected and freed for garbage collection.

humanize #

boolean | Time

Random variation +/-0.01s to the scheduled time. Or give it a time value which it will randomize by.

interval #

Time

The time between successive callbacks.


import { Loop, Transport } from "tone";
const loop = new Loop();
loop.interval = "8n"; // loop every 8n

iterations #

number

The number of iterations of the loop. The default value is Infinity (loop forever).

mute #

boolean

Muting the Loop means that no callbacks are invoked.

name #

string

pattern #

PatternName

The pattern type. See Tone.CtrlPattern for the full list of patterns.

playbackRate #

Positive

The playback rate of the loop. The normal playback rate is 1 (no change). A playbackRate of 2 would be twice as fast.

probability #

NormalRange

The probably of the callback being invoked.

progress #

readonly NormalRange

The progress of the loop as a value between 0-1. 0, when the loop is stopped or done iterating.

sampleTime #

readonly Seconds

The duration in seconds of one sample.

state #

readonly BasicPlaybackState

The state of the Loop, either started or stopped.

value #

readonly ValueType | undefined

The current value of the pattern.

values #

ValueType []

The array of events.

static version #

string

The version number semver

Methods

cancel #

Cancel all scheduled events greater than or equal to the given time

cancel (
time?:TransportTime

The time after which events will be cancel.

) => this

dispose #

disconnect and dispose.

dispose ( ) => this

get #

Get the object's attributes.


import { Oscillator } from "tone";
const osc = new Oscillator();
console.log(osc.get());
// returns {"type" : "sine", "frequency" : 440, ...etc}
get ( ) => PatternOptions<ValueType >

static getDefaults #

Returns all of the default options belonging to the class.

getDefaults ( ) => PatternOptions<any >

immediate #

Return the current time of the Context clock without any lookAhead.

immediate ( ) => Seconds

now #

Return the current time of the Context clock plus the lookAhead.

now ( ) => Seconds

set #

Set multiple properties at once with an object.


import { Filter } from "tone";
const filter = new Filter();
// set values using an object
filter.set({
	frequency: 300,
	type: "highpass"
});
set (
props:RecursivePartial<PatternOptions<ValueType > >
) => this

start #

Start the loop at the specified time along the Transport's timeline.

start (
time?:TransportTime

When to start the Loop.

) => this

stop #

Stop the loop at the given time.

stop (
time?:TransportTime

When to stop the Loop.

) => this

toFrequency #

Convert the input to a frequency number

toFrequency (
freq:Frequency
) => Hertz

toSeconds #

Convert the incoming time to seconds

toSeconds (
time?:Time
) => Seconds

toString #

Convert the class to a string


import { Oscillator } from "tone";
const osc = new Oscillator();
console.log(osc.toString());
toString ( ) => string

toTicks #

Convert the input time into ticks

toTicks (
time?:Time | TimeClass
) => Ticks