403 lines
14 KiB
C#
403 lines
14 KiB
C#
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!");
|
|
}
|
|
}
|