292 lines
9.0 KiB
C#
292 lines
9.0 KiB
C#
/*
|
|
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
|
* All rights reserved.
|
|
*
|
|
* Licensed under the Oculus SDK License Agreement (the "License");
|
|
* you may not use the Oculus SDK except in compliance with the License,
|
|
* which is provided at the time of installation or download, or which
|
|
* otherwise accompanies this software in either electronic or hard copy form.
|
|
*
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* https://developer.oculus.com/licenses/oculussdk/
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, the Oculus SDK
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
using UnityEngine;
|
|
using Random = UnityEngine.Random;
|
|
|
|
namespace Oculus.Interaction
|
|
{
|
|
/// <summary>
|
|
/// Triggers audio clips. Place this component on a GameObject alongside a <cref="AudioSource" /> component.
|
|
/// In an event wrapper, call AudioTrigger.PlayAudio() to trigger the audio.
|
|
/// </summary>
|
|
public class AudioTrigger : MonoBehaviour
|
|
{
|
|
[SerializeField]
|
|
private AudioSource _audioSource;
|
|
|
|
/// <summary>
|
|
/// A list of audio clips. The audio clip played will be randomly selected from the list.
|
|
/// </summary>
|
|
[Tooltip("Audio clip arrays with a value greater than 1 will have randomized playback.")]
|
|
[SerializeField]
|
|
private AudioClip[] _audioClips;
|
|
|
|
/// <summary>
|
|
/// The default playback volume of the audio clip. Volume set here will override the volume set on the attached sound source component.
|
|
/// </summary>
|
|
[Tooltip("Volume set here will override the volume set on the attached sound source component.")]
|
|
[Range(0f, 1f)]
|
|
[SerializeField]
|
|
private float _volume = 0.7f;
|
|
public float Volume
|
|
{
|
|
get
|
|
{
|
|
return _volume;
|
|
}
|
|
set
|
|
{
|
|
_volume = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// A random range of volumes at which to play the audio clip. Check the 'Use Random Range' bool and adjust the min and max slider values for randomized volume level playback.
|
|
/// </summary>
|
|
[Tooltip("Check the 'Use Random Range' bool and adjust the min and max slider values for randomized volume level playback.")]
|
|
[SerializeField]
|
|
private MinMaxPair _volumeRandomization;
|
|
public MinMaxPair VolumeRandomization
|
|
{
|
|
get
|
|
{
|
|
return _volumeRandomization;
|
|
}
|
|
set
|
|
{
|
|
_volumeRandomization = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The default pitch of the audio clip. Pitch set here will override the volume set on the attached sound source component.
|
|
/// </summary>
|
|
[Tooltip("Pitch set here will override the volume set on the attached sound source component.")]
|
|
[SerializeField]
|
|
[Range(-3f, 3f)]
|
|
[Space(10)]
|
|
private float _pitch = 1f;
|
|
public float Pitch
|
|
{
|
|
get
|
|
{
|
|
return _pitch;
|
|
}
|
|
set
|
|
{
|
|
_pitch = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// A random range of pitches at which to play the audio clip.
|
|
/// Check the 'Use Random Range' bool and adjust the min and max slider values for randomized volume level playback.
|
|
/// </summary>
|
|
[Tooltip("Check the 'Use Random Range' bool and adjust the min and max slider values for randomized volume level playback.")]
|
|
[SerializeField]
|
|
private MinMaxPair _pitchRandomization;
|
|
public MinMaxPair PitchRandomization
|
|
{
|
|
get
|
|
{
|
|
return _pitchRandomization;
|
|
}
|
|
set
|
|
{
|
|
_pitchRandomization = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// True by default. Set to false for sounds to bypass the spatializer plugin. Will override settings on attached audio source.
|
|
/// </summary>
|
|
[Tooltip("True by default. Set to false for sounds to bypass the spatializer plugin. Will override settings on attached audio source.")]
|
|
[SerializeField]
|
|
[Space(10)]
|
|
private bool _spatialize = true;
|
|
public bool Spatialize
|
|
{
|
|
get
|
|
{
|
|
return _spatialize;
|
|
}
|
|
set
|
|
{
|
|
_spatialize = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// False by default. Set to true to enable looping on this sound. Will override settings on attached audio source.
|
|
/// </summary>
|
|
[Tooltip("False by default. Set to true to enable looping on this sound. Will override settings on attached audio source.")]
|
|
[SerializeField]
|
|
private bool _loop = false;
|
|
public bool Loop
|
|
{
|
|
get
|
|
{
|
|
return _loop;
|
|
}
|
|
set
|
|
{
|
|
_loop = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 100% by default. Sets likelihood sample will actually play when called.
|
|
/// </summary>
|
|
[Tooltip("100% by default. Sets likelihood sample will actually play when called.")]
|
|
[SerializeField]
|
|
private float _chanceToPlay = 100;
|
|
public float ChanceToPlay
|
|
{
|
|
get
|
|
{
|
|
return _chanceToPlay;
|
|
}
|
|
set
|
|
{
|
|
_chanceToPlay = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// If enabled, audio will play automatically when this gameobject is enabled.
|
|
/// </summary>
|
|
[Tooltip("If enabled, audio will play automatically when this gameobject is enabled.")]
|
|
[SerializeField, Optional]
|
|
private bool _playOnStart = false;
|
|
|
|
private int _previousAudioClipIndex = -1;
|
|
|
|
protected virtual void Start()
|
|
{
|
|
if (_audioSource == null)
|
|
{
|
|
_audioSource = gameObject.GetComponent<AudioSource>();
|
|
}
|
|
|
|
this.AssertField(_audioSource, nameof(_audioSource));
|
|
this.AssertCollectionField(_audioClips, nameof(_audioClips));
|
|
|
|
// Play audio on start if enabled
|
|
if (_playOnStart)
|
|
{
|
|
PlayAudio();
|
|
}
|
|
}
|
|
|
|
public void PlayAudio()
|
|
{
|
|
// Check if random chance is set
|
|
float pick = Random.Range(0.0f, 100.0f);
|
|
if (_chanceToPlay < 100 && pick > _chanceToPlay)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Check if volume randomization is set
|
|
if (_volumeRandomization.UseRandomRange == true)
|
|
{
|
|
_audioSource.volume = Random.Range(_volumeRandomization.Min, _volumeRandomization.Max);
|
|
}
|
|
else
|
|
{
|
|
_audioSource.volume = _volume;
|
|
}
|
|
|
|
// Check if pitch randomization is set
|
|
if (_pitchRandomization.UseRandomRange == true)
|
|
{
|
|
_audioSource.pitch = Random.Range(_pitchRandomization.Min, _pitchRandomization.Max);
|
|
}
|
|
else
|
|
{
|
|
_audioSource.pitch = _pitch;
|
|
}
|
|
|
|
_audioSource.spatialize = _spatialize;
|
|
_audioSource.loop = _loop;
|
|
|
|
_audioSource.clip = RandomClipWithoutRepeat();
|
|
|
|
_audioSource.Play();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Choose a random clip without repeating the last clip
|
|
/// </summary>
|
|
private AudioClip RandomClipWithoutRepeat()
|
|
{
|
|
if (_audioClips.Length == 1)
|
|
{
|
|
return _audioClips[0];
|
|
}
|
|
|
|
int randomOffset = Random.Range(1, _audioClips.Length);
|
|
int index = (_previousAudioClipIndex + randomOffset) % _audioClips.Length;
|
|
_previousAudioClipIndex = index;
|
|
return _audioClips[index];
|
|
}
|
|
|
|
#region Inject
|
|
|
|
public void InjectAllAudioTrigger(AudioSource audioSource, AudioClip[] audioClips)
|
|
{
|
|
InjectAudioSource(audioSource);
|
|
InjectAudioClips(audioClips);
|
|
}
|
|
|
|
public void InjectAudioSource(AudioSource audioSource)
|
|
{
|
|
_audioSource = audioSource;
|
|
}
|
|
public void InjectAudioClips(AudioClip[] audioClips)
|
|
{
|
|
_audioClips = audioClips;
|
|
}
|
|
|
|
public void InjectOptionalPlayOnStart(bool playOnStart)
|
|
{
|
|
_playOnStart = playOnStart;
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
[System.Serializable]
|
|
public struct MinMaxPair
|
|
{
|
|
[SerializeField]
|
|
private bool _useRandomRange;
|
|
[SerializeField]
|
|
private float _min;
|
|
[SerializeField]
|
|
private float _max;
|
|
|
|
public bool UseRandomRange => _useRandomRange;
|
|
public float Min => _min;
|
|
public float Max => _max;
|
|
}
|
|
}
|