2294 lines
66 KiB
C#
2294 lines
66 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using DarkTonic.MasterAudio;
|
|
using Rewired;
|
|
using UnityEngine;
|
|
using UnityEngine.Audio;
|
|
using UnityEngine.InputSystem;
|
|
using UnityEngine.UI;
|
|
|
|
public class SettingsManager : MonoBehaviour
|
|
{
|
|
private enum DisplayMode
|
|
{
|
|
Fullscreen = 0,
|
|
Windowed = 1
|
|
}
|
|
|
|
private enum QualityMode
|
|
{
|
|
Low = 0,
|
|
Medium = 1,
|
|
High = 2,
|
|
VeryHigh = 3,
|
|
Ultra = 4
|
|
}
|
|
|
|
private enum TextureQualityMode
|
|
{
|
|
Ultra = 0,
|
|
High = 1,
|
|
Medium = 2,
|
|
Low = 3
|
|
}
|
|
|
|
private enum WaterQualityMode
|
|
{
|
|
Low = 0,
|
|
Medium = 1,
|
|
High = 2,
|
|
Ultra = 3
|
|
}
|
|
|
|
private enum VsyncMode
|
|
{
|
|
Off = 0,
|
|
On = 1
|
|
}
|
|
|
|
private enum BlurMode
|
|
{
|
|
Off = 0,
|
|
On = 1
|
|
}
|
|
|
|
private enum BloomMode
|
|
{
|
|
Off = 0,
|
|
On = 1
|
|
}
|
|
|
|
private enum ChromaticMode
|
|
{
|
|
Off = 0,
|
|
On = 1
|
|
}
|
|
|
|
private enum AAMode
|
|
{
|
|
Off = 0,
|
|
FXAA = 1,
|
|
SMAA = 2,
|
|
TXAA = 3
|
|
}
|
|
|
|
private enum AOMode
|
|
{
|
|
Off = 0,
|
|
On = 1
|
|
}
|
|
|
|
private enum ResidenceMusic
|
|
{
|
|
Off = 0,
|
|
On = 1
|
|
}
|
|
|
|
private enum FishCursorMode
|
|
{
|
|
Off = 0,
|
|
On = 1
|
|
}
|
|
|
|
private enum InvertMouse
|
|
{
|
|
Off = 0,
|
|
On = 1
|
|
}
|
|
|
|
private enum SmoothCamera
|
|
{
|
|
Off = 0,
|
|
On = 1
|
|
}
|
|
|
|
private enum UnitWeight
|
|
{
|
|
Kg = 0,
|
|
Lb = 1
|
|
}
|
|
|
|
private enum UnitLength
|
|
{
|
|
cm = 0,
|
|
cals = 1,
|
|
foots = 2
|
|
}
|
|
|
|
private enum TimeZone
|
|
{
|
|
_24 = 0,
|
|
_12 = 1
|
|
}
|
|
|
|
private enum LightShafts
|
|
{
|
|
Off = 0,
|
|
On = 1
|
|
}
|
|
|
|
private enum TemperatureUnit
|
|
{
|
|
C = 0,
|
|
F = 1,
|
|
K = 2
|
|
}
|
|
|
|
private enum ControllerSetup
|
|
{
|
|
LeftHand = 0,
|
|
RightHand = 1
|
|
}
|
|
|
|
private enum ControllerVibration
|
|
{
|
|
Off = 0,
|
|
On = 1
|
|
}
|
|
|
|
private enum ShadowOnWater
|
|
{
|
|
Off = 0,
|
|
On = 1
|
|
}
|
|
|
|
private enum RealisticLineIndicator
|
|
{
|
|
Off = 0,
|
|
On = 1
|
|
}
|
|
|
|
private enum HideChat
|
|
{
|
|
Off = 0,
|
|
On = 1
|
|
}
|
|
|
|
public Camera mCamera;
|
|
|
|
public PlayerHeader playerHeader;
|
|
|
|
public Image mainContentMaskImage;
|
|
|
|
public GameObject ApplyButton;
|
|
|
|
public Transform[] SettingsContents;
|
|
|
|
public Text[] controlsLabelText;
|
|
|
|
private bool isLanguageChanged;
|
|
|
|
private int currentLanguageIndex;
|
|
|
|
public Text displayLanguageText;
|
|
|
|
public Text fovText;
|
|
|
|
private float currentFov = 42f;
|
|
|
|
public Slider fovSlider;
|
|
|
|
private bool isDisplayChanged;
|
|
|
|
private bool isGraphicsChanged;
|
|
|
|
private bool isGraphicsPostprocessingChanged;
|
|
|
|
private Resolution[] resolutions;
|
|
|
|
public Text resolutionText;
|
|
|
|
private int currentSetsresolution;
|
|
|
|
private DisplayMode displayMod;
|
|
|
|
public Text displayModeText;
|
|
|
|
private int currentDisplayMode;
|
|
|
|
private QualityMode qualityMode = QualityMode.High;
|
|
|
|
public Text displayQualityText;
|
|
|
|
private int currentQualityMode;
|
|
|
|
private TextureQualityMode textureQualityMode;
|
|
|
|
public Text displayTextureQualityText;
|
|
|
|
private int currentTextureQualityMode = 3;
|
|
|
|
private WaterQualityMode waterPlanarMode = WaterQualityMode.Medium;
|
|
|
|
public Text waterPlanarText;
|
|
|
|
private int currentWaterPlanarMode;
|
|
|
|
private WaterQualityMode waterSSRMode = WaterQualityMode.Medium;
|
|
|
|
public Text waterSSRText;
|
|
|
|
private int currentWaterSSRMode;
|
|
|
|
private VsyncMode vsyncMode = VsyncMode.On;
|
|
|
|
public Text displayVsyncText;
|
|
|
|
private int currentVsyncMode;
|
|
|
|
private BlurMode blurMode = BlurMode.On;
|
|
|
|
public Text displayBlurText;
|
|
|
|
private int currentBlurMode;
|
|
|
|
public Text blurUnderwaterText;
|
|
|
|
public Slider blurUnderwaterSlider;
|
|
|
|
private float currentBlurUnderwater;
|
|
|
|
private BloomMode bloomMode = BloomMode.On;
|
|
|
|
public Text displayBloomText;
|
|
|
|
private int currentBloomMode;
|
|
|
|
private ChromaticMode chromaticMode = ChromaticMode.On;
|
|
|
|
public Text displayChromaticText;
|
|
|
|
private int currentChromaticMode;
|
|
|
|
private AAMode aaMode = AAMode.SMAA;
|
|
|
|
public Text displayAaText;
|
|
|
|
private int currentAaMode;
|
|
|
|
private AOMode aoMode = AOMode.On;
|
|
|
|
public Text displayAoText;
|
|
|
|
private int currentAoMode;
|
|
|
|
private ResidenceMusic residenceMusic = ResidenceMusic.On;
|
|
|
|
public Text displayResidenceMusicText;
|
|
|
|
private int currentResidenceMusicMode;
|
|
|
|
private int targetMaxFPS;
|
|
|
|
public Text displayMaxFps;
|
|
|
|
public Button[] MaxFpsButtons;
|
|
|
|
public Image MaxFpsButtonImage;
|
|
|
|
private int currentMaxFPSIndex;
|
|
|
|
public Text volumeText;
|
|
|
|
private float currentSoundsVolume = 1f;
|
|
|
|
public Slider soundVolume;
|
|
|
|
private bool isSoundsChanged;
|
|
|
|
public Text musicVolumeText;
|
|
|
|
private float currentMusicVolume = 1f;
|
|
|
|
public Slider musicVolume;
|
|
|
|
public Text fxVolumeText;
|
|
|
|
private float currentFxSoundsVolume = 1f;
|
|
|
|
public Slider fxVolume;
|
|
|
|
public Text UnderwaterVolumeText;
|
|
|
|
private float currentUnderwaterSoundsVolume = 1f;
|
|
|
|
public Slider UnderwaterVolume;
|
|
|
|
public Text WaterVolumeText;
|
|
|
|
private float currentWaterSoundsVolume = 1f;
|
|
|
|
public Slider WaterVolume;
|
|
|
|
public Text UIVolumeText;
|
|
|
|
private float currentUISoundsVolume = 0.5f;
|
|
|
|
public Slider UIVolume;
|
|
|
|
public Text EnviroVolumeText;
|
|
|
|
private float currentEnviroSoundsVolume = 0.5f;
|
|
|
|
public Slider EnviroVolume;
|
|
|
|
public Text WeatherVolumeText;
|
|
|
|
private float currentWeatherSoundsVolume = 0.5f;
|
|
|
|
public Slider WeatherVolume;
|
|
|
|
public Text VehicleVolumeText;
|
|
|
|
private float currentVehicleSoundsVolume = 0.5f;
|
|
|
|
public Slider VehicleVolume;
|
|
|
|
public Text intesityFogText;
|
|
|
|
private float currentintesityFog = 1f;
|
|
|
|
public Slider intesityFog;
|
|
|
|
private float currentMouseSensitivity = 2f;
|
|
|
|
private float currentCursorSensitivity = 2f;
|
|
|
|
public Slider mouseSensitivity;
|
|
|
|
public Slider cursorSensitivity;
|
|
|
|
private FishCursorMode fishCursorMode = FishCursorMode.On;
|
|
|
|
public Text displayFishCursorText;
|
|
|
|
private int currentFishCursorMode;
|
|
|
|
private InvertMouse invertMouseMode;
|
|
|
|
private int currentInvertMouse;
|
|
|
|
public Text displayInvertMouseText;
|
|
|
|
private InvertMouse invertMouseXMode;
|
|
|
|
private int currentInvertMouseX;
|
|
|
|
public Text displayInvertMouseXText;
|
|
|
|
private bool isControlsChanged;
|
|
|
|
private SmoothCamera smoothcamera = SmoothCamera.On;
|
|
|
|
public Text smoothCameraText;
|
|
|
|
private int currentsmooothcamera;
|
|
|
|
private UnitWeight unitWeight;
|
|
|
|
public Text unitWeightText;
|
|
|
|
private int currentunitWeight;
|
|
|
|
private UnitLength unitLength;
|
|
|
|
public Text unitLengthText;
|
|
|
|
private int currentunitLength;
|
|
|
|
private TimeZone timeZone;
|
|
|
|
public Text timeZoneText;
|
|
|
|
private int currenttimeZone;
|
|
|
|
private LightShafts lightShafts = LightShafts.On;
|
|
|
|
private int currentlightShafts;
|
|
|
|
public Text displayLightShaftsText;
|
|
|
|
private TemperatureUnit temperature;
|
|
|
|
public Text temperatureUnitText;
|
|
|
|
private int currentunitTemperature;
|
|
|
|
private ControllerSetup controllerSetup = ControllerSetup.RightHand;
|
|
|
|
private int currentcontrollerSetup;
|
|
|
|
public Text displayControllerSetupText;
|
|
|
|
private ControllerVibration controllerVibration = ControllerVibration.On;
|
|
|
|
public Text controllerVibrationText;
|
|
|
|
private int currentcontrollerVibration;
|
|
|
|
public Text shadowDistanceText;
|
|
|
|
private float currentShadowDistance = 1f;
|
|
|
|
public Slider shadowDistance;
|
|
|
|
private ShadowOnWater shadowOnWater = ShadowOnWater.On;
|
|
|
|
private int currentShadowOnWater;
|
|
|
|
public Text shadowOnWaterText;
|
|
|
|
public Text floatScaleText;
|
|
|
|
private float currentfloatScale = 1f;
|
|
|
|
public Slider floatScaleSlider;
|
|
|
|
private RealisticLineIndicator realisticLineIndicator;
|
|
|
|
private int currentRealisticLineIndicator;
|
|
|
|
public Text RealisticLineIndicatorText;
|
|
|
|
private HideChat hideChat;
|
|
|
|
private int currentHideChat;
|
|
|
|
public Text hideChatText;
|
|
|
|
public GameObject ControllerSetupGameObject;
|
|
|
|
public GameObject ControllerVibrationGameObject;
|
|
|
|
public GameObject[] HideInNormalMode;
|
|
|
|
public GameObject[] HideInRealisticMode;
|
|
|
|
[SerializeField]
|
|
private AudioMixer enviroMixer;
|
|
|
|
[SerializeField]
|
|
private AudioMixer FXMixer;
|
|
|
|
[SerializeField]
|
|
private AudioMixer musicMixer;
|
|
|
|
[SerializeField]
|
|
private AudioMixer UIMixer;
|
|
|
|
[SerializeField]
|
|
private AudioMixer underwaterMixer;
|
|
|
|
[SerializeField]
|
|
private AudioMixer vehicleMixer;
|
|
|
|
[SerializeField]
|
|
private AudioMixer waterMixer;
|
|
|
|
[SerializeField]
|
|
private AudioMixer weatherMixer;
|
|
|
|
private int currentSettingContent;
|
|
|
|
public const string _WaterSSRModeKey = "Settings_WaterSSRMode";
|
|
|
|
public const string _WaterPlanarModeKey = "Settings_WaterPlanarMode";
|
|
|
|
private int currentMeshDetail;
|
|
|
|
private int currentWaveDetail;
|
|
|
|
private int currentDynamicWavesDetail;
|
|
|
|
private int currentReflectionsLevel;
|
|
|
|
private int currentWaterVolumetricLighting;
|
|
|
|
private int currentCausticLevel;
|
|
|
|
[SerializeField]
|
|
private Text _MeshDetailText;
|
|
|
|
[SerializeField]
|
|
private Text _WaveDetailText;
|
|
|
|
[SerializeField]
|
|
private Text _DynamicWavesDetail;
|
|
|
|
[SerializeField]
|
|
private Text _ReflectionDetailText;
|
|
|
|
[SerializeField]
|
|
private Text _VolumetricLightingText;
|
|
|
|
[SerializeField]
|
|
private Text _CausticLightingText;
|
|
|
|
public static event Action<int> OnSetMeshDetail;
|
|
|
|
public static event Action<int> OnSetWavesDetail;
|
|
|
|
public static event Action<int> OnSetDynamicWaves;
|
|
|
|
public static event Action<int> OnSetReflectionsLevel;
|
|
|
|
public static event Action<int> OnSetVolumetricLighting;
|
|
|
|
public static event Action<int> OnSetCausticLevel;
|
|
|
|
public static event Action<bool> OnSetReflection;
|
|
|
|
public static event Action OnSettingApply;
|
|
|
|
private void Start()
|
|
{
|
|
ReInput.userDataStore.Load();
|
|
ApplyButton.SetActive(value: false);
|
|
if (FScriptsHandler.Instance != null)
|
|
{
|
|
playerHeader.gameObject.SetActive(value: true);
|
|
mainContentMaskImage.enabled = true;
|
|
mCamera.transform.SetPositionAndRotation(FScriptsHandler.Instance.m_PlayerMain.m_Camera.transform.position, FScriptsHandler.Instance.m_PlayerMain.m_Camera.transform.rotation);
|
|
}
|
|
else if ((bool)UnityEngine.Object.FindObjectOfType<Residence>())
|
|
{
|
|
playerHeader.gameObject.SetActive(value: true);
|
|
mainContentMaskImage.enabled = true;
|
|
mCamera.transform.SetPositionAndRotation(Camera.main.transform.position, Camera.main.transform.rotation);
|
|
}
|
|
else
|
|
{
|
|
playerHeader.gameObject.SetActive(value: false);
|
|
mainContentMaskImage.enabled = false;
|
|
}
|
|
if (UnityEngine.Object.FindObjectsOfType<AudioListener>().Length > 1)
|
|
{
|
|
mCamera.GetComponent<AudioListener>().enabled = false;
|
|
}
|
|
if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().GameMode == GameManager.PlayerData.CPlayer.GameMode.Normal)
|
|
{
|
|
for (int i = 0; i < HideInNormalMode.Length; i++)
|
|
{
|
|
HideInNormalMode[i].SetActive(value: false);
|
|
}
|
|
}
|
|
if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().GameMode == GameManager.PlayerData.CPlayer.GameMode.Realistic)
|
|
{
|
|
for (int j = 0; j < HideInRealisticMode.Length; j++)
|
|
{
|
|
HideInRealisticMode[j].SetActive(value: false);
|
|
}
|
|
}
|
|
ShowContent(1);
|
|
}
|
|
|
|
private void FixedUpdate()
|
|
{
|
|
if (Gamepad.current != null)
|
|
{
|
|
ControllerSetupGameObject.SetActive(value: true);
|
|
ControllerVibrationGameObject.SetActive(value: true);
|
|
}
|
|
else
|
|
{
|
|
ControllerSetupGameObject.SetActive(value: false);
|
|
ControllerVibrationGameObject.SetActive(value: false);
|
|
}
|
|
SetupControlsPageByController();
|
|
}
|
|
|
|
private void SetupControlsPageByController()
|
|
{
|
|
if (GameManager.Instance.controllerType == GameManager.ControllerType.KeyboardMouse)
|
|
{
|
|
controlsLabelText[0].text = LanguageManager.Instance.GetText("SETTINGS_MOUSE_SENSITIVE");
|
|
controlsLabelText[1].text = LanguageManager.Instance.GetText("SETTINGS_INVERT_MOUSE_AXIS");
|
|
}
|
|
else
|
|
{
|
|
controlsLabelText[0].text = LanguageManager.Instance.GetText("SETTINGS_GAMEPAD_SENSITIVE");
|
|
controlsLabelText[1].text = LanguageManager.Instance.GetText("SETTINGS_INVERT_GAMEPAD_AXIS");
|
|
}
|
|
}
|
|
|
|
public void ShowContent(int index)
|
|
{
|
|
for (int i = 0; i < SettingsContents.Length; i++)
|
|
{
|
|
SettingsContents[i].gameObject.SetActive(value: false);
|
|
}
|
|
SettingsContents[index].gameObject.SetActive(value: true);
|
|
currentSettingContent = index;
|
|
if (index == 5)
|
|
{
|
|
ApplyButton.SetActive(value: false);
|
|
}
|
|
switch (index)
|
|
{
|
|
case 0:
|
|
GetLanguageStartsSettings();
|
|
break;
|
|
case 1:
|
|
GetGraphicStartsSettings();
|
|
break;
|
|
case 2:
|
|
GetSoundsStartsSettings();
|
|
break;
|
|
case 3:
|
|
GetControlsStartsSettings();
|
|
break;
|
|
case 4:
|
|
GetDisplayStartsSettings();
|
|
break;
|
|
case 6:
|
|
GetGraphicWaterStartsSettings();
|
|
break;
|
|
case 5:
|
|
break;
|
|
}
|
|
}
|
|
|
|
public void DefualtButton()
|
|
{
|
|
GameManager.Instance.CreateMessageBox("SETTINGS_RESET_TO_DEFAULT", GetComponent<Canvas>().transform, 12);
|
|
}
|
|
|
|
public void ResetsSettingsToDefault()
|
|
{
|
|
Singleton<SaveDataManager>.Instance.ResetSettingsData();
|
|
ShowContent(currentSettingContent);
|
|
}
|
|
|
|
private void GetControlsStartsSettings()
|
|
{
|
|
currentMouseSensitivity = Singleton<SaveDataManager>.Instance.SettingsData.MouseSensitivityValue;
|
|
mouseSensitivity.value = currentMouseSensitivity;
|
|
currentCursorSensitivity = Singleton<SaveDataManager>.Instance.SettingsData.GamepadCursorSensitivityValue;
|
|
cursorSensitivity.value = currentCursorSensitivity;
|
|
invertMouseMode = (Singleton<SaveDataManager>.Instance.SettingsData.IsMouseYInverted ? InvertMouse.On : InvertMouse.Off);
|
|
currentInvertMouse = (int)invertMouseMode;
|
|
if (invertMouseMode == InvertMouse.Off)
|
|
{
|
|
displayInvertMouseText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
}
|
|
if (invertMouseMode == InvertMouse.On)
|
|
{
|
|
displayInvertMouseText.text = LanguageManager.Instance.GetText("SETTINGS_ON");
|
|
}
|
|
invertMouseXMode = (Singleton<SaveDataManager>.Instance.SettingsData.IsMouseXInverted ? InvertMouse.On : InvertMouse.Off);
|
|
currentInvertMouseX = (int)invertMouseXMode;
|
|
if (invertMouseXMode == InvertMouse.Off)
|
|
{
|
|
displayInvertMouseXText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
}
|
|
if (invertMouseXMode == InvertMouse.On)
|
|
{
|
|
displayInvertMouseXText.text = LanguageManager.Instance.GetText("SETTINGS_ON");
|
|
}
|
|
smoothcamera = (Singleton<SaveDataManager>.Instance.SettingsData.IsSmoothCameraEnabled ? SmoothCamera.On : SmoothCamera.Off);
|
|
currentsmooothcamera = (int)smoothcamera;
|
|
if (smoothcamera == SmoothCamera.Off)
|
|
{
|
|
smoothCameraText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
}
|
|
if (smoothcamera == SmoothCamera.On)
|
|
{
|
|
smoothCameraText.text = LanguageManager.Instance.GetText("SETTINGS_ON");
|
|
}
|
|
controllerSetup = (ControllerSetup)GameManager.Instance._playerData.Player[GameManager.Instance._playerData.currentPlayerProfileIndex].controllerSetup;
|
|
currentcontrollerSetup = (int)controllerSetup;
|
|
unitWeightText.text = unitWeight.ToString();
|
|
if (controllerSetup == ControllerSetup.LeftHand)
|
|
{
|
|
displayControllerSetupText.text = LanguageManager.Instance.GetText("SETTINGS_CONTROLLER_LEFT_HAND");
|
|
}
|
|
if (controllerSetup == ControllerSetup.RightHand)
|
|
{
|
|
displayControllerSetupText.text = LanguageManager.Instance.GetText("SETTINGS_CONTROLLER_RIGHT_HAND");
|
|
}
|
|
controllerVibration = (Singleton<SaveDataManager>.Instance.SettingsData.IsControllerVibrationEnabled ? ControllerVibration.On : ControllerVibration.Off);
|
|
currentcontrollerVibration = (int)controllerVibration;
|
|
if (controllerVibration == ControllerVibration.Off)
|
|
{
|
|
controllerVibrationText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
}
|
|
if (controllerVibration == ControllerVibration.On)
|
|
{
|
|
controllerVibrationText.text = LanguageManager.Instance.GetText("SETTINGS_ON");
|
|
}
|
|
}
|
|
|
|
private void GetSoundsStartsSettings()
|
|
{
|
|
currentSoundsVolume = Singleton<SaveDataManager>.Instance.SettingsData.MasterVolume;
|
|
SetSliderAndText(soundVolume, volumeText, currentSoundsVolume);
|
|
currentMusicVolume = Singleton<SaveDataManager>.Instance.SettingsData.MusicVolume;
|
|
SetSliderAndText(musicVolume, musicVolumeText, currentMusicVolume);
|
|
currentFxSoundsVolume = Singleton<SaveDataManager>.Instance.SettingsData.FXVolume;
|
|
SetSliderAndText(fxVolume, fxVolumeText, currentFxSoundsVolume);
|
|
currentUnderwaterSoundsVolume = Singleton<SaveDataManager>.Instance.SettingsData.UnderwaterVolume;
|
|
SetSliderAndText(UnderwaterVolume, UnderwaterVolumeText, currentUnderwaterSoundsVolume);
|
|
currentWaterSoundsVolume = Singleton<SaveDataManager>.Instance.SettingsData.WaterVolume;
|
|
SetSliderAndText(WaterVolume, WaterVolumeText, currentWaterSoundsVolume);
|
|
currentUISoundsVolume = Singleton<SaveDataManager>.Instance.SettingsData.UIVolume;
|
|
SetSliderAndText(UIVolume, UIVolumeText, currentUISoundsVolume);
|
|
currentEnviroSoundsVolume = Singleton<SaveDataManager>.Instance.SettingsData.EnviroVolume;
|
|
SetSliderAndText(EnviroVolume, EnviroVolumeText, currentEnviroSoundsVolume);
|
|
currentWeatherSoundsVolume = Singleton<SaveDataManager>.Instance.SettingsData.WeatherVolume;
|
|
SetSliderAndText(WeatherVolume, WeatherVolumeText, currentWeatherSoundsVolume);
|
|
currentVehicleSoundsVolume = Singleton<SaveDataManager>.Instance.SettingsData.VehicleVolume;
|
|
SetSliderAndText(VehicleVolume, VehicleVolumeText, currentVehicleSoundsVolume);
|
|
if ((bool)displayResidenceMusicText)
|
|
{
|
|
residenceMusic = (Singleton<SaveDataManager>.Instance.SettingsData.IsResidenceMusicEnabled ? ResidenceMusic.On : ResidenceMusic.Off);
|
|
displayResidenceMusicText.text = ((residenceMusic == ResidenceMusic.Off) ? LanguageManager.Instance.GetText("SETTINGS_OFF") : LanguageManager.Instance.GetText("SETTINGS_ON"));
|
|
}
|
|
static void SetSliderAndText(Slider slider, Text text, float value)
|
|
{
|
|
if ((bool)slider && (bool)text)
|
|
{
|
|
slider.value = value;
|
|
text.text = (value * 100f).ToString("F0") + "%";
|
|
}
|
|
}
|
|
}
|
|
|
|
private void GetDisplayStartsSettings()
|
|
{
|
|
currentFov = Singleton<SaveDataManager>.Instance.SettingsData.FOVValue;
|
|
fovSlider.value = currentFov;
|
|
fovText.text = currentFov.ToString("F0") + "°";
|
|
fishCursorMode = (Singleton<SaveDataManager>.Instance.SettingsData.IsFishCursorEnabled ? FishCursorMode.On : FishCursorMode.Off);
|
|
currentFishCursorMode = (int)fishCursorMode;
|
|
if (fishCursorMode == FishCursorMode.Off)
|
|
{
|
|
displayFishCursorText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
}
|
|
if (fishCursorMode == FishCursorMode.On)
|
|
{
|
|
displayFishCursorText.text = LanguageManager.Instance.GetText("SETTINGS_ON");
|
|
}
|
|
lightShafts = (Singleton<SaveDataManager>.Instance.SettingsData.IsLightShaftEnabled ? LightShafts.On : LightShafts.Off);
|
|
currentlightShafts = (int)lightShafts;
|
|
if (lightShafts == LightShafts.Off)
|
|
{
|
|
displayLightShaftsText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
}
|
|
if (lightShafts == LightShafts.On)
|
|
{
|
|
displayLightShaftsText.text = LanguageManager.Instance.GetText("SETTINGS_ON");
|
|
}
|
|
unitWeight = (UnitWeight)Singleton<SaveDataManager>.Instance.SettingsData.WeightUnitIndex;
|
|
currentunitWeight = (int)unitWeight;
|
|
unitWeightText.text = unitWeight.ToString();
|
|
if (unitWeight == UnitWeight.Kg)
|
|
{
|
|
unitWeightText.text = LanguageManager.Instance.GetText("SETTINGS_KG");
|
|
}
|
|
if (unitWeight == UnitWeight.Lb)
|
|
{
|
|
unitWeightText.text = LanguageManager.Instance.GetText("SETTINGS_LB");
|
|
}
|
|
unitLength = (UnitLength)Singleton<SaveDataManager>.Instance.SettingsData.LengthUnitIndex;
|
|
currentunitLength = (int)unitLength;
|
|
unitLengthText.text = unitWeight.ToString();
|
|
if (unitLength == UnitLength.cm)
|
|
{
|
|
unitLengthText.text = LanguageManager.Instance.GetText("SETTINGS_CM");
|
|
}
|
|
if (unitLength == UnitLength.cals)
|
|
{
|
|
unitLengthText.text = LanguageManager.Instance.GetText("SETTINGS_INCHES");
|
|
}
|
|
if (unitLength == UnitLength.foots)
|
|
{
|
|
unitLengthText.text = LanguageManager.Instance.GetText("SETTINGS_FOOTS");
|
|
}
|
|
currentintesityFog = Singleton<SaveDataManager>.Instance.SettingsData.FogIntensityValue;
|
|
intesityFog.value = currentintesityFog;
|
|
intesityFogText.text = (currentintesityFog * 100f).ToString("F0") + "%";
|
|
timeZone = (TimeZone)Singleton<SaveDataManager>.Instance.SettingsData.TimeConventionIndex;
|
|
currenttimeZone = (int)timeZone;
|
|
timeZoneText.text = timeZone.ToString();
|
|
if (timeZone == TimeZone._24)
|
|
{
|
|
timeZoneText.text = LanguageManager.Instance.GetText("SETTINGS_24");
|
|
}
|
|
if (timeZone == TimeZone._12)
|
|
{
|
|
timeZoneText.text = LanguageManager.Instance.GetText("SETTINGS_12");
|
|
}
|
|
temperature = (TemperatureUnit)Singleton<SaveDataManager>.Instance.SettingsData.TemperatureUnitIndex;
|
|
currentunitTemperature = (int)temperature;
|
|
temperatureUnitText.text = temperature.ToString();
|
|
if (temperature == TemperatureUnit.C)
|
|
{
|
|
temperatureUnitText.text = "C";
|
|
}
|
|
if (temperature == TemperatureUnit.F)
|
|
{
|
|
temperatureUnitText.text = "F";
|
|
}
|
|
if (temperature == TemperatureUnit.K)
|
|
{
|
|
temperatureUnitText.text = "K";
|
|
}
|
|
currentfloatScale = Singleton<SaveDataManager>.Instance.SettingsData.FloatSizeValue;
|
|
floatScaleSlider.value = currentfloatScale;
|
|
floatScaleText.text = "x" + currentfloatScale.ToString("F0");
|
|
realisticLineIndicator = (Singleton<SaveDataManager>.Instance.SettingsData.IsLineIndicatorEnabledOnRealistic ? RealisticLineIndicator.On : RealisticLineIndicator.Off);
|
|
currentRealisticLineIndicator = (int)realisticLineIndicator;
|
|
if (currentRealisticLineIndicator == 0)
|
|
{
|
|
RealisticLineIndicatorText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
}
|
|
if (currentRealisticLineIndicator == 1)
|
|
{
|
|
RealisticLineIndicatorText.text = LanguageManager.Instance.GetText("SETTINGS_ON");
|
|
}
|
|
hideChat = (Singleton<SaveDataManager>.Instance.SettingsData.IsChatEnabled ? HideChat.On : HideChat.Off);
|
|
currentHideChat = (int)hideChat;
|
|
if (currentHideChat == 0)
|
|
{
|
|
hideChatText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
}
|
|
if (currentHideChat == 1)
|
|
{
|
|
hideChatText.text = LanguageManager.Instance.GetText("SETTINGS_ON");
|
|
}
|
|
}
|
|
|
|
private void GetLanguageStartsSettings()
|
|
{
|
|
displayLanguageText.text = LanguageManager.Instance.currentLanguage;
|
|
currentLanguageIndex = LanguageManager.Instance.languagesList.IndexOf(LanguageManager.Instance.currentLanguage);
|
|
}
|
|
|
|
public void SetFov()
|
|
{
|
|
currentFov = fovSlider.value;
|
|
fovText.text = currentFov.ToString("F0") + "°";
|
|
if (currentFov != Singleton<SaveDataManager>.Instance.SettingsData.FOVValue)
|
|
{
|
|
ApplyButton.SetActive(value: true);
|
|
isDisplayChanged = true;
|
|
}
|
|
}
|
|
|
|
public void SetFishCursorMode(int arrow)
|
|
{
|
|
currentFishCursorMode += arrow;
|
|
if (currentFishCursorMode < 0)
|
|
{
|
|
currentFishCursorMode = 1;
|
|
}
|
|
if (currentFishCursorMode == 2)
|
|
{
|
|
currentFishCursorMode = 0;
|
|
}
|
|
fishCursorMode = (FishCursorMode)currentFishCursorMode;
|
|
if (fishCursorMode == FishCursorMode.Off)
|
|
{
|
|
displayFishCursorText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
}
|
|
if (fishCursorMode == FishCursorMode.On)
|
|
{
|
|
displayFishCursorText.text = LanguageManager.Instance.GetText("SETTINGS_ON");
|
|
}
|
|
ApplyButton.SetActive(value: true);
|
|
isDisplayChanged = true;
|
|
}
|
|
|
|
public void SetLanguage(int arrow)
|
|
{
|
|
currentLanguageIndex += arrow;
|
|
if (currentLanguageIndex < 0)
|
|
{
|
|
currentLanguageIndex = LanguageManager.Instance.languagesList.Count - 1;
|
|
}
|
|
if (currentLanguageIndex == LanguageManager.Instance.languagesList.Count)
|
|
{
|
|
currentLanguageIndex = 0;
|
|
}
|
|
displayLanguageText.text = LanguageManager.Instance.languagesList[currentLanguageIndex];
|
|
ApplyButton.SetActive(value: true);
|
|
isLanguageChanged = true;
|
|
}
|
|
|
|
public void SetCursorSensitivitySlider(float value)
|
|
{
|
|
cursorSensitivity.value += value;
|
|
}
|
|
|
|
public void SetCursorSensitivity()
|
|
{
|
|
currentCursorSensitivity = cursorSensitivity.value;
|
|
ApplyButton.SetActive(value: true);
|
|
isControlsChanged = true;
|
|
}
|
|
|
|
public void SetMouseSensitivitySlider(float value)
|
|
{
|
|
mouseSensitivity.value += value;
|
|
}
|
|
|
|
public void SetMouseSensitivity()
|
|
{
|
|
currentMouseSensitivity = mouseSensitivity.value;
|
|
ApplyButton.SetActive(value: true);
|
|
isControlsChanged = true;
|
|
}
|
|
|
|
public void SetInvertMouseMode(int arrow)
|
|
{
|
|
currentInvertMouse += arrow;
|
|
if (currentInvertMouse < 0)
|
|
{
|
|
currentInvertMouse = 1;
|
|
}
|
|
if (currentInvertMouse == 2)
|
|
{
|
|
currentInvertMouse = 0;
|
|
}
|
|
invertMouseMode = (InvertMouse)currentInvertMouse;
|
|
if (invertMouseMode == InvertMouse.Off)
|
|
{
|
|
displayInvertMouseText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
}
|
|
if (invertMouseMode == InvertMouse.On)
|
|
{
|
|
displayInvertMouseText.text = LanguageManager.Instance.GetText("SETTINGS_ON");
|
|
}
|
|
ApplyButton.SetActive(value: true);
|
|
isControlsChanged = true;
|
|
}
|
|
|
|
public void SetInvertMouseXMode(int arrow)
|
|
{
|
|
currentInvertMouseX += arrow;
|
|
if (currentInvertMouseX < 0)
|
|
{
|
|
currentInvertMouseX = 1;
|
|
}
|
|
if (currentInvertMouseX == 2)
|
|
{
|
|
currentInvertMouseX = 0;
|
|
}
|
|
invertMouseXMode = (InvertMouse)currentInvertMouseX;
|
|
if (invertMouseXMode == InvertMouse.Off)
|
|
{
|
|
displayInvertMouseXText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
}
|
|
if (invertMouseXMode == InvertMouse.On)
|
|
{
|
|
displayInvertMouseXText.text = LanguageManager.Instance.GetText("SETTINGS_ON");
|
|
}
|
|
ApplyButton.SetActive(value: true);
|
|
isControlsChanged = true;
|
|
}
|
|
|
|
public void SetSmoothCamera(int arrow)
|
|
{
|
|
currentsmooothcamera += arrow;
|
|
if (currentsmooothcamera < 0)
|
|
{
|
|
currentsmooothcamera = 1;
|
|
}
|
|
if (currentsmooothcamera == 2)
|
|
{
|
|
currentsmooothcamera = 0;
|
|
}
|
|
smoothcamera = (SmoothCamera)currentsmooothcamera;
|
|
if (smoothcamera == SmoothCamera.Off)
|
|
{
|
|
smoothCameraText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
}
|
|
if (smoothcamera == SmoothCamera.On)
|
|
{
|
|
smoothCameraText.text = LanguageManager.Instance.GetText("SETTINGS_ON");
|
|
}
|
|
ApplyButton.SetActive(value: true);
|
|
isControlsChanged = true;
|
|
}
|
|
|
|
public void SetControllerSetup(int arrow)
|
|
{
|
|
currentcontrollerSetup += arrow;
|
|
if (currentcontrollerSetup < 0)
|
|
{
|
|
currentcontrollerSetup = 1;
|
|
}
|
|
if (currentcontrollerSetup == 2)
|
|
{
|
|
currentcontrollerSetup = 0;
|
|
}
|
|
controllerSetup = (ControllerSetup)currentcontrollerSetup;
|
|
if (controllerSetup == ControllerSetup.LeftHand)
|
|
{
|
|
displayControllerSetupText.text = LanguageManager.Instance.GetText("SETTINGS_CONTROLLER_LEFT_HAND");
|
|
}
|
|
if (controllerSetup == ControllerSetup.RightHand)
|
|
{
|
|
displayControllerSetupText.text = LanguageManager.Instance.GetText("SETTINGS_CONTROLLER_RIGHT_HAND");
|
|
}
|
|
ApplyButton.SetActive(value: true);
|
|
isControlsChanged = true;
|
|
}
|
|
|
|
public void SetControllerVibration(int arrow)
|
|
{
|
|
currentcontrollerVibration += arrow;
|
|
if (currentcontrollerVibration < 0)
|
|
{
|
|
currentcontrollerVibration = 1;
|
|
}
|
|
if (currentcontrollerVibration == 2)
|
|
{
|
|
currentcontrollerVibration = 0;
|
|
}
|
|
controllerVibration = (ControllerVibration)currentcontrollerVibration;
|
|
if (controllerVibration == ControllerVibration.Off)
|
|
{
|
|
controllerVibrationText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
}
|
|
if (controllerVibration == ControllerVibration.On)
|
|
{
|
|
controllerVibrationText.text = LanguageManager.Instance.GetText("SETTINGS_ON");
|
|
}
|
|
ApplyButton.SetActive(value: true);
|
|
isControlsChanged = true;
|
|
}
|
|
|
|
public void SetSoundVolume()
|
|
{
|
|
volumeText.text = (soundVolume.value * 100f).ToString("F0") + "%";
|
|
currentSoundsVolume = soundVolume.value;
|
|
if (currentSoundsVolume != AudioListener.volume)
|
|
{
|
|
AudioListener.volume = currentSoundsVolume;
|
|
isSoundsChanged = true;
|
|
}
|
|
}
|
|
|
|
public void SetUIVolume()
|
|
{
|
|
UIVolumeText.text = (UIVolume.value * 100f).ToString("F0") + "%";
|
|
currentUISoundsVolume = UIVolume.value;
|
|
float uIVolume = Singleton<SaveDataManager>.Instance.SettingsData.UIVolume;
|
|
if (currentUISoundsVolume != uIVolume)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.SettingsData.UIVolume = currentUISoundsVolume;
|
|
isSoundsChanged = true;
|
|
}
|
|
float value = Mathf.Log10(Mathf.Clamp(Singleton<SaveDataManager>.Instance.SettingsData.UIVolume, 0.0001f, 1f)) * 20f;
|
|
UIMixer?.SetFloat("MasterVolume", value);
|
|
FScriptsHandler.Instance?.AffectSoundVolume();
|
|
UnityEngine.Object.FindObjectOfType<Residence>()?.AffectSoundVolume();
|
|
}
|
|
|
|
public void SetUIVolumeSlider(float value)
|
|
{
|
|
UIVolume.value += value;
|
|
}
|
|
|
|
public void SetSoundVolumeSlider(float value)
|
|
{
|
|
soundVolume.value += value;
|
|
}
|
|
|
|
public void SetMusicVolume()
|
|
{
|
|
musicVolumeText.text = (musicVolume.value * 100f).ToString("F0") + "%";
|
|
currentMusicVolume = musicVolume.value;
|
|
float num = Singleton<SaveDataManager>.Instance.SettingsData.MusicVolume;
|
|
if (currentMusicVolume != num)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.SettingsData.MusicVolume = currentMusicVolume;
|
|
isSoundsChanged = true;
|
|
}
|
|
float value = Mathf.Log10(Mathf.Clamp(Singleton<SaveDataManager>.Instance.SettingsData.MusicVolume, 0.0001f, 1f)) * 20f;
|
|
musicMixer?.SetFloat("MasterVolume", value);
|
|
FScriptsHandler.Instance?.AffectSoundVolume();
|
|
UnityEngine.Object.FindObjectOfType<Residence>()?.AffectSoundVolume();
|
|
}
|
|
|
|
public void SetMusicVolumeSlider(float value)
|
|
{
|
|
musicVolume.value += value;
|
|
}
|
|
|
|
public void SetFxVolume()
|
|
{
|
|
fxVolumeText.text = (fxVolume.value * 100f).ToString("F0") + "%";
|
|
currentFxSoundsVolume = fxVolume.value;
|
|
float fXVolume = Singleton<SaveDataManager>.Instance.SettingsData.FXVolume;
|
|
if (currentFxSoundsVolume != fXVolume)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.SettingsData.FXVolume = currentFxSoundsVolume;
|
|
isSoundsChanged = true;
|
|
}
|
|
float value = Mathf.Log10(Mathf.Clamp(Singleton<SaveDataManager>.Instance.SettingsData.FXVolume, 0.0001f, 1f)) * 20f;
|
|
enviroMixer?.SetFloat("MasterVolume", value);
|
|
FXMixer?.SetFloat("MasterVolume", value);
|
|
UIMixer?.SetFloat("MasterVolume", value);
|
|
vehicleMixer?.SetFloat("MasterVolume", value);
|
|
waterMixer?.SetFloat("MasterVolume", value);
|
|
weatherMixer?.SetFloat("MasterVolume", value);
|
|
FScriptsHandler.Instance?.AffectSoundVolume();
|
|
UnityEngine.Object.FindObjectOfType<Residence>()?.AffectSoundVolume();
|
|
}
|
|
|
|
public void SetFxVolumeSlider(float value)
|
|
{
|
|
fxVolume.value += value;
|
|
}
|
|
|
|
public void SetEnviroVolume()
|
|
{
|
|
EnviroVolumeText.text = (EnviroVolume.value * 100f).ToString("F0") + "%";
|
|
currentEnviroSoundsVolume = EnviroVolume.value;
|
|
float enviroVolume = Singleton<SaveDataManager>.Instance.SettingsData.EnviroVolume;
|
|
if (currentEnviroSoundsVolume != enviroVolume)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.SettingsData.EnviroVolume = currentEnviroSoundsVolume;
|
|
isSoundsChanged = true;
|
|
}
|
|
float value = Mathf.Log10(Mathf.Clamp(Singleton<SaveDataManager>.Instance.SettingsData.EnviroVolume, 0.0001f, 1f)) * 20f;
|
|
enviroMixer?.SetFloat("MasterVolume", value);
|
|
FScriptsHandler.Instance?.AffectSoundVolume();
|
|
UnityEngine.Object.FindObjectOfType<Residence>()?.AffectSoundVolume();
|
|
}
|
|
|
|
public void SetEnviroVolumeSlider(float value)
|
|
{
|
|
EnviroVolume.value += value;
|
|
}
|
|
|
|
public void SetWeatherVolume()
|
|
{
|
|
WeatherVolumeText.text = (WeatherVolume.value * 100f).ToString("F0") + "%";
|
|
currentWeatherSoundsVolume = WeatherVolume.value;
|
|
float weatherVolume = Singleton<SaveDataManager>.Instance.SettingsData.WeatherVolume;
|
|
if (currentWeatherSoundsVolume != weatherVolume)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.SettingsData.WeatherVolume = currentWeatherSoundsVolume;
|
|
isSoundsChanged = true;
|
|
}
|
|
float value = Mathf.Log10(Mathf.Clamp(Singleton<SaveDataManager>.Instance.SettingsData.WeatherVolume, 0.0001f, 1f)) * 20f;
|
|
weatherMixer?.SetFloat("MasterVolume", value);
|
|
FScriptsHandler.Instance?.AffectSoundVolume();
|
|
UnityEngine.Object.FindObjectOfType<Residence>()?.AffectSoundVolume();
|
|
}
|
|
|
|
public void SetWeatherVolumeSlider(float value)
|
|
{
|
|
WeatherVolume.value += value;
|
|
}
|
|
|
|
public void SetVehicleVolume()
|
|
{
|
|
VehicleVolumeText.text = (VehicleVolume.value * 100f).ToString("F0") + "%";
|
|
currentVehicleSoundsVolume = VehicleVolume.value;
|
|
float vehicleVolume = Singleton<SaveDataManager>.Instance.SettingsData.VehicleVolume;
|
|
if (currentVehicleSoundsVolume != vehicleVolume)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.SettingsData.VehicleVolume = currentVehicleSoundsVolume;
|
|
isSoundsChanged = true;
|
|
}
|
|
float value = Mathf.Log10(Mathf.Clamp(Singleton<SaveDataManager>.Instance.SettingsData.VehicleVolume, 0.0001f, 1f)) * 20f;
|
|
vehicleMixer?.SetFloat("MasterVolume", value);
|
|
FScriptsHandler.Instance?.AffectSoundVolume();
|
|
UnityEngine.Object.FindObjectOfType<Residence>()?.AffectSoundVolume();
|
|
}
|
|
|
|
public void SetVehicleVolumeSlider(float value)
|
|
{
|
|
VehicleVolume.value += value;
|
|
}
|
|
|
|
public void SetWaterVolume()
|
|
{
|
|
WaterVolumeText.text = (WaterVolume.value * 100f).ToString("F0") + "%";
|
|
currentWaterSoundsVolume = WaterVolume.value;
|
|
float waterVolume = Singleton<SaveDataManager>.Instance.SettingsData.WaterVolume;
|
|
if (currentWaterSoundsVolume != waterVolume)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.SettingsData.WaterVolume = currentWaterSoundsVolume;
|
|
isSoundsChanged = true;
|
|
}
|
|
float value = Mathf.Log10(Mathf.Clamp(Singleton<SaveDataManager>.Instance.SettingsData.WaterVolume, 0.0001f, 1f)) * 20f;
|
|
waterMixer?.SetFloat("MasterVolume", value);
|
|
FScriptsHandler.Instance?.AffectSoundVolume();
|
|
UnityEngine.Object.FindObjectOfType<Residence>()?.AffectSoundVolume();
|
|
}
|
|
|
|
public void SetWaterVolumeSlider(float value)
|
|
{
|
|
WaterVolume.value += value;
|
|
}
|
|
|
|
public void SetUnderwaterVolume()
|
|
{
|
|
UnderwaterVolumeText.text = (UnderwaterVolume.value * 100f).ToString("F0") + "%";
|
|
currentUnderwaterSoundsVolume = UnderwaterVolume.value;
|
|
float underwaterVolume = Singleton<SaveDataManager>.Instance.SettingsData.UnderwaterVolume;
|
|
if (currentUnderwaterSoundsVolume != underwaterVolume)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.SettingsData.UnderwaterVolume = currentUnderwaterSoundsVolume;
|
|
isSoundsChanged = true;
|
|
}
|
|
float value = Mathf.Log10(Mathf.Clamp(Singleton<SaveDataManager>.Instance.SettingsData.UnderwaterVolume, 0.0001f, 1f)) * 20f;
|
|
underwaterMixer?.SetFloat("MasterVolume", value);
|
|
FScriptsHandler.Instance?.AffectSoundVolume();
|
|
UnityEngine.Object.FindObjectOfType<Residence>()?.AffectSoundVolume();
|
|
}
|
|
|
|
public void SetUnderwaterVolumeSlider(float value)
|
|
{
|
|
UnderwaterVolume.value += value;
|
|
}
|
|
|
|
public void SetFogInsensity()
|
|
{
|
|
intesityFogText.text = (intesityFog.value * 100f).ToString("F0") + "%";
|
|
currentintesityFog = intesityFog.value;
|
|
ApplyButton.SetActive(value: true);
|
|
isDisplayChanged = true;
|
|
}
|
|
|
|
public void SetFogInsensitySlider(float value)
|
|
{
|
|
intesityFog.value += value;
|
|
ApplyButton.SetActive(value: true);
|
|
isDisplayChanged = true;
|
|
}
|
|
|
|
public void SetShadowDistance()
|
|
{
|
|
shadowDistanceText.text = shadowDistance.value.ToString("F0");
|
|
currentShadowDistance = shadowDistance.value;
|
|
ApplyButton.SetActive(value: true);
|
|
isGraphicsChanged = true;
|
|
}
|
|
|
|
public void SetShadowDisnaceSlider(float value)
|
|
{
|
|
shadowDistance.value += value;
|
|
ApplyButton.SetActive(value: true);
|
|
isGraphicsChanged = true;
|
|
}
|
|
|
|
public void SetFloatSize()
|
|
{
|
|
floatScaleText.text = "x" + floatScaleSlider.value.ToString("F0");
|
|
currentfloatScale = floatScaleSlider.value;
|
|
if (currentfloatScale != Singleton<SaveDataManager>.Instance.SettingsData.FloatSizeValue)
|
|
{
|
|
ApplyButton.SetActive(value: true);
|
|
isDisplayChanged = true;
|
|
}
|
|
}
|
|
|
|
public void SetFloatSizeSlider(float value)
|
|
{
|
|
floatScaleSlider.value += value;
|
|
}
|
|
|
|
private void GetGraphicStartsSettings()
|
|
{
|
|
List<Resolution> list = new List<Resolution>();
|
|
resolutions = Screen.resolutions;
|
|
for (int i = 0; i < resolutions.Length; i++)
|
|
{
|
|
if (resolutions[i].refreshRate >= 30)
|
|
{
|
|
list.Add(resolutions[i]);
|
|
}
|
|
}
|
|
resolutions = list.ToArray();
|
|
int num = ((GameManager.Instance._playerData.Player[GameManager.Instance._playerData.currentPlayerProfileIndex].LastChoosenRefreshRate != 0) ? GameManager.Instance._playerData.Player[GameManager.Instance._playerData.currentPlayerProfileIndex].LastChoosenRefreshRate : Screen.currentResolution.refreshRate);
|
|
bool flag = false;
|
|
for (int j = 0; j < resolutions.Length; j++)
|
|
{
|
|
if (Screen.fullScreen)
|
|
{
|
|
if (resolutions[j].width == Screen.currentResolution.width && resolutions[j].height == Screen.currentResolution.height && (resolutions[j].refreshRate == num || Mathf.Abs(resolutions[j].refreshRate - num) <= 1))
|
|
{
|
|
currentSetsresolution = j;
|
|
flag = true;
|
|
break;
|
|
}
|
|
}
|
|
else if (resolutions[j].width == Screen.width && resolutions[j].height == Screen.height && resolutions[j].refreshRate == num)
|
|
{
|
|
currentSetsresolution = j;
|
|
flag = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!flag)
|
|
{
|
|
currentSetsresolution = resolutions.Length - 1;
|
|
num = resolutions[resolutions.Length - 1].refreshRate;
|
|
}
|
|
resolutionText.text = (Screen.fullScreen ? (resolutions[currentSetsresolution].width + "x" + resolutions[currentSetsresolution].height + " " + num + " Hz") : (Screen.width + "x" + Screen.height + " " + num + " Hz"));
|
|
displayMod = ((!Screen.fullScreen) ? DisplayMode.Windowed : DisplayMode.Fullscreen);
|
|
currentDisplayMode = (int)displayMod;
|
|
if (displayMod == DisplayMode.Fullscreen)
|
|
{
|
|
displayModeText.text = LanguageManager.Instance.GetText("SETTINGS_FULLSCREEN");
|
|
}
|
|
if (displayMod == DisplayMode.Windowed)
|
|
{
|
|
displayModeText.text = LanguageManager.Instance.GetText("SETTINGS_WINDOWED");
|
|
}
|
|
qualityMode = (QualityMode)QualitySettings.GetQualityLevel();
|
|
currentQualityMode = (int)qualityMode;
|
|
displayQualityText.text = qualityMode.ToString();
|
|
if (qualityMode == QualityMode.Low)
|
|
{
|
|
displayQualityText.text = LanguageManager.Instance.GetText("SETTINGS_LOW");
|
|
}
|
|
if (qualityMode == QualityMode.Medium)
|
|
{
|
|
displayQualityText.text = LanguageManager.Instance.GetText("SETTINGS_MEDIUM");
|
|
}
|
|
if (qualityMode == QualityMode.High)
|
|
{
|
|
displayQualityText.text = LanguageManager.Instance.GetText("SETTINGS_HIGH");
|
|
}
|
|
if (qualityMode == QualityMode.VeryHigh)
|
|
{
|
|
displayQualityText.text = LanguageManager.Instance.GetText("SETTINGS_ULTRA");
|
|
}
|
|
textureQualityMode = (TextureQualityMode)Singleton<SaveDataManager>.Instance.SettingsData.TextureQualityModeIndex;
|
|
currentTextureQualityMode = (int)textureQualityMode;
|
|
displayTextureQualityText.text = textureQualityMode.ToString();
|
|
if (textureQualityMode == TextureQualityMode.Ultra)
|
|
{
|
|
displayTextureQualityText.text = LanguageManager.Instance.GetText("SETTINGS_ULTRA");
|
|
}
|
|
if (textureQualityMode == TextureQualityMode.High)
|
|
{
|
|
displayTextureQualityText.text = LanguageManager.Instance.GetText("SETTINGS_HIGH");
|
|
}
|
|
if (textureQualityMode == TextureQualityMode.Medium)
|
|
{
|
|
displayTextureQualityText.text = LanguageManager.Instance.GetText("SETTINGS_MEDIUM");
|
|
}
|
|
if (textureQualityMode == TextureQualityMode.Low)
|
|
{
|
|
displayTextureQualityText.text = LanguageManager.Instance.GetText("SETTINGS_LOW");
|
|
}
|
|
displayMaxFps.text = GameManager.Instance._playerData.Player[GameManager.Instance._playerData.currentPlayerProfileIndex].MaxFps[Singleton<SaveDataManager>.Instance.SettingsData.MaxFpsIndex].ToString();
|
|
for (int k = 0; k < GameManager.Instance._playerData.Player[GameManager.Instance._playerData.currentPlayerProfileIndex].MaxFps.Length - 1; k++)
|
|
{
|
|
if (Application.targetFrameRate == GameManager.Instance._playerData.Player[GameManager.Instance._playerData.currentPlayerProfileIndex].MaxFps[k])
|
|
{
|
|
currentMaxFPSIndex = k;
|
|
break;
|
|
}
|
|
}
|
|
vsyncMode = (Singleton<SaveDataManager>.Instance.SettingsData.IsVSyncEnabled ? VsyncMode.On : VsyncMode.Off);
|
|
currentVsyncMode = (int)vsyncMode;
|
|
if (vsyncMode == VsyncMode.Off)
|
|
{
|
|
displayVsyncText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
MaxFpsButtons[0].interactable = true;
|
|
MaxFpsButtons[1].interactable = true;
|
|
MaxFpsButtonImage.color = Color.white;
|
|
Application.targetFrameRate = GameManager.Instance._playerData.Player[GameManager.Instance._playerData.currentPlayerProfileIndex].MaxFps[Singleton<SaveDataManager>.Instance.SettingsData.MaxFpsIndex];
|
|
}
|
|
if (vsyncMode == VsyncMode.On)
|
|
{
|
|
displayVsyncText.text = LanguageManager.Instance.GetText("SETTINGS_ON");
|
|
MaxFpsButtons[0].interactable = false;
|
|
MaxFpsButtons[1].interactable = false;
|
|
MaxFpsButtonImage.color = Color.grey;
|
|
}
|
|
blurMode = (Singleton<SaveDataManager>.Instance.SettingsData.IsBlurEnabled ? BlurMode.On : BlurMode.Off);
|
|
currentBlurMode = (int)blurMode;
|
|
if (blurMode == BlurMode.Off)
|
|
{
|
|
displayBlurText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
}
|
|
if (blurMode == BlurMode.On)
|
|
{
|
|
displayBlurText.text = LanguageManager.Instance.GetText("SETTINGS_ON");
|
|
}
|
|
bloomMode = (Singleton<SaveDataManager>.Instance.SettingsData.IsBloomEnabled ? BloomMode.On : BloomMode.Off);
|
|
currentBloomMode = (int)bloomMode;
|
|
if (bloomMode == BloomMode.Off)
|
|
{
|
|
displayBloomText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
}
|
|
if (bloomMode == BloomMode.On)
|
|
{
|
|
displayBloomText.text = LanguageManager.Instance.GetText("SETTINGS_ON");
|
|
}
|
|
chromaticMode = (Singleton<SaveDataManager>.Instance.SettingsData.IsChromaticAberrationEnabled ? ChromaticMode.On : ChromaticMode.Off);
|
|
currentChromaticMode = (int)chromaticMode;
|
|
if (chromaticMode == ChromaticMode.Off)
|
|
{
|
|
displayChromaticText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
}
|
|
if (chromaticMode == ChromaticMode.On)
|
|
{
|
|
displayChromaticText.text = LanguageManager.Instance.GetText("SETTINGS_ON");
|
|
}
|
|
aoMode = (Singleton<SaveDataManager>.Instance.SettingsData.IsAmbientOcclusionEnabled ? AOMode.On : AOMode.Off);
|
|
currentAoMode = (int)aoMode;
|
|
if (aoMode == AOMode.Off)
|
|
{
|
|
displayAoText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
}
|
|
if (aoMode == AOMode.On)
|
|
{
|
|
displayAoText.text = LanguageManager.Instance.GetText("SETTINGS_ON");
|
|
}
|
|
aaMode = (AAMode)Singleton<SaveDataManager>.Instance.SettingsData.AntiAliasingModeIndex;
|
|
currentAaMode = (int)aaMode;
|
|
displayAaText.text = ((aaMode == AAMode.Off) ? LanguageManager.Instance.GetText("SETTINGS_OFF") : aaMode.ToString());
|
|
currentShadowDistance = Singleton<SaveDataManager>.Instance.SettingsData.ShadowDistanceValue;
|
|
currentShadowDistance = Mathf.Clamp(currentShadowDistance, shadowDistance.minValue, shadowDistance.maxValue);
|
|
shadowDistance.value = currentShadowDistance;
|
|
shadowDistanceText.text = currentShadowDistance.ToString("F0");
|
|
}
|
|
|
|
private void GetGraphicWaterStartsSettings()
|
|
{
|
|
currentBlurUnderwater = Singleton<SaveDataManager>.Instance.SettingsData.BlurUnderwaterSetting;
|
|
currentBlurUnderwater = Mathf.Clamp(currentBlurUnderwater, blurUnderwaterSlider.minValue, blurUnderwaterSlider.maxValue);
|
|
blurUnderwaterSlider.value = currentBlurUnderwater;
|
|
blurUnderwaterText.text = (currentBlurUnderwater * 100f).ToString("F0");
|
|
waterPlanarMode = (WaterQualityMode)PlayerPrefs.GetInt("Settings_WaterPlanarMode", 1);
|
|
currentWaterPlanarMode = (int)waterPlanarMode;
|
|
waterPlanarText.text = waterPlanarMode.ToString();
|
|
if (waterPlanarMode == (WaterQualityMode)4)
|
|
{
|
|
waterPlanarText.text = LanguageManager.Instance.GetText("SETTINGS_ULTRA");
|
|
}
|
|
if (waterPlanarMode == WaterQualityMode.Ultra)
|
|
{
|
|
waterPlanarText.text = LanguageManager.Instance.GetText("SETTINGS_HIGH");
|
|
}
|
|
if (waterPlanarMode == WaterQualityMode.High)
|
|
{
|
|
waterPlanarText.text = LanguageManager.Instance.GetText("SETTINGS_MEDIUM");
|
|
}
|
|
if (waterPlanarMode == WaterQualityMode.Medium)
|
|
{
|
|
waterPlanarText.text = LanguageManager.Instance.GetText("SETTINGS_LOW");
|
|
}
|
|
if (waterPlanarMode == WaterQualityMode.Low)
|
|
{
|
|
waterPlanarText.text = LanguageManager.Instance.GetText("SETTINGS_VERY_LOW");
|
|
}
|
|
if (waterPlanarMode == (WaterQualityMode)(-1))
|
|
{
|
|
waterPlanarText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
}
|
|
waterSSRMode = (WaterQualityMode)PlayerPrefs.GetInt("Settings_WaterSSRMode", 1);
|
|
currentWaterSSRMode = (int)waterSSRMode;
|
|
waterSSRText.text = waterSSRMode.ToString();
|
|
if (waterSSRMode == (WaterQualityMode)4)
|
|
{
|
|
waterSSRText.text = LanguageManager.Instance.GetText("SETTINGS_ULTRA");
|
|
}
|
|
if (waterSSRMode == WaterQualityMode.Ultra)
|
|
{
|
|
waterSSRText.text = LanguageManager.Instance.GetText("SETTINGS_HIGH");
|
|
}
|
|
if (waterSSRMode == WaterQualityMode.High)
|
|
{
|
|
waterSSRText.text = LanguageManager.Instance.GetText("SETTINGS_MEDIUM");
|
|
}
|
|
if (waterSSRMode == WaterQualityMode.Medium)
|
|
{
|
|
waterSSRText.text = LanguageManager.Instance.GetText("SETTINGS_LOW");
|
|
}
|
|
if (waterSSRMode == WaterQualityMode.Low)
|
|
{
|
|
waterSSRText.text = LanguageManager.Instance.GetText("SETTINGS_VERY_LOW");
|
|
}
|
|
if (waterSSRMode == (WaterQualityMode)(-1))
|
|
{
|
|
waterSSRText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
}
|
|
shadowOnWater = (GameManager.Instance._playerData.Player[GameManager.Instance._playerData.currentPlayerProfileIndex].shadowOnWater ? ShadowOnWater.On : ShadowOnWater.Off);
|
|
currentShadowOnWater = (int)shadowOnWater;
|
|
if (shadowOnWater == ShadowOnWater.Off)
|
|
{
|
|
shadowOnWaterText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
}
|
|
if (shadowOnWater == ShadowOnWater.On)
|
|
{
|
|
shadowOnWaterText.text = LanguageManager.Instance.GetText("SETTINGS_ON");
|
|
}
|
|
}
|
|
|
|
public void SetResolution(int arrow)
|
|
{
|
|
currentSetsresolution += arrow;
|
|
if (currentSetsresolution < 0)
|
|
{
|
|
currentSetsresolution = resolutions.Length - 1;
|
|
}
|
|
if (currentSetsresolution == resolutions.Length)
|
|
{
|
|
currentSetsresolution = 0;
|
|
}
|
|
resolutionText.text = resolutions[currentSetsresolution].width + "x" + resolutions[currentSetsresolution].height + " " + resolutions[currentSetsresolution].refreshRate + " Hz";
|
|
ApplyButton.SetActive(value: true);
|
|
isGraphicsChanged = true;
|
|
}
|
|
|
|
public void SetDisplayMode(int arrow)
|
|
{
|
|
currentDisplayMode += arrow;
|
|
if (currentDisplayMode < 0)
|
|
{
|
|
currentDisplayMode = 1;
|
|
}
|
|
if (currentDisplayMode > 1)
|
|
{
|
|
currentDisplayMode = 0;
|
|
}
|
|
displayMod = (DisplayMode)currentDisplayMode;
|
|
if (displayMod == DisplayMode.Fullscreen)
|
|
{
|
|
displayModeText.text = LanguageManager.Instance.GetText("SETTINGS_FULLSCREEN");
|
|
}
|
|
if (displayMod == DisplayMode.Windowed)
|
|
{
|
|
displayModeText.text = LanguageManager.Instance.GetText("SETTINGS_WINDOWED");
|
|
}
|
|
ApplyButton.SetActive(value: true);
|
|
isGraphicsChanged = true;
|
|
}
|
|
|
|
public void SetWaterSSR(int arrow)
|
|
{
|
|
currentWaterSSRMode += arrow;
|
|
if (currentWaterSSRMode < -1)
|
|
{
|
|
currentWaterSSRMode = 4;
|
|
}
|
|
if (currentWaterSSRMode > 4)
|
|
{
|
|
currentWaterSSRMode = -1;
|
|
}
|
|
waterSSRMode = (WaterQualityMode)currentWaterSSRMode;
|
|
if (waterSSRMode == (WaterQualityMode)4)
|
|
{
|
|
waterSSRText.text = LanguageManager.Instance.GetText("SETTINGS_ULTRA");
|
|
}
|
|
if (waterSSRMode == WaterQualityMode.Ultra)
|
|
{
|
|
waterSSRText.text = LanguageManager.Instance.GetText("SETTINGS_HIGH");
|
|
}
|
|
if (waterSSRMode == WaterQualityMode.High)
|
|
{
|
|
waterSSRText.text = LanguageManager.Instance.GetText("SETTINGS_MEDIUM");
|
|
}
|
|
if (waterSSRMode == WaterQualityMode.Medium)
|
|
{
|
|
waterSSRText.text = LanguageManager.Instance.GetText("SETTINGS_LOW");
|
|
}
|
|
if (waterSSRMode == WaterQualityMode.Low)
|
|
{
|
|
waterSSRText.text = LanguageManager.Instance.GetText("SETTINGS_VERY_LOW");
|
|
}
|
|
if (waterSSRMode == (WaterQualityMode)(-1))
|
|
{
|
|
waterSSRText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
}
|
|
ApplyButton.SetActive(value: true);
|
|
}
|
|
|
|
public void SetWaterPlanar(int arrow)
|
|
{
|
|
currentWaterPlanarMode += arrow;
|
|
if (currentWaterPlanarMode < -1)
|
|
{
|
|
currentWaterPlanarMode = 4;
|
|
}
|
|
if (currentWaterPlanarMode > 4)
|
|
{
|
|
currentWaterPlanarMode = -1;
|
|
}
|
|
waterPlanarMode = (WaterQualityMode)currentWaterPlanarMode;
|
|
if (waterPlanarMode == (WaterQualityMode)4)
|
|
{
|
|
waterPlanarText.text = LanguageManager.Instance.GetText("SETTINGS_ULTRA");
|
|
}
|
|
if (waterPlanarMode == WaterQualityMode.Ultra)
|
|
{
|
|
waterPlanarText.text = LanguageManager.Instance.GetText("SETTINGS_HIGH");
|
|
}
|
|
if (waterPlanarMode == WaterQualityMode.High)
|
|
{
|
|
waterPlanarText.text = LanguageManager.Instance.GetText("SETTINGS_MEDIUM");
|
|
}
|
|
if (waterPlanarMode == WaterQualityMode.Medium)
|
|
{
|
|
waterPlanarText.text = LanguageManager.Instance.GetText("SETTINGS_LOW");
|
|
}
|
|
if (waterPlanarMode == WaterQualityMode.Low)
|
|
{
|
|
waterPlanarText.text = LanguageManager.Instance.GetText("SETTINGS_VERY_LOW");
|
|
}
|
|
if (waterPlanarMode == (WaterQualityMode)(-1))
|
|
{
|
|
waterPlanarText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
}
|
|
ApplyButton.SetActive(value: true);
|
|
}
|
|
|
|
public void SetUnderwaterBlur()
|
|
{
|
|
blurUnderwaterText.text = (blurUnderwaterSlider.value * 100f).ToString("F0");
|
|
currentBlurUnderwater = blurUnderwaterSlider.value;
|
|
if (currentBlurUnderwater != Singleton<SaveDataManager>.Instance.SettingsData.BlurUnderwaterSetting)
|
|
{
|
|
ApplyButton.SetActive(value: true);
|
|
isGraphicsPostprocessingChanged = true;
|
|
}
|
|
}
|
|
|
|
public void SetQualityMode(int arrow)
|
|
{
|
|
currentQualityMode += arrow;
|
|
if (currentQualityMode < 0)
|
|
{
|
|
currentQualityMode = 3;
|
|
}
|
|
if (currentQualityMode > 3)
|
|
{
|
|
currentQualityMode = 0;
|
|
}
|
|
qualityMode = (QualityMode)currentQualityMode;
|
|
if (qualityMode == QualityMode.Low)
|
|
{
|
|
displayQualityText.text = LanguageManager.Instance.GetText("SETTINGS_LOW");
|
|
}
|
|
if (qualityMode == QualityMode.Medium)
|
|
{
|
|
displayQualityText.text = LanguageManager.Instance.GetText("SETTINGS_MEDIUM");
|
|
}
|
|
if (qualityMode == QualityMode.High)
|
|
{
|
|
displayQualityText.text = LanguageManager.Instance.GetText("SETTINGS_HIGH");
|
|
}
|
|
if (qualityMode == QualityMode.VeryHigh)
|
|
{
|
|
displayQualityText.text = LanguageManager.Instance.GetText("SETTINGS_ULTRA");
|
|
}
|
|
ApplyButton.SetActive(value: true);
|
|
isGraphicsChanged = true;
|
|
}
|
|
|
|
public void SetTextureQualityMode(int arrow)
|
|
{
|
|
currentTextureQualityMode += arrow;
|
|
if (currentTextureQualityMode > 3)
|
|
{
|
|
currentTextureQualityMode = 0;
|
|
}
|
|
if (currentTextureQualityMode < 0)
|
|
{
|
|
currentTextureQualityMode = 3;
|
|
}
|
|
textureQualityMode = (TextureQualityMode)currentTextureQualityMode;
|
|
if (textureQualityMode == TextureQualityMode.Low)
|
|
{
|
|
displayTextureQualityText.text = LanguageManager.Instance.GetText("SETTINGS_LOW");
|
|
}
|
|
if (textureQualityMode == TextureQualityMode.Medium)
|
|
{
|
|
displayTextureQualityText.text = LanguageManager.Instance.GetText("SETTINGS_MEDIUM");
|
|
}
|
|
if (textureQualityMode == TextureQualityMode.High)
|
|
{
|
|
displayTextureQualityText.text = LanguageManager.Instance.GetText("SETTINGS_HIGH");
|
|
}
|
|
if (textureQualityMode == TextureQualityMode.Ultra)
|
|
{
|
|
displayTextureQualityText.text = LanguageManager.Instance.GetText("SETTINGS_ULTRA");
|
|
}
|
|
ApplyButton.SetActive(value: true);
|
|
isGraphicsChanged = true;
|
|
}
|
|
|
|
public void SetVsyncMode(int arrow)
|
|
{
|
|
currentVsyncMode += arrow;
|
|
if (currentVsyncMode < 0)
|
|
{
|
|
currentVsyncMode = 1;
|
|
}
|
|
if (currentVsyncMode == 2)
|
|
{
|
|
currentVsyncMode = 0;
|
|
}
|
|
vsyncMode = (VsyncMode)currentVsyncMode;
|
|
if (vsyncMode == VsyncMode.Off)
|
|
{
|
|
displayVsyncText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
MaxFpsButtons[0].interactable = true;
|
|
MaxFpsButtons[1].interactable = true;
|
|
MaxFpsButtonImage.color = Color.white;
|
|
}
|
|
if (vsyncMode == VsyncMode.On)
|
|
{
|
|
displayVsyncText.text = LanguageManager.Instance.GetText("SETTINGS_ON");
|
|
MaxFpsButtons[0].interactable = false;
|
|
MaxFpsButtons[1].interactable = false;
|
|
MaxFpsButtonImage.color = Color.grey;
|
|
}
|
|
ApplyButton.SetActive(value: true);
|
|
isGraphicsChanged = true;
|
|
}
|
|
|
|
public void SetBlurMode(int arrow)
|
|
{
|
|
currentBlurMode += arrow;
|
|
if (currentBlurMode < 0)
|
|
{
|
|
currentBlurMode = 1;
|
|
}
|
|
if (currentBlurMode == 2)
|
|
{
|
|
currentBlurMode = 0;
|
|
}
|
|
blurMode = (BlurMode)currentBlurMode;
|
|
if (blurMode == BlurMode.Off)
|
|
{
|
|
displayBlurText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
}
|
|
if (blurMode == BlurMode.On)
|
|
{
|
|
displayBlurText.text = LanguageManager.Instance.GetText("SETTINGS_ON");
|
|
}
|
|
ApplyButton.SetActive(value: true);
|
|
isGraphicsPostprocessingChanged = true;
|
|
}
|
|
|
|
public void SetBloomMode(int arrow)
|
|
{
|
|
currentBloomMode += arrow;
|
|
if (currentBloomMode < 0)
|
|
{
|
|
currentBloomMode = 1;
|
|
}
|
|
if (currentBloomMode == 2)
|
|
{
|
|
currentBloomMode = 0;
|
|
}
|
|
bloomMode = (BloomMode)currentBloomMode;
|
|
if (bloomMode == BloomMode.Off)
|
|
{
|
|
displayBloomText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
}
|
|
if (bloomMode == BloomMode.On)
|
|
{
|
|
displayBloomText.text = LanguageManager.Instance.GetText("SETTINGS_ON");
|
|
}
|
|
ApplyButton.SetActive(value: true);
|
|
isGraphicsPostprocessingChanged = true;
|
|
}
|
|
|
|
public void SetChromaticAbberationMode(int arrow)
|
|
{
|
|
currentChromaticMode += arrow;
|
|
if (currentChromaticMode < 0)
|
|
{
|
|
currentChromaticMode = 1;
|
|
}
|
|
if (currentChromaticMode == 2)
|
|
{
|
|
currentChromaticMode = 0;
|
|
}
|
|
chromaticMode = (ChromaticMode)currentChromaticMode;
|
|
if (chromaticMode == ChromaticMode.Off)
|
|
{
|
|
displayChromaticText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
}
|
|
if (chromaticMode == ChromaticMode.On)
|
|
{
|
|
displayChromaticText.text = LanguageManager.Instance.GetText("SETTINGS_ON");
|
|
}
|
|
ApplyButton.SetActive(value: true);
|
|
isGraphicsPostprocessingChanged = true;
|
|
}
|
|
|
|
public void SetAntiAliasingMode(int arrow)
|
|
{
|
|
currentAaMode += arrow;
|
|
if (currentAaMode < 0)
|
|
{
|
|
currentAaMode = 3;
|
|
}
|
|
if (currentAaMode == 4)
|
|
{
|
|
currentAaMode = 0;
|
|
}
|
|
aaMode = (AAMode)currentAaMode;
|
|
displayAaText.text = ((aaMode == AAMode.Off) ? LanguageManager.Instance.GetText("SETTINGS_OFF") : aaMode.ToString());
|
|
ApplyButton.SetActive(value: true);
|
|
isGraphicsPostprocessingChanged = true;
|
|
}
|
|
|
|
public void SetAmbientOculssionMode(int arrow)
|
|
{
|
|
currentAoMode += arrow;
|
|
if (currentAoMode < 0)
|
|
{
|
|
currentAoMode = 1;
|
|
}
|
|
if (currentAoMode == 2)
|
|
{
|
|
currentAoMode = 0;
|
|
}
|
|
aoMode = (AOMode)currentAoMode;
|
|
if (aoMode == AOMode.Off)
|
|
{
|
|
displayAoText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
}
|
|
if (aoMode == AOMode.On)
|
|
{
|
|
displayAoText.text = LanguageManager.Instance.GetText("SETTINGS_ON");
|
|
}
|
|
ApplyButton.SetActive(value: true);
|
|
isGraphicsPostprocessingChanged = true;
|
|
}
|
|
|
|
public void SetUnitWeight(int arrow)
|
|
{
|
|
currentunitWeight += arrow;
|
|
if (currentunitWeight < 0)
|
|
{
|
|
currentunitWeight = 1;
|
|
}
|
|
if (currentunitWeight == 2)
|
|
{
|
|
currentunitWeight = 0;
|
|
}
|
|
unitWeight = (UnitWeight)currentunitWeight;
|
|
if (unitWeight == UnitWeight.Kg)
|
|
{
|
|
unitWeightText.text = LanguageManager.Instance.GetText("SETTINGS_KG");
|
|
}
|
|
if (unitWeight == UnitWeight.Lb)
|
|
{
|
|
unitWeightText.text = LanguageManager.Instance.GetText("SETTINGS_LB");
|
|
}
|
|
ApplyButton.SetActive(value: true);
|
|
}
|
|
|
|
public void SetUnitLength(int arrow)
|
|
{
|
|
currentunitLength += arrow;
|
|
if (currentunitLength < 0)
|
|
{
|
|
currentunitLength = 2;
|
|
}
|
|
if (currentunitLength == 3)
|
|
{
|
|
currentunitLength = 0;
|
|
}
|
|
unitLength = (UnitLength)currentunitLength;
|
|
if (unitLength == UnitLength.cm)
|
|
{
|
|
unitLengthText.text = LanguageManager.Instance.GetText("SETTINGS_CM");
|
|
}
|
|
if (unitLength == UnitLength.cals)
|
|
{
|
|
unitLengthText.text = LanguageManager.Instance.GetText("SETTINGS_INCHES");
|
|
}
|
|
if (unitLength == UnitLength.foots)
|
|
{
|
|
unitLengthText.text = LanguageManager.Instance.GetText("SETTINGS_FOOTS");
|
|
}
|
|
ApplyButton.SetActive(value: true);
|
|
isGraphicsPostprocessingChanged = true;
|
|
}
|
|
|
|
public void SetTimeZone(int arrow)
|
|
{
|
|
currenttimeZone += arrow;
|
|
if (currenttimeZone < 0)
|
|
{
|
|
currenttimeZone = 1;
|
|
}
|
|
if (currenttimeZone == 2)
|
|
{
|
|
currenttimeZone = 0;
|
|
}
|
|
timeZone = (TimeZone)currenttimeZone;
|
|
if (timeZone == TimeZone._24)
|
|
{
|
|
timeZoneText.text = LanguageManager.Instance.GetText("SETTINGS_24");
|
|
}
|
|
if (timeZone == TimeZone._12)
|
|
{
|
|
timeZoneText.text = LanguageManager.Instance.GetText("SETTINGS_12");
|
|
}
|
|
ApplyButton.SetActive(value: true);
|
|
}
|
|
|
|
public void SetUnitTemperature(int arrow)
|
|
{
|
|
currentunitTemperature += arrow;
|
|
if (currentunitTemperature < 0)
|
|
{
|
|
currentunitTemperature = 2;
|
|
}
|
|
if (currentunitTemperature == 3)
|
|
{
|
|
currentunitTemperature = 0;
|
|
}
|
|
temperature = (TemperatureUnit)currentunitTemperature;
|
|
if (temperature == TemperatureUnit.C)
|
|
{
|
|
temperatureUnitText.text = "C";
|
|
}
|
|
if (temperature == TemperatureUnit.F)
|
|
{
|
|
temperatureUnitText.text = "F";
|
|
}
|
|
if (temperature == TemperatureUnit.K)
|
|
{
|
|
temperatureUnitText.text = "K";
|
|
}
|
|
ApplyButton.SetActive(value: true);
|
|
}
|
|
|
|
public void SetLightShaft(int arrow)
|
|
{
|
|
currentlightShafts += arrow;
|
|
if (currentlightShafts < 0)
|
|
{
|
|
currentlightShafts = 1;
|
|
}
|
|
if (currentlightShafts == 2)
|
|
{
|
|
currentlightShafts = 0;
|
|
}
|
|
Debug.Log(currentlightShafts);
|
|
lightShafts = (LightShafts)currentlightShafts;
|
|
if (lightShafts == LightShafts.On)
|
|
{
|
|
displayLightShaftsText.text = LanguageManager.Instance.GetText("SETTINGS_ON");
|
|
}
|
|
if (lightShafts == LightShafts.Off)
|
|
{
|
|
displayLightShaftsText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
}
|
|
ApplyButton.SetActive(value: true);
|
|
isDisplayChanged = true;
|
|
}
|
|
|
|
public void SetShadowOnWater(int arrow)
|
|
{
|
|
currentShadowOnWater += arrow;
|
|
if (currentShadowOnWater < 0)
|
|
{
|
|
currentShadowOnWater = 1;
|
|
}
|
|
if (currentShadowOnWater == 2)
|
|
{
|
|
currentShadowOnWater = 0;
|
|
}
|
|
shadowOnWater = (ShadowOnWater)currentShadowOnWater;
|
|
if (shadowOnWater == ShadowOnWater.On)
|
|
{
|
|
shadowOnWaterText.text = LanguageManager.Instance.GetText("SETTINGS_ON");
|
|
}
|
|
if (shadowOnWater == ShadowOnWater.Off)
|
|
{
|
|
shadowOnWaterText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
}
|
|
ApplyButton.SetActive(value: true);
|
|
isGraphicsChanged = true;
|
|
}
|
|
|
|
public void SetWaterReflection(int arrow)
|
|
{
|
|
}
|
|
|
|
public void SetLineIndicator(int arrow)
|
|
{
|
|
currentRealisticLineIndicator += arrow;
|
|
if (currentRealisticLineIndicator < 0)
|
|
{
|
|
currentRealisticLineIndicator = 1;
|
|
}
|
|
if (currentRealisticLineIndicator == 2)
|
|
{
|
|
currentRealisticLineIndicator = 0;
|
|
}
|
|
realisticLineIndicator = (RealisticLineIndicator)currentRealisticLineIndicator;
|
|
if (realisticLineIndicator == RealisticLineIndicator.On)
|
|
{
|
|
RealisticLineIndicatorText.text = LanguageManager.Instance.GetText("SETTINGS_ON");
|
|
}
|
|
if (realisticLineIndicator == RealisticLineIndicator.Off)
|
|
{
|
|
RealisticLineIndicatorText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
}
|
|
ApplyButton.SetActive(value: true);
|
|
isDisplayChanged = true;
|
|
}
|
|
|
|
public void SetHideChat(int arrow)
|
|
{
|
|
currentHideChat += arrow;
|
|
if (currentHideChat < 0)
|
|
{
|
|
currentHideChat = 1;
|
|
}
|
|
if (currentHideChat == 2)
|
|
{
|
|
currentHideChat = 0;
|
|
}
|
|
hideChat = (HideChat)currentHideChat;
|
|
if (hideChat == HideChat.On)
|
|
{
|
|
hideChatText.text = LanguageManager.Instance.GetText("SETTINGS_ON");
|
|
}
|
|
if (hideChat == HideChat.Off)
|
|
{
|
|
hideChatText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
}
|
|
ApplyButton.SetActive(value: true);
|
|
isDisplayChanged = true;
|
|
}
|
|
|
|
public void SetMaxFps(int arrow)
|
|
{
|
|
currentMaxFPSIndex += arrow;
|
|
if (currentMaxFPSIndex >= 0)
|
|
{
|
|
if (currentMaxFPSIndex > GameManager.Instance._playerData.Player[GameManager.Instance._playerData.currentPlayerProfileIndex].MaxFps.Length - 1)
|
|
{
|
|
currentMaxFPSIndex = 0;
|
|
targetMaxFPS = -1;
|
|
}
|
|
else
|
|
{
|
|
targetMaxFPS = ((currentMaxFPSIndex >= 1) ? GameManager.Instance._playerData.Player[GameManager.Instance._playerData.currentPlayerProfileIndex].MaxFps[currentMaxFPSIndex] : (-1));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
currentMaxFPSIndex = GameManager.Instance._playerData.Player[GameManager.Instance._playerData.currentPlayerProfileIndex].MaxFps.Length - 1;
|
|
targetMaxFPS = GameManager.Instance._playerData.Player[GameManager.Instance._playerData.currentPlayerProfileIndex].MaxFps[currentMaxFPSIndex];
|
|
}
|
|
displayMaxFps.text = GameManager.Instance._playerData.Player[GameManager.Instance._playerData.currentPlayerProfileIndex].MaxFps[currentMaxFPSIndex].ToString();
|
|
ApplyButton.SetActive(value: true);
|
|
isGraphicsChanged = true;
|
|
}
|
|
|
|
public void SetResidenceMusicMode(int arrow)
|
|
{
|
|
currentResidenceMusicMode += arrow;
|
|
if (currentResidenceMusicMode < 0)
|
|
{
|
|
currentResidenceMusicMode = 1;
|
|
}
|
|
if (currentResidenceMusicMode == 2)
|
|
{
|
|
currentResidenceMusicMode = 0;
|
|
}
|
|
residenceMusic = (ResidenceMusic)currentResidenceMusicMode;
|
|
if (residenceMusic == ResidenceMusic.Off)
|
|
{
|
|
displayResidenceMusicText.text = LanguageManager.Instance.GetText("SETTINGS_OFF");
|
|
}
|
|
if (residenceMusic == ResidenceMusic.On)
|
|
{
|
|
displayResidenceMusicText.text = LanguageManager.Instance.GetText("SETTINGS_ON");
|
|
}
|
|
ApplyButton.SetActive(value: true);
|
|
isSoundsChanged = true;
|
|
}
|
|
|
|
public void SetMeshDetail(int value)
|
|
{
|
|
currentMeshDetail = Mathf.Clamp(currentMeshDetail + value, 0, 3);
|
|
SettingChanged(currentMeshDetail, _MeshDetailText);
|
|
SettingsManager.OnSetMeshDetail?.Invoke(currentMeshDetail);
|
|
}
|
|
|
|
public void SetWavesDetail(int value)
|
|
{
|
|
currentWaveDetail = Mathf.Clamp(currentWaveDetail + value, 0, 3);
|
|
SettingChanged(currentWaveDetail, _WaveDetailText);
|
|
SettingsManager.OnSetWavesDetail?.Invoke(currentWaveDetail);
|
|
}
|
|
|
|
public void SetDynamicWavesDetail(int value)
|
|
{
|
|
currentDynamicWavesDetail = Mathf.Clamp(currentDynamicWavesDetail + value, 0, 3);
|
|
SettingChanged(currentDynamicWavesDetail, _DynamicWavesDetail);
|
|
SettingsManager.OnSetDynamicWaves?.Invoke(currentDynamicWavesDetail);
|
|
}
|
|
|
|
public void SetReflectionsLevel(int value)
|
|
{
|
|
currentReflectionsLevel = Mathf.Clamp(currentReflectionsLevel + value, 0, 3);
|
|
SettingChanged(currentReflectionsLevel, _ReflectionDetailText);
|
|
SettingsManager.OnSetReflectionsLevel?.Invoke(currentReflectionsLevel);
|
|
}
|
|
|
|
public void SetVolumetricLighting(int value)
|
|
{
|
|
currentWaterVolumetricLighting = Mathf.Clamp(currentWaterVolumetricLighting + value, 0, 3);
|
|
SettingChanged(currentWaterVolumetricLighting, _VolumetricLightingText);
|
|
SettingsManager.OnSetVolumetricLighting?.Invoke(currentWaterVolumetricLighting);
|
|
}
|
|
|
|
public void SetCaustic(int value)
|
|
{
|
|
currentCausticLevel = Mathf.Clamp(currentCausticLevel + value, 0, 3);
|
|
SettingChanged(currentCausticLevel, _CausticLightingText);
|
|
SettingsManager.OnSetCausticLevel?.Invoke(currentCausticLevel);
|
|
}
|
|
|
|
private void SettingChanged(int qualityMode, Text textMesh)
|
|
{
|
|
if (qualityMode == 0)
|
|
{
|
|
textMesh.text = LanguageManager.Instance.GetText("SETTINGS_LOW");
|
|
}
|
|
if (qualityMode == 1)
|
|
{
|
|
textMesh.text = LanguageManager.Instance.GetText("SETTINGS_MEDIUM");
|
|
}
|
|
if (qualityMode == 2)
|
|
{
|
|
textMesh.text = LanguageManager.Instance.GetText("SETTINGS_HIGH");
|
|
}
|
|
if (qualityMode == 3)
|
|
{
|
|
textMesh.text = LanguageManager.Instance.GetText("SETTINGS_ULTRA");
|
|
}
|
|
ApplyButton.SetActive(value: true);
|
|
isGraphicsChanged = true;
|
|
}
|
|
|
|
public void ApplySettings()
|
|
{
|
|
int currentPlayerProfileIndex = GameManager.Instance._playerData.currentPlayerProfileIndex;
|
|
PlayerPrefs.SetInt("Settings_WaterPlanarMode", currentWaterPlanarMode);
|
|
PlayerPrefs.SetInt("Settings_WaterSSRMode", currentWaterSSRMode);
|
|
if (isDisplayChanged)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.SettingsData.FOVValue = currentFov;
|
|
Singleton<SaveDataManager>.Instance.SettingsData.FogIntensityValue = currentintesityFog;
|
|
Singleton<SaveDataManager>.Instance.SettingsData.GamepadCursorSensitivityValue = currentCursorSensitivity;
|
|
Singleton<SaveDataManager>.Instance.SettingsData.IsFishCursorEnabled = currentFishCursorMode == 1;
|
|
Singleton<SaveDataManager>.Instance.SettingsData.IsLightShaftEnabled = currentlightShafts == 1;
|
|
Singleton<SaveDataManager>.Instance.SettingsData.IsLineIndicatorEnabledOnRealistic = currentRealisticLineIndicator == 1;
|
|
Singleton<SaveDataManager>.Instance.SettingsData.IsChatEnabled = currentHideChat == 1;
|
|
Singleton<SaveDataManager>.Instance.SettingsData.TimeConventionIndex = currenttimeZone;
|
|
Singleton<SaveDataManager>.Instance.SettingsData.LengthUnitIndex = currentunitLength;
|
|
Singleton<SaveDataManager>.Instance.SettingsData.WeightUnitIndex = currentunitWeight;
|
|
Singleton<SaveDataManager>.Instance.SettingsData.TemperatureUnitIndex = currentunitTemperature;
|
|
Singleton<SaveDataManager>.Instance.SettingsData.FloatSizeValue = currentfloatScale;
|
|
if (FScriptsHandler.Instance != null)
|
|
{
|
|
FScriptsHandler.Instance.AffectDisplaySetting();
|
|
}
|
|
isDisplayChanged = false;
|
|
}
|
|
if (isControlsChanged)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.SettingsData.MouseSensitivityValue = mouseSensitivity.value;
|
|
Singleton<SaveDataManager>.Instance.SettingsData.GamepadCursorSensitivityValue = cursorSensitivity.value;
|
|
GameManager.Instance._playerData.Player[currentPlayerProfileIndex].controllerSetup = currentcontrollerSetup;
|
|
Singleton<SaveDataManager>.Instance.SettingsData.IsMouseYInverted = currentInvertMouse == 1;
|
|
Singleton<SaveDataManager>.Instance.SettingsData.IsMouseXInverted = currentInvertMouseX == 1;
|
|
Singleton<SaveDataManager>.Instance.SettingsData.IsSmoothCameraEnabled = currentsmooothcamera == 1;
|
|
Singleton<SaveDataManager>.Instance.SettingsData.IsControllerVibrationEnabled = currentcontrollerVibration == 1;
|
|
if (FScriptsHandler.Instance != null)
|
|
{
|
|
FScriptsHandler.Instance.AffectControlsSetting();
|
|
}
|
|
isControlsChanged = false;
|
|
}
|
|
if (isGraphicsChanged)
|
|
{
|
|
bool fullscreen = displayMod == DisplayMode.Fullscreen;
|
|
Screen.SetResolution(resolutions[currentSetsresolution].width, resolutions[currentSetsresolution].height, fullscreen, resolutions[currentSetsresolution].refreshRate);
|
|
GameManager.Instance._playerData.Player[GameManager.Instance._playerData.currentPlayerProfileIndex].LastChoosenRefreshRate = resolutions[currentSetsresolution].refreshRate;
|
|
QualitySettings.SetQualityLevel(currentQualityMode);
|
|
QualitySettings.masterTextureLimit = currentTextureQualityMode;
|
|
QualitySettings.vSyncCount = currentVsyncMode;
|
|
if (currentVsyncMode == 0)
|
|
{
|
|
Application.targetFrameRate = targetMaxFPS;
|
|
}
|
|
GameManager.Instance._playerData.Player[currentPlayerProfileIndex].shadowOnWater = currentShadowOnWater == 1;
|
|
Singleton<SaveDataManager>.Instance.SettingsData.TextureQualityModeIndex = currentTextureQualityMode;
|
|
Singleton<SaveDataManager>.Instance.SettingsData.IsVSyncEnabled = currentVsyncMode == 1;
|
|
Singleton<SaveDataManager>.Instance.SettingsData.ShadowDistanceValue = currentShadowDistance;
|
|
Singleton<SaveDataManager>.Instance.SettingsData.MaxFpsIndex = currentMaxFPSIndex;
|
|
if (FScriptsHandler.Instance != null)
|
|
{
|
|
FScriptsHandler.Instance.AffectGraphicsSetting();
|
|
}
|
|
isGraphicsChanged = false;
|
|
}
|
|
if (isGraphicsPostprocessingChanged)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.SettingsData.IsBlurEnabled = currentBlurMode == 1;
|
|
Singleton<SaveDataManager>.Instance.SettingsData.BlurUnderwaterSetting = currentBlurUnderwater;
|
|
Singleton<SaveDataManager>.Instance.SettingsData.IsBloomEnabled = currentBloomMode == 1;
|
|
Singleton<SaveDataManager>.Instance.SettingsData.IsChromaticAberrationEnabled = currentChromaticMode == 1;
|
|
Singleton<SaveDataManager>.Instance.SettingsData.AntiAliasingModeIndex = ((currentAaMode > 0) ? currentAaMode : 0);
|
|
Singleton<SaveDataManager>.Instance.SettingsData.IsAmbientOcclusionEnabled = currentAoMode == 1;
|
|
if (FScriptsHandler.Instance != null)
|
|
{
|
|
FScriptsHandler.Instance.AffectPostProccesingFromSettings();
|
|
}
|
|
isGraphicsPostprocessingChanged = false;
|
|
}
|
|
if (isLanguageChanged)
|
|
{
|
|
LanguageManager.Instance.SetLanguage(currentLanguageIndex);
|
|
PlayerPrefs.SetInt("IsSetLanguageManual", currentLanguageIndex);
|
|
isLanguageChanged = false;
|
|
}
|
|
if (isSoundsChanged)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.SettingsData.IsResidenceMusicEnabled = currentResidenceMusicMode == 1;
|
|
if (Singleton<SaveDataManager>.Instance.SettingsData.IsResidenceMusicEnabled)
|
|
{
|
|
MasterAudio.UnmuteGroup("mississippi_catfish_loop");
|
|
}
|
|
else
|
|
{
|
|
MasterAudio.MuteGroup("mississippi_catfish_loop");
|
|
}
|
|
isSoundsChanged = false;
|
|
}
|
|
SettingsManager.OnSettingApply?.Invoke();
|
|
ApplyButton.SetActive(value: false);
|
|
}
|
|
|
|
private void OnDestroy()
|
|
{
|
|
ReInput.userDataStore.Save();
|
|
Debug.Log("exit settings: " + isSoundsChanged);
|
|
if (isSoundsChanged)
|
|
{
|
|
Singleton<SaveDataManager>.Instance.SettingsData.MasterVolume = currentSoundsVolume;
|
|
Singleton<SaveDataManager>.Instance.SettingsData.MusicVolume = currentMusicVolume;
|
|
Singleton<SaveDataManager>.Instance.SettingsData.FXVolume = currentFxSoundsVolume;
|
|
Singleton<SaveDataManager>.Instance.SettingsData.UnderwaterVolume = currentUnderwaterSoundsVolume;
|
|
}
|
|
}
|
|
}
|