ADOFAIRenderer/Patch/Engine/AudioPatches.cs

using System;
using System.Collections.Generic;
using ADOFAIRenderer.Core;
using ADOFAIRenderer.Util.Audio;
using ADOFAIRenderer.Util.Audio.Clip;
using HarmonyLib;
using UnityEngine;
using UnityEngine.Audio;

namespace ADOFAIRenderer.Patch.Engine;

/// <summary>
/// Records the file path of each external clip the game loads (always active, also outside rendering,
/// because levels load their song and PlaySound files before a render starts).
/// FindOrLoadAudioClipExternal returns the clip already in audioLib when its key exists, so the path is recorded
/// only when the key is missing and the file is about to be loaded.
/// </summary>
[HarmonyPatch(typeof(AudioManager), nameof(AudioManager.FindOrLoadAudioClipExternal))]
public static class AudioManagerFindOrLoadAudioClipExternalPatch
{
    /// <summary>Records <paramref name="path"/> in <see cref="AudioClipPaths"/> when its audioLib key is not loaded yet. Runs the original always.</summary>
    [HarmonyPrefix]
    // ReSharper disable once InconsistentNaming
    public static void Prefix(AudioManager __instance, string path)
    {
        if (string.IsNullOrEmpty(path)) return;
        if (__instance.audioLib.ContainsKey(AudioClipPaths.KeyOf(path))) return;
        AudioClipPaths.Record(path);
    }
}

/// <summary>
/// AudioManager._Play (private; AudioManager.Play forwards to it): registers each scheduled effect sound (hit sounds, PlaySound
/// events, hold sounds without an end time) as an effect voice of the offline mixer and maps the returned AudioSource to it.
/// Active while capturing (RenderManager.IsCapturingActive) with RenderAudio on. The original always runs: it creates the
/// AudioSource the game keeps using (its PlayScheduled call is blocked during rendering by another patch), and the game sets
/// time/pitch/SetScheduledEndTime on it afterwards, which the <see cref="EffectSource"/> patches forward to the mapped state.
/// The game volume is passed through; the start pitch is 1 because _Play sets pitch = 1 before PlayScheduled.
/// </summary>
[HarmonyPatch(typeof(AudioManager), "_Play")]
public static class AudioManagerPlayPatch
{
    /// <summary>Opens the clip's source so its first chunk starts loading. Returns true (the original runs).</summary>
    [HarmonyPrefix]
    public static bool Prefix(string snd, double time, AudioMixerGroup group, float volume, int priority)
    {
        if (RenderManager.IsCapturingActive && RenderManager.Instance.Configuration.AudioConfig.RenderAudio)
        {
            // Cache the clip on the main thread
            RenderManager.Instance.AudioMixer?.CacheClip(snd);
        }
        return true; // Let the original method execute to prevent NullReferenceException
    }

    /// <summary>
    /// Registers the sound at <paramref name="time"/> (absolute DSP time, converted to render time) as a non-looping effect voice,
    /// maps <paramref name="__result"/> to it and queues the source's game object for deactivation at the end of the frame.
    /// </summary>
    [HarmonyPostfix]
    // ReSharper disable once InconsistentNaming
    public static void Postfix(AudioSource __result, string snd, double time, AudioMixerGroup group, float volume, int priority)
    {
        if (RenderManager.IsCapturingActive && RenderManager.Instance.Configuration.AudioConfig.RenderAudio && __result != null)
        {
            // Convert absolute DSP time to relative time in seconds from render start
            double relativeStartTime = time - RenderManager.Instance.dspTimeBase;

            // Register event to the offline mixer (default pitch = 1.0f) and map it to the AudioSource
            var mixer = RenderManager.Instance.AudioMixer;
            if (mixer == null) return;
            mixer.RegisterSoundEvent(__result, snd, relativeStartTime, -1.0, volume, 1.0f, RenderManager.Instance.AudioTime);
            EffectSource.DeactivateAtFrameEnd(__result);
        }
    }
}

/// <summary>
/// scrConductor.PlayWithEndTime: registers a looping effect voice until the end time. The AudioSource it creates with
/// AudioManager.MakeSource is mapped to that voice (<see cref="AudioManagerMakeSourcePatch"/>).
/// Active while capturing (RenderManager.IsCapturingActive) with RenderAudio on; the original always runs. The game calls it for
/// hold sounds with an end time above 0 (scrConductor hold sound scheduling); it sets loop = true, pitch = 1, PlayScheduled(time) and
/// SetScheduledEndTime(endTime) on the new source. pitch and SetScheduledEndTime reach the mapped state through the
/// <see cref="EffectSource"/> patches; PlayScheduled is blocked during rendering by another patch.
/// </summary>
[HarmonyPatch(typeof(scrConductor), "PlayWithEndTime")]
public static class PlayWithEndTimePatch
{
    /// <summary>State registered by the running PlayWithEndTime call, until its MakeSource returns. Main thread only.</summary>
    internal static SourceState? PendingState;

    /// <summary>Clears <see cref="PendingState"/> when PlayWithEndTime returns or throws, so it cannot map a later MakeSource call.</summary>
    [HarmonyFinalizer]
    public static void Finalizer() => PendingState = null;

    /// <summary>
    /// Opens the clip's source and registers a looping voice from <paramref name="time"/> to <paramref name="endTime"/>
    /// (absolute DSP times, converted to render time); the state waits in <see cref="PendingState"/>. Returns true (the original runs).
    /// </summary>
    [HarmonyPrefix]
    public static bool Prefix(string snd, double time, double endTime, float volume, int priority)
    {
        if (RenderManager.IsCapturingActive && RenderManager.Instance.Configuration.AudioConfig.RenderAudio)
        {
            var mixer = RenderManager.Instance.AudioMixer;
            if (mixer != null)
            {
                // Cache the clip on the main thread
                mixer.CacheClip(snd);

                // Convert absolute DSP times to relative times in seconds from render start
                double relativeStartTime = time - RenderManager.Instance.dspTimeBase;
                double relativeEndTime = endTime - RenderManager.Instance.dspTimeBase;

                // Register looping sound event to the offline mixer (default pitch = 1.0f)
                PendingState = mixer.RegisterSoundEvent(null, snd, relativeStartTime, relativeEndTime, volume, 1.0f, RenderManager.Instance.AudioTime);
            }
        }
        return true; // Let the original method execute
    }
}

/// <summary>
/// Maps the AudioSource created inside scrConductor.PlayWithEndTime to its state (<see cref="PlayWithEndTimePatch.PendingState"/>).
/// Active only while a PlayWithEndTime call registered a state (capturing with RenderAudio on); every other MakeSource call
/// (including the one inside AudioManager._Play) is left unchanged.
/// </summary>
[HarmonyPatch(typeof(AudioManager), nameof(AudioManager.MakeSource))]
public static class AudioManagerMakeSourcePatch
{
    /// <summary>
    /// Takes the pending state, maps <paramref name="__result"/> to it and queues the source's game object for deactivation at
    /// the end of the frame.
    /// </summary>
    [HarmonyPostfix]
    // ReSharper disable once InconsistentNaming
    public static void Postfix(AudioSource __result)
    {
        var state = PlayWithEndTimePatch.PendingState;
        if (state == null || !__result) return;
        PlayWithEndTimePatch.PendingState = null;
        var mixer = RenderManager.Instance.AudioMixer;
        if (mixer == null) return;
        mixer.MapSource(__result, state);
        EffectSource.DeactivateAtFrameEnd(__result);
    }
}

/// <summary>
/// AudioSource members of an effect source mapped to a <see cref="SourceState"/> during rendering: the patches below skip the
/// Unity implementation and read or change the state instead (isPlaying, time, timeSamples, pitch, SetScheduledEndTime, Stop).
/// The patches apply only while <see cref="TryGet"/> returns true: rendering is capturing (RenderManager.IsCapturingActive,
/// stage Render), the render has an audio mixer (created when the render starts, cleared when it ends), and the source is mapped
/// in that mixer (mappings are created only when RenderAudio is on). Otherwise they run the Unity implementation, so sources
/// without a mapping (the song, menu sounds) and all sources outside rendering behave as in the game.
///
/// The game object of a mapped source is deactivated at the end of the frame it was mapped in: the mixer produces its sound and the
/// state answers every member above, so Unity does not process the source. The game activates it again when AudioManager.MakeSource
/// reuses it. Active AudioSources add main-thread time per frame in proportion to their count, and dense levels keep thousands of
/// scheduled effect sources alive.
/// </summary>
internal static class EffectSource
{
    /// <summary>Sources mapped during the current frame, deactivated by <see cref="DeactivateMappedSources"/>. Main thread only.</summary>
    private static readonly List<AudioSource> PendingDeactivation = new();

    /// <summary>Deactivates the game object of <paramref name="source"/> at the end of the current frame (<see cref="DeactivateMappedSources"/>).</summary>
    public static void DeactivateAtFrameEnd(AudioSource source) => PendingDeactivation.Add(source);

    /// <summary>
    /// Deactivates the game objects of the sources mapped this frame that are still mapped and not destroyed.
    /// Called by RenderManager.OnPostFrame after the audio commands of the frame are committed, which runs only in stage Render with
    /// an audio mixer; sources are added only by the render-time registrations (AudioManager._Play and scrConductor.PlayWithEndTime
    /// patches with RenderAudio on).
    /// </summary>
    public static void DeactivateMappedSources(OfflineAudioMixer mixer)
    {
        foreach (var source in PendingDeactivation)
        {
            if (source && mixer.TryGetSourceState(source, out _)) source.gameObject.SetActive(false);
        }
        PendingDeactivation.Clear();
    }

    /// <summary>
    /// State mapped to <paramref name="source"/> in the mixer of the current render, with the current render time in <paramref name="now"/>.
    /// False outside rendering (stage below Render), without a mixer, or for a source that is not mapped.
    /// </summary>
    public static bool TryGet(AudioSource source, out SourceState state, out double now)
    {
        state = null!;
        now = 0;
        if (!RenderManager.IsCapturingActive) return false;
        var mixer = RenderManager.Instance.AudioMixer;
        if (mixer == null || !mixer.TryGetSourceState(source, out state)) return false;
        now = RenderManager.Instance.AudioTime;
        return true;
    }
}

/// <summary>
/// AudioSource.isPlaying getter (<see cref="EffectSource"/>): true from the scheduling call until Stop(), the scheduled end time or
/// the end of the clip, including before the scheduled start. AudioManager.Update returns a source to its reusable pool once this is false.
/// </summary>
[HarmonyPatch(typeof(AudioSource), "isPlaying", MethodType.Getter)]
public static class AudioSourceIsPlayingPatch
{
    /// <summary>When <see cref="EffectSource.TryGet"/> finds a mapped state, uses it and returns false (Unity is skipped); otherwise returns true.</summary>
    [HarmonyPrefix]
    // ReSharper disable once InconsistentNaming
    public static bool Prefix(AudioSource __instance, ref bool __result)
    {
        if (!EffectSource.TryGet(__instance, out var state, out var now)) return true;
        __result = state.IsPlaying(now);
        return false;
    }
}

/// <summary>AudioSource.time getter (<see cref="EffectSource"/>): clip position in seconds while playing, 0 while not playing.</summary>
[HarmonyPatch(typeof(AudioSource), "time", MethodType.Getter)]
public static class AudioSourceTimeGetterPatch
{
    /// <summary>When <see cref="EffectSource.TryGet"/> finds a mapped state, uses it and returns false (Unity is skipped); otherwise returns true.</summary>
    [HarmonyPrefix]
    // ReSharper disable once InconsistentNaming
    public static bool Prefix(AudioSource __instance, ref float __result)
    {
        if (!EffectSource.TryGet(__instance, out var state, out var now)) return true;
        __result = state.GetTime(now);
        return false;
    }
}

/// <summary>
/// AudioSource.time setter (<see cref="EffectSource"/>): moves the playback position (clip seconds) from the current render time.
/// Set before the scheduled start (ffxPlaySound sets it right after AudioManager.Play), it becomes the start position.
/// </summary>
[HarmonyPatch(typeof(AudioSource), "time", MethodType.Setter)]
public static class AudioSourceTimePatch
{
    /// <summary>When <see cref="EffectSource.TryGet"/> finds a mapped state, uses it and returns false (Unity is skipped); otherwise returns true.</summary>
    [HarmonyPrefix]
    // ReSharper disable once InconsistentNaming
    public static bool Prefix(AudioSource __instance, float value)
    {
        if (!EffectSource.TryGet(__instance, out var state, out var now)) return true;
        state.SetTime(value, now);
        return false;
    }
}

/// <summary>
/// AudioSource.timeSamples getter (<see cref="EffectSource"/>): clip position in samples of the clip while playing; while not playing,
/// the last value set through time or timeSamples (0 after Stop()).
/// </summary>
[HarmonyPatch(typeof(AudioSource), "timeSamples", MethodType.Getter)]
public static class AudioSourceTimeSamplesGetterPatch
{
    /// <summary>When <see cref="EffectSource.TryGet"/> finds a mapped state, uses it and returns false (Unity is skipped); otherwise returns true.</summary>
    [HarmonyPrefix]
    // ReSharper disable once InconsistentNaming
    public static bool Prefix(AudioSource __instance, ref int __result)
    {
        if (!EffectSource.TryGet(__instance, out var state, out var now)) return true;
        __result = state.GetTimeSamples(now);
        return false;
    }
}

/// <summary>AudioSource.timeSamples setter (<see cref="EffectSource"/>): moves the playback position (samples of the clip).</summary>
[HarmonyPatch(typeof(AudioSource), "timeSamples", MethodType.Setter)]
public static class AudioSourceTimeSamplesPatch
{
    /// <summary>When <see cref="EffectSource.TryGet"/> finds a mapped state, uses it and returns false (Unity is skipped); otherwise returns true.</summary>
    [HarmonyPrefix]
    // ReSharper disable once InconsistentNaming
    public static bool Prefix(AudioSource __instance, int value)
    {
        if (!EffectSource.TryGet(__instance, out var state, out var now)) return true;
        state.SetTimeSamples(value, now);
        return false;
    }
}

/// <summary>AudioSource.pitch getter (<see cref="EffectSource"/>): the last pitch set.</summary>
[HarmonyPatch(typeof(AudioSource), "pitch", MethodType.Getter)]
public static class AudioSourcePitchGetterPatch
{
    /// <summary>When <see cref="EffectSource.TryGet"/> finds a mapped state, uses it and returns false (Unity is skipped); otherwise returns true.</summary>
    [HarmonyPrefix]
    // ReSharper disable once InconsistentNaming
    public static bool Prefix(AudioSource __instance, ref float __result)
    {
        if (!EffectSource.TryGet(__instance, out var state, out _)) return true;
        __result = state.GetPitch();
        return false;
    }
}

/// <summary>AudioSource.pitch setter (<see cref="EffectSource"/>): changes the playback rate from the current render time.</summary>
[HarmonyPatch(typeof(AudioSource), "pitch", MethodType.Setter)]
public static class AudioSourcePitchPatch
{
    /// <summary>When <see cref="EffectSource.TryGet"/> finds a mapped state, uses it and returns false (Unity is skipped); otherwise returns true.</summary>
    [HarmonyPrefix]
    // ReSharper disable once InconsistentNaming
    public static bool Prefix(AudioSource __instance, float value)
    {
        if (!EffectSource.TryGet(__instance, out var state, out var now)) return true;
        state.SetPitch(value, now);
        return false;
    }
}

/// <summary>AudioSource.SetScheduledEndTime (<see cref="EffectSource"/>): DSP time (absolute) at which playback stops.</summary>
[HarmonyPatch(typeof(AudioSource), "SetScheduledEndTime", typeof(double))]
public static class AudioSourceSetScheduledEndTimePatch
{
    /// <summary>When <see cref="EffectSource.TryGet"/> finds a mapped state, uses it and returns false (Unity is skipped); otherwise returns true.</summary>
    [HarmonyPrefix]
    // ReSharper disable once InconsistentNaming
    public static bool Prefix(AudioSource __instance, double time)
    {
        if (!EffectSource.TryGet(__instance, out var state, out var now)) return true;
        state.SetEndTime(time - RenderManager.Instance.dspTimeBase, now);
        return false;
    }
}

/// <summary>
/// AudioSource.Stop() (<see cref="EffectSource"/>): stops playback at the current render time. The mapping stays, so the source
/// keeps reporting the stopped state. AudioManager.Update calls Stop() on sources it returns to the pool, which are no longer
/// playing, so their voices are left unchanged.
/// </summary>
[HarmonyPatch(typeof(AudioSource), "Stop", new Type[0])]
public static class AudioSourceStopPatch
{
    /// <summary>When <see cref="EffectSource.TryGet"/> finds a mapped state, uses it and returns false (Unity is skipped); otherwise returns true.</summary>
    [HarmonyPrefix]
    // ReSharper disable once InconsistentNaming
    public static bool Prefix(AudioSource __instance)
    {
        if (!EffectSource.TryGet(__instance, out var state, out var now)) return true;
        state.Stop(now);
        return false;
    }
}

/// <summary>
/// AudioManager.StopAllSounds destroys every source in liveSources (all AudioManager._Play and scrConductor.PlayWithEndTime sources),
/// so every effect voice stops at the current render time, including ones scheduled to start later.
/// Callers include scrConductor.PlayHitTimes (from its second call), ScrubMusicToTile/Time, KillAllSoundsCoroutine,
/// scrController.FailAction, scrController.DebugUpdate, scnGame.Play and PauseMenu.Choose.
/// Active while capturing (RenderManager.IsCapturingActive) with RenderAudio on; the original always runs (it destroys the sources).
/// </summary>
[HarmonyPatch(typeof(AudioManager), nameof(AudioManager.StopAllSounds))]
public static class AudioManagerStopAllSoundsPatch
{
    /// <summary>Stops every effect voice while capturing with RenderAudio on. The original always runs (no return value).</summary>
    [HarmonyPrefix]
    public static void Prefix()
    {
        if (RenderManager.IsCapturingActive && RenderManager.Instance.Configuration.AudioConfig.RenderAudio)
        {
            RenderManager.Instance.AudioMixer?.StopAllEffects(RenderManager.Instance.AudioTime);
        }
    }
}