HauntedBloodlines/Assets/Scripts/Menu/SettingsMenu.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Audio;
using UnityEngine.UI;
using TMPro;
using UnityEngine.Rendering.HighDefinition;
using UnityEngine.Rendering;
using System.IO;

public class SettingsMenu : MonoBehaviour
{
    public AudioMixer gameAudioMixer;

    private Resolution[] resolutions;

    public TMP_Dropdown resolutionDropdown;
    public TMP_Dropdown graphicsDropdown;
    public TMP_Dropdown antiAliasingDropdown;
    public TMP_Dropdown volumetricFogFropdown;
    public Toggle fullScreenToggle;

    public Slider masterVolumeSlider;
    public Slider musicVolumeSlider;
    public Slider sfxVolumeSlider;
    public Slider menuVolumeSlider;

    public Slider mouseCameraSensitivitySlider;
    public Slider controllerCameraSensitivitySlider;
    public Toggle controllerRumbleToggle;

    public HDAdditionalCameraData hdCameraData;
    public Volume[] volumes;
    // Store the original value of fog.quality
    public List<float> fogBudget;
    public List<float> fogResolutionDepthRatio;

    public SettingsData settingsData;
    public string settingsPath;

    private bool ValuesInitialised;

    private void Awake()
    {
        settingsPath = Application.persistentDataPath + "/settings.json";
    }

    private void Start()
    {
        hdCameraData = GameObject.FindWithTag("MainCamera").GetComponent<HDAdditionalCameraData>();
        volumes = FindObjectsOfType<Volume>();
        foreach (var volume in volumes)
        {
            if (volume.profile.TryGet(out Fog fog))
            {
                fogBudget.Add(fog.volumetricFogBudget);
                fogResolutionDepthRatio.Add(fog.resolutionDepthRatio);

            }
        }
        //settingsPath = Application.persistentDataPath + "/settings.json";

        resolutions = Screen.resolutions;
        resolutionDropdown.ClearOptions();

        List<string> options = new List<string>();

        int currentResolutionIndex = 0;
        for (int i = 0; i < resolutions.Length; i++)
        {
            string option = resolutions[i].width + "x" + resolutions[i].height + " " + resolutions[i].refreshRate + "Hz";
            options.Add(option);

            if (resolutions[i].width == Screen.currentResolution.width &&
                resolutions[i].height == Screen.currentResolution.height)
            {
                currentResolutionIndex = i;
            }
        }

        resolutionDropdown.AddOptions(options);
        resolutionDropdown.value = currentResolutionIndex;
        resolutionDropdown.RefreshShownValue();

        LoadSettings();
    }

    public void SetResolution(int resolutionIndex)
    {
        if (ValuesInitialised)
        {
            Resolution resolution = resolutions[resolutionIndex];
            Screen.SetResolution(resolution.width, resolution.height, Screen.fullScreen);

            settingsData.resolutionIndex = resolutionIndex;
            SaveSettings();
        }
    }

    public void SetVolumetricFog(int volumetricFogResIndex)
    {   
        // Store the current value of the Volumetric Fog Budget
        //float originalFogBudget = 0f; // Assuming you store it here

        // Iterate through each Volume and check if it contains Volumetric Fog
        foreach (var volume in volumes)
        {
            if (volume.profile.TryGet(out Fog fog))
            {    
                // Store the original value of fog.quality
                //float fogBudget = fog.volumetricFogBudget;
                //float forResolutionDepthRatio = fog.resolutionDepthRatio;

                // You can store these Volumetric Fog components in a list or dictionary for later use
                // For simplicity, let's just adjust the quality directly here
                if (volumetricFogResIndex == 0)
                {
                    fog.quality.value = 2;

                    foreach (var _fogBudget in fogBudget)
                    {
                        fog.volumetricFogBudget = _fogBudget;
                        //StartCoroutine(LerpFogBudget(fog, _fogBudget));
                    }
                    foreach (var _fogResolutionDepthRatio in fogResolutionDepthRatio)
                    {                     
                        fog.resolutionDepthRatio = _fogResolutionDepthRatio;
                    }
                    //fog.volumetricFogBudget = fogBudget;
                    //fog.resolutionDepthRatio = forResolutionDepthRatio;
   
                }
                else if(volumetricFogResIndex == 1) 
                {
                    fog.quality.value = 0;
                }
                else if(volumetricFogResIndex == 2) 
                {
                    fog.quality.value = 1;
                }

                // Restore the original value of the Volumetric Fog Budget
                // Assuming you stored the original value earlier
                
                // Adjust other volumetric fog settings based on your needs
            }
        }
        settingsData.volumetricFogResIndex = volumetricFogResIndex;
        SaveSettings();
    }

    IEnumerator LerpFogBudget(Fog fog, float target)
    {
        float elapsedTime = 0f;
        float lerpDuration = 1f; // Duration of the lerp in seconds
        float startFogBudget = fog.volumetricFogBudget;

        while (elapsedTime < lerpDuration)
        {
            // Calculate lerp value
            float t = elapsedTime / lerpDuration;
            // Lerp the fog budget value
            fog.volumetricFogBudget = Mathf.Lerp(startFogBudget, target, t);
            // Increment time
            elapsedTime += Time.deltaTime;
            // Wait for the next frame
            yield return null;
        }

        // Ensure we set the target value exactly at the end of the lerp
        fog.volumetricFogBudget = target;
    }

    public void SetMasterVolume(float volume)
    {
        gameAudioMixer.SetFloat("masterVolume", volume);
        Debug.Log("the volume is" + volume);
        settingsData.masterVolume = volume;
        SaveSettings();
    }

    public void SetMusicVolume(float volume)
    {
        gameAudioMixer.SetFloat("musicVolume", volume);
        Debug.Log("the volume is" + volume);
        settingsData.musicVolume = volume;
        SaveSettings();
    }

    public void SetSfxVolume(float volume)
    {
        gameAudioMixer.SetFloat("sfxVolume", volume);
        Debug.Log("the volume is" + volume);
        settingsData.sfxVolume = volume;
        SaveSettings();
    }

    public void SetMenuVolume(float volume)
    {
        gameAudioMixer.SetFloat("menuVolume", volume);
        Debug.Log("the volume is" + volume);
        settingsData.menuVolume = volume;
        SaveSettings();
    }

    public void SetQuality(int qualityIndex)
    {
        QualitySettings.SetQualityLevel(qualityIndex);

        settingsData.qualityIndex = qualityIndex;
        SaveSettings();
    }

    public void SetFullscreen(bool isFullscreen)
    {
        Screen.fullScreen = isFullscreen;

        settingsData.fullscreen = isFullscreen;
        SaveSettings();
    }

    public void SetControllerRumble(bool shouldRumble) 
    {
        settingsData.shouldRumble = shouldRumble;
        if (RumbleManager.GetInstance() != null)
        {
            RumbleManager.GetInstance().shouldRumble = settingsData.shouldRumble;
        }
        SaveSettings();
    }

    public void SetAntiAliasing(int aliasingIndex)
    {
        if (aliasingIndex == 0)
        {
            hdCameraData.antialiasing = HDAdditionalCameraData.AntialiasingMode.None;
            hdCameraData.allowDynamicResolution = true;
            hdCameraData.allowDeepLearningSuperSampling = true;
            hdCameraData.allowFidelityFX2SuperResolution = false;

        }
        else if (aliasingIndex == 1)
        {
            hdCameraData.antialiasing = HDAdditionalCameraData.AntialiasingMode.None;
            hdCameraData.allowDynamicResolution = true;
            hdCameraData.allowFidelityFX2SuperResolution = true;
            hdCameraData.allowDeepLearningSuperSampling = false;
        }
        settingsData.antiAliasingIndex = aliasingIndex;
        SaveSettings();
    }

    public void SetMouseCameraSensitivity(float sensitivity)
    {
        mouseCameraSensitivitySlider.value = sensitivity;
        settingsData.mouseCameraSensitivity = sensitivity;
        if (PlayerManager.GetInstance() != null)
        {
            PlayerManager.GetInstance()._cameraMovement._mouseSensitivity = settingsData.mouseCameraSensitivity;
        }
        SaveSettings();
    }

    public void SetControllerCameraSensitivity(float sensitivity)
    {
        controllerCameraSensitivitySlider.value = sensitivity;
        settingsData.controllerCameraSensitivity = sensitivity;
        if (PlayerManager.GetInstance() != null)
        {
            PlayerManager.GetInstance()._cameraMovement.controllerSensitivity = settingsData.controllerCameraSensitivity;
        }
        SaveSettings();
    }

    private void LoadSettings()
    {
        SettingsData existingData = SaveSlotManager.LoadSettingsData(settingsPath);

        if (File.Exists(settingsPath))
        {
            string json = File.ReadAllText(settingsPath);
            //settingsData = JsonUtility.FromJson<SettingsData>(json);

            settingsData.resolutionIndex = existingData.resolutionIndex;
            settingsData.volume = existingData.volume;
            settingsData.qualityIndex = existingData.qualityIndex;
            settingsData.fullscreen = existingData.fullscreen;
            settingsData.antiAliasingIndex = existingData.antiAliasingIndex;
            settingsData.volumetricFogResIndex = existingData.volumetricFogResIndex;

            settingsData.masterVolume = existingData.masterVolume;
            settingsData.musicVolume = existingData.musicVolume;
            settingsData.sfxVolume = existingData.sfxVolume;
            settingsData.menuVolume = existingData.menuVolume;

            settingsData.mouseCameraSensitivity = existingData.mouseCameraSensitivity;
            settingsData.controllerCameraSensitivity = existingData.controllerCameraSensitivity;
            settingsData.shouldRumble = existingData.shouldRumble;

            Debug.Log("Settings file exists");
            ApplySettings();
            ValuesInitialised = true;
        }
        else
        {
            settingsData = new SettingsData();

            settingsData.qualityIndex = 2;
            settingsData.antiAliasingIndex = 0;
            settingsData.fullscreen = true;
            settingsData.volumetricFogResIndex = 0;

            settingsData.mouseCameraSensitivity = 3.5f;
            settingsData.controllerCameraSensitivity = 5.5f;
            settingsData.shouldRumble = true;

            List<string> options = new List<string>();


            int currentResolutionIndex = 0;
            for (int i = 0; i < resolutions.Length; i++)
            {
                string option = resolutions[i].width + "x" + resolutions[i].height;
                options.Add(option);

                if (resolutions[i].width == Screen.currentResolution.width &&
                    resolutions[i].height == Screen.currentResolution.height)
                {
                    currentResolutionIndex = i;
                }
            }

            settingsData.resolutionIndex = currentResolutionIndex;
            print("Resolution Index = " + currentResolutionIndex + "Width: " + Screen.currentResolution.width + "Height: " + Screen.currentResolution.height);

            Debug.Log("Settings file DOES NOT exist");
            ApplySettings(); // Apply default settings
            SaveSettings();  // Save default settings
            ValuesInitialised = true;
        }
    }

    private void ApplySettings()
    {
        Screen.SetResolution(resolutions[settingsData.resolutionIndex].width,
                             resolutions[settingsData.resolutionIndex].height,
                             settingsData.fullscreen);

        //audioMixer.SetFloat("volume", settingsData.volume);
        QualitySettings.SetQualityLevel(settingsData.qualityIndex);
        Screen.fullScreen = settingsData.fullscreen;

        #region Dropdowns
        graphicsDropdown.SetValueWithoutNotify(settingsData.qualityIndex);
        antiAliasingDropdown.SetValueWithoutNotify(settingsData.antiAliasingIndex);
        fullScreenToggle.SetIsOnWithoutNotify(settingsData.fullscreen);
        volumetricFogFropdown.SetValueWithoutNotify(settingsData.volumetricFogResIndex);
        controllerRumbleToggle.SetIsOnWithoutNotify(settingsData.shouldRumble);
        resolutionDropdown.SetValueWithoutNotify(settingsData.resolutionIndex);
        #endregion

        SetAntiAliasing(settingsData.antiAliasingIndex);
        SetFullscreen(settingsData.fullscreen);
        SetVolumetricFog(settingsData.volumetricFogResIndex);
        #region Volume related
        SetMasterVolume(settingsData.masterVolume);
        SetMenuVolume(settingsData.menuVolume);
        SetMusicVolume(settingsData.musicVolume);
        SetSfxVolume(settingsData.sfxVolume);

        masterVolumeSlider.SetValueWithoutNotify(settingsData.masterVolume);
        menuVolumeSlider.SetValueWithoutNotify(settingsData.menuVolume);
        musicVolumeSlider.SetValueWithoutNotify(settingsData.musicVolume);
        sfxVolumeSlider.SetValueWithoutNotify(settingsData.sfxVolume);

        mouseCameraSensitivitySlider.SetValueWithoutNotify(settingsData.mouseCameraSensitivity);
        controllerCameraSensitivitySlider.SetValueWithoutNotify(settingsData.controllerCameraSensitivity);
        SetControllerRumble(settingsData.shouldRumble);

        if(PlayerManager.GetInstance()!= null) 
        {
            PlayerManager.GetInstance()._cameraMovement._mouseSensitivity = settingsData.mouseCameraSensitivity;
            PlayerManager.GetInstance()._cameraMovement.controllerSensitivity = settingsData.controllerCameraSensitivity;
        }

        if(RumbleManager.GetInstance()!= null) 
        {
            RumbleManager.GetInstance().shouldRumble = settingsData.shouldRumble;
        }

        #endregion

        // Implement loading of other settings...
    }

    public void SaveSettings()
    {
        string json = JsonUtility.ToJson(settingsData);
        File.WriteAllText(settingsPath, json);
        print("Settings are saved!");
    }
}