Documentation
    Preparing search index...

    Class TickParam<TypeName>

    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

    Type Parameters

    • TypeName extends "hertz" | "bpm"

    Hierarchy (View Summary)

    Index

    The timeline which tracks all of the automations.

    _initialValue: number

    The default value before anything is assigned

    _param: AudioParam

    The native parameter to control

    _swappable: boolean

    If the underlying AudioParam can be swapped out using the setParam method.

    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.

    input: AudioParam | GainNode
    name: string

    The name of the class

    overridden: boolean

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

    units: keyof UnitMap

    The unit type

    version: string

    The version number semver

    • get blockTime(): number

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

      Returns number

      console.log(Tone.Destination.blockTime);
      
    • get defaultValue(): UnitMap[TypeName]

      Returns UnitMap[TypeName]

    • get disposed(): 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.

      Returns boolean

    • get maxValue(): number

      The maximum value of the output given the units

      Returns number

    • get minValue(): number

      The minimum value of the output given the units

      Returns number

    • get multiplier(): number

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

      Returns number

    • set multiplier(m: number): void

      Parameters

      • m: number

      Returns void

    • get sampleTime(): number

      The duration in seconds of one sample.

      Returns number

    • get value(): UnitMap[TypeName]

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

      Returns UnitMap[TypeName]

    • set value(value: UnitMap[TypeName]): void

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

      Parameters

      Returns void

    • Parameters

      • t0: number
      • v0: number
      • v1: number
      • timeConstant: number
      • t: number

      Returns number

    • Parameters

      • t0: number
      • v0: number
      • t1: number
      • v1: number
      • t: number

      Returns number

    • Convert from the type when the unit value is BPM

      Parameters

      Returns number

    • Parameters

      • t0: number
      • v0: number
      • t1: number
      • v1: number
      • t: number

      Returns number

    • Special case of type conversion where the units === "bpm"

      Parameters

      • val: number

      Returns UnitMap[TypeName]

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

      Parameters

      • param: AudioParam | Param<"number">

      Returns this

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

      Parameters

      Returns this

      return Tone.Offline(() => {
      const signal = new Tone.Signal(0).toDestination();
      signal.linearRampTo(1, 0.5, 0);
      signal.cancelAndHoldAtTime(0.3);
      }, 0.5, 1);
    • Cancels all scheduled parameter changes with times greater than or equal to startTime.

      Parameters

      Returns this

      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);
    • disconnect and dispose.

      Returns this

    • 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'

      Parameters

      • value: UnitMap[TypeName]

        The value to ramp to.

      • time: Time

        When the ramp should start.

      • rampTime: Time

        the time that it takes the value to ramp from it's current value

      Returns this

      const osc = new Tone.Oscillator().toDestination().start();
      // exponential approach over 4 seconds starting in 1 second
      osc.frequency.exponentialApproachValueAtTime("C4", "+1", 4);
    • 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.

      Parameters

      • value: UnitMap[TypeName]

        The value to ramp to.

      • rampTime: Time

        the time that it takes the value to ramp from it's current value

      • OptionalstartTime: Time

        When the ramp should start.

      Returns this

      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);
    • Schedules an exponential continuous change in parameter value from the previous scheduled parameter value to the given value.

      Parameters

      Returns this

      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);
    • Get the object's attributes.

      Returns ParamOptions

      const osc = new Tone.Oscillator();
      console.log(osc.get());
    • Return the elapsed time of the number of ticks from the given time

      Parameters

      • ticks: number

        The number of ticks to calculate

      • time: Time

        The time to get the next tick from

      Returns number

      The duration of the number of ticks from the given time in seconds

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

      Parameters

      • time: Time

        The time to get the tick count at

      Returns number

      The number of ticks which have elapsed at the time given any automations.

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

      Parameters

      • tick: number

      Returns number

      The time that the tick occurs.

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

      Parameters

      • time: Time

        When to get the value

      Returns UnitMap[TypeName]

      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);
    • Return the current time of the Context clock without any lookAhead.

      Returns number

      setInterval(() => {
      console.log(Tone.immediate());
      }, 100);
    • 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.

      Parameters

      • value: UnitMap[TypeName]

        The value to ramp to.

      • rampTime: Time

        the time that it takes the value to ramp from it's current value

      • OptionalstartTime: Time

        When the ramp should start.

      Returns this

      this

      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);
    • Schedules a linear continuous change in parameter value from the previous scheduled parameter value to the given value.

      Parameters

      Returns this

      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);
    • Prints the outputs to the console log for debugging purposes. Prints the contents only if either the object has a property called debug set to true, or a variable called TONE_DEBUG_CLASS is set to the name of the class.

      Parameters

      • ...args: any[]

      Returns void

      const osc = new Tone.Oscillator();
      // prints all logs originating from this oscillator
      osc.debug = true;
      // calls to start/stop will print in the console
      osc.start();
    • Return the current time of the Context clock plus the lookAhead.

      Returns number

      setInterval(() => {
      console.log(Tone.now());
      }, 100);
    • 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

      Parameters

      • value: UnitMap[TypeName]
      • OptionalrampTime: Time

        The time that it takes the value to ramp from it's current value

      • OptionalstartTime: Time

        When the ramp should start.

      Returns this

      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");
    • Set multiple properties at once with an object.

      Parameters

      Returns this

      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;
    • Replace the Param's internal AudioParam. Will apply scheduled curves onto the parameter and replace the connections.

      Parameters

      • param: AudioParam

      Returns this

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

      Parameters

      • time: Time

        When to add a ramp point.

      Returns this

      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");
    • Start exponentially approaching the target value at the given time with a rate having the given time constant.

      Parameters

      Returns this

    • Schedules a parameter value change at the given time.

      Parameters

      • value: UnitMap[TypeName]

        The value to set the signal.

      • time: Time

        The time when the change should occur.

      Returns this

      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);
    • Sets an array of arbitrary parameter values starting at the given time for the given duration.

      Parameters

      • values: UnitMap[TypeName][]
      • startTime: Time
      • duration: Time
      • Optionalscaling: number

        If the values in the curve should be scaled by some value

      Returns this

      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);
    • 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.

      Parameters

      • value: UnitMap[TypeName]

        The value to ramp to.

      • rampTime: Time

        the time that it takes the value to ramp from it's current value

      • OptionalstartTime: Time

        When the ramp should start.

      Returns this

      
      
      return Tone.Offline(() => {
      const signal = new Tone.Signal(1).toDestination();
      signal.targetRampTo(0, 0.3, 0.1);
      }, 0.5, 1);
    • Convert some number of ticks their the duration in seconds accounting for any automation curves starting at the given time.

      Parameters

      • ticks: number

        The number of ticks to convert to seconds.

      • when: Time

        When along the automation timeline to convert the ticks.

      Returns number

      The duration in seconds of the ticks.

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

      Parameters

      • duration: Time

        The time interval to convert to ticks.

      • when: Time

        When along the automation timeline to convert the ticks.

      Returns number

      The duration in ticks.

    • Convert the input to a frequency number

      Parameters

      Returns number

      const gain = new Tone.Gain();
      console.log(gain.toFrequency("4n"));
    • Convert the incoming time to seconds. This is calculated against the current TransportClass bpm

      Parameters

      Returns number

      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);
    • Convert the class to a string

      Returns string

      const osc = new Tone.Oscillator();
      console.log(osc.toString());
    • Convert the input time into ticks

      Parameters

      Returns number

      const gain = new Tone.Gain();
      console.log(gain.toTicks("4n"));
    • Returns all of the default options belonging to the class.

      Returns TickParamOptions<any>