plugins/synths.cracked.js

  1. /**
  2.  * gang_of_oscillators
  3.  *
  4.  * Just a bunch of oscillators
  5.  *
  6.  * [See more synth examples](examples/synth.html)
  7.  *
  8.  * @plugin
  9.  * @category Synth
  10.  * @function
  11.  * @memberof cracked
  12.  * @name cracked#gang_of_oscillators
  13.  * @public
  14.  * @param {Object} [params] map of optional values
  15.  */
  17. cracked.gang_of_oscillators = function(params) {
  19.     /*
  20.      //expected format
  21.      {
  22.      size:16,
  23.      lp_freq:20000,
  24.      type:sine
  25.      }
  26.      //or just type as a string
  27.      */
  29.     var type = __.isStr(params) ? params : __.isObj(params) && params.type ? params.type : "sine";
  30.     var lp_freq =  __.isObj(params) && params.lp_freq ? params.lp_freq : 20000;
  31.     var size =  __.isObj(params) && params.size ? params.size : 16;
  33.     __().begin("gang_of_oscillators",params);
  34.     __().gain();
  35.     for(var i=0;i<size;i++) {
  36.         __().begin("v"+(i+1)).osc({type:type}).lowpass(lp_freq).gain(0).end("v"+(i+1)).connect("gain");
  37.     }
  38.     __.end("gang_of_oscillators");
  40.     return cracked;
  41. };
  43. /**
  44.  * monosynth
  45.  *
  46.  * Simple monophonic synth
  47.  *
  48.  * [See more synth examples](examples/synth.html)
  49.  *
  50.  * @plugin
  51.  * @category Synth
  52.  * @function
  53.  * @memberof cracked
  54.  * @name cracked#monosynth
  55.  * @public
  56.  * @param {Object} [params] map of optional values
  57.  */
  58. cracked.monosynth = function (params) {
  60.     var methods = {
  61.         init: function (options) {
  63.             var opts = options || {};
  65.             /*
  66.              expected format
  67.              {
  68.                  lfo_type:"sawtooth",
  69.                  lfo_intensity:0,
  70.                  lfo_speed:5
  71.                  osc_type:"sine",
  72.                  osc_frequency:440,
  73.                  osc_detune:0
  74.                  lp_q:0,
  75.                  lp_frequency:440
  76.                  adsr_envelope:0.5
  77.                  gain_volume:1
  78.              }
  79.              */
  81.             //set up a basic synth: lfo, sine, lowpass, envelope
  82.             //options:
  83.             //lfo- type, intensity, speed
  84.             //osc- type, frequency, detune
  85.             //lowpass- q, frequency
  86.             //adsr- envelope
  87.             //gain- volume
  89.             var lfo_type        = opts.lfo_type         || "sawtooth",
  90.                 lfo_intensity   = opts.lfo_intensity    || 0,
  91.                 lfo_speed       = opts.lfo_speed        || 5,
  92.                 osc_type        = opts.osc_type         || "sine",
  93.                 osc_frequency   = opts.osc_frequency    || 440,
  94.                 osc_detune      = opts.osc_detune       || 0,
  95.                 lp_q            = opts.lp_q             || 0,
  96.                 lp_frequency    = opts.lp_frequency     || 440,
  97.                 adsr_envelope   = opts.adsr_envelope    || 0.5,
  98.                 gain_volume     = opts.gain_volume      || 1;
  100.             __().begin("monosynth", params).
  102.                 lfo({
  103.                     gain:lfo_intensity,
  104.                     frequency:lfo_speed,
  105.                     type:lfo_type
  106.                 }).
  108.                 osc({
  109.                     detune:osc_detune,
  110.                     frequency:osc_frequency,
  111.                     type:osc_type
  112.                 }).
  114.                 lowpass({
  115.                     q: lp_q,
  116.                     frequency:lp_frequency
  117.                 }).
  119.                 adsr({
  120.                     envelope:adsr_envelope
  121.                 }).
  123.                 gain({
  124.                     gain:gain_volume
  125.                 }).
  127.                 end("monosynth");
  128.         },
  129.         noteOn: function (params) {
  130.             //process incoming arguments for this note
  131.             var args = params || {};
  132.             var freq = __.isNum(params) ? __.pitch2freq(params) : __.pitch2freq(args.pitch);
  133.             var vel = __.isNum(args.velocity) ? args.velocity/127 : 0.5;
  134.             var env = args.envelope || [0.01,0.1,0.5];
  136.             //loop thru selected nodes
  137.             cracked.each("monosynth", function (el, index, arr) {
  138.                 //select any internal oscillator nodes the monosynth contains (using "el.search(osc)")
  139.                 //and then call frequency() passing in the pitch argument we got w noteOn.
  140.                 cracked.exec("frequency", [freq], el.search("osc"));
  141.                 //apply the velocity to the output gain
  142.                 cracked.exec("volume", [vel], el.search("gain"));
  143.                 //grab internal adsr and call trigger, pass the envelope parameter we received
  144.                 cracked.exec("adsr", ["trigger", env], el.search("adsr"));
  145.             });
  146.         },
  147.         noteOff: function (params) {
  148.             cracked.each("monosynth", function (el, index, arr) {
  149.                 params = __.ifUndef(params,0.1);
  150.                 var p = __.isNum(params) ? params : __.ifUndef(params.envelope,0.1);
  151.                 //call the adsr release
  152.                 cracked.exec("adsr", ["release",p], el.search("adsr"));
  153.             });
  154.         }
  155.     };
  157.     if (methods[params]) {
  158.         methods[params].apply(this, Array.prototype.slice.call(arguments, 1));
  159.     } else {
  160.         methods.init(params);
  161.     }
  163.     return cracked;
  164. };
  167. /**
  168.  * polysynth
  169.  *
  170.  * Simple polyphonic synth
  171.  *
  172.  * [See more synth examples](examples/synth.html)
  173.  *
  174.  * @plugin
  175.  * @category Synth
  176.  * @function
  177.  * @memberof cracked
  178.  * @name cracked#polysynth
  179.  * @public
  180.  * @param {Object} [params] map of optional values
  181.  */
  182. cracked.polysynth = function (params) {
  184.     var methods = {
  185.         init: function (options) {
  187.             var opts = options || {};
  189.             /*
  190.              expected format
  191.              {
  192.                  lfo_type:"sawtooth",
  193.                  lfo_intensity:0,
  194.                  lfo_speed:5
  195.                  osc_type:"sine",
  196.                  osc_frequency:440,
  197.                  osc_detune:0
  198.                  lp_q:0,
  199.                  lp_frequency:440
  200.                  adsr_envelope:0.5
  201.                  gain_volume:1
  202.              }
  203.              */
  205.             //set up a basic synth: lfo, sine, lowpass, envelope
  206.             //options:
  207.             //lfo- type, intensity, speed
  208.             //osc- type, frequency, detune
  209.             //lowpass- q, frequency
  210.             //adsr- envelope
  211.             //gain- volume
  213.             params = params || {};
  215.             //defaults
  216.             params.lfo_type        = opts.lfo_type         || "sawtooth";
  217.             params.lfo_intensity   = opts.lfo_intensity    || 0;
  218.             params.lfo_speed       = opts.lfo_speed        || 5;
  219.             params.osc_type        = opts.osc_type         || "sine";
  220.             params.osc_frequency   = opts.osc_frequency    || 440;
  221.             params.osc_detune      = opts.osc_detune       || 0;
  222.             params.lp_q            = opts.lp_q             || 0;
  223.             params.lp_frequency    = opts.lp_frequency     || 440;
  224.             params.adsr_envelope   = opts.adsr_envelope    || 0.5;
  225.             params.gain_volume     = opts.gain_volume      || 1;
  227.             //we'll add a map so we can track active voices
  228.             params.active_voices = {};
  230.             //just a stub we'll attach voices to in the noteon method
  231.             __().begin("polysynth", params).
  233.                 gain({
  234.                     gain:params.gain_volume
  235.                 }).
  237.                 end("polysynth");
  238.         },
  239.         noteOn: function (params) {
  240.             //process incoming arguments for this note
  241.             var args = params || {};
  242.             var note_number = __.isNum(params) ? params : args.pitch;
  243.             var freq = __.pitch2freq(note_number);
  244.             var vel = __.isNum(args.velocity) ? args.velocity/127 : 0.5;
  245.             var env = args.envelope || [0.01,0.1,0.5];
  246.             var instance_id = note_number+"_"+Date.now();
  248.             //loop thru selected nodes, filtering on the type polysynth
  249.             cracked.each("polysynth", function (el, index, arr) {
  251.                 //get the settings that were stored when the object was created
  252.                 var voices = el.getParams().settings.active_voices;
  253.                 var settings = el.getParams().settings;
  255.                 //if not currently active
  256.                 if(!voices[note_number]) {
  258.                     //ignore the grid while we're creating the voice
  259.                     __.loop("toggle_grid");
  261.                     //create a new voice
  262.                     __().lfo({
  263.                             type:settings.lfo_type,
  264.                             gain:settings.lfo_intensity,
  265.                             frequency:settings.lfo_speed,
  266.                             id:instance_id+"_lfo",
  267.                             class:instance_id+"_class",
  268.                             modulates:"frequency"
  269.                         }).osc({
  270.                             id:instance_id+"_osc",
  271.                             class:instance_id+"_class",
  272.                             frequency:freq,
  273.                             type:settings.osc_type,
  274.                             detune: settings.osc_detune
  275.                         }).adsr({
  276.                             envelope:env,
  277.                             id:instance_id+"_adsr",
  278.                             class:instance_id+"_class"
  279.                         }).lowpass({
  280.                             id:instance_id+"_lp",
  281.                             class:instance_id+"_class",
  282.                             frequency:settings.lp_frequency,
  283.                             q:settings.lp_q
  284.                         }).gain({
  285.                             id:instance_id+"_gain",
  286.                             class:instance_id+"_class",
  287.                             gain:vel
  288.                         }).connect(el);
  290.                     //flip it back before we start it up
  291.                     __.loop("toggle_grid");
  293.                     //start it up
  294.                     cracked.exec("start", [], __.find("."+instance_id+"_class"));
  295.                     //trigger the envelope
  296.                     cracked.exec("adsr", ["trigger", env], __.find("#"+instance_id+"_adsr"));
  298.                     voices[note_number]=instance_id;
  299.                 }
  301.             });
  302.         },
  303.         noteOff: function (params) {
  304.             cracked.each("polysynth", function (el, index, arr) {
  306.                 //the only params should be the pitch and the (optional) envelope release time
  307.                 var note_number = __.isNum(params) ? params : params.pitch;
  308.                 var release = __.ifUndef(params.envelope,0.1);
  309.                 //get the active voices map
  310.                 var voices = el.getParams().settings.active_voices;
  311.                 //and the instance id
  312.                 var instance_id = note_number ? voices[note_number] : false;
  313.                 //if its active
  314.                 if(instance_id) {
  315.                     //call the adsr release
  316.                     cracked.exec("adsr", ["release", release], __.find("#"+instance_id+"_adsr"));
  317.                     //schedule the removal of the voice after it's done playing
  318.                     cracked.exec("remove", [((release*1000)+250)], __.find("."+instance_id+"_class"));
  319.                     //clear the active status so it can be run again
  320.                     delete voices[note_number];
  321.                 }
  323.             });
  324.         },
  325.         update:function (params) {
  326.             //update synth params from control
  327.             cracked.each("polysynth", function (el, index, arr) {
  329.                 //get the active voices map
  330.                 var settings = el.getParams().settings;
  331.                 var voices = el.getParams().settings.active_voices;
  333.                 //iterate over the node's params and update with any new values
  334.                 //any new voices will created with these values
  335.                 Object.keys(params).map(function(setting,index,arr){
  336.                     settings[setting]=params[setting];
  337.                 });
  339.                 //iterate over the voices currently playing and update their values
  340.                 Object.keys(voices).map(function(pitch,index,arr){
  341.                     var instance_id = voices[pitch];
  342.                     Object.keys(params).map(function(param,index,arr){
  343.                         switch (param) {
  344.                             case "lfo_speed":
  345.                                 cracked.exec("frequency", [params[param]], __.find("#"+instance_id+"_lfo"));
  346.                                 break;
  347.                             case "lfo_intensity":
  348.                                 cracked.exec("volume", [params[param]], __.find("#"+instance_id+"_lfo"));
  349.                                 break;
  350.                             case "lp_frequency":
  351.                                 cracked.exec("frequency", [params[param]], __.find("#"+instance_id+"_lp"));
  352.                                 break;
  353.                             case "lp_q":
  354.                                 cracked.exec("q", [params[param]], __.find("#"+instance_id+"_lp"));
  355.                                 break;
  356.                         }
  357.                     });
  358.                 });
  360.             });
  361.         }
  362.     };
  364.     if (methods[params]) {
  365.         methods[params].apply(this, Array.prototype.slice.call(arguments, 1));
  366.     } else {
  367.         methods.init(params);
  368.     }
  370.     return cracked;
  371. };