notice: Flash editor updated! Join the development! Thanks to MiniBuilder


embed

noswf download fullscreen
flash swf thumbnail play
download fullscreen
FORKED
>sort

Dynamic Sound Generation forked from: Dynamic Sound Generation [diff(1)]

  1. // forked from seagirl's Dynamic Sound Generation
  2. // write as3 code here..
  3. package
  4. {
  5.     import flash.display.Sprite;
  6.     import flash.events.Event;
  7.     import flash.events.TimerEvent;
  8.     import flash.utils.Timer;
  10.     [SWF(backgroundColor="#000000")]
  11.     
  12.     public class DSG extends Sprite
  13.     {
  14.         public function DSG()
  15.         {
  16.             super();
  17.             
  18.             init();
  19.         }
  20.         
  21.         private var timer:Timer;
  22.         private var noteNumbers:Array = [60, 62, 64, 65, 67, 69, 71, 72];
  23.         
  24.         private function init():void
  25.         {
  26.             ring();
  27.             
  28.             timer = new Timer(1000);
  29.             timer.addEventListener(TimerEvent.TIMER, timerHandler);
  30.             timer.start();
  31.         }
  32.         
  33.         private function ring():void
  34.         {
  35.             if (noteNumbers.length == 0)
  36.                 return;
  37.             
  38.             var noteNumber:int = noteNumbers[int(Math.random() * noteNumbers.length)];    
  40.             var attack:Number = Math.random() * 5;
  41.                         var decay:Number = Math.random() * 5;
  42.                         var release:Number = 10 - attack - decay;
  44.             new Tone(noteNumber, 2, 8, attack, decay, 5, release).start();
  45.             new Particle(noteNumber, 2, 8, attack, decay, 5, release, this).start();
  46.         }
  47.         
  48.         private function timerHandler(event:TimerEvent):void
  49.         {
  50.             ring();
  51.         }
  52.         
  53.     }
  54. }
  56. import flash.display.Sprite;
  57. import flash.events.Event;
  58. import flash.events.TimerEvent;
  59. import flash.utils.Timer;
  61. class Particle extends Sprite
  62. {
  63.     public static const UNIT:int = 10;
  64.     
  65.     public static const TIMER_RATE:int = 20;
  66.     
  67.     public function Particle(noteNumber:uint, length:Number, volume:Number, attack:Number, decay:Number, sustain:Number, release:Number, parent:Sprite)
  68.     {    
  69.         this.noteNumber = noteNumber;
  70.         this.length = length;
  71.         this.volume = volume;
  72.         this.attack = attack;
  73.         this.decay = decay;
  74.         this.sustain = sustain;
  75.         this.release = release;
  76.         
  77.         amplify = volume > sustain ? volume : sustain;
  78.         
  79.         parent.addChildAt(this, 0);
  80.         
  81.         check();
  82.         initializeVelocity();
  83.     }
  84.     
  85.     private var timer:Timer;
  86.     
  87.     private var radius:Number = 0;
  88.     private var alphaValue:Number = 1;
  89.     private var amplify:Number = 0;
  90.     
  91.     private var state:int = 1; // 1: Attack, 2: Decay, 3: Release
  92.     
  93.     private var noteNumber:uint;
  94.     private var length:Number;
  95.     private var volume:Number;
  96.     private var attack:Number;
  97.     private var decay:Number;
  98.     private var sustain:Number;
  99.     private var release:Number;
  100.     
  101.     private var v1:Number;
  102.     private var v2:Number;
  103.     private var v3:Number;
  104.     
  105.     private function check():void
  106.     {
  107.         if (attack + decay + release != UNIT)
  108.         {
  109.              attack = 0;
  110.              decay = 5;
  111.              release = 5;
  112.         }
  113.             
  114.         if (volume > UNIT)
  115.             volume = UNIT;
  116.         
  117.         if (volume < 0)
  118.             volume = 0;
  119.             
  120.         if (sustain > UNIT)
  121.             sustain = UNIT;
  122.             
  123.         if (sustain < 0)
  124.             sustain = 0;
  125.     }
  126.     
  127.     private function initializeVelocity():void
  128.     {            
  129.         v1 = volume / (TIMER_RATE * length * attack / UNIT);
  130.         v2 = (volume - sustain) / (TIMER_RATE * length * decay / UNIT);
  131.         v3 = sustain / (TIMER_RATE * length * release / UNIT);
  132.         
  133.         alphaValue = volume > sustain ? volume : sustain;
  134.     }
  135.     
  136.     private function init():void
  137.     {
  138.         timer = new Timer(1000 / TIMER_RATE);
  139.         timer.addEventListener(TimerEvent.TIMER, timerHandler);
  140.         timer.start();
  141.     }
  142.     
  143.     private function update():void
  144.     {
  145.         drawGraphics();
  146.         updateParams();
  147.     }
  148.     
  149.     private function drawGraphics():void
  150.     {
  151.         graphics.clear();
  152.         
  153.         graphics.beginFill(0xFFFFFF, alphaValue / 10);
  154.         graphics.drawCircle(0, 0, radius * 0.8 * amplify);
  155.         graphics.endFill();
  156.     }
  157.     
  158.     private function updateParams():void
  159.     {
  160.         if (state == 1)
  161.         {
  162.             radius += v1;
  164.             if (radius >= volume)
  165.             {
  166.                 radius = volume;
  167.                 state = 2;
  168.             }
  169.         }
  170.         else if (state == 2)
  171.         {
  172.             if (volume < sustain)
  173.             {
  174.                 radius -= v2;
  175.                 
  176.                 if (radius >= sustain)
  177.                 {
  178.                     radius = sustain;
  179.                     state = 3;
  180.                 }
  181.             }
  182.             else
  183.             {
  184.                 alphaValue -= v2;
  185.                 
  186.                 if (alphaValue <= sustain)
  187.                 {
  188.                     alphaValue = sustain;
  189.                     state = 3;
  190.                 }
  191.             }    
  192.         }
  193.         else if (state == 3)
  194.         {
  195.             alphaValue -= v3;
  196.             
  197.             if (alphaValue <= 0)
  198.             {
  199.                 alphaValue = 0;
  200.                 
  201.                 stop();
  202.             }
  203.         }
  204.     }
  205.     
  206.     public function start():void
  207.     {
  208.         if (!parent)
  209.             throw new Error("parent must be specified.");
  210.         
  211.         if (x == 0 && y == 0)
  212.         {
  213.             x = Math.random() * stage.stageWidth;
  214.             y = Math.random() * stage.stageHeight;
  215.         }
  216.         
  217.         timer = new Timer(1000 / TIMER_RATE);
  218.         timer.addEventListener(TimerEvent.TIMER, timerHandler);
  219.         timer.start();
  220.     }
  221.     
  222.     public function stop():void
  223.     {
  224.         timer.removeEventListener(TimerEvent.TIMER, timerHandler);
  225.         
  226.         parent.removeChild(this);
  227.         
  228.         dispatchEvent(new Event(Event.COMPLETE));
  229.     }
  230.     
  231.     private function timerHandler(event:TimerEvent):void
  232.     {
  233.         update();
  234.     }
  235.     
  236. }
  238. import flash.events.Event;
  239. import flash.events.EventDispatcher;
  240. import flash.events.SampleDataEvent;
  241. import flash.media.Sound;
  242. import flash.utils.ByteArray;
  244. class Tone extends EventDispatcher
  245. {
  246.     public static const SAMPLING_RATE:Number = 44100;
  247.     public static const BUFFER_SIZE:int = 8192;
  248.         
  249.     public static const UNIT:int = 10;
  250.     
  251.     public function Tone(noteNumber:uint, length:Number, volume:Number, attack:Number, decay:Number, sustain:Number, release:Number)
  252.     {    
  253.         this.frequency = noteNumber2frequency(noteNumber);
  254.         this.length = length;
  255.         this.volume = volume;
  256.         this.attack = attack;
  257.         this.decay = decay;
  258.         this.sustain = sustain;
  259.         this.release = release;
  260.         
  261.         check();
  262.         initializeVelocity();
  263.     }
  264.     
  265.     private var sound:Sound;
  266.     
  267.     private var phase:Number = 0;
  268.     private var amplify:Number = 0;
  269.     
  270.     private var state:int = 1; // 1: Attack, 2: Decay, 3: Release
  271.     
  272.     private var frequency:Number;
  273.     private var length:Number;
  274.     private var volume:Number;
  275.     private var attack:Number;
  276.     private var decay:Number;
  277.     private var sustain:Number;
  278.     private var release:Number;
  279.     
  280.     private var v1:Number;
  281.     private var v2:Number;
  282.     private var v3:Number;
  283.         
  284.     private function check():void
  285.     {
  286.         if (attack + decay + release != UNIT)
  287.         {
  288.              attack = 0;
  289.              decay = 5;
  290.              release = 5;
  291.         }
  292.             
  293.         if (volume > UNIT)
  294.             volume = UNIT;
  295.         
  296.         if (volume < 0)
  297.             volume = 0;
  298.             
  299.         if (sustain > UNIT)
  300.             sustain = UNIT;
  301.             
  302.         if (sustain < 0)
  303.             sustain = 0;
  304.     }
  305.     
  306.     private function initializeVelocity():void
  307.     {            
  308.         v1 = volume / (SAMPLING_RATE * length * attack / UNIT);
  309.         v2 = (volume - sustain) / (SAMPLING_RATE * length * decay / UNIT);
  310.         v3 = sustain / (SAMPLING_RATE * length * release / UNIT);
  311.     }
  312.     
  313.     private function updateAmplify():void
  314.     {
  315.         if (state == 1)
  316.         {
  317.             amplify += v1;
  319.             if (amplify >= volume)
  320.             {
  321.                 amplify = volume;
  322.                 state = 2;
  323.             }
  324.         }
  325.         else if (state == 2)
  326.         {
  327.             amplify -= v2;
  328.             
  329.             if (volume < sustain)
  330.             {
  331.                 if (amplify >= sustain)
  332.                 {
  333.                     amplify = sustain;
  334.                     state = 3;
  335.                 }
  336.             }
  337.             else
  338.             {
  339.                 if (amplify <= sustain)
  340.                 {
  341.                     amplify = sustain;
  342.                     state = 3;
  343.                 }
  344.             }    
  345.         }
  346.         else if (state == 3)
  347.         {
  348.             amplify -= v3;
  349.             
  350.             if (amplify <= 0)
  351.             {
  352.                 amplify = 0;
  353.                 
  354.                 stop();
  355.             }
  356.         }
  357.     }
  358.     
  359.     public function start():void
  360.     {                    
  361.         sound = new Sound();
  362.         sound.addEventListener(SampleDataEvent.SAMPLE_DATA, soundSampleDataHandler);
  363.         sound.play();
  364.     }
  365.     
  366.     public function stop():void
  367.     {
  368.         sound.removeEventListener(SampleDataEvent.SAMPLE_DATA, soundSampleDataHandler);
  369.         dispatchEvent(new Event(Event.COMPLETE));
  370.     }
  371.     
  372.     private function soundSampleDataHandler(event:SampleDataEvent):void
  373.     {    
  374.         var bytes:ByteArray = new ByteArray();
  375.         
  376.         for (var i:int = 0; i < BUFFER_SIZE; ++i)
  377.         {
  378.             phase += frequency / SAMPLING_RATE;  
  379.             
  380.             var phaseAngle:Number = phase * Math.PI * 2;
  381.             var sample:Number = Math.sin(phaseAngle) * amplify / UNIT;
  382.             
  383.             sample *= 0.2;
  384.             
  385.             bytes.writeFloat(sample);
  386.             bytes.writeFloat(sample);
  387.             
  388.             updateAmplify();
  389.         }
  390.         
  391.         event.data.writeBytes(bytes);
  392.     }
  393.     
  394. }
  396. function noteNumber2frequency(value:uint):Number
  397. {
  398.     if (value > 127)
  399.         value = 127;
  400.     
  401.     return 440 * Math.pow(2, (value - 69) / 12);
  402. }
noswf

Dynamic Sound Generation forked from: Dynamic Sound Generation [diff(11)]

  1. // forked from seagirl's Dynamic Sound Generation
  2. // write as3 code here..
  3. package
  4. {
  5.     import flash.display.Sprite;
  6.     import flash.events.Event;
  7.     import flash.events.TimerEvent;
  8.     import flash.utils.Timer;
  10.     [SWF(backgroundColor="#ffffff")]
  11.     
  12.     public class DSG extends Sprite
  13.     {
  14.         public function DSG()
  15.         {
  16.             super();
  17.             
  18.             init();
  19.         }
  20.         
  21.         private var timer:Timer;
  22.         private var noteNumbers:Array = [80, 82, 84, 85, 87, 89, 91, 92];
  23.         
  24.         private function init():void
  25.         {
  26.             ring();
  27.             
  28.             timer = new Timer(1000);
  29.             timer.addEventListener(TimerEvent.TIMER, timerHandler);
  30.             timer.start();
  31.         }
  32.         
  33.         private function ring():void
  34.         {
  35.             if (noteNumbers.length == 0)
  36.                 return;
  37.             
  38.             var noteNumber:int = noteNumbers[int(Math.random() * noteNumbers.length)];    
  40.             var attack:Number = Math.random() * 5;
  41.                         var decay:Number = Math.random() * 5;
  42.                         var release:Number = 10 - attack - decay;
  44.             new Tone(noteNumber, 2, 8, attack, decay, 5, release).start();
  45.             new Particle(noteNumber, 2, 8, attack, decay, 5, release, this).start();
  46.         }
  47.         
  48.         private function timerHandler(event:TimerEvent):void
  49.         {
  50.             ring();
  51.         }
  52.         
  53.     }
  54. }
  56. import flash.display.Sprite;
  57. import flash.events.Event;
  58. import flash.events.TimerEvent;
  59. import flash.utils.Timer;
  61. class Particle extends Sprite
  62. {
  63.     public static const UNIT:int = Math.round(Math.random()*100);
  64.     
  65.     public static const TIMER_RATE:int = 200;
  66.     
  67.     public function Particle(noteNumber:uint, length:Number, volume:Number, attack:Number, decay:Number, sustain:Number, release:Number, parent:Sprite)
  68.     {    
  69.         this.noteNumber = noteNumber;
  70.         this.length = length;
  71.         this.volume = volume;
  72.         this.attack = attack;
  73.         this.decay = decay;
  74.         this.sustain = sustain;
  75.         this.release = release;
  76.         
  77.         amplify = volume > sustain ? volume : sustain;
  78.         
  79.         parent.addChildAt(this, 0);
  80.         
  81.         check();
  82.         initializeVelocity();
  83.     }
  84.     
  85.     private var timer:Timer;
  86.     
  87.     private var radius:Number = 0;
  88.     private var alphaValue:Number = 1;
  89.     private var amplify:Number = 0;
  90.     
  91.     private var state:int = 1; // 1: Attack, 2: Decay, 3: Release
  92.     
  93.     private var noteNumber:uint;
  94.     private var length:Number;
  95.     private var volume:Number;
  96.     private var attack:Number;
  97.     private var decay:Number;
  98.     private var sustain:Number;
  99.     private var release:Number;
  100.     
  101.     private var v1:Number;
  102.     private var v2:Number;
  103.     private var v3:Number;
  104.     
  105.     private function check():void
  106.     {
  107.         if (attack + decay + release != UNIT)
  108.         {
  109.              attack = 0;
  110.              decay = 1;
  111.              release = 1;
  112.         }
  113.             
  114.         if (volume > UNIT)
  115.             volume = UNIT;
  116.         
  117.         if (volume < 0)
  118.             volume = 0;
  119.             
  120.         if (sustain > UNIT)
  121.             sustain = UNIT;
  122.             
  123.         if (sustain < 0)
  124.             sustain = 0;
  125.     }
  126.     
  127.     private function initializeVelocity():void
  128.     {            
  129.         v1 = volume / (TIMER_RATE * length * attack / UNIT);
  130.         v2 = (volume - sustain) / (TIMER_RATE * length * decay / UNIT);
  131.         v3 = sustain / (TIMER_RATE * length * release / UNIT);
  132.         
  133.         alphaValue = volume > sustain ? volume : sustain;
  134.     }
  135.     
  136.     private function init():void
  137.     {
  138.         timer = new Timer(10000 / TIMER_RATE);
  139.         timer.addEventListener(TimerEvent.TIMER, timerHandler);
  140.         timer.start();
  141.     }
  142.     
  143.     private function update():void
  144.     {
  145.         drawGraphics();
  146.         updateParams();
  147.     }
  148.     
  149.     private function drawGraphics():void
  150.     {
  151.         graphics.clear();
  152.         
  153.         graphics.beginFill(0xFF0000, alphaValue / 40);
  154.         graphics.drawRect(-500,-500, 1000,1000);
  155.         graphics.endFill();
  156.     }
  157.     
  158.     private function updateParams():void
  159.     {
  160.         if (state == 1)
  161.         {
  162.             radius += v1;
  164.             if (radius >= volume)
  165.             {
  166.                 radius = volume;
  167.                 state = 2;
  168.             }
  169.         }
  170.         else if (state == 2)
  171.         {
  172.             if (volume < sustain)
  173.             {
  174.                 radius -= v2;
  175.                 
  176.                 if (radius >= sustain)
  177.                 {
  178.                     radius = sustain;
  179.                     state = 3;
  180.                 }
  181.             }
  182.             else
  183.             {
  184.                 alphaValue -= v2;
  185.                 
  186.                 if (alphaValue <= sustain)
  187.                 {
  188.                     alphaValue = sustain;
  189.                     state = 3;
  190.                 }
  191.             }    
  192.         }
  193.         else if (state == 3)
  194.         {
  195.             alphaValue -= v3;
  196.             
  197.             if (alphaValue <= 0)
  198.             {
  199.                 alphaValue = 0;
  200.                 
  201.                 stop();
  202.             }
  203.         }
  204.     }
  205.     
  206.     public function start():void
  207.     {
  208.         if (!parent)
  209.             throw new Error("parent must be specified.");
  210.         
  211.         if (x == 0 && y == 0)
  212.         {
  213.             x = Math.random() * stage.stageWidth;
  214.             y = Math.random() * stage.stageHeight;
  215.         }
  216.         
  217.         timer = new Timer(1000 / TIMER_RATE);
  218.         timer.addEventListener(TimerEvent.TIMER, timerHandler);
  219.         timer.start();
  220.     }
  221.     
  222.     public function stop():void
  223.     {
  224.         timer.removeEventListener(TimerEvent.TIMER, timerHandler);
  225.         
  226.         parent.removeChild(this);
  227.         
  228.         dispatchEvent(new Event(Event.COMPLETE));
  229.     }
  230.     
  231.     private function timerHandler(event:TimerEvent):void
  232.     {
  233.         update();
  234.     }
  235.     
  236. }
  238. import flash.events.Event;
  239. import flash.events.EventDispatcher;
  240. import flash.events.SampleDataEvent;
  241. import flash.media.Sound;
  242. import flash.utils.ByteArray;
  244. class Tone extends EventDispatcher
  245. {
  246.     public static const SAMPLING_RATE:Number = 44100;
  247.     public static const BUFFER_SIZE:int = 8192;
  248.         
  249.     public static const UNIT:int = Math.round(Math.random()*50);
  250.     
  251.     public function Tone(noteNumber:uint, length:Number, volume:Number, attack:Number, decay:Number, sustain:Number, release:Number)
  252.     {    
  253.         this.frequency = noteNumber2frequency(noteNumber);
  254.         this.length = length;
  255.         this.volume = volume;
  256.         this.attack = attack;
  257.         this.decay = decay;
  258.         this.sustain = sustain;
  259.         this.release = release;
  260.         
  261.         check();
  262.         initializeVelocity();
  263.     }
  264.     
  265.     private var sound:Sound;
  266.     
  267.     private var phase:Number = 0;
  268.     private var amplify:Number = 0;
  269.     
  270.     private var state:int = 1; // 1: Attack, 2: Decay, 3: Release
  271.     
  272.     private var frequency:Number;
  273.     private var length:Number;
  274.     private var volume:Number;
  275.     private var attack:Number;
  276.     private var decay:Number;
  277.     private var sustain:Number;
  278.     private var release:Number;
  279.     
  280.     private var v1:Number;
  281.     private var v2:Number;
  282.     private var v3:Number;
  283.         
  284.     private function check():void
  285.     {
  286.         if (attack + decay + release != UNIT)
  287.         {
  288.              attack = 0;
  289.              decay = 5;
  290.              release = 5;
  291.         }
  292.             
  293.         if (volume > UNIT)
  294.             volume = UNIT;
  295.         
  296.         if (volume < 0)
  297.             volume = 0;
  298.             
  299.         if (sustain > UNIT)
  300.             sustain = UNIT;
  301.             
  302.         if (sustain < 0)
  303.             sustain = 0;
  304.     }
  305.     
  306.     private function initializeVelocity():void
  307.     {            
  308.         v1 = volume / (SAMPLING_RATE * length * attack / UNIT);
  309.         v2 = (volume - sustain) / (SAMPLING_RATE * length * decay / UNIT);
  310.         v3 = sustain / (SAMPLING_RATE * length * release / UNIT);
  311.     }
  312.     
  313.     private function updateAmplify():void
  314.     {
  315.         if (state == 1)
  316.         {
  317.             amplify += v1;
  319.             if (amplify >= volume)
  320.             {
  321.                 amplify = volume;
  322.                 state = 2;
  323.             }
  324.         }
  325.         else if (state == 2)
  326.         {
  327.             amplify -= v2;
  328.             
  329.             if (volume < sustain)
  330.             {
  331.                 if (amplify >= sustain)
  332.                 {
  333.                     amplify = sustain;
  334.                     state = 3;
  335.                 }
  336.             }
  337.             else
  338.             {
  339.                 if (amplify <= sustain)
  340.                 {
  341.                     amplify = sustain;
  342.                     state = 3;
  343.                 }
  344.             }    
  345.         }
  346.         else if (state == 3)
  347.         {
  348.             amplify -= v3;
  349.             
  350.             if (amplify <= 0)
  351.             {
  352.                 amplify = 0;
  353.                 
  354.                 stop();
  355.             }
  356.         }
  357.     }
  358.     
  359.     public function start():void
  360.     {                    
  361.         sound = new Sound();
  362.         sound.addEventListener(SampleDataEvent.SAMPLE_DATA, soundSampleDataHandler);
  363.         sound.play();
  364.     }
  365.     
  366.     public function stop():void
  367.     {
  368.         sound.removeEventListener(SampleDataEvent.SAMPLE_DATA, soundSampleDataHandler);
  369.         dispatchEvent(new Event(Event.COMPLETE));
  370.     }
  371.     
  372.     private function soundSampleDataHandler(event:SampleDataEvent):void
  373.     {    
  374.         var bytes:ByteArray = new ByteArray();
  375.         
  376.         for (var i:int = 0; i < BUFFER_SIZE; ++i)
  377.         {
  378.             phase += frequency / SAMPLING_RATE;  
  379.             
  380.             var phaseAngle:Number = phase * Math.PI * 2;
  381.             var sample:Number = Math.sin(phaseAngle) * amplify / UNIT;
  382.             
  383.             sample *= 0.2;
  384.             
  385.             bytes.writeFloat(sample);
  386.             bytes.writeFloat(sample);
  387.             
  388.             updateAmplify();
  389.         }
  390.         
  391.         event.data.writeBytes(bytes);
  392.     }
  393.     
  394. }
  396. function noteNumber2frequency(value:uint):Number
  397. {
  398.     if (value > 127)
  399.         value = 127;
  400.     
  401.     return 440 * Math.pow(2, (value - 69) / 12);
  402. }
noswf

Dynamic Sound Generation forked from: Dynamic Sound Generation [diff(5)]

  1. // forked from seagirl's Dynamic Sound Generation
  2. // write as3 code here..
  3. package
  4. {
  5.     import flash.display.Sprite;
  6.     import flash.events.Event;
  7.     import flash.events.TimerEvent;
  8.     import flash.utils.Timer;
  10.     [SWF(backgroundColor="#000000")]
  11.     
  12.     public class DSG extends Sprite
  13.     {
  14.         public function DSG()
  15.         {
  16.             super();
  17.             
  18.             init();
  19.         }
  20.         
  21.         private var timer:Timer;
  22.         private var noteNumbers:Array = [68, 19, 96, 14, 67, 69, 71, 72];
  23.         
  24.         private function init():void
  25.         {
  26.             ring();
  27.             
  28.             timer = new Timer(1000);
  29.             timer.addEventListener(TimerEvent.TIMER, timerHandler);
  30.             timer.start();
  31.         }
  32.         
  33.         private function ring():void
  34.         {
  35.             if (noteNumbers.length == 0)
  36.                 return;
  37.             
  38.             var noteNumber:int = noteNumbers[int(Math.random() * noteNumbers.length)];    
  40.             var attack:Number = Math.random() * 5;
  41.                         var decay:Number = Math.random() * 5;
  42.                         var release:Number = 10 - attack - decay;
  44.             new Tone(noteNumber, 2, 8, attack, decay, 5, release).start();
  45.             new Particle(noteNumber, 2, 8, attack, decay, 5, release, this).start();
  46.         }
  47.         
  48.         private function timerHandler(event:TimerEvent):void
  49.         {
  50.             ring();
  51.         }
  52.         
  53.     }
  54. }
  56. import flash.display.Sprite;
  57. import flash.events.Event;
  58. import flash.events.TimerEvent;
  59. import flash.utils.Timer;
  61. class Particle extends Sprite
  62. {
  63.     public static const UNIT:int = 10;
  64.     
  65.     public static const TIMER_RATE:int = 20;
  66.     
  67.     public function Particle(noteNumber:uint, length:Number, volume:Number, attack:Number, decay:Number, sustain:Number, release:Number, parent:Sprite)
  68.     {    
  69.         this.noteNumber = noteNumber;
  70.         this.length = length;
  71.         this.volume = volume;
  72.         this.attack = attack;
  73.         this.decay = decay;
  74.         this.sustain = sustain;
  75.         this.release = release;
  76.         
  77.         amplify = volume > sustain ? volume : sustain;
  78.         
  79.         parent.addChildAt(this, 0);
  80.         
  81.         check();
  82.         initializeVelocity();
  83.     }
  84.     
  85.     private var timer:Timer;
  86.     
  87.     private var radius:Number = 0;
  88.     private var alphaValue:Number = 2;
  89.     private var amplify:Number = 0;
  90.     
  91.     private var state:int = 1; // 1: Attack, 2: Decay, 3: Release
  92.     
  93.     private var noteNumber:uint;
  94.     private var length:Number;
  95.     private var volume:Number;
  96.     private var attack:Number;
  97.     private var decay:Number;
  98.     private var sustain:Number;
  99.     private var release:Number;
  100.     
  101.     private var v1:Number;
  102.     private var v2:Number;
  103.     private var v3:Number;
  104.     
  105.     private function check():void
  106.     {
  107.         if (attack + decay + release != UNIT)
  108.         {
  109.              attack = 0;
  110.              decay = 5;
  111.              release = 5;
  112.         }
  113.             
  114.         if (volume > UNIT)
  115.             volume = UNIT;
  116.         
  117.         if (volume < 0)
  118.             volume = 0;
  119.             
  120.         if (sustain > UNIT)
  121.             sustain = UNIT;
  122.             
  123.         if (sustain < 0)
  124.             sustain = 0;
  125.     }
  126.     
  127.     private function initializeVelocity():void
  128.     {            
  129.         v1 = volume / (TIMER_RATE * length * attack / UNIT);
  130.         v2 = (volume - sustain) / (TIMER_RATE * length * decay / UNIT);
  131.         v3 = sustain / (TIMER_RATE * length * release / UNIT);
  132.         
  133.         alphaValue = volume > sustain ? volume : sustain;
  134.     }
  135.     
  136.     private function init():void
  137.     {
  138.         timer = new Timer(1000 / TIMER_RATE);
  139.         timer.addEventListener(TimerEvent.TIMER, timerHandler);
  140.         timer.start();
  141.     }
  142.     
  143.     private function update():void
  144.     {
  145.         drawGraphics();
  146.         updateParams();
  147.     }
  148.     
  149.     private function drawGraphics():void
  150.     {
  151.         graphics.clear();
  152.         
  153.         graphics.beginFill(0xFFFFFF, alphaValue / 10);
  154.         graphics.drawCircle(0, 0, radius * 0.8 * amplify);
  155.         graphics.endFill();
  156.     }
  157.     
  158.     private function updateParams():void
  159.     {
  160.         if (state == 1)
  161.         {
  162.             radius += v1;
  164.             if (radius >= volume)
  165.             {
  166.                 radius = volume;
  167.                 state = 2;
  168.             }
  169.         }
  170.         else if (state == 2)
  171.         {
  172.             if (volume < sustain)
  173.             {
  174.                 radius -= v2;
  175.                 
  176.                 if (radius >= sustain)
  177.                 {
  178.                     radius = sustain;
  179.                     state = 3;
  180.                 }
  181.             }
  182.             else
  183.             {
  184.                 alphaValue -= v2;
  185.                 
  186.                 if (alphaValue <= sustain)
  187.                 {
  188.                     alphaValue = sustain;
  189.                     state = 3;
  190.                 }
  191.             }    
  192.         }
  193.         else if (state == 3)
  194.         {
  195.             alphaValue -= v3;
  196.             
  197.             if (alphaValue <= 0)
  198.             {
  199.                 alphaValue = 0;
  200.                 
  201.                 stop();
  202.             }
  203.         }
  204.     }
  205.     
  206.     public function start():void
  207.     {
  208.         if (!parent)
  209.             throw new Error("parent must be specified.");
  210.         
  211.         if (x == 0 && y == 0)
  212.         {
  213.             x = Math.random() * stage.stageWidth;
  214.             y = Math.random() * stage.stageHeight;
  215.         }
  216.         
  217.         timer = new Timer(1000 / TIMER_RATE);
  218.         timer.addEventListener(TimerEvent.TIMER, timerHandler);
  219.         timer.start();
  220.     }
  221.     
  222.     public function stop():void
  223.     {
  224.         timer.removeEventListener(TimerEvent.TIMER, timerHandler);
  225.         
  226.         parent.removeChild(this);
  227.         
  228.         dispatchEvent(new Event(Event.COMPLETE));
  229.     }
  230.     
  231.     private function timerHandler(event:TimerEvent):void
  232.     {
  233.         update();
  234.     }
  235.     
  236. }
  238. import flash.events.Event;
  239. import flash.events.EventDispatcher;
  240. import flash.events.SampleDataEvent;
  241. import flash.media.Sound;
  242. import flash.utils.ByteArray;
  244. class Tone extends EventDispatcher
  245. {
  246.     public static const SAMPLING_RATE:Number = 44100;
  247.     public static const BUFFER_SIZE:int = 8192;
  248.         
  249.     public static const UNIT:int = 10;
  250.     
  251.     public function Tone(noteNumber:uint, length:Number, volume:Number, attack:Number, decay:Number, sustain:Number, release:Number)
  252.     {    
  253.         this.frequency = noteNumber2frequency(noteNumber);
  254.         this.length = length;
  255.         this.volume = volume;
  256.         this.attack = attack;
  257.         this.decay = decay;
  258.         this.sustain = sustain;
  259.         this.release = release;
  260.         
  261.         check();
  262.         initializeVelocity();
  263.     }
  264.     
  265.     private var sound:Sound;
  266.     
  267.     private var phase:Number = 0;
  268.     private var amplify:Number = 0;
  269.     
  270.     private var state:int = 1; // 1: Attack, 2: Decay, 3: Release
  271.     
  272.     private var frequency:Number;
  273.     private var length:Number;
  274.     private var volume:Number;
  275.     private var attack:Number;
  276.     private var decay:Number;
  277.     private var sustain:Number;
  278.     private var release:Number;
  279.     
  280.     private var v1:Number;
  281.     private var v2:Number;
  282.     private var v3:Number;
  283.         
  284.     private function check():void
  285.     {
  286.         if (attack + decay + release != UNIT)
  287.         {
  288.              attack = 0;
  289.              decay = 5;
  290.              release = 5;
  291.         }
  292.             
  293.         if (volume > UNIT)
  294.             volume = UNIT;
  295.         
  296.         if (volume < 0)
  297.             volume = 0;
  298.             
  299.         if (sustain > UNIT)
  300.             sustain = UNIT;
  301.             
  302.         if (sustain < 0)
  303.             sustain = 0;
  304.     }
  305.     
  306.     private function initializeVelocity():void
  307.     {            
  308.         v1 = volume / (SAMPLING_RATE * length * attack / UNIT);
  309.         v2 = (volume - sustain) / (SAMPLING_RATE * length * decay / UNIT);
  310.         v3 = sustain / (SAMPLING_RATE * length * release / UNIT);
  311.     }
  312.     
  313.     private function updateAmplify():void
  314.     {
  315.         if (state == 1)
  316.         {
  317.             amplify += v3;
  319.             if (amplify >= volume)
  320.             {
  321.                 amplify = volume;
  322.                 state = 2;
  323.             }
  324.         }
  325.         else if (state == 2)
  326.         {
  327.             amplify -= v2;
  328.             
  329.             if (volume < sustain)
  330.             {
  331.                 if (amplify >= sustain)
  332.                 {
  333.                     amplify = sustain;
  334.                     state = 3;
  335.                 }
  336.             }
  337.             else
  338.             {
  339.                 if (amplify <= sustain)
  340.                 {
  341.                     amplify = sustain;
  342.                     state = 15;
  343.                 }
  344.             }    
  345.         }
  346.         else if (state == 3)
  347.         {
  348.             amplify -= v3;
  349.             
  350.             if (amplify <= 0)
  351.             {
  352.                 amplify = 0;
  353.                 
  354.                 stop();
  355.             }
  356.         }
  357.     }
  358.     
  359.     public function start():void
  360.     {                    
  361.         sound = new Sound();
  362.         sound.addEventListener(SampleDataEvent.SAMPLE_DATA, soundSampleDataHandler);
  363.         sound.play();
  364.     }
  365.     
  366.     public function stop():void
  367.     {
  368.         sound.removeEventListener(SampleDataEvent.SAMPLE_DATA, soundSampleDataHandler);
  369.         dispatchEvent(new Event(Event.COMPLETE));
  370.     }
  371.     
  372.     private function soundSampleDataHandler(event:SampleDataEvent):void
  373.     {    
  374.         var bytes:ByteArray = new ByteArray();
  375.         
  376.         for (var i:int = 0; i < BUFFER_SIZE; ++i)
  377.         {
  378.             phase += frequency / SAMPLING_RATE;  
  379.             
  380.             var phaseAngle:Number = phase * Math.PI * 2;
  381.             var sample:Number = Math.sin(phaseAngle) * amplify / UNIT;
  382.             
  383.             sample *= 0.2;
  384.             
  385.             bytes.writeFloat(sample);
  386.             bytes.writeFloat(sample);
  387.             
  388.             updateAmplify();
  389.         }
  390.         
  391.         event.data.writeBytes(bytes);
  392.     }
  393.     
  394. }
  396. function noteNumber2frequency(value:uint):Number
  397. {
  398.     if (value > 127)
  399.         value = 127;
  400.     
  401.     return 440 * Math.pow(2, (value - 69) / 12);
  402. }
noswf

Dynamic Sound Generation forked from: Dynamic Sound Generation [diff(1)]

  1. // forked from seagirl's Dynamic Sound Generation
  2. // write as3 code here..
  3. package
  4. {
  5.     import flash.display.Sprite;
  6.     import flash.events.Event;
  7.     import flash.events.TimerEvent;
  8.     import flash.utils.Timer;
  10.     [SWF(backgroundColor="#000000")]
  11.     
  12.     public class DSG extends Sprite
  13.     {
  14.         public function DSG()
  15.         {
  16.             super();
  17.             
  18.             init();
  19.         }
  20.         
  21.         private var timer:Timer;
  22.         private var noteNumbers:Array = [60, 62, 64, 65, 67, 69, 71, 72];
  23.         
  24.         private function init():void
  25.         {
  26.             ring();
  27.             
  28.             timer = new Timer(1000);
  29.             timer.addEventListener(TimerEvent.TIMER, timerHandler);
  30.             timer.start();
  31.         }
  32.         
  33.         private function ring():void
  34.         {
  35.             if (noteNumbers.length == 0)
  36.                 return;
  37.             
  38.             var noteNumber:int = noteNumbers[int(Math.random() * noteNumbers.length)];    
  40.             var attack:Number = Math.random() * 5;
  41.                         var decay:Number = Math.random() * 5;
  42.                         var release:Number = 10 - attack - decay;
  44.             new Tone(noteNumber, 2, 8, attack, decay, 5, release).start();
  45.             new Particle(noteNumber, 2, 8, attack, decay, 5, release, this).start();
  46.         }
  47.         
  48.         private function timerHandler(event:TimerEvent):void
  49.         {
  50.             ring();
  51.         }
  52.         
  53.     }
  54. }
  56. import flash.display.Sprite;
  57. import flash.events.Event;
  58. import flash.events.TimerEvent;
  59. import flash.utils.Timer;
  61. class Particle extends Sprite
  62. {
  63.     public static const UNIT:int = 10;
  64.     
  65.     public static const TIMER_RATE:int = 20;
  66.     
  67.     public function Particle(noteNumber:uint, length:Number, volume:Number, attack:Number, decay:Number, sustain:Number, release:Number, parent:Sprite)
  68.     {    
  69.         this.noteNumber = noteNumber;
  70.         this.length = length;
  71.         this.volume = volume;
  72.         this.attack = attack;
  73.         this.decay = decay;
  74.         this.sustain = sustain;
  75.         this.release = release;
  76.         
  77.         amplify = volume > sustain ? volume : sustain;
  78.         
  79.         parent.addChildAt(this, 0);
  80.         
  81.         check();
  82.         initializeVelocity();
  83.     }
  84.     
  85.     private var timer:Timer;
  86.     
  87.     private var radius:Number = 0;
  88.     private var alphaValue:Number = 1;
  89.     private var amplify:Number = 0;
  90.     
  91.     private var state:int = 1; // 1: Attack, 2: Decay, 3: Release
  92.     
  93.     private var noteNumber:uint;
  94.     private var length:Number;
  95.     private var volume:Number;
  96.     private var attack:Number;
  97.     private var decay:Number;
  98.     private var sustain:Number;
  99.     private var release:Number;
  100.     
  101.     private var v1:Number;
  102.     private var v2:Number;
  103.     private var v3:Number;
  104.     
  105.     private function check():void
  106.     {
  107.         if (attack + decay + release != UNIT)
  108.         {
  109.              attack = 0;
  110.              decay = 5;
  111.              release = 5;
  112.         }
  113.             
  114.         if (volume > UNIT)
  115.             volume = UNIT;
  116.         
  117.         if (volume < 0)
  118.             volume = 0;
  119.             
  120.         if (sustain > UNIT)
  121.             sustain = UNIT;
  122.             
  123.         if (sustain < 0)
  124.             sustain = 0;
  125.     }
  126.     
  127.     private function initializeVelocity():void
  128.     {            
  129.         v1 = volume / (TIMER_RATE * length * attack / UNIT);
  130.         v2 = (volume - sustain) / (TIMER_RATE * length * decay / UNIT);
  131.         v3 = sustain / (TIMER_RATE * length * release / UNIT);
  132.         
  133.         alphaValue = volume > sustain ? volume : sustain;
  134.     }
  135.     
  136.     private function init():void
  137.     {
  138.         timer = new Timer(1000 / TIMER_RATE);
  139.         timer.addEventListener(TimerEvent.TIMER, timerHandler);
  140.         timer.start();
  141.     }
  142.     
  143.     private function update():void
  144.     {
  145.         drawGraphics();
  146.         updateParams();
  147.     }
  148.     
  149.     private function drawGraphics():void
  150.     {
  151.         graphics.clear();
  152.         
  153.         graphics.beginFill(0xFFFFFF, alphaValue / 10);
  154.         graphics.drawCircle(0, 0, radius * 0.8 * amplify);
  155.         graphics.endFill();
  156.     }
  157.     
  158.     private function updateParams():void
  159.     {
  160.         if (state == 1)
  161.         {
  162.             radius += v1;
  164.             if (radius >= volume)
  165.             {
  166.                 radius = volume;
  167.                 state = 2;
  168.             }
  169.         }
  170.         else if (state == 2)
  171.         {
  172.             if (volume < sustain)
  173.             {
  174.                 radius -= v2;
  175.                 
  176.                 if (radius >= sustain)
  177.                 {
  178.                     radius = sustain;
  179.                     state = 3;
  180.                 }
  181.             }
  182.             else
  183.             {
  184.                 alphaValue -= v2;
  185.                 
  186.                 if (alphaValue <= sustain)
  187.                 {
  188.                     alphaValue = sustain;
  189.                     state = 3;
  190.                 }
  191.             }    
  192.         }
  193.         else if (state == 3)
  194.         {
  195.             alphaValue -= v3;
  196.             
  197.             if (alphaValue <= 0)
  198.             {
  199.                 alphaValue = 0;
  200.                 
  201.                 stop();
  202.             }
  203.         }
  204.     }
  205.     
  206.     public function start():void
  207.     {
  208.         if (!parent)
  209.             throw new Error("parent must be specified.");
  210.         
  211.         if (x == 0 && y == 0)
  212.         {
  213.             x = Math.random() * stage.stageWidth;
  214.             y = Math.random() * stage.stageHeight;
  215.         }
  216.         
  217.         timer = new Timer(1000 / TIMER_RATE);
  218.         timer.addEventListener(TimerEvent.TIMER, timerHandler);
  219.         timer.start();
  220.     }
  221.     
  222.     public function stop():void
  223.     {
  224.         timer.removeEventListener(TimerEvent.TIMER, timerHandler);
  225.         
  226.         parent.removeChild(this);
  227.         
  228.         dispatchEvent(new Event(Event.COMPLETE));
  229.     }
  230.     
  231.     private function timerHandler(event:TimerEvent):void
  232.     {
  233.         update();
  234.     }
  235.     
  236. }
  238. import flash.events.Event;
  239. import flash.events.EventDispatcher;
  240. import flash.events.SampleDataEvent;
  241. import flash.media.Sound;
  242. import flash.utils.ByteArray;
  244. class Tone extends EventDispatcher
  245. {
  246.     public static const SAMPLING_RATE:Number = 44100;
  247.     public static const BUFFER_SIZE:int = 8192;
  248.         
  249.     public static const UNIT:int = 10;
  250.     
  251.     public function Tone(noteNumber:uint, length:Number, volume:Number, attack:Number, decay:Number, sustain:Number, release:Number)
  252.     {    
  253.         this.frequency = noteNumber2frequency(noteNumber);
  254.         this.length = length;
  255.         this.volume = volume;
  256.         this.attack = attack;
  257.         this.decay = decay;
  258.         this.sustain = sustain;
  259.         this.release = release;
  260.         
  261.         check();
  262.         initializeVelocity();
  263.     }
  264.     
  265.     private var sound:Sound;
  266.     
  267.     private var phase:Number = 0;
  268.     private var amplify:Number = 0;
  269.     
  270.     private var state:int = 1; // 1: Attack, 2: Decay, 3: Release
  271.     
  272.     private var frequency:Number;
  273.     private var length:Number;
  274.     private var volume:Number;
  275.     private var attack:Number;
  276.     private var decay:Number;
  277.     private var sustain:Number;
  278.     private var release:Number;
  279.     
  280.     private var v1:Number;
  281.     private var v2:Number;
  282.     private var v3:Number;
  283.         
  284.     private function check():void
  285.     {
  286.         if (attack + decay + release != UNIT)
  287.         {
  288.              attack = 0;
  289.              decay = 5;
  290.              release = 5;
  291.         }
  292.             
  293.         if (volume > UNIT)
  294.             volume = UNIT;
  295.         
  296.         if (volume < 0)
  297.             volume = 0;
  298.             
  299.         if (sustain > UNIT)
  300.             sustain = UNIT;
  301.             
  302.         if (sustain < 0)
  303.             sustain = 0;
  304.     }
  305.     
  306.     private function initializeVelocity():void
  307.     {            
  308.         v1 = volume / (SAMPLING_RATE * length * attack / UNIT);
  309.         v2 = (volume - sustain) / (SAMPLING_RATE * length * decay / UNIT);
  310.         v3 = sustain / (SAMPLING_RATE * length * release / UNIT);
  311.     }
  312.     
  313.     private function updateAmplify():void
  314.     {
  315.         if (state == 1)
  316.         {
  317.             amplify += v1;
  319.             if (amplify >= volume)
  320.             {
  321.                 amplify = volume;
  322.                 state = 2;
  323.             }
  324.         }
  325.         else if (state == 2)
  326.         {
  327.             amplify -= v2;
  328.             
  329.             if (volume < sustain)
  330.             {
  331.                 if (amplify >= sustain)
  332.                 {
  333.                     amplify = sustain;
  334.                     state = 3;
  335.                 }
  336.             }
  337.             else
  338.             {
  339.                 if (amplify <= sustain)
  340.                 {
  341.                     amplify = sustain;
  342.                     state = 3;
  343.                 }
  344.             }    
  345.         }
  346.         else if (state == 3)
  347.         {
  348.             amplify -= v3;
  349.             
  350.             if (amplify <= 0)
  351.             {
  352.                 amplify = 0;
  353.                 
  354.                 stop();
  355.             }
  356.         }
  357.     }
  358.     
  359.     public function start():void
  360.     {                    
  361.         sound = new Sound();
  362.         sound.addEventListener(SampleDataEvent.SAMPLE_DATA, soundSampleDataHandler);
  363.         sound.play();
  364.     }
  365.     
  366.     public function stop():void
  367.     {
  368.         sound.removeEventListener(SampleDataEvent.SAMPLE_DATA, soundSampleDataHandler);
  369.         dispatchEvent(new Event(Event.COMPLETE));
  370.     }
  371.     
  372.     private function soundSampleDataHandler(event:SampleDataEvent):void
  373.     {    
  374.         var bytes:ByteArray = new ByteArray();
  375.         
  376.         for (var i:int = 0; i < BUFFER_SIZE; ++i)
  377.         {
  378.             phase += frequency / SAMPLING_RATE;  
  379.             
  380.             var phaseAngle:Number = phase * Math.PI * 2;
  381.             var sample:Number = Math.sin(phaseAngle) * amplify / UNIT;
  382.             
  383.             sample *= 0.2;
  384.             
  385.             bytes.writeFloat(sample);
  386.             bytes.writeFloat(sample);
  387.             
  388.             updateAmplify();
  389.         }
  390.         
  391.         event.data.writeBytes(bytes);
  392.     }
  393.     
  394. }
  396. function noteNumber2frequency(value:uint):Number
  397. {
  398.     if (value > 127)
  399.         value = 127;
  400.     
  401.     return 440 * Math.pow(2, (value - 69) / 12);
  402. }
noswf

Dynamic Sound Generation forked from: Dynamic Sound Generation [diff(8)]

  1. // forked from seagirl's Dynamic Sound Generation
  2. // write as3 code here..
  3. package
  4. {
  5.     import flash.display.Sprite;
  6.     import flash.events.Event;
  7.     import flash.events.TimerEvent;
  8.     import flash.utils.Timer;
  10.     [SWF(backgroundColor="#000000")]
  11.     
  12.     public class DSG extends Sprite
  13.     {
  14.         public function DSG()
  15.         {
  16.         
  17.             init();
  18.         }
  19.         
  20.         private var timer:Timer;
  21.         private var noteNumbers:Array = [60, 62, 100];
  22.         
  23.         private function init():void
  24.         {
  25.             //ring();
  26.             
  27.             timer = new Timer(1000);
  28.             timer.addEventListener(TimerEvent.TIMER, timerHandler);
  29.             timer.start();
  30.         }
  31.         
  32.         private function ring():void
  33.         {
  34.             if (noteNumbers.length == 0)
  35.                 return;
  36.             
  37.             var noteNumber:int = noteNumbers[int(1)];    
  39.             var attack:Number = Math.random() * 5;
  40.                         var decay:Number = Math.random() * 5;
  41.                         var release:Number = 10 - attack - decay;
  43.             new Tone(noteNumber, 2, 8, attack, decay, 5, release).start();
  44.             //new Particle(noteNumber, 2, 8, attack, decay, 5, release, this).start();
  45.         }
  46.         
  47.         private function timerHandler(event:TimerEvent):void
  48.         {
  49.             ring();
  50.         }
  51.         
  52.     }
  53. }
  55. import flash.display.Sprite;
  56. import flash.events.Event;
  57. import flash.events.TimerEvent;
  58. import flash.utils.Timer;
  60. class Particle extends Sprite
  61. {
  62.     public static const UNIT:int = 10;
  63.     
  64.     public static const TIMER_RATE:int = 20;
  65.     
  66.     public function Particle(noteNumber:uint, length:Number, volume:Number, attack:Number, decay:Number, sustain:Number, release:Number, parent:Sprite)
  67.     {    
  68.         this.noteNumber = noteNumber;
  69.         this.length = length;
  70.         this.volume = volume;
  71.         this.attack = attack;
  72.         this.decay = decay;
  73.         this.sustain = sustain;
  74.         this.release = release;
  75.         
  76.         amplify = volume > sustain ? volume : sustain;
  77.         
  78.         parent.addChildAt(this, 0);
  79.         
  80.         check();
  81.         initializeVelocity();
  82.     }
  83.     
  84.     private var timer:Timer;
  85.     
  86.     private var radius:Number = 0;
  87.     private var alphaValue:Number = 1;
  88.     private var amplify:Number = 0;
  89.     
  90.     private var state:int = 1; // 1: Attack, 2: Decay, 3: Release
  91.     
  92.     private var noteNumber:uint;
  93.     private var length:Number;
  94.     private var volume:Number;
  95.     private var attack:Number;
  96.     private var decay:Number;
  97.     private var sustain:Number;
  98.     private var release:Number;
  99.     
  100.     private var v1:Number;
  101.     private var v2:Number;
  102.     private var v3:Number;
  103.     
  104.     private function check():void
  105.     {
  106.         if (attack + decay + release != UNIT)
  107.         {
  108.              attack = 0;
  109.              decay = 5;
  110.              release = 5;
  111.         }
  112.             
  113.         if (volume > UNIT)
  114.             volume = UNIT;
  115.         
  116.         if (volume < 0)
  117.             volume = 0;
  118.             
  119.         if (sustain > UNIT)
  120.             sustain = UNIT;
  121.             
  122.         if (sustain < 0)
  123.             sustain = 0;
  124.     }
  125.     
  126.     private function initializeVelocity():void
  127.     {            
  128.         v1 = volume / (TIMER_RATE * length * attack / UNIT);
  129.         v2 = (volume - sustain) / (TIMER_RATE * length * decay / UNIT);
  130.         v3 = sustain / (TIMER_RATE * length * release / UNIT);
  131.         
  132.         alphaValue = volume > sustain ? volume : sustain;
  133.     }
  134.     
  135.     private function init():void
  136.     {
  137.         timer = new Timer(1000 / TIMER_RATE);
  138.         timer.addEventListener(TimerEvent.TIMER, timerHandler);
  139.         timer.start();
  140.     }
  141.     
  142.     private function update():void
  143.     {
  144.         drawGraphics();
  145.         updateParams();
  146.     }
  147.     
  148.     private function drawGraphics():void
  149.     {
  150.         graphics.clear();
  151.         
  152.         graphics.beginFill(0xFFFFFF, alphaValue / 10);
  153.         graphics.drawCircle(0, 0, radius * 0.8 * amplify);
  154.         graphics.endFill();
  155.     }
  156.     
  157.     private function updateParams():void
  158.     {
  159.         if (state == 1)
  160.         {
  161.             radius += v1;
  163.             if (radius >= volume)
  164.             {
  165.                 radius = volume;
  166.                 state = 2;
  167.             }
  168.         }
  169.         else if (state == 2)
  170.         {
  171.             if (volume < sustain)
  172.             {
  173.                 radius -= v2;
  174.                 
  175.                 if (radius >= sustain)
  176.                 {
  177.                     radius = sustain;
  178.                     state = 3;
  179.                 }
  180.             }
  181.             else
  182.             {
  183.                 alphaValue -= v2;
  184.                 
  185.                 if (alphaValue <= sustain)
  186.                 {
  187.                     alphaValue = sustain;
  188.                     state = 3;
  189.                 }
  190.             }    
  191.         }
  192.         else if (state == 3)
  193.         {
  194.             alphaValue -= v3;
  195.             
  196.             if (alphaValue <= 0)
  197.             {
  198.                 alphaValue = 0;
  199.                 
  200.                 stop();
  201.             }
  202.         }
  203.     }
  204.     
  205.     public function start():void
  206.     {
  207.         if (!parent)
  208.             throw new Error("parent must be specified.");
  209.         
  210.         if (x == 0 && y == 0)
  211.         {
  212.             x = Math.random() * stage.stageWidth;
  213.             y = Math.random() * stage.stageHeight;
  214.         }
  215.         
  216.         timer = new Timer(1000 / TIMER_RATE);
  217.         timer.addEventListener(TimerEvent.TIMER, timerHandler);
  218.         timer.start();
  219.     }
  220.     
  221.     public function stop():void
  222.     {
  223.         timer.removeEventListener(TimerEvent.TIMER, timerHandler);
  224.         
  225.         parent.removeChild(this);
  226.         
  227.         dispatchEvent(new Event(Event.COMPLETE));
  228.     }
  229.     
  230.     private function timerHandler(event:TimerEvent):void
  231.     {
  232.         update();
  233.     }
  234.     
  235. }
  237. import flash.events.Event;
  238. import flash.events.EventDispatcher;
  239. import flash.events.SampleDataEvent;
  240. import flash.media.Sound;
  241. import flash.utils.ByteArray;
  243. class Tone extends EventDispatcher
  244. {
  245.     public static const SAMPLING_RATE:Number = 44100;
  246.     public static const BUFFER_SIZE:int = 441;
  247.         
  248.     public static const UNIT:int = 10;
  249.     
  250.     public function Tone(noteNumber:uint, length:Number, volume:Number, attack:Number, decay:Number, sustain:Number, release:Number)
  251.     {    
  252.         this.frequency = noteNumber2frequency(noteNumber);
  253.         this.length = length;
  254.         this.volume = volume;
  255.         this.attack = attack;
  256.         this.decay = decay;
  257.         this.sustain = sustain;
  258.         this.release = release;
  259.         
  260.         check();
  261.         initializeVelocity();
  262.     }
  263.     
  264.     private var sound:Sound;
  265.     
  266.     private var phase:Number = 0;
  267.     private var amplify:Number = 0;
  268.     
  269.     private var state:int = 1; // 1: Attack, 2: Decay, 3: Release
  270.     
  271.     private var frequency:Number;
  272.     private var length:Number;
  273.     private var volume:Number;
  274.     private var attack:Number;
  275.     private var decay:Number;
  276.     private var sustain:Number;
  277.     private var release:Number;
  278.     
  279.     private var v1:Number;
  280.     private var v2:Number;
  281.     private var v3:Number;
  282.         
  283.     private function check():void
  284.     {
  285.         if (attack + decay + release != UNIT)
  286.         {
  287.              attack = 0;
  288.              decay = 5;
  289.              release = 5;
  290.         }
  291.             
  292.         if (volume > UNIT)
  293.             volume = UNIT;
  294.         
  295.         if (volume < 0)
  296.             volume = 0;
  297.             
  298.         if (sustain > UNIT)
  299.             sustain = UNIT;
  300.             
  301.         if (sustain < 0)
  302.             sustain = 0;
  303.     }
  304.     
  305.     private function initializeVelocity():void
  306.     {            
  307.         v1 = volume / (SAMPLING_RATE * length * attack / UNIT);
  308.         v2 = (volume - sustain) / (SAMPLING_RATE * length * decay / UNIT);
  309.         v3 = sustain / (SAMPLING_RATE * length * release / UNIT);
  310.     }
  311.     
  312.     private function updateAmplify():void
  313.     {
  314.         if (state == 1)
  315.         {
  316.             amplify += v1;
  318.             if (amplify >= volume)
  319.             {
  320.                 amplify = volume;
  321.                 state = 2;
  322.             }
  323.         }
  324.         else if (state == 2)
  325.         {
  326.             amplify -= v2;
  327.             
  328.             if (volume < sustain)
  329.             {
  330.                 if (amplify >= sustain)
  331.                 {
  332.                     amplify = sustain;
  333.                     state = 3;
  334.                 }
  335.             }
  336.             else
  337.             {
  338.                 if (amplify <= sustain)
  339.                 {
  340.                     amplify = sustain;
  341.                     state = 3;
  342.                 }
  343.             }    
  344.         }
  345.         else if (state == 3)
  346.         {
  347.             amplify -= v3;
  348.             
  349.             if (amplify <= 0)
  350.             {
  351.                 amplify = 0;
  352.                 
  353.                 stop();
  354.             }
  355.         }
  356.     }
  357.     
  358.     public function start():void
  359.     {                    
  360.         sound = new Sound();
  361.         sound.addEventListener(SampleDataEvent.SAMPLE_DATA, soundSampleDataHandler);
  362.         sound.play();
  363.     }
  364.     
  365.     public function stop():void
  366.     {
  367.         sound.removeEventListener(SampleDataEvent.SAMPLE_DATA, soundSampleDataHandler);
  368.         dispatchEvent(new Event(Event.COMPLETE));
  369.     }
  370.     
  371.     private function soundSampleDataHandler(event:SampleDataEvent):void
  372.     {    
  373.         var bytes:ByteArray = new ByteArray();
  374.         
  375.         for (var i:int = 0; i < BUFFER_SIZE; ++i)
  376.         {
  377.             phase += frequency / SAMPLING_RATE;  
  378.             
  379.             var phaseAngle:Number = phase * Math.PI * 2;
  380.             var sample:Number = Math.sin(phaseAngle) * amplify / UNIT;
  381.             
  382.             sample *= 0.2;
  383.             
  384.             bytes.writeFloat(sample);
  385.             bytes.writeFloat(sample);
  386.             
  387.             updateAmplify();
  388.         }
  389.         
  390.         event.data.writeBytes(bytes);
  391.     }
  392.     
  393. }
  395. function noteNumber2frequency(value:uint):Number
  396. {
  397.     if (value > 127)
  398.         value = 127;
  399.     
  400.     return 440 * Math.pow(2, (value - 69) / 12);
  401. }
noswf
Get Adobe Flash Player