@vpmedia/phaser 1.0.1 → 1.0.2

package/src/phaser/core/sound.js

@@ -0,0 +1,538 @@
+/**
+ * @author       Andras Csizmadia <andras@vpmedia.hu>
+ * @author       Richard Davey <rich@photonstorm.com>
+ * @copyright    Copyright (c) 2018-present Richard Davey, Photon Storm Ltd., Andras Csizmadia <andras@vpmedia.hu> (www.vpmedia.hu)
+ */
+import Signal from './signal';
+
+export default class {
+
+  constructor(game, key, volume = 1, loop = false, connect = null) {
+    if (!connect) {
+      connect = game.sound.connectToMaster;
+    }
+    this.game = game;
+    this.name = key;
+    this.key = key;
+    this.loop = loop;
+    this.markers = {};
+    this.context = null;
+    this.autoplay = false;
+    this.totalDuration = 0;
+    this.startTime = 0;
+    this.currentTime = 0;
+    this.duration = 0;
+    this.durationMS = 0;
+    this.position = 0;
+    this.stopTime = 0;
+    this.paused = false;
+    this.pausedPosition = 0;
+    this.pausedTime = 0;
+    this.isPlaying = false;
+    this.currentMarker = '';
+    this.fadeTween = null;
+    this.pendingPlayback = false;
+    this.override = false;
+    this.allowMultiple = false;
+    this.usingWebAudio = this.game.sound.usingWebAudio;
+    this.usingAudioTag = this.game.sound.usingAudioTag;
+    this.externalNode = null;
+    this.masterGainNode = null;
+    this.gainNode = null;
+    this._sound = null;
+    this._markedToDelete = false;
+    this._removeFromSoundManager = false;
+    if (this.usingWebAudio) {
+      this.context = this.game.sound.context;
+      this.masterGainNode = this.game.sound.masterGain;
+      if (this.context.createGain === undefined) {
+        this.gainNode = this.context.createGainNode();
+      } else {
+        this.gainNode = this.context.createGain();
+      }
+      this.gainNode.gain.value = volume * this.game.sound.volume;
+      if (connect) {
+        this.gainNode.connect(this.masterGainNode);
+      }
+    } else if (this.usingAudioTag) {
+      if (this.game.cache.getSound(key) && this.game.cache.isSoundReady(key)) {
+        this._sound = this.game.cache.getSoundData(key);
+        this.totalDuration = 0;
+        if (this._sound.duration) {
+          this.totalDuration = this._sound.duration;
+        }
+      } else {
+        this.game.cache.onSoundUnlock.add(this.soundHasUnlocked, this);
+      }
+    }
+    this.onDecoded = new Signal();
+    this.onPlay = new Signal();
+    this.onPause = new Signal();
+    this.onResume = new Signal();
+    this.onLoop = new Signal();
+    this.onStop = new Signal();
+    this.onMute = new Signal();
+    this.onMarkerComplete = new Signal();
+    this.onFadeComplete = new Signal();
+    this._volume = volume;
+    this._buffer = null;
+    this._muted = false;
+    this._tempMarker = 0;
+    this._tempPosition = 0;
+    this._tempVolume = 0;
+    this._tempPause = 0;
+    this._muteVolume = 0;
+    this._tempLoop = 0;
+    this._paused = false;
+    this._onDecodedEventDispatched = false;
+  }
+
+  soundHasUnlocked(key) {
+    if (key === this.key) {
+      this._sound = this.game.cache.getSoundData(this.key);
+      this.totalDuration = this._sound.duration;
+    }
+  }
+
+  addMarker(name, start, duration = 1, volume = 1, loop = false) {
+    this.markers[name] = {
+      name,
+      start,
+      stop: start + duration,
+      volume,
+      duration,
+      durationMS: duration * 1000,
+      loop,
+    };
+  }
+
+  removeMarker(name) {
+    delete this.markers[name];
+  }
+
+  onEndedHandler() {
+    this._sound.onended = null;
+    this.isPlaying = false;
+    this.currentTime = this.durationMS;
+    this.stop();
+    if (this._markedToDelete) {
+      if (this.externalNode) {
+        this._sound.disconnect(this.externalNode);
+      } else if (this.gainNode) {
+        this._sound.disconnect(this.gainNode);
+      }
+      if (this._removeFromSoundManager) {
+        this.game.sound.remove(this);
+      } else {
+        this.markers = {};
+        this.context = null;
+        this._buffer = null;
+        this.externalNode = null;
+        this.onDecoded.dispose();
+        this.onPlay.dispose();
+        this.onPause.dispose();
+        this.onResume.dispose();
+        this.onLoop.dispose();
+        this.onStop.dispose();
+        this.onMute.dispose();
+        this.onMarkerComplete.dispose();
+      }
+    }
+  }
+
+  update() {
+    if (!this.game.cache.checkSoundKey(this.key)) {
+      this.destroy();
+      return;
+    }
+    if (this.isDecoded && !this._onDecodedEventDispatched) {
+      this.onDecoded.dispatch(this);
+      this._onDecodedEventDispatched = true;
+    }
+    if (this.pendingPlayback && this.game.cache.isSoundReady(this.key)) {
+      this.pendingPlayback = false;
+      this.play(this._tempMarker, this._tempPosition, this._tempVolume, this._tempLoop);
+    }
+    if (!this.isPlaying) {
+      return;
+    }
+    this.currentTime = this.game.time.time - this.startTime;
+    if (this.currentTime >= this.durationMS) {
+      if (this.usingWebAudio) {
+        if (this.loop) {
+          //  won't work with markers, needs to reset the position
+          this.onLoop.dispatch(this);
+          //  Gets reset by the play function
+          this.isPlaying = false;
+          if (this.currentMarker === '') {
+            this.currentTime = 0;
+            this.startTime = this.game.time.time;
+            this.isPlaying = true; // play not called again in this case
+          } else {
+            this.onMarkerComplete.dispatch(this.currentMarker, this);
+            this.play(this.currentMarker, 0, this.volume, true, true);
+          }
+        } else if (this.currentMarker !== '') {
+          //  Stop if we're using an audio marker, otherwise we let onended handle it
+          this.stop();
+        }
+      } else if (this.loop) {
+        this.onLoop.dispatch(this);
+        if (this.currentMarker === '') {
+          this.currentTime = 0;
+          this.startTime = this.game.time.time;
+        }
+        //  Gets reset by the play function
+        this.isPlaying = false;
+        this.play(this.currentMarker, 0, this.volume, true, true);
+      } else {
+        this.stop();
+      }
+    }
+  }
+
+  loopFull(volume) {
+    return this.play(null, 0, volume, true);
+  }
+
+  play(marker, position, volume, loop, forceRestart) {
+    if (marker === undefined || marker === false || marker === null) { marker = ''; }
+    if (forceRestart === undefined) { forceRestart = true; }
+
+    if (this.isPlaying && !this.allowMultiple && !forceRestart && !this.override) {
+      //  Use Restart instead
+      return this;
+    }
+    if (this._sound && this.isPlaying && !this.allowMultiple && (this.override || forceRestart)) {
+      if (this.usingWebAudio) {
+        if (this._sound.stop === undefined) {
+          this._sound.noteOff(0);
+        } else {
+          try {
+            this._sound.stop(0);
+          } catch (e) {
+            // pass
+          }
+        }
+        if (this.externalNode) {
+          this._sound.disconnect(this.externalNode);
+        } else if (this.gainNode) {
+          this._sound.disconnect(this.gainNode);
+        }
+      } else if (this.usingAudioTag) {
+        this._sound.pause();
+        this._sound.currentTime = 0;
+      }
+      this.isPlaying = false;
+    }
+    if (marker === '' && Object.keys(this.markers).length > 0) {
+      //  If they didn't specify a marker but this is an audio sprite,
+      //  we should never play the entire thing
+      return this;
+    }
+    if (marker !== '') {
+      if (this.markers[marker]) {
+        this.currentMarker = marker;
+        //  Playing a marker? Then we default to the marker values
+        this.position = this.markers[marker].start;
+        this.volume = this.markers[marker].volume;
+        this.loop = this.markers[marker].loop;
+        this.duration = this.markers[marker].duration;
+        this.durationMS = this.markers[marker].durationMS;
+        if (typeof volume !== 'undefined') {
+          this.volume = volume;
+        }
+        if (typeof loop !== 'undefined') {
+          this.loop = loop;
+        }
+        this._tempMarker = marker;
+        this._tempPosition = this.position;
+        this._tempVolume = this.volume;
+        this._tempLoop = this.loop;
+      } else {
+        console.warn('Sound.play: audio marker ' + marker + ' does not exist');
+        return this;
+      }
+    } else {
+      position = position || 0;
+      if (volume === undefined) { volume = this._volume; }
+      if (loop === undefined) { loop = this.loop; }
+      this.position = Math.max(0, position);
+      this.volume = volume;
+      this.loop = loop;
+      this.duration = 0;
+      this.durationMS = 0;
+      this._tempMarker = marker;
+      this._tempPosition = position;
+      this._tempVolume = volume;
+      this._tempLoop = loop;
+    }
+    if (this.usingWebAudio) {
+      //  Does the sound need decoding?
+      if (this.game.cache.isSoundDecoded(this.key)) {
+        this._sound = this.context.createBufferSource();
+        if (this.externalNode) {
+          this._sound.connect(this.externalNode);
+        } else {
+          this._sound.connect(this.gainNode);
+        }
+        this._buffer = this.game.cache.getSoundData(this.key);
+        this._sound.buffer = this._buffer;
+        if (this.loop && marker === '') {
+          this._sound.loop = true;
+        }
+        if (!this.loop && marker === '') {
+          this._sound.onended = this.onEndedHandler.bind(this);
+        }
+        this.totalDuration = this._sound.buffer.duration;
+        if (this.duration === 0) {
+          this.duration = this.totalDuration;
+          this.durationMS = Math.ceil(this.totalDuration * 1000);
+        }
+        //  Useful to cache this somewhere perhaps?
+        if (this._sound.start === undefined) {
+          this._sound.noteGrainOn(0, this.position, this.duration);
+        } else if (this.loop && marker === '') {
+          this._sound.start(0, 0);
+        } else {
+          this._sound.start(0, this.position, this.duration);
+        }
+        this.isPlaying = true;
+        this.startTime = this.game.time.time;
+        this.currentTime = 0;
+        this.stopTime = this.startTime + this.durationMS;
+        this.onPlay.dispatch(this);
+      } else {
+        this.pendingPlayback = true;
+        if (this.game.cache.getSound(this.key) && this.game.cache.getSound(this.key).isDecoding === false) {
+          this.game.sound.decode(this.key, this);
+        }
+      }
+    } else if (this.game.cache.getSound(this.key) && this.game.cache.getSound(this.key).locked) {
+      this.game.cache.reloadSound(this.key);
+      this.pendingPlayback = true;
+    } else if (this._sound && (this.game.device.cocoonJS || this._sound.readyState === 4)) {
+      this._sound.play();
+      //  This doesn't become available until you call play(), wonderful ...
+      this.totalDuration = this._sound.duration;
+      if (this.duration === 0) {
+        this.duration = this.totalDuration;
+        this.durationMS = this.totalDuration * 1000;
+      }
+      this._sound.currentTime = this.position;
+      this._sound.muted = this._muted;
+      if (this._muted || this.game.sound.mute) {
+        this._sound.volume = 0;
+      } else {
+        this._sound.volume = this._volume;
+      }
+      this.isPlaying = true;
+      this.startTime = this.game.time.time;
+      this.currentTime = 0;
+      this.stopTime = this.startTime + this.durationMS;
+      this.onPlay.dispatch(this);
+    } else {
+      this.pendingPlayback = true;
+    }
+    return this;
+  }
+
+  restart(marker = '', position = 0, volume = 1, loop = false) {
+    this.play(marker, position, volume, loop, true);
+  }
+
+  pause() {
+    if (this.isPlaying && this._sound) {
+      this.paused = true;
+      this.pausedPosition = this.currentTime;
+      this.pausedTime = this.game.time.time;
+      this._tempPause = this._sound.currentTime;
+      this.onPause.dispatch(this);
+      this.stop();
+    }
+  }
+
+  resume() {
+    if (this.paused && this._sound) {
+      if (this.usingWebAudio) {
+        const p = Math.max(0, this.position + (this.pausedPosition / 1000));
+        this._sound = this.context.createBufferSource();
+        this._sound.buffer = this._buffer;
+        if (this.externalNode) {
+          this._sound.connect(this.externalNode);
+        } else {
+          this._sound.connect(this.gainNode);
+        }
+        if (this.loop) {
+          this._sound.loop = true;
+        }
+        if (!this.loop && this.currentMarker === '') {
+          this._sound.onended = this.onEndedHandler.bind(this);
+        }
+        const duration = this.duration - (this.pausedPosition / 1000);
+        if (this._sound.start === undefined) {
+          this._sound.noteGrainOn(0, p, duration);
+          // this._sound.noteOn(0); // the zero is vitally important, crashes iOS6 without it
+        } else if (this.loop && this.game.device.chrome) {
+          // Handle chrome bug: https://code.google.com/p/chromium/issues/detail?id=457099
+          if (this.game.device.chromeVersion === 42) {
+            this._sound.start(0);
+          } else {
+            this._sound.start(0, p);
+          }
+        } else {
+          this._sound.start(0, p, duration);
+        }
+      } else {
+        this._sound.currentTime = this._tempPause;
+        this._sound.play();
+      }
+      this.isPlaying = true;
+      this.paused = false;
+      this.startTime += (this.game.time.time - this.pausedTime);
+      this.onResume.dispatch(this);
+    }
+  }
+
+  stop() {
+    if (this.isPlaying && this._sound) {
+      if (this.usingWebAudio) {
+        if (this._sound.stop === undefined) {
+          this._sound.noteOff(0);
+        } else {
+          try {
+            this._sound.stop(0);
+          } catch (e) {
+            //  Thanks Android 4.4
+          }
+        }
+        if (this.externalNode) {
+          this._sound.disconnect(this.externalNode);
+        } else if (this.gainNode) {
+          this._sound.disconnect(this.gainNode);
+        }
+      } else if (this.usingAudioTag) {
+        this._sound.pause();
+        this._sound.currentTime = 0;
+      }
+    }
+    this.pendingPlayback = false;
+    this.isPlaying = false;
+    if (!this.paused) {
+      const prevMarker = this.currentMarker;
+      if (this.currentMarker !== '') {
+        this.onMarkerComplete.dispatch(this.currentMarker, this);
+      }
+      this.currentMarker = '';
+      if (this.fadeTween !== null) {
+        this.fadeTween.stop();
+      }
+      this.onStop.dispatch(this, prevMarker);
+    }
+  }
+
+  fadeIn(duration, loop = false, marker = this.currentMarker) {
+    if (this.paused) {
+      return;
+    }
+    this.play(marker, 0, 0, loop);
+    this.fadeTo(duration, 1);
+  }
+
+  fadeOut(duration) {
+    this.fadeTo(duration, 0);
+  }
+
+  fadeTo(duration = 100, volume = 0) {
+    if (!this.isPlaying || this.paused || volume === this.volume) {
+      return;
+    }
+    this.fadeTween = this.game.tweens.create(this).to({ volume }, duration, 'Linear', true);
+    this.fadeTween.onComplete.add(this.fadeComplete, this);
+  }
+
+  fadeComplete() {
+    this.onFadeComplete.dispatch(this, this.volume);
+    if (this.volume === 0) {
+      this.stop();
+    }
+  }
+
+  updateGlobalVolume(globalVolume) {
+    //  this._volume is the % of the global volume this sound should be played at
+    if (this.usingAudioTag && this._sound) {
+      this._sound.volume = globalVolume * this._volume;
+    }
+
+  }
+
+  destroy(remove = true) {
+    this._markedToDelete = true;
+    this._removeFromSoundManager = remove;
+    this.stop();
+    if (remove) {
+      this.game.sound.remove(this);
+    } else {
+      this.markers = {};
+      this.context = null;
+      this._buffer = null;
+      this.externalNode = null;
+      this.onDecoded.dispose();
+      this.onPlay.dispose();
+      this.onPause.dispose();
+      this.onResume.dispose();
+      this.onLoop.dispose();
+      this.onStop.dispose();
+      this.onMute.dispose();
+      this.onMarkerComplete.dispose();
+    }
+  }
+
+  get mute() {
+    return (this._muted || this.game.sound.mute);
+  }
+
+  set mute(value) {
+    value = value || false;
+    if (value === this._muted) {
+      return;
+    }
+    if (value) {
+      this._muted = true;
+      this._muteVolume = this._tempVolume;
+      if (this.usingWebAudio) {
+        this.gainNode.gain.value = 0;
+      } else if (this.usingAudioTag && this._sound) {
+        this._sound.volume = 0;
+      }
+    } else {
+      this._muted = false;
+      if (this.usingWebAudio) {
+        this.gainNode.gain.value = this._muteVolume;
+      } else if (this.usingAudioTag && this._sound) {
+        this._sound.volume = this._muteVolume;
+      }
+    }
+    this.onMute.dispatch(this);
+  }
+
+  get volume() {
+    return this._volume;
+  }
+
+  set volume(value) {
+    const normalizedValue = this.usingAudioTag ? Math.max(0, Math.min(1, value)) : value;
+    if (this._muted) {
+      this._muteVolume = normalizedValue;
+      return;
+    }
+    this._tempVolume = normalizedValue;
+    this._volume = normalizedValue;
+    if (this.usingWebAudio) {
+      this.gainNode.gain.value = normalizedValue;
+    } else if (this.usingAudioTag && this._sound) {
+      this._sound.volume = normalizedValue;
+    }
+  }
+
+}