You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
311 lines
9.1 KiB
311 lines
9.1 KiB
using UnityEngine;
|
|
using UnityEngine.Audio;
|
|
|
|
namespace OVR
|
|
{
|
|
|
|
public enum SoundFXNext {
|
|
Random = 0,
|
|
Sequential = 1,
|
|
}
|
|
|
|
public enum FreqHint {
|
|
None = 0,
|
|
Wide = 1,
|
|
Narrow = 2,
|
|
}
|
|
|
|
public enum SoundPriority {
|
|
VeryLow = -2,
|
|
Low = -1,
|
|
Default = 0,
|
|
High = 1,
|
|
VeryHigh = 2,
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class OSPProps {
|
|
public OSPProps() {
|
|
enableSpatialization = false;
|
|
useFastOverride = false;
|
|
gain = 0.0f;
|
|
enableInvSquare = false;
|
|
volumetric = 0.0f;
|
|
invSquareFalloff = new Vector2( 1.0f, 25.0f );
|
|
}
|
|
|
|
[Tooltip( "Set to true to play the sound FX spatialized with binaural HRTF, default = false")]
|
|
public bool enableSpatialization = false;
|
|
[Tooltip( "Play the sound FX with reflections, default = false")]
|
|
public bool useFastOverride = false;
|
|
[Tooltip( "Boost the gain on the spatialized sound FX, default = 0.0")]
|
|
[Range( 0.0f, 24.0f )]
|
|
public float gain = 0.0f;
|
|
[Tooltip("Enable Inverse Square attenuation curve, default = false")]
|
|
public bool enableInvSquare = false;
|
|
[Tooltip("Change the sound from point source (0.0f) to a spherical volume, default = 0.0")]
|
|
[Range(0.0f, 1000.0f)]
|
|
public float volumetric = 0.0f;
|
|
[Tooltip("Set the near and far falloff value for the OSP attenuation curve, default = 1.0")]
|
|
[MinMax ( 1.0f, 25.0f, 0.0f, 250.0f )]
|
|
public Vector2 invSquareFalloff = new Vector2( 1.0f, 25.0f );
|
|
}
|
|
|
|
/*
|
|
-----------------------
|
|
|
|
SoundFX
|
|
|
|
-----------------------
|
|
*/
|
|
[System.Serializable]
|
|
public class SoundFX {
|
|
public SoundFX() {
|
|
playback = SoundFXNext.Random;
|
|
volume = 1.0f;
|
|
pitchVariance = Vector2.one;
|
|
falloffDistance = new Vector2( 1.0f, 25.0f );
|
|
falloffCurve = AudioRolloffMode.Linear;
|
|
volumeFalloffCurve = new AnimationCurve( new Keyframe[2] { new Keyframe( 0f, 1.0f ), new Keyframe( 1f, 1f ) } );
|
|
reverbZoneMix = new AnimationCurve( new Keyframe[2] { new Keyframe( 0f, 1.0f ), new Keyframe( 1f, 1f ) } );
|
|
spread = 0.0f;
|
|
pctChanceToPlay = 1.0f;
|
|
priority = SoundPriority.Default;
|
|
delay = Vector2.zero;
|
|
looping = false;
|
|
ospProps = new OSPProps();
|
|
}
|
|
|
|
[Tooltip( "Each sound FX should have a unique name")]
|
|
public string name = string.Empty;
|
|
[Tooltip( "Sound diversity playback option when multiple audio clips are defined, default = Random")]
|
|
public SoundFXNext playback = SoundFXNext.Random;
|
|
[Tooltip( "Default volume for this sound FX, default = 1.0")]
|
|
[Range (0.0f, 1.0f)]
|
|
public float volume = 1.0f;
|
|
[Tooltip( "Random pitch variance each time a sound FX is played, default = 1.0 (none)")]
|
|
[MinMax ( 1.0f, 1.0f, 0.0f, 2.0f )]
|
|
public Vector2 pitchVariance = Vector2.one;
|
|
[Tooltip( "Falloff distance for the sound FX, default = 1m min to 25m max")]
|
|
[MinMax ( 1.0f, 25.0f, 0.0f, 250.0f )]
|
|
public Vector2 falloffDistance = new Vector2( 1.0f, 25.0f );
|
|
[Tooltip( "Volume falloff curve - sets how the sound FX attenuates over distance, default = Linear")]
|
|
public AudioRolloffMode falloffCurve = AudioRolloffMode.Linear;
|
|
[Tooltip( "Defines the custom volume falloff curve")]
|
|
public AnimationCurve volumeFalloffCurve = new AnimationCurve( new Keyframe[2] { new Keyframe( 0f, 1.0f ), new Keyframe( 1f, 1f ) } );
|
|
[Tooltip( "The amount by which the signal from the AudioSource will be mixed into the global reverb associated with the Reverb Zones | Valid range is 0.0 - 1.1, default = 1.0" )]
|
|
public AnimationCurve reverbZoneMix = new AnimationCurve( new Keyframe[2] { new Keyframe( 0f, 1.0f ), new Keyframe( 1f, 1f ) } );
|
|
[Tooltip( "Sets the spread angle (in degrees) of a 3d stereo or multichannel sound in speaker space, default = 0")]
|
|
[Range (0.0f, 360.0f)]
|
|
public float spread = 0.0f;
|
|
[Tooltip( "The percentage chance that this sound FX will play | 0.0 = none, 1.0 = 100%, default = 1.0")]
|
|
[Range (0.0f, 1.0f)]
|
|
public float pctChanceToPlay = 1.0f;
|
|
[Tooltip( "Sets the priority for this sound to play and/or to override a currently playing sound FX, default = Default")]
|
|
public SoundPriority priority = SoundPriority.Default;
|
|
[Tooltip( "Specifies the default delay when this sound FX is played, default = 0.0 secs")]
|
|
[MinMax ( 0.0f, 0.0f, 0.0f, 2.0f )]
|
|
public Vector2 delay = Vector2.zero; // this overrides any delay passed into PlaySound() or PlaySoundAt()
|
|
[Tooltip( "Set to true for the sound to loop continuously, default = false")]
|
|
public bool looping = false;
|
|
public OSPProps ospProps = new OSPProps();
|
|
[Tooltip( "List of the audio clips assigned to this sound FX")]
|
|
public AudioClip[] soundClips = new AudioClip[1];
|
|
// editor only - unfortunately if we set it not to serialize, we can't query it from the editor
|
|
public bool visibilityToggle = false;
|
|
// runtime vars
|
|
[System.NonSerialized]
|
|
private SoundGroup soundGroup = null;
|
|
private int lastIdx = -1;
|
|
private int playingIdx = -1;
|
|
|
|
public int Length { get { return soundClips.Length; } }
|
|
public bool IsValid { get { return ( ( soundClips.Length != 0 ) && ( soundClips[0] != null ) ); } }
|
|
public SoundGroup Group { get { return soundGroup; } set { soundGroup = value; } }
|
|
public float MaxFalloffDistSquared { get { return falloffDistance.y * falloffDistance.y; } }
|
|
public float GroupVolumeOverride { get { return ( soundGroup != null ) ? soundGroup.volumeOverride : 1.0f; } }
|
|
|
|
/*
|
|
-----------------------
|
|
GetClip()
|
|
-----------------------
|
|
*/
|
|
public AudioClip GetClip() {
|
|
if ( soundClips.Length == 0 ) {
|
|
return null;
|
|
} else if ( soundClips.Length == 1 ) {
|
|
return soundClips[0];
|
|
}
|
|
if ( playback == SoundFXNext.Random ) {
|
|
// random, but don't pick the last one
|
|
int idx = Random.Range( 0, soundClips.Length );
|
|
while ( idx == lastIdx ) {
|
|
idx = Random.Range( 0, soundClips.Length );
|
|
}
|
|
lastIdx = idx;
|
|
return soundClips[idx];
|
|
} else {
|
|
// sequential
|
|
if ( ++lastIdx >= soundClips.Length ) {
|
|
lastIdx = 0;
|
|
}
|
|
return soundClips[lastIdx];
|
|
}
|
|
}
|
|
|
|
/*
|
|
-----------------------
|
|
GetMixerGroup()
|
|
-----------------------
|
|
*/
|
|
public AudioMixerGroup GetMixerGroup( AudioMixerGroup defaultMixerGroup ) {
|
|
if ( soundGroup != null ) {
|
|
return ( soundGroup.mixerGroup != null ) ? soundGroup.mixerGroup : defaultMixerGroup;
|
|
}
|
|
return defaultMixerGroup;
|
|
}
|
|
|
|
/*
|
|
-----------------------
|
|
ReachedGroupPlayLimit()
|
|
-----------------------
|
|
*/
|
|
public bool ReachedGroupPlayLimit() {
|
|
if ( soundGroup != null ) {
|
|
return !soundGroup.CanPlaySound();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
-----------------------
|
|
GetClipLength()
|
|
-----------------------
|
|
*/
|
|
public float GetClipLength( int idx ) {
|
|
if ( ( idx == -1 ) || ( soundClips.Length == 0 ) || ( idx >= soundClips.Length ) || ( soundClips[idx] == null ) ) {
|
|
return 0.0f;
|
|
} else {
|
|
return soundClips[idx].length;
|
|
}
|
|
}
|
|
|
|
/*
|
|
-----------------------
|
|
GetPitch()
|
|
-----------------------
|
|
*/
|
|
public float GetPitch() {
|
|
return Random.Range( pitchVariance.x, pitchVariance.y );
|
|
}
|
|
|
|
/*
|
|
-----------------------
|
|
PlaySound()
|
|
-----------------------
|
|
*/
|
|
public int PlaySound( float delaySecs = 0.0f ) {
|
|
playingIdx = -1;
|
|
|
|
if ( !IsValid ) {
|
|
return playingIdx;
|
|
}
|
|
|
|
// check the random chance to play here to save the function calls
|
|
if ( ( pctChanceToPlay > 0.99f ) || ( Random.value < pctChanceToPlay ) ) {
|
|
if ( delay.y > 0.0f ) {
|
|
delaySecs = Random.Range( delay.x, delay.y );
|
|
}
|
|
playingIdx = AudioManager.PlaySound( this, EmitterChannel.Any, delaySecs );
|
|
}
|
|
|
|
return playingIdx;
|
|
}
|
|
|
|
/*
|
|
-----------------------
|
|
PlaySoundAt()
|
|
-----------------------
|
|
*/
|
|
public int PlaySoundAt( Vector3 pos, float delaySecs = 0.0f, float volumeOverride = 1.0f, float pitchMultiplier = 1.0f ) {
|
|
playingIdx = -1;
|
|
|
|
if ( !IsValid ) {
|
|
return playingIdx;
|
|
}
|
|
|
|
// check the random chance to play here to save the function calls
|
|
if ( ( pctChanceToPlay > 0.99f ) || ( Random.value < pctChanceToPlay ) ) {
|
|
if ( delay.y > 0.0f ) {
|
|
delaySecs = Random.Range( delay.x, delay.y );
|
|
}
|
|
playingIdx = AudioManager.PlaySoundAt( pos, this, EmitterChannel.Any, delaySecs, volumeOverride, pitchMultiplier );
|
|
}
|
|
|
|
return playingIdx;
|
|
}
|
|
|
|
/*
|
|
-----------------------
|
|
SetOnFinished()
|
|
get a callback when the sound is finished playing
|
|
-----------------------
|
|
*/
|
|
public void SetOnFinished( System.Action onFinished ) {
|
|
if ( playingIdx > -1 ) {
|
|
AudioManager.SetOnFinished( playingIdx, onFinished );
|
|
}
|
|
}
|
|
|
|
/*
|
|
-----------------------
|
|
SetOnFinished()
|
|
get a callback with an object parameter when the sound is finished playing
|
|
-----------------------
|
|
*/
|
|
public void SetOnFinished( System.Action<object> onFinished, object obj ) {
|
|
if ( playingIdx > -1 ) {
|
|
AudioManager.SetOnFinished( playingIdx, onFinished, obj );
|
|
}
|
|
}
|
|
|
|
/*
|
|
-----------------------
|
|
StopSound()
|
|
-----------------------
|
|
*/
|
|
public bool StopSound() {
|
|
bool stopped = false;
|
|
|
|
if (playingIdx > -1){
|
|
stopped = AudioManager.StopSound(playingIdx);
|
|
playingIdx = -1;
|
|
}
|
|
|
|
return stopped;
|
|
}
|
|
|
|
/*
|
|
-----------------------
|
|
AttachToParent()
|
|
-----------------------
|
|
*/
|
|
public void AttachToParent( Transform parent) {
|
|
if (playingIdx > -1) {
|
|
AudioManager.AttachSoundToParent(playingIdx, parent);
|
|
}
|
|
}
|
|
|
|
/*
|
|
-----------------------
|
|
DetachFromParent()
|
|
-----------------------
|
|
*/
|
|
public void DetachFromParent() {
|
|
if (playingIdx > -1) {
|
|
AudioManager.DetachSoundFromParent(playingIdx);
|
|
}
|
|
}
|
|
}
|
|
|
|
} // namespace OVR
|