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)

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 UnitMap[TypeName]

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.

name #

string

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.

units #

UnitName

The unit type

value #

UnitMap[TypeName]

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.

cancelAndHoldAtTime (
time:Time
) => this

cancelScheduledValues #

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

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'


import { Oscillator } from "tone";
const osc = new Oscillator().toDestination().start();
// exponential approach over 4 seconds starting in 1 second
osc.frequency.exponentialApproachValueAtTime("C4", "+1", 4);
exponentialApproachValueAtTime (
value:UnitMap[TypeName] ,
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.


import { FeedbackDelay, Noise } from "tone";
const delay = new FeedbackDelay(0.5, 0.98).toDestination();
// a short burst of noise through the feedback delay
const noise = new 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);
exponentialRampTo (
value:UnitMap[TypeName] ,
rampTime:Time ,
startTime?:Time
) => this

exponentialRampToValueAtTime #

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

exponentialRampToValueAtTime (
value:UnitMap[TypeName] ,
time:Time
) => 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 ( ) => 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.


import { now, Oscillator } from "tone";
const osc = new Oscillator().toDestination().start();
// set the frequency to "G4" in exactly 1 second from now.
osc.frequency.setValueAtTime("G4", "+1");
setInterval(() => {
	// check the value every 100 ms
	osc.frequency.getValueAtTime(now());
}, 100);
getValueAtTime (
time:Time
) => UnitMap[TypeName]

immediate #

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

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.


import { FeedbackDelay, Noise } from "tone";
const delay = new FeedbackDelay(0.5, 0.98).toDestination();
// a short burst of noise through the feedback delay
const noise = new Noise().connect(delay).start().stop("+0.1");
// linearly ramp to the value 4 over 3 seconds.
delay.delayTime.linearRampTo(4, 3);
linearRampTo (
value:UnitMap[TypeName] ,
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.

linearRampToValueAtTime (
value:UnitMap[TypeName] ,
time:Time
) => this

now #

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

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


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

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

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<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.


import { Oscillator } from "tone";
const osc = new 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:UnitMap[TypeName] ,
time:Time ,
constant:number
) => this

setValueAtTime #

Schedules a parameter value change at the given time.


import { Oscillator } from "tone";
const osc = new Oscillator().toDestination().start();
// set the frequency to "G4" in exactly 1 second from now.
osc.frequency.setValueAtTime("G4", "+1");
setValueAtTime (
value:UnitMap[TypeName] ,
time:Time
) => this

setValueCurveAtTime #

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

setValueCurveAtTime (
values:UnitMap[TypeName] [] ,
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.


import { Oscillator } from "tone";
const osc = new Oscillator().toDestination().start();
osc.frequency.targetRampTo("C4", 4);
targetRampTo (
value:UnitMap[TypeName] ,
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

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