Example #1
0
        /// <summary>
        /// Repeatedly trigger the one-off container based on the loop time.
        /// </summary>
        private IEnumerator PlayLoopingOneOffContainerCoroutine(ActiveEvent activeEvent)
        {
            int?currentIndex = null;

            while (!activeEvent.StopRequested)
            {
                UPlayable currentPlayable = null;

                if (!this.IsSimultaneous)
                {
                    currentIndex    = this.GenerateNextClipIndex(currentIndex);
                    currentPlayable = this.sounds[currentIndex.Value];
                }

                // Start coroutine (don't yield return) so that the wait time is accurate, since length includes delay.
                StartCoroutine(PlayOneOffContainerCoroutine(activeEvent, currentPlayable));

                float eventLoopTime = loopTime;

                // Protect against containers looping every frame by defaulting to the length of the audio clip.
                if (eventLoopTime == 0)
                {
                    if (!this.IsSimultaneous)
                    {
                        eventLoopTime = currentPlayable.GetLength();
                    }
                    else
                    {
                        eventLoopTime = this.GetLength();
                    }
                }

                yield return(new WaitForSeconds(eventLoopTime));
            }
        }
Example #2
0
        private IEnumerator PlayClipCoroutine(UPlayable playable, ActiveEvent activeEvent)
        {
            if (this.IsSimultaneous || this.PlaySimultaneous)
            {
                playable.PlaySimultaneous = true;
            }

            yield return(playable.PlayAsync(activeEvent));
        }
Example #3
0
 /// <summary>
 /// Begin playing a non-continuous container, loop if applicable.
 /// </summary>
 private IEnumerator StartOneOffEventCoroutine(ActiveEvent activeEvent, UPlayable playable)
 {
     if (Loop)
     {
         yield return(PlayLoopingOneOffContainerCoroutine(activeEvent));
     }
     else
     {
         yield return(PlayOneOffContainerCoroutine(activeEvent, playable));
     }
 }
Example #4
0
 /// <summary>
 /// Play a non-continuous container.
 /// </summary>
 private IEnumerator PlayOneOffContainerCoroutine(ActiveEvent activeEvent, UPlayable playable)
 {
     // Simultaneous sounds.
     if (this.IsSimultaneous)
     {
         foreach (UPlayable sound in sounds)
         {
             // We start coroutines here. Since we want to all the sounds to start playing at the same time.
             StartCoroutine(PlayClipCoroutine(sound, activeEvent));
         }
     }
     // Sequential and Random sounds.
     else
     {
         yield return(PlayClipCoroutine(playable, activeEvent));
     }
 }
Example #5
0
        /// <summary>
        /// Determine which rules to follow for container playback, and begin the appropriate function.
        /// </summary>
        public override IEnumerator PlayAsync(ActiveEvent activeEvent)
        {
            BeginPlay();

            if (sounds.Length == 0)
            {
                Debug.LogErrorFormat(this, "Trying to play container \"{0}\" with no clips.", this);
                yield break;
            }

            // We store the playable before the delay, so that we have the correct one in the case where another instance (without delay) was started.
            UPlayable currentPlayable = null;

            if (this.currentClipIndex.HasValue)
            {
                currentPlayable = CurrentPlayable;
            }

            if (this.CurrentDelay > 0.0f)
            {
                yield return(new WaitForSeconds(this.CurrentDelay));
            }

            if (!activeEvent.StopRequested)
            {
                switch (containerType)
                {
                case AudioContainerType.Random:
                case AudioContainerType.Simultaneous:
                case AudioContainerType.Sequence:
                    yield return(StartOneOffEventCoroutine(activeEvent, currentPlayable));

                    break;

                case AudioContainerType.ContinuousSequence:
                case AudioContainerType.ContinuousRandom:
                    yield return(PlayContinuousContainerCoroutine(activeEvent));

                    break;

                default:
                    Debug.LogErrorFormat(this, "Trying to play container \"{0}\" with an unknown AudioContainerType \"{1}\".", this, containerType);
                    yield break;
                }
            }
        }
Example #6
0
        /// <summary>
        /// Coroutine for "continuous" containers that alternates between two sources to crossfade clips for continuous playlist looping.
        /// </summary>
        /// <returns>The coroutine.</returns>
        private IEnumerator PlayContinuousContainerCoroutine(ActiveEvent activeEvent)
        {
            float waitTime     = 0;
            int?  currentIndex = null;

            while (!activeEvent.StopRequested)
            {
                currentIndex = this.GenerateNextClipIndex(currentIndex);
                UPlayable tempClip = this.sounds[currentIndex.Value];

                if (tempClip.IsEmpty())
                {
                    Debug.LogErrorFormat(this, "Sound clip in event \"{0}\" is null!", activeEvent.audioEvent.name);
                    waitTime = 0;
                }
                else
                {
                    if (!activeEvent.IsPlayingSecondary)
                    {
                        activeEvent.volDest    = activeEvent.audioEvent.volumeCenter;
                        activeEvent.altVolDest = 0f;
                    }
                    else
                    {
                        activeEvent.volDest    = 0f;
                        activeEvent.altVolDest = activeEvent.audioEvent.volumeCenter;
                    }

                    activeEvent.CurrentAudioSource.volume = 0f;
                    activeEvent.currentFade = crossfadeTime;
                    yield return(PlayClipCoroutine(tempClip, activeEvent));

                    waitTime = tempClip.GetLength() - crossfadeTime;
                }

                // Alternate playing on primary / secondary audio sources.
                activeEvent.IsPlayingSecondary = !activeEvent.IsPlayingSecondary;

                yield return(new WaitForSeconds(waitTime));
            }
        }
Example #7
0
        private void AddSound(AudioContainer audioContainer, SerializedObject audioContainerSO, UPlayable newPlayable)
        {
            if (audioContainer.sounds == null)
            {
                audioContainer.sounds = new UPlayable[0];
            }

            audioContainerSO.FindProperty("sounds").InsertArrayElementAtIndex(audioContainer.sounds.Length);
            audioContainerSO.FindProperty("sounds").GetArrayElementAtIndex(audioContainer.sounds.Length).objectReferenceValue = newPlayable;
        }
Example #8
0
        private void DrawSoundClipInspector(AudioContainer audioContainer, SerializedObject audioContainerSerializedObject)
        {
            bool oldAllowLooping = allowLooping;

            allowLooping = allowLooping && !audioContainer.Loop && !audioContainer.IsContinuous;

            for (int i = 0; audioContainer.sounds != null && i < audioContainer.sounds.Length; i++)
            {
                if (audioContainer.sounds[i] == null)
                {
                    UAudioClip audioClip = this.playablesGameObject.AddComponent <UAudioClip>();
                    audioContainer.sounds[i] = audioClip;
                }

                UPlayable currentSound = audioContainer.sounds[i];

                EditorGUILayout.Space();
                EditorGUILayout.Space();

                bool wasRemoved = false;

                EditorGUILayout.BeginHorizontal();

                soundElementArrowsStyle.margin.top = allowLooping ? 10 : 0;

                EditorGUILayout.BeginVertical(soundElementArrowsStyle);

                EditorGUI.BeginDisabledGroup(i <= 0);
                if (GUILayout.Button("▲", GUILayout.Width(20), GUILayout.Height(15)))
                {
                    MoveSound(audioContainer, audioContainerSerializedObject, i, -1);
                }
                EditorGUI.EndDisabledGroup();

                EditorGUI.BeginDisabledGroup(i >= audioContainer.sounds.Length - 1);
                if (GUILayout.Button("▼", GUILayout.Width(20), GUILayout.Height(15)))
                {
                    MoveSound(audioContainer, audioContainerSerializedObject, i, 1);
                }
                EditorGUI.EndDisabledGroup();

                EditorGUILayout.EndVertical();

                EditorGUILayout.BeginVertical();

                if (currentSound is UAudioClip)
                {
                    DrawAudioClipInspector(audioContainer, (UAudioClip)currentSound, out wasRemoved);
                }
                else if (currentSound is AudioContainer)
                {
                    DrawContainerInspector((AudioContainer)currentSound, true, out wasRemoved);
                }

                EditorGUILayout.EndVertical();
                EditorGUILayout.EndHorizontal();

                if (wasRemoved)
                {
                    audioContainerSerializedObject.FindProperty("sounds").GetArrayElementAtIndex(i).DeleteCommand();
                    audioContainerSerializedObject.FindProperty("sounds").DeleteArrayElementAtIndex(i);

                    DestroyImmediate(currentSound);
                    RemoveAt(audioContainer.sounds, i);
                }
            }

            allowLooping = oldAllowLooping;
        }