tone
Version:
A Web Audio framework for making interactive music in the browser.
105 lines (104 loc) • 3.72 kB
TypeScript
import { Param } from "../core/context/Param.js";
import { OutputNode, ToneAudioNode, ToneAudioNodeOptions } from "../core/context/ToneAudioNode.js";
import { Decibels, Frequency, NormalRange, Time } from "../core/type/Units.js";
export interface InstrumentOptions extends ToneAudioNodeOptions {
volume: Decibels;
}
/**
* Base-class for all instruments
*/
export declare abstract class Instrument<Options extends InstrumentOptions> extends ToneAudioNode<Options> {
/**
* The output and volume triming node
*/
private _volume;
output: OutputNode;
/**
* The instrument only has an output
*/
input: undefined;
/**
* The volume of the output in decibels.
* @example
* const amSynth = new Tone.AMSynth().toDestination();
* amSynth.volume.value = -6;
* amSynth.triggerAttackRelease("G#3", 0.2);
*/
volume: Param<"decibels">;
/**
* Keep track of all events scheduled to the transport
* when the instrument is 'synced'
*/
private _scheduledEvents;
/**
* If the instrument is currently synced
*/
private _synced;
constructor(options?: Partial<InstrumentOptions>);
static getDefaults(): InstrumentOptions;
/**
* Sync the instrument to the Transport. All subsequent calls of
* {@link triggerAttack} and {@link triggerRelease} will be scheduled along the transport.
* @example
* const fmSynth = new Tone.FMSynth().toDestination();
* fmSynth.volume.value = -6;
* fmSynth.sync();
* // schedule 3 notes when the transport first starts
* fmSynth.triggerAttackRelease("C4", "8n", 0);
* fmSynth.triggerAttackRelease("E4", "8n", "8n");
* fmSynth.triggerAttackRelease("G4", "8n", "4n");
* // start the transport to hear the notes
* Tone.Transport.start();
*/
sync(): this;
/**
* set _sync
*/
protected _syncState(): boolean;
/**
* Wrap the given method so that it can be synchronized
* @param method Which method to wrap and sync
* @param timePosition What position the time argument appears in
*/
protected _syncMethod(method: string, timePosition: number): void;
/**
* Unsync the instrument from the Transport
*/
unsync(): this;
/**
* Trigger the attack and then the release after the duration.
* @param note The note to trigger.
* @param duration How long the note should be held for before
* triggering the release. This value must be greater than 0.
* @param time When the note should be triggered.
* @param velocity The velocity the note should be triggered at.
* @example
* const synth = new Tone.Synth().toDestination();
* // trigger "C4" for the duration of an 8th note
* synth.triggerAttackRelease("C4", "8n");
*/
triggerAttackRelease(note: Frequency, duration: Time, time?: Time, velocity?: NormalRange): this;
/**
* Start the instrument's note.
* @param note the note to trigger
* @param time the time to trigger the note
* @param velocity the velocity to trigger the note (between 0-1)
*/
abstract triggerAttack(note: Frequency, time?: Time, velocity?: NormalRange): this;
private _original_triggerAttack;
/**
* Trigger the release phase of the current note.
* @param time when to trigger the release
*/
abstract triggerRelease(...args: any[]): this;
private _original_triggerRelease;
/**
* The release which is scheduled to the timeline.
*/
protected _syncedRelease: (time: number) => this;
/**
* clean up
* @returns {Instrument} this
*/
dispose(): this;
}