holopy3/Assets/SteamVR/InteractionSystem/Core/Scripts/PlaySound.cs

//======= Copyright (c) Valve Corporation, All rights reserved. ===============
//
// Purpose: Plays one of many audio files with possible randomized parameters
//
//=============================================================================

using UnityEngine;
using System.Collections;

namespace Valve.VR.InteractionSystem
{
	//-------------------------------------------------------------------------
	[RequireComponent( typeof( AudioSource ) )]
	public class PlaySound : MonoBehaviour
	{
		[Tooltip( "List of audio clips to play." )]
		public AudioClip[] waveFile;
		[Tooltip( "Stops the currently playing clip in the audioSource. Otherwise clips will overlap/mix." )]
		public bool stopOnPlay;
		[Tooltip( "After the audio clip finishes playing, disable the game object the sound is on." )]
		public bool disableOnEnd;
		[Tooltip( "Loop the sound after the wave file variation has been chosen." )]
		public bool looping;
		[Tooltip( "If the sound is looping and updating it's position every frame, stop the sound at the end of the wav/clip length. " )]
		public bool stopOnEnd;
		[Tooltip( "Start a wave file playing on awake, but after a delay." )]
		public bool playOnAwakeWithDelay;

		[Header ( "Random Volume" )]
		public bool useRandomVolume = true;
		[Tooltip( "Minimum volume that will be used when randomly set." )]
		[Range( 0.0f, 1.0f )]
		public float volMin = 1.0f;
		[Tooltip( "Maximum volume that will be used when randomly set." )]
		[Range( 0.0f, 1.0f )]
		public float volMax = 1.0f;

		[Header ( "Random Pitch" )]
		[Tooltip( "Use min and max random pitch levels when playing sounds." )]
		public bool useRandomPitch = true;
		[Tooltip( "Minimum pitch that will be used when randomly set." )]
		[Range( -3.0f, 3.0f )]
		public float pitchMin = 1.0f;
		[Tooltip( "Maximum pitch that will be used when randomly set." )]
		[Range( -3.0f, 3.0f )]
		public float pitchMax = 1.0f;

		[Header( "Random Time" )]
		[Tooltip( "Use Retrigger Time to repeat the sound within a time range" )]
		public bool useRetriggerTime = false;
		[Tooltip( "Inital time before the first repetion starts" )]
		[Range( 0.0f, 360.0f )]
		public float timeInitial = 0.0f;
		[Tooltip( "Minimum time that will pass before the sound is retriggered" )]
		[Range( 0.0f, 360.0f )]
		public float timeMin = 0.0f;
		[Tooltip( "Maximum pitch that will be used when randomly set." )]
		[Range( 0.0f, 360.0f )]
		public float timeMax = 0.0f;

		[Header ( "Random Silence" )]
		[Tooltip( "Use Retrigger Time to repeat the sound within a time range" )]
		public bool useRandomSilence = false;
		[Tooltip( "Percent chance that the wave file will not play" )]
		[Range( 0.0f, 1.0f )]
		public float percentToNotPlay = 0.0f;

		[Header( "Delay Time" )]
		[Tooltip( "Time to offset playback of sound" )]
		public float delayOffsetTime = 0.0f;


		private AudioSource audioSource;
		private AudioClip clip;

		//-------------------------------------------------
		void Awake()
		{
			audioSource = GetComponent<AudioSource>();
			clip = audioSource.clip;

			// audio source play on awake is true, just play the PlaySound immediately
			if ( audioSource.playOnAwake )
			{
				if ( useRetriggerTime )
					InvokeRepeating( "Play", timeInitial, Random.Range( timeMin, timeMax ) );
				else
					Play();
			}

			// if playOnAwake is false, but the playOnAwakeWithDelay on the PlaySound is true, play the sound on away but with a delay
			else if ( !audioSource.playOnAwake && playOnAwakeWithDelay )
			{
				PlayWithDelay( delayOffsetTime );

				if ( useRetriggerTime )
					InvokeRepeating( "Play", timeInitial, Random.Range( timeMin, timeMax ) );
			}

			// in the case where both playOnAwake and playOnAwakeWithDelay are both set to true, just to the same as above, play the sound but with a delay
			else if ( audioSource.playOnAwake && playOnAwakeWithDelay )
			{
				PlayWithDelay( delayOffsetTime );

				if ( useRetriggerTime )
					InvokeRepeating( "Play", timeInitial, Random.Range( timeMin, timeMax ) );
			}
		}


		//-------------------------------------------------
		// Play a random clip from those available
		//-------------------------------------------------
		public void Play()
		{
			if ( looping )
			{
				PlayLooping();

			}

			else PlayOneShotSound();
		}


		//-------------------------------------------------
		public void PlayWithDelay( float delayTime )
		{
			if ( looping )
				Invoke( "PlayLooping", delayTime );
			else
				Invoke( "PlayOneShotSound", delayTime );
		}


		//-------------------------------------------------
		// Play random wave clip on audiosource as a one shot
		//-------------------------------------------------
		public AudioClip PlayOneShotSound()
		{
			if ( !this.audioSource.isActiveAndEnabled )
				return null;

			SetAudioSource();
			if ( this.stopOnPlay )
				audioSource.Stop();
			if ( this.disableOnEnd )
				Invoke( "Disable", clip.length );
			this.audioSource.PlayOneShot( this.clip );
			return this.clip;
		}


		//-------------------------------------------------
		public AudioClip PlayLooping()
		{
			// get audio source properties, and do any special randomizations
			SetAudioSource();

			// if the audio source has forgotten to be set to looping, set it to looping
			if ( !audioSource.loop )
				audioSource.loop = true;

			// play the clip in the audio source, all the meanwhile updating it's location
			this.audioSource.Play();

			// if disable on end is checked, stop playing the wave file after the first loop has finished.
			if ( stopOnEnd )
				Invoke( "Stop", audioSource.clip.length );
			return this.clip;
		}


		//-------------------------------------------------
		public void Disable()
		{
			gameObject.SetActive( false );
		}


		//-------------------------------------------------
		public void Stop()
		{
			audioSource.Stop();
		}


		//-------------------------------------------------
		private void SetAudioSource()
		{
			if ( this.useRandomVolume )
			{
				//randomly apply a volume between the volume min max
				this.audioSource.volume = Random.Range( this.volMin, this.volMax );

				if ( useRandomSilence && ( Random.Range( 0, 1 ) < percentToNotPlay ) )
				{
					this.audioSource.volume = 0;
				}
			}

			if ( this.useRandomPitch )
			{
				//randomly apply a pitch between the pitch min max
				this.audioSource.pitch = Random.Range( this.pitchMin, this.pitchMax );
			}

			if ( this.waveFile.Length > 0 )
			{
				// randomly assign a wave file from the array into the audioSource clip property
				audioSource.clip = this.waveFile[Random.Range( 0, waveFile.Length )];
				clip = audioSource.clip;
			}
		}
	}
}