gibberwocky/js/audio.js

music sequencing for Live and Max/MSP

const Gibberish = require( 'gibberish-dsp' )

module.exports = function( Gibber ){

  let Audio = {
    initialized:false,
    instruments:{},
    oscillators:{},
    effects:{},
    exportTarget:null,

    export( obj ) {
      if( Audio.initialized ) 
        Object.assign( obj, this.instruments, this.oscillators, this.effects )
      else
        Audio.exportTarget = obj

    },

    init() {
      window.Gibberish = Gibberish
      window.addEventListener( 'load', Audio.onload )
    },

    // XXX stop clock from being cleared.
    clear() { Gibberish.clear() },

    onload() {
      // XXX define path to AudioWorklet module.
      Gibberish.workletPath = './dist/gibberish_worklet.js'

      Gibberish.init().then( processorNode => {
        Audio.initialized = true
        Audio.node = processorNode
        Audio.createUgens()
        Audio.createClock()

        if( Audio.exportTarget !== null ) Audio.export( Audio.exportTarget )


        window.removeEventListener( 'load', Audio.onload )
      })
    },

    createClock() {
      this.beat = 11025

      const clockFunc  = ()=> {
        Gibberish.processor.port.postMessage({
          address:'clock'
        })
      }

      this.clockSeq  = Gibberish.Sequencer.make( [clockFunc], [this.beat] ).start()

      this.beatCount = 0
      Gibberish.utilities.workletHandlers.clock = () => {
        this.beatCount += 1
        this.beatCount = this.beatCount % 4 

        Gibber.Scheduler.seq( this.beatCount + 1, 'internal' )
      }

      let syn = Gibberish.instruments.Synth().connect()
      syn.disconnect()
    },

    createUgens() {
      for( let instrumentName in Gibberish.instruments ) {
        const gibberishConstructor = Gibberish.instruments[ instrumentName ]
        const defaults = gibberishConstructor.defaults
        
        const constructor = function( ...args ) {
          const __wrappedObject = gibberishConstructor( ...args )
          const obj = { __wrapped__:__wrappedObject }
          for( let propertyName in defaults ) {
            obj[ propertyName ] = value => {
              if( value !== undefined ) {
                __wrappedObject[ propertyName ] = value
              }else{
                return __wrappedObject[ propertyName ]
              }
            }

            obj[ propertyName ].seq = function( values, timings ) {
              obj[ propertyName ].sequencer = Gibberish.Sequencer({ values, timings, target:__wrappedObject, key:propertyName }).start()
            }
          }
          
          obj.note = __wrappedObject.note.bind( __wrappedObject )
          obj.note.seq = function( values, timings, delay=0 ) {
            obj.note.sequencer = Gibberish.Sequencer({ values, timings, target:__wrappedObject, key:'note' }).start( delay )
          }
          obj.trigger = __wrappedObject.trigger.bind( __wrappedObject )
          obj.trigger.seq = function( values, timings, delay=0 ) {
            obj.trigger.sequencer = Gibberish.Sequencer({ values, timings, target:__wrappedObject, key:'trigger' }).start( delay )
          }
          obj.id = 10000
          obj.connect = dest => { __wrappedObject.connect( dest ); return obj } 

          return obj
        }
        
        Audio.instruments[ instrumentName ] = constructor        
      }
    }  
  }

  return Audio
}