TickParam < TypeName >

  • TypeName: "hertz" | "bpm"

A Param class just for computing ticks. Similar to the Param class, but offers conversion to BPM values as well as ability to compute tick duration and elapsed ticks

Hierarchy

  • Param<TypeName >
    • TickParam

Constructor

new TickParam (
value?:undefined | number

The initial value of the signal

) => TickParam
new TickParam (
options:Partial<TickParamOptions<TypeName > >
) => TickParam

Properties

blockTime #

readonly Seconds

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


console.log(Tone.Destination.blockTime);

context #

BaseContext

The context belonging to the node.

convert #

boolean

If the value should be converted or not

debug #

boolean

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

defaultValue #

readonly [object Object]

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.

input #

GainNode | AudioParam

maxValue #

readonly number

The maximum value of the output given the units

minValue #

readonly number

The minimum value of the output given the units

multiplier #

number

A multiplier on the bpm value. Useful for setting a PPQ relative to the base frequency value.

overridden #

boolean

True if the signal value is being overridden by a connected signal. Internal use only.

sampleTime #

readonly Seconds

The duration in seconds of one sample.


console.log(Tone.Transport.sampleTime);

units #

UnitName

The unit type

value #

[object Object]

The current value of the parameter. Setting this value is equivalent to setValueAtTime(value, context.currentTime)

static version #

string

The version number semver

Methods

apply #

Apply all of the previously scheduled events to the passed in Param or AudioParam. The applied values will start at the context's current time and schedule all of the events which are scheduled on this Param onto the passed in param.

apply (
param:Param | AudioParam
) => this

cancelAndHoldAtTime #

This is similar to cancelScheduledValues except it holds the automated value at time until the next automated event.


return Tone.Offline(() => {
	const signal = new Tone.Signal(0).toDestination();
	signal.linearRampTo(1, 0.5, 0);
	signal.cancelAndHoldAtTime(0.3);
}, 0.5, 1);
cancelAndHoldAtTime (
time:Time
) => this

cancelScheduledValues #

Cancels all scheduled parameter changes with times greater than or equal to startTime.


return Tone.Offline(() => {
	const signal = new Tone.Signal(0).toDestination();
	signal.setValueAtTime(0.1, 0.1);
	signal.setValueAtTime(0.2, 0.2);
	signal.setValueAtTime(0.3, 0.3);
	signal.setValueAtTime(0.4, 0.4);
	// cancels the last two scheduled changes
	signal.cancelScheduledValues(0.3);
}, 0.5, 1);
cancelScheduledValues (
time:Time
) => this

dispose #

disconnect and dispose.

dispose ( ) => this

exponentialApproachValueAtTime #

Start exponentially approaching the target value at the given time. Since it is an exponential approach it will continue approaching after the ramp duration. The rampTime is the time that it takes to reach over 99% of the way towards the value. This methods is similar to setTargetAtTime except the third argument is a time instead of a 'timeConstant'


const osc = new Tone.Oscillator().toDestination().start();
// exponential approach over 4 seconds starting in 1 second
osc.frequency.exponentialApproachValueAtTime("C4", "+1", 4);
exponentialApproachValueAtTime (
value:[object Object] ,
time:Time ,
rampTime:Time
) => this

exponentialRampTo #

Schedules an exponential continuous change in parameter value from the current time and current value to the given value over the duration of the rampTime.


const delay = new Tone.FeedbackDelay(0.5, 0.98).toDestination();
// a short burst of noise through the feedback delay
const noise = new Tone.Noise().connect(delay).start().stop("+0.1");
// making the delay time shorter over time will also make the pitch rise
delay.delayTime.exponentialRampTo(0.01, 20);

return Tone.Offline(() => {
	const signal = new Tone.Signal(.1).toDestination();
	signal.exponentialRampTo(5, 0.3, 0.1);
}, 0.5, 1);
exponentialRampTo (
value:[object Object] ,
rampTime:Time ,
startTime?:Time
) => this

exponentialRampToValueAtTime #

Schedules an exponential continuous change in parameter value from the previous scheduled parameter value to the given value.


return Tone.Offline(() => {
	const signal = new Tone.Signal(1).toDestination();
	// the ramp starts from the previously scheduled value, which must be positive
	signal.setValueAtTime(1, 0.1);
	signal.exponentialRampToValueAtTime(0, 0.4);
}, 0.5, 1);
exponentialRampToValueAtTime (
value:[object Object] ,
time:Time
) => this

get #

Get the object's attributes.


const osc = new Tone.Oscillator();
console.log(osc.get());
get ( ) => ParamOptions<TypeName >

static getDefaults #

Returns all of the default options belonging to the class.

getDefaults ( ) => TickParamOptions<any >

getDurationOfTicks #

Return the elapsed time of the number of ticks from the given time

getDurationOfTicks (
ticks:Ticks ,

The number of ticks to calculate

time:Time

The time to get the next tick from

) => Seconds
The duration of the number of ticks from the given time in seconds

getTicksAtTime #

Returns the tick value at the time. Takes into account any automation curves scheduled on the signal.

getTicksAtTime (
time:Time

The time to get the tick count at

) => Ticks
The number of ticks which have elapsed at the time given any automations.

getTimeOfTick #

Given a tick, returns the time that tick occurs at.

getTimeOfTick (
tick:Ticks
) => Seconds
The time that the tick occurs.

getValueAtTime #

Get the signals value at the given time. Subsequent scheduling may invalidate the returned value.


const signal = new Tone.Signal().toDestination();
// ramp up to '8' over 3 seconds
signal.rampTo(8, 3);
// ramp back down to '0' over 3 seconds
signal.rampTo(0, 3, "+3");
setInterval(() => {
	// check the value every 100 ms
	console.log(signal.getValueAtTime(Tone.now()));
}, 100);
getValueAtTime (
time:Time
) => [object Object]

immediate #

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


setInterval(() => {
	console.log(Tone.immediate());
}, 100);
immediate ( ) => Seconds

linearRampTo #

Schedules an linear continuous change in parameter value from the current time and current value to the given value over the duration of the rampTime.


const delay = new Tone.FeedbackDelay(0.5, 0.98).toDestination();
// a short burst of noise through the feedback delay
const noise = new Tone.Noise().connect(delay).start().stop("+0.1");
// making the delay time shorter over time will also make the pitch rise
delay.delayTime.linearRampTo(0.01, 20);

return Tone.Offline(() => {
	const signal = new Tone.Signal(1).toDestination();
	signal.linearRampTo(0, 0.3, 0.1);
}, 0.5, 1);
linearRampTo (
value:[object Object] ,
rampTime:Time ,
startTime?:Time
) => this
this

linearRampToValueAtTime #

Schedules a linear continuous change in parameter value from the previous scheduled parameter value to the given value.


return Tone.Offline(() => {
	const signal = new Tone.Signal(0).toDestination();
	// the ramp starts from the previously scheduled value
	signal.setValueAtTime(0, 0.1);
	signal.linearRampToValueAtTime(1, 0.4);
}, 0.5, 1);
linearRampToValueAtTime (
value:[object Object] ,
time:Time
) => this

now #

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


setInterval(() => {
	console.log(Tone.now());
}, 100);
now ( ) => Seconds

rampTo #

Ramps to the given value over the duration of the rampTime. Automatically selects the best ramp type (exponential or linear) depending on the units of the signal


const osc = new Tone.Oscillator().toDestination().start();
// schedule it to ramp either linearly or exponentially depending on the units
osc.frequency.rampTo("A2", 10);

const osc = new Tone.Oscillator().toDestination().start();
// schedule it to ramp starting at a specific time
osc.frequency.rampTo("A2", 10, "+2");
rampTo (
value:[object Object] ,
rampTime= 0.1:Time ,
startTime?:Time
) => this

set #

Set multiple properties at once with an object.


const filter = new Tone.Filter().toDestination();
// set values using an object
filter.set({
	frequency: "C6",
	type: "highpass"
});
const player = new Tone.Player("https://tonejs.github.io/audio/berklee/Analogsynth_octaves_highmid.mp3").connect(filter);
player.autostart = true;
set (
props:RecursivePartial<ParamOptions<TypeName > >
) => this

setParam #

Replace the Param's internal AudioParam. Will apply scheduled curves onto the parameter and replace the connections.

setParam (
param:AudioParam
) => this

setRampPoint #

Creates a schedule point with the current value at the current time. Automation methods like linearRampToValueAtTime and exponentialRampToValueAtTime require a starting automation value usually set by setValueAtTime. This method is useful since it will do a setValueAtTime with whatever the currently computed value at the given time is.


const osc = new Tone.Oscillator().toDestination().start();
// set the frequency to "G4" in exactly 1 second from now.
osc.frequency.setRampPoint("+1");
osc.frequency.linearRampToValueAtTime("C1", "+2");
setRampPoint (
time:Time
) => this

setTargetAtTime #

Start exponentially approaching the target value at the given time with a rate having the given time constant.

setTargetAtTime (
value:[object Object] ,
time:Time ,
constant:number
) => this

setValueAtTime #

Schedules a parameter value change at the given time.


return Tone.Offline(() => {
	const osc = new Tone.Oscillator(20).toDestination().start();
	// set the frequency to 40 at exactly 0.25 seconds
	osc.frequency.setValueAtTime(40, 0.25);
}, 0.5, 1);
setValueAtTime (
value:[object Object] ,
time:Time
) => this

setValueCurveAtTime #

Sets an array of arbitrary parameter values starting at the given time for the given duration.


return Tone.Offline(() => {
	const signal = new Tone.Signal(1).toDestination();
	signal.setValueCurveAtTime([1, 0.2, 0.8, 0.1, 0], 0.2, 0.3);
}, 0.5, 1);
setValueCurveAtTime (
values:[object Object] [] ,
startTime:Time ,
duration:Time ,
scaling= 1:number
) => this

targetRampTo #

Start exponentially approaching the target value at the given time. Since it is an exponential approach it will continue approaching after the ramp duration. The rampTime is the time that it takes to reach over 99% of the way towards the value.


return Tone.Offline(() => {
	const signal = new Tone.Signal(1).toDestination();
	signal.targetRampTo(0, 0.3, 0.1);
}, 0.5, 1);
targetRampTo (
value:[object Object] ,
rampTime:Time ,
startTime?:Time
) => this

ticksToTime #

Convert some number of ticks their the duration in seconds accounting for any automation curves starting at the given time.

ticksToTime (
ticks:Ticks ,

The number of ticks to convert to seconds.

when:Time

When along the automation timeline to convert the ticks.

) => Seconds
The duration in seconds of the ticks.

timeToTicks #

The inverse of ticksToTime. Convert a duration in seconds to the corresponding number of ticks accounting for any automation curves starting at the given time.

timeToTicks (
duration:Time ,

The time interval to convert to ticks.

when:Time

When along the automation timeline to convert the ticks.

) => Ticks
The duration in ticks.

toFrequency #

Convert the input to a frequency number


const gain = new Tone.Gain();
console.log(gain.toFrequency("4n"));
toFrequency (
freq:Frequency
) => Hertz

toSeconds #

Convert the incoming time to seconds. This is calculated against the current Tone.Transport bpm


const gain = new Tone.Gain();
setInterval(() => console.log(gain.toSeconds("4n")), 100);
// ramp the tempo to 60 bpm over 30 seconds
Tone.getTransport().bpm.rampTo(60, 30);
toSeconds (
time?:Time
) => Seconds

toString #

Convert the class to a string


const osc = new Tone.Oscillator();
console.log(osc.toString());
toString ( ) => string

toTicks #

Convert the input time into ticks


const gain = new Tone.Gain();
console.log(gain.toTicks("4n"));
toTicks (
time?:Time | TimeClass
) => Ticks