ixfx
    Preparing search index...

    ADSR (Attack Decay Sustain Release) envelope. An envelope is a value that changes over time, usually in response to an intial trigger.

    See the ixfx Guide on Envelopes.

    const env = new Envelopes.Adsr({
    attackDuration: 1000,
    decayDuration: 200,
    sustainDuration: 100
    });

    Options for envelope are as follows:

    initialLevel?: number
    attackBend: number
    attackDuration: number
    decayBend: number
    decayDuration:number
    sustainLevel: number
    releaseBend: number
    releaseDuration: number
    releaseLevel?: number
    peakLevel: number
    retrigger?: boolean
    shouldLoop: boolean

    If retrigger is false (default), a re-triggered envelope continues at current value rather than resetting to initialLevel.

    If shouldLoop is true, envelope loops until release() is called.

    env.trigger(); // Start envelope
    ...
    // Get current value of envelope
    const [state, scaled, raw] = env.compute();
    • state is a string, one of the following: 'attack', 'decay', 'sustain', 'release', 'complete'
    • scaled is a value scaled according to the stage's levels
    • raw is the progress from 0 to 1 within a stage. ie. 0.5 means we're halfway through a stage.

    Instead of compute(), most usage of the envelope is just fetching the value property, which returns the same scaled value of compute():

    const value = env.value; // Get scaled number
    
    env.trigger(true);   // Pass in true to hold
    ...envelope will stop at sustain stage...
    env.release(); // Release into decay

    Check if it's done:

    env.isDone; // True if envelope is completed
    

    Envelope has events to track activity: 'change' and 'complete':

    env.addEventListener(`change`, ev => {
    console.log(`Old: ${evt.oldState} new: ${ev.newState}`);
    })

    It's also possible to iterate over the values of the envelope:

    const env = new Envelopes.Adsr();
    for await (const v of env) {
    // v is the numeric value
    await Flow.sleep(100); // Want to pause a little to give envelope time to run
    }
    // Envelope has finished

    Hierarchy (View Summary)

    Implements

    • Iterable<number>
    Index

    Accessors

    Constructors

    Methods

    • Compute value of envelope at this point in time.

      Returns an array of [stage, scaled, raw]. Most likely you want to use value to just get the scaled value.

      Parameters

      • allowStateChange: boolean = true

        If true (default) envelope will be allowed to change state if necessary before returning value

      • allowLooping: boolean = true

      Returns [stage: string, scaled: number, raw: number]

    • Computes a stage's progress from 0-1

      Parameters

      • allowStateChange: boolean = true
      • allowLooping: boolean = true

      Returns [stage: string, amount: number, prevStage: string]

    • Triggers envelope, optionally holding it.

      If hold is false (default), envelope will run through all stages, but sustain stage won't have an affect.

      If hold is true, it will run to, and stay at the sustain stage. Use release to later release the envelope.

      If event is already trigged it will be retriggered. Initial value depends on opts.retrigger

      • false (default): envelope continues at current value.
      • true: envelope value resets to opts.initialValue.

      Parameters

      • hold: boolean = false

        If true envelope will hold at sustain stage

      Returns void

    Properties

    attackBend: any
    attackDuration: number
    attackPath: Path
    decayBend: any
    decayDuration: number
    decayDurationTotal: number
    decayPath: Path
    initialLevel: any
    initialLevelOverride: undefined | number
    peakLevel: any
    releaseBend: any
    releaseDuration: number
    releaseLevel: any
    releasePath: Path
    retrigger: boolean
    shouldLoop: boolean

    If true envelope will loop

    sustainLevel: any