zombie_mp/Assets/Scripts/Menu/settings.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.Rendering.PostProcessing;

public class settings : MonoBehaviour
{
    public AudioSource audSrc;
    public GameObject[] settingsSections;
    public Button[] settingsSectionsBtns;
    public AudioClip settingsSectionSelectedSFX;
    public AudioClip settingsChangedSFX;
    public AudioClip onHoverSfx;

    [Header("Graphics")]
    public Toggle vsync;
    public Toggle fullscreen;
    public Dropdown shadows;
    public Dropdown aa;
    public Dropdown pp;
    public Dropdown particles;
    public Dropdown textureQ;
    public Dropdown meshQ;
    public Dropdown lightningQ;
    public Dropdown resolution;

    CanvasGroup canvasGroup;
    public void show()
    {
        canvasGroup.blocksRaycasts = canvasGroup.interactable = true;
    }

    public void hide()
    {
        canvasGroup.blocksRaycasts = canvasGroup.interactable = false;
    }


    void Start()
    {//Resolutions
        resolution.options.Clear();
        Vector2[] resList = {
            new Vector2(7680,4320),
            new Vector2(3840, 2160),
            new Vector2(2048, 1080),
            new Vector2(2560, 1440),
            new Vector2(1920,1080),
            new Vector2(1366,768),
            new Vector2(1024, 720),
            new Vector2(620, 480),

        };
        canvasGroup = GetComponent<CanvasGroup>();
        SettingPage.instance = this;
        vsync.onValueChanged.AddListener((bool b) => {
            PlayerPrefs.SetInt("vsync", (b) ? 1 : 0);
            PlayerPrefs.Save();
            playSettingsChangedSFX();
            reloadGraphicSettings();
        });

        fullscreen.onValueChanged.AddListener((bool b) => {
            PlayerPrefs.SetInt("fullscreen", (b) ? 1 : 0);
            PlayerPrefs.Save();
            playSettingsChangedSFX();
            reloadGraphicSettings();
        });

        shadows.onValueChanged.AddListener((int option) =>
        {
            PlayerPrefs.SetInt("shadows", option);
            PlayerPrefs.Save();
            playSettingsChangedSFX();
            reloadGraphicSettings();
        });

        aa.onValueChanged.AddListener((int option) =>
        {
            PlayerPrefs.SetInt("aa", option);
            PlayerPrefs.Save();
            playSettingsChangedSFX();
            reloadGraphicSettings();
        });

        pp.onValueChanged.AddListener((int option) =>
        {
            PlayerPrefs.SetInt("pp", option);
            PlayerPrefs.Save();
            playSettingsChangedSFX();
            reloadGraphicSettings();
        });

        particles.onValueChanged.AddListener((int option) =>
        {
            PlayerPrefs.SetInt("particles", option);
            PlayerPrefs.Save();
            playSettingsChangedSFX();
            reloadGraphicSettings();
        });

        textureQ.onValueChanged.AddListener((int option) =>
        {
            PlayerPrefs.SetInt("textureQ", option);
            PlayerPrefs.Save();
            playSettingsChangedSFX();
            reloadGraphicSettings();
        });

        meshQ.onValueChanged.AddListener((int option) =>
        {
            PlayerPrefs.SetInt("meshQ", option);
            PlayerPrefs.Save();
            playSettingsChangedSFX();
            reloadGraphicSettings();
        });

        lightningQ.onValueChanged.AddListener((int option) =>
        {
            PlayerPrefs.SetInt("lightningQ", option);
            PlayerPrefs.Save();
            playSettingsChangedSFX();
            reloadGraphicSettings();
        });

        resolution.onValueChanged.AddListener((int option) =>
        {
            //resolution.options[resolution.value].text
            PlayerPrefs.SetString("resolution", option.ToString());
            PlayerPrefs.Save();
            playSettingsChangedSFX();
            reloadGraphicSettings();
        });

        
        Display display = Display.main;
        foreach (Vector2 res in resList)
        {
            if(res.x <= display.systemWidth && res.y <= display.systemHeight)
            {
                resolution.options.Add(new Dropdown.OptionData(res.x +"x"+res.y));
            }
        }

        
      //  initLOD();
        reloadSettings();

        if (settingsSections.Length != settingsSectionsBtns.Length) { Debug.LogError("IMBALANCED SETTINGS CONFIG!"); }
        else
        {
            for (int i = 0; i < settingsSectionsBtns.Length; i++)
            {
                int x = i;
                settingsSectionsBtns[x].onClick.AddListener(() => { onSettingsSectionClick(x); });
            }
        }
        onSettingsSectionClick(0);
    }
    GameObject[] hqLights;
    public void reloadSettings()
    {
        reloadGraphicSettings();
    }


    void onSettingsSectionClick(int i)
    {
        Debug.Log("Selected " + i + " button");
        for (int x = 0; x < settingsSectionsBtns.Length; x++)
        {
            settingsSectionsBtns[x].interactable = (x != i);
            settingsSections[x].SetActive((x == i));
        }
        reloadGraphicSettings();
        audSrc.PlayOneShot(settingsSectionSelectedSFX);
    }

    void playSettingsChangedSFX()
    {
        audSrc.PlayOneShot(settingsChangedSFX);
    }

    public void OnHoverSFX()
    {
        audSrc.PlayOneShot(onHoverSfx);
    }

    // Update is called once per frame
    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Escape))
        {
            hide();
        }

        if (canvasGroup.interactable && canvasGroup.alpha < 1)
        {
            canvasGroup.alpha += 0.05f;
        }
        if (!canvasGroup.interactable && canvasGroup.alpha > 0)
        {
            canvasGroup.alpha -= 0.05f;
        }
    }


    public void reloadGraphicSettings()
    {
        hqLights = GameObject.FindGameObjectsWithTag("HQLights");
        //Read all settings from prefs
        vsync.isOn = PlayerPrefs.GetInt("vsync") == 1;
        fullscreen.isOn = PlayerPrefs.GetInt("fullscreen") == 1;
        shadows.value = PlayerPrefs.GetInt("shadows");
        aa.value = PlayerPrefs.GetInt("aa");
        pp.value = PlayerPrefs.GetInt("pp");
        particles.value = PlayerPrefs.GetInt("particles");
        textureQ.value = PlayerPrefs.GetInt("textureQ");
        meshQ.value = PlayerPrefs.GetInt("meshQ");
        lightningQ.value = PlayerPrefs.GetInt("lightningQ");
        resolution.value = resolution.options.IndexOf(new Dropdown.OptionData(PlayerPrefs.GetString("resolution")));

        //APPLY EACH
        QualitySettings.vSyncCount = PlayerPrefs.GetInt("vsync");
        QualitySettings.softParticles = pp.value == 1;

        switch (shadows.value)
        {
            case 0:
                QualitySettings.shadows = ShadowQuality.All;
                QualitySettings.shadowResolution = ShadowResolution.VeryHigh;
                break;

            case 1:
                QualitySettings.shadows = ShadowQuality.All;
                QualitySettings.shadowResolution = ShadowResolution.High;
                break;

            case 2:
                QualitySettings.shadows = ShadowQuality.HardOnly;
                QualitySettings.shadowResolution = ShadowResolution.Medium;
                break;

            case 3:
                QualitySettings.shadows = ShadowQuality.HardOnly;
                QualitySettings.shadowResolution = ShadowResolution.Low;
                break;

            case 4:
                QualitySettings.shadows = ShadowQuality.Disable;
                break;
        }

        switch (aa.value)
        {
            case 0:
                QualitySettings.antiAliasing = 0;
                break;

            case 1:
                QualitySettings.antiAliasing = 2;
                break;

            case 2:
                QualitySettings.antiAliasing = 4;
                break;

            case 3:
                QualitySettings.antiAliasing = 8;
                break;
        }

        PostProcessVolume[] volumes = FindObjectsOfType<PostProcessVolume>();
        switch (pp.value)
        {

            case 0:                
                foreach (PostProcessVolume vol in volumes)
                {
                    vol.enabled = true;
                }
                break;

            case 3:
                foreach(PostProcessVolume vol in volumes)
                {
                    vol.enabled = false;
                }
                break;
        }

        QualitySettings.masterTextureLimit = (textureQ.value > 2)? 6 : textureQ.value;

     //   changeLodDef(meshQ.value);
        
        switch (lightningQ.value)
        {
            case 0:
                
                foreach(GameObject light in hqLights)
                {
                    if (light.GetComponent<Light>()) { continue; }
                    light.GetComponent<Light>().enabled = true;
                }
                break;

            case 1:
                foreach (GameObject light in hqLights)
                {
                    if (light.GetComponent<Light>()) { continue; }
                    light.GetComponent<Light>().enabled = false;
                }
                break;
        }

        Screen.fullScreen = fullscreen.isOn;

        string[] res = PlayerPrefs.GetString("resolution").Split('x');
        Screen.SetResolution(int.Parse(res[0]), int.Parse(res[1]), fullscreen.isOn);
    }


    public void initLOD()
    {
        LODGroup[] lods = FindObjectsOfType<LODGroup>();

        foreach(LODGroup lod in lods)
        {
            if (lod.lodCount != 3) { continue; }

            LODDataHolder data = lod.gameObject.AddComponent(typeof(LODDataHolder)) as LODDataHolder;

            // data.LODs = lod.GetLODs();
            List<Mesh> meshes = new List<Mesh>();

            Debug.Log($"Got {lod.lodCount} LODS");
            
            for (int i =0; i < lod.lodCount; i++)
            {                
                if(lod.GetLODs()[i].renderers.Length == 0) { continue; }

                if (lod.GetLODs()[i].renderers[0].GetComponent<MeshFilter>() == null) { Debug.Log("GOT EM!"); }

                if(lod.GetLODs()[i].renderers[0].GetComponent<MeshCollider>()!= null) { meshes.Add(lod.GetLODs()[i].renderers[0].GetComponent<MeshCollider>().sharedMesh); continue; }

                meshes.Add(lod.GetLODs()[i].renderers[0].GetComponent<MeshFilter>().mesh);
            }

            data.LODs = meshes.ToArray();
        }
    }

    public void changeLodDef(int value)
    {
        LODDataHolder[] lodsData = FindObjectsOfType<LODDataHolder>();
        foreach(LODDataHolder lodData in lodsData)
        {
            LODGroup lodGroup = lodData.GetComponent<LODGroup>();
            switch (value)
            {
                case 0:
                    lodGroup.GetLODs()[0].renderers[0].GetComponent<MeshFilter>().mesh = lodData.LODs[value];
                    lodGroup.ForceLOD(-1);
                    break;

                case 1:
                    lodGroup.GetLODs()[0].renderers[0].GetComponent<MeshFilter>().mesh = lodData.LODs[1];
                    lodGroup.ForceLOD(-1);
                    break;

                case 2:
                    lodGroup.ForceLOD(2);
                    break;
            }
            
            try
            {
                lodGroup.GetLODs()[0].renderers[0].GetComponent<MeshFilter>().mesh = lodData.LODs[value];
            }
            catch { Debug.Log(lodGroup.name); }
            try
            {
                lodGroup.GetLODs()[1].renderers[0].GetComponent<MeshFilter>().mesh = lodData.LODs[(value == 2) ? 2 : 1];
            }
            catch { Debug.Log(lodGroup.name); }
            try
            {
                lodGroup.GetLODs()[2].renderers[0].GetComponent<MeshFilter>().mesh = lodData.LODs[2];
            }
            catch { Debug.Log(lodGroup.name); }
        }
    }

}


public static class SettingPage
{
    public static settings instance;
}