public void Apply()
{
// Resolution
Resolution resolution = Screen.resolutions[resolutionDropdown.value];
FullScreenMode fsm = (FullScreenMode)fullscreenDropdown.value;
SettingsManager.settingsData.width = resolution.width;
SettingsManager.settingsData.height = resolution.height;
SettingsManager.settingsData.fullScreenMode = fullscreenDropdown.value;
Debug.Log(resolution.ToString());
Debug.Log(fsm);
Screen.SetResolution(resolution.width, resolution.height, fsm);
// Shadow Quality
SettingsManager.settingsData.shadowQuality = shadowQualityDropdown.value;
ShadowQuality sq = (ShadowQuality)shadowQualityDropdown.value;
Debug.Log(sq);
QualitySettings.shadows = sq;
// Shadow Distance
QualitySettings.shadowDistance = SettingsManager.settingsData.shadowDistance;
// Anisotropic Filtering
SettingsManager.settingsData.anisotropicFiltering = anisotropicFilteringDropdown.value;
AnisotropicFiltering af = (AnisotropicFiltering)anisotropicFilteringDropdown.value;
Debug.Log(af);
QualitySettings.anisotropicFiltering = af;
// Anti-Aliasing
QualitySettings.antiAliasing = SettingsManager.settingsData.antiAliasing;
}
// Use this for initialization
void Start()
{
//Resolution
fullScreen = Screen.fullScreen;
//Rendering
antiAliasing = QualitySettings.antiAliasing;
anisotropicFilt = QualitySettings.anisotropicFiltering;
textureQuality = QualitySettings.masterTextureLimit;
pixelLightCount = QualitySettings.pixelLightCount;
//Shadow
shadowProjection = QualitySettings.shadowProjection;
shadowDistance = QualitySettings.shadowDistance;
shadowCascade = QualitySettings.shadowCascades;
//Other
vSync = QualitySettings.vSyncCount;
particleRaycastBudget = QualitySettings.particleRaycastBudget;
frameRate = Application.targetFrameRate;
//FPS
frameUpdateTimer = new System.Timers.Timer(refreshRateMS);
frameUpdateTimer.Elapsed += new ElapsedEventHandler(frameUpdateTimer_Elapsed);
frameUpdateTimer.AutoReset = true;
frameUpdateTimer.Start();
//Volume
masterVolume = AudioListener.volume * 100;
}
//Apply loaded settings to the current game
private void applySettings()
{
if (myPlayer != null)
{
myPlayer.setMouseSens(mouseSpeed);
myPlayer.setFov(fov);
myPlayer.setVolume(volume);
}
AnisotropicFiltering filter = AnisotropicFiltering.Disable;
if (anisotropicFiltering)
{
filter = AnisotropicFiltering.ForceEnable;
}
int textureLimit = 2 - (int)textureSize;
QualitySettings.anisotropicFiltering = filter;
QualitySettings.antiAliasing = (int)antiAliasing;
QualitySettings.masterTextureLimit = textureLimit;
QualitySettings.pixelLightCount = (int)lightingLevel;
QualitySettings.shadowCascades = (int)lightingLevel;
QualitySettings.vSyncCount = (int)vsyncLevel;
}
static int IntToEnum(IntPtr L)
{
int arg0 = (int)LuaDLL.lua_tonumber(L, 1);
AnisotropicFiltering o = (AnisotropicFiltering)arg0;
LuaScriptMgr.PushEnum(L, o);
return(1);
}
public static void SetQuality(int index)
{
int wasVSync = QualitySettings.vSyncCount;
AnisotropicFiltering wasAnisotropic = QualitySettings.anisotropicFiltering;
QualitySettings.SetQualityLevel(index, true);
QualitySettings.anisotropicFiltering = wasAnisotropic;
QualitySettings.vSyncCount = wasVSync;
}
float RenderingGroup(float xStart, float yStart)
{
float xPos = xStart + 25;
float yPos = yStart + 25;
GUI.Label(new Rect(xPos, yPos, sWidthHeight.x, sWidthHeight.y), EUtils.UnityColoredText("Rendering", headingColor));
yPos = yPos + sWidthHeight.y;
//Anti Analysing
GUI.Label(new Rect(xPos, yPos, sWidthHeight.x, sWidthHeight.y), "Antialiasing: " + QualitySettings.antiAliasing);
antiAliasing = GUI.HorizontalSlider(new Rect(xPos + sWidthHeight.x, yPos, sWidthHeight.x, sWidthHeight.y), antiAliasing, 0, maxAntiAliasing);
if (antiAliasing != QualitySettings.antiAliasing)
{
antiAliasing = (int)Mathf.ClosestPowerOfTwo((int)antiAliasing);
if (antiAliasing == 1)
{
antiAliasing = 0;
}
QualitySettings.antiAliasing = (int)Mathf.ClosestPowerOfTwo((int)antiAliasing);
}
//End anti Analysing
//Anisotropic Filtering
yPos = yPos + sWidthHeight.y;
GUI.Label(new Rect(xPos, yPos, sWidthHeight.x, sWidthHeight.y), "Anisotropic Filtering: " + QualitySettings.anisotropicFiltering.ToString());
yPos = yPos + sWidthHeight.y;
if (GUI.Button(new Rect(xPos, yPos, bWidthHeight.x, bWidthHeight.y), AnisotropicFiltering.Disable.ToString()))
{
anisotropicFilt = AnisotropicFiltering.Disable;
}
if (GUI.Button(new Rect(xPos + bWidthHeight.x, yPos, bWidthHeight.x, bWidthHeight.y), AnisotropicFiltering.Enable.ToString()))
{
anisotropicFilt = AnisotropicFiltering.Enable;
}
if (GUI.Button(new Rect(xPos + (bWidthHeight.x * 2), yPos, bWidthHeight.x, bWidthHeight.y), AnisotropicFiltering.ForceEnable.ToString()))
{
anisotropicFilt = AnisotropicFiltering.ForceEnable;
}
QualitySettings.anisotropicFiltering = anisotropicFilt;
//End Anisotropic Filtering
//Texture Quality
yPos = yPos + bWidthHeight.y;
GUI.Label(new Rect(xPos, yPos, sWidthHeight.x, sWidthHeight.y), "Texture Quality(Beter to worse): " + QualitySettings.masterTextureLimit);
textureQuality = GUI.HorizontalSlider(new Rect(xPos + sWidthHeight.x, yPos, sWidthHeight.x, 25), textureQuality, 0, maxTextureQuality);
QualitySettings.masterTextureLimit = (int)textureQuality;
//End Texture Quality
//Pixel Light Count
yPos = yPos + sWidthHeight.y;
GUI.Label(new Rect(xPos, yPos, sWidthHeight.x, sWidthHeight.y), "Pixel Light Count: " + QualitySettings.pixelLightCount);
pixelLightCount = GUI.HorizontalSlider(new Rect(xPos + sWidthHeight.x, yPos, sWidthHeight.x, sWidthHeight.y), pixelLightCount, 0, maxPixelLightCount);
QualitySettings.pixelLightCount = (int)pixelLightCount;
//End Pixel Light Count
return(yPos);
}
public static void StoreRenderQuality()
{
anisotropicFiltering = QualitySettings.anisotropicFiltering;
antiAliasing = QualitySettings.antiAliasing;
lodBias = QualitySettings.lodBias;
maximumLODLevel = QualitySettings.maximumLODLevel;
pixelLightCount = QualitySettings.pixelLightCount;
shadowCascades = QualitySettings.shadowCascades;
shadowDistance = QualitySettings.shadowDistance;
softVegetation = QualitySettings.softVegetation;
}
internal void CopySettings(MenuSettings settings)
{
volume = settings.volume;
shadows = settings.shadows;
shadowsQuality = settings.shadowsQuality;
antiAliasing = settings.antiAliasing;
anisotropicFiltering = settings.anisotropicFiltering;
realTimeReflections = settings.realTimeReflections;
vSync = settings.vSync;
resolution = settings.resolution;
fullScreen = settings.fullScreen;
}
private void ApplyAnisotropic()
{
bool value = Settings.Get("AnisotropicFiltering", true);
AnisotropicFilteringToggle.isOn = value;
AnisotropicFiltering af = AnisotropicFiltering.Disable; if (value)
{
af = AnisotropicFiltering.Enable;
}
QualitySettings.anisotropicFiltering = af;
}
public MenuSettings()
{
volume = 1;
shadows = Shadow.Soft;
shadowsQuality = ShadowQuality.Ultra;
antiAliasing = AntiAliasing.X8;
anisotropicFiltering = AnisotropicFiltering.Enable;
realTimeReflections = true;
vSync = VSync.Half;
resolution = MaxResolution;
fullScreen = true;
}
private static int set_anisotropicFiltering(IntPtr L)
{
int result;
try
{
AnisotropicFiltering anisotropicFiltering = (int)ToLua.CheckObject(L, 2, typeof(AnisotropicFiltering));
Texture.set_anisotropicFiltering(anisotropicFiltering);
result = 0;
}
catch (Exception e)
{
result = LuaDLL.toluaL_exception(L, e, null);
}
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="isSet"></param>
public QualitySettingsKun(bool isSet) : base()
{
isDirty = false;
if (isSet)
{
activeColorSpace = QualitySettings.activeColorSpace;
anisotropicFiltering = QualitySettings.anisotropicFiltering;
antiAliasing = QualitySettings.antiAliasing;
asyncUploadBufferSize = QualitySettings.asyncUploadBufferSize;
asyncUploadPersistentBuffer = QualitySettings.asyncUploadPersistentBuffer;
asyncUploadTimeSlice = QualitySettings.asyncUploadTimeSlice;
billboardsFaceCameraPosition = QualitySettings.billboardsFaceCameraPosition;
desiredColorSpace = QualitySettings.desiredColorSpace;
lodBias = QualitySettings.lodBias;
masterTextureLimit = QualitySettings.masterTextureLimit;
maximumLODLevel = QualitySettings.maximumLODLevel;
maxQueuedFrames = QualitySettings.maxQueuedFrames;
names = QualitySettings.names;
particleRaycastBudget = QualitySettings.particleRaycastBudget;
pixelLightCount = QualitySettings.pixelLightCount;
realtimeReflectionProbes = QualitySettings.realtimeReflectionProbes;
resolutionScalingFixedDPIFactor = QualitySettings.resolutionScalingFixedDPIFactor;
shadowCascade2Split = QualitySettings.shadowCascade2Split;
mShadowCascade4Split = new Vector3Kun(QualitySettings.shadowCascade4Split);
shadowCascades = QualitySettings.shadowCascades;
shadowDistance = QualitySettings.shadowDistance;
shadowmaskMode = QualitySettings.shadowmaskMode;
shadowNearPlaneOffset = QualitySettings.shadowNearPlaneOffset;
shadowProjection = QualitySettings.shadowProjection;
shadowResolution = QualitySettings.shadowResolution;
shadows = QualitySettings.shadows;
#if UNITY_2019_1_OR_NEWER
skinWeights = QualitySettings.skinWeights;
#endif
softParticles = QualitySettings.softParticles;
softVegetation = QualitySettings.softVegetation;
streamingMipmapsActive = QualitySettings.streamingMipmapsActive;
streamingMipmapsAddAllCameras = QualitySettings.streamingMipmapsAddAllCameras;
streamingMipmapsMaxFileIORequests = QualitySettings.streamingMipmapsMaxFileIORequests;
streamingMipmapsMaxLevelReduction = QualitySettings.streamingMipmapsMaxLevelReduction;
streamingMipmapsMemoryBudget = QualitySettings.streamingMipmapsMemoryBudget;
streamingMipmapsRenderersPerFrame = QualitySettings.streamingMipmapsRenderersPerFrame;
vSyncCount = QualitySettings.vSyncCount;
}
}
/// <summary>
///
/// </summary>
/// <param name="binaryReader"></param>
public virtual void Deserialize(BinaryReader binaryReader)
{
activeColorSpace = (ColorSpace)binaryReader.ReadInt32();
anisotropicFiltering = (AnisotropicFiltering)binaryReader.ReadInt32();
antiAliasing = binaryReader.ReadInt32();
asyncUploadBufferSize = binaryReader.ReadInt32();
asyncUploadPersistentBuffer = binaryReader.ReadBoolean();
asyncUploadTimeSlice = binaryReader.ReadInt32();
billboardsFaceCameraPosition = binaryReader.ReadBoolean();
desiredColorSpace = (ColorSpace)binaryReader.ReadInt32();
lodBias = binaryReader.ReadSingle();
masterTextureLimit = binaryReader.ReadInt32();
maximumLODLevel = binaryReader.ReadInt32();
maxQueuedFrames = binaryReader.ReadInt32();
names = SerializerKun.DesirializeStrings(binaryReader);
particleRaycastBudget = binaryReader.ReadInt32();
pixelLightCount = binaryReader.ReadInt32();
realtimeReflectionProbes = binaryReader.ReadBoolean();
resolutionScalingFixedDPIFactor = binaryReader.ReadSingle();
shadowCascade2Split = binaryReader.ReadSingle();
mShadowCascade4Split = SerializerKun.DesirializeObject <Vector3Kun>(binaryReader);
shadowCascades = binaryReader.ReadInt32();
shadowDistance = binaryReader.ReadSingle();
shadowmaskMode = (ShadowmaskMode)binaryReader.ReadInt32();
shadowNearPlaneOffset = binaryReader.ReadSingle();
shadowProjection = (ShadowProjection)binaryReader.ReadInt32();
shadowResolution = (ShadowResolution)binaryReader.ReadInt32();
shadows = (ShadowQuality)binaryReader.ReadInt32();
#if UNITY_2019_1_OR_NEWER
skinWeights = (SkinWeights)binaryReader.ReadInt32();
#endif
softParticles = binaryReader.ReadBoolean();
softVegetation = binaryReader.ReadBoolean();
streamingMipmapsActive = binaryReader.ReadBoolean();
streamingMipmapsAddAllCameras = binaryReader.ReadBoolean();
streamingMipmapsMaxFileIORequests = binaryReader.ReadInt32();
streamingMipmapsMaxLevelReduction = binaryReader.ReadInt32();
streamingMipmapsMemoryBudget = binaryReader.ReadSingle();
streamingMipmapsRenderersPerFrame = binaryReader.ReadInt32();
vSyncCount = binaryReader.ReadInt32();
isDirty = binaryReader.ReadBoolean();
}
/// <summary>
/// Gets the int TO anisotropic filtering.
/// </summary>
/// <returns>The int TO anisotropic filtering.</returns>
/// <param name="value">Value.</param>
public static AnisotropicFiltering GetIntTOAnisotropicFiltering(int value)
{
AnisotropicFiltering aniso = AnisotropicFiltering.Disable;
switch (value)
{
case 0:
aniso = AnisotropicFiltering.Disable;
break;
case 1:
aniso = AnisotropicFiltering.Enable;
break;
case 2:
aniso = AnisotropicFiltering.ForceEnable;
break;
}
return(aniso);
}
/// <summary>
/// Gets the anisotropic filtering from application to int.
/// </summary>
/// <returns>The anisotropic filtering from application to int.</returns>
public static int GetAnisotropicFilteringToInt()
{
AnisotropicFiltering aniso = QualitySettings.anisotropicFiltering;
int result = 0;
switch (aniso)
{
case AnisotropicFiltering.Disable:
result = 0;
break;
case AnisotropicFiltering.Enable:
result = 1;
break;
case AnisotropicFiltering.ForceEnable:
result = 2;
break;
}
return(result);
}
private void LoadAllValues()
{
tog_fullScreen.isOn = Screen.fullScreen;
tog_vSync.isOn = (QualitySettings.vSyncCount > 0);
plac_targetFPS.text = Application.targetFrameRate.ToString();
slid_texQuality.value = slid_texQuality.maxValue - QualitySettings.masterTextureLimit;
AnisotropicFiltering aniso = QualitySettings.anisotropicFiltering;
if (aniso.Equals(AnisotropicFiltering.Disable))
{
slid_aniso.value = slid_aniso.minValue;
}
else if (aniso.Equals(AnisotropicFiltering.Enable))
{
slid_aniso.value = 1f;
}
else if (aniso.Equals(AnisotropicFiltering.ForceEnable))
{
slid_aniso.value = slid_aniso.maxValue;
}
int aaValue = QualitySettings.antiAliasing;
if (aaValue == 0)
{
slid_antialias.value = slid_antialias.minValue;
}
else if (aaValue == 2)
{
slid_antialias.value = 1f;
}
else if (aaValue == 4)
{
slid_antialias.value = 2f;
}
else if (aaValue == 8)
{
slid_antialias.value = slid_antialias.maxValue;
}
ShadowQuality shadowQual = QualitySettings.shadows;
if (shadowQual.Equals(ShadowQuality.Disable))
{
slid_shadows.value = slid_shadows.minValue;
}
else if (shadowQual.Equals(ShadowQuality.HardOnly))
{
slid_shadows.value = 1f;
}
else if (shadowQual.Equals(ShadowQuality.All))
{
slid_shadows.value = slid_shadows.maxValue;
}
ShadowResolution shadowRes = QualitySettings.shadowResolution;
if (shadowRes.Equals(ShadowResolution.Low))
{
slid_shadowRes.value = slid_shadowRes.minValue;
}
else if (shadowRes.Equals(ShadowResolution.Medium))
{
slid_shadowRes.value = 1f;
}
else if (shadowRes.Equals(ShadowResolution.High))
{
slid_shadowRes.value = 2f;
}
else if (shadowRes.Equals(ShadowResolution.VeryHigh))
{
slid_shadowRes.value = slid_shadowRes.maxValue;
}
ShadowProjection shadowProj = QualitySettings.shadowProjection;
if (shadowProj.Equals(ShadowProjection.CloseFit))
{
slid_shadowProj.value = slid_shadowProj.minValue;
}
else if (shadowProj.Equals(ShadowProjection.StableFit))
{
slid_shadowProj.value = slid_shadowProj.maxValue;
}
int shadowCasc = QualitySettings.shadowCascades;
if (shadowCasc == 1)
{
slid_shadowCasc.value = slid_shadowCasc.minValue;
}
else if (shadowCasc == 2)
{
slid_shadowCasc.value = 1f;
}
else if (shadowCasc == 4)
{
slid_shadowCasc.value = slid_shadowCasc.maxValue;
}
plac_shadowDist.text = ((int)QualitySettings.shadowDistance).ToString();
plac_pixelLights.text = QualitySettings.pixelLightCount.ToString();
}
void SetAnisotropicFiltering(AnisotropicFiltering state)
{
QualitySettings.anisotropicFiltering = state;
}
public static void SetAnisotropicFiltering(AnisotropicFiltering mode)
{
QualitySettings.anisotropicFiltering = mode;
}
public static void SaveScreenshot(this Camera cam, string name, int width, int height, bool transparent, int SuperSampleSize)
{
RenderTexture temporary = RenderTexture.GetTemporary(width * SuperSampleSize, height * SuperSampleSize, 24, RenderTextureFormat.ARGB32, RenderTextureReadWrite.sRGB);
Color color = cam.backgroundColor;
CameraClearFlags cameraClearFlag = cam.clearFlags;
RenderTexture renderTexture = cam.targetTexture;
int num = QualitySettings.antiAliasing;
AnisotropicFiltering anisotropicFiltering = QualitySettings.anisotropicFiltering;
bool flag = GL.sRGBWrite;
GameObject gameObject = new GameObject();
cam.forceIntoRenderTexture = true;
cam.targetTexture = temporary;
cam.aspect = 1f;
cam.renderingPath = RenderingPath.UsePlayerSettings;
cam.rect = new Rect(0f, 0f, 1f, 1f);
cam.allowHDR = true;
Texture.SetGlobalAnisotropicFilteringLimits(16, 16);
QualitySettings.anisotropicFiltering = AnisotropicFiltering.ForceEnable;
QualitySettings.antiAliasing = 8;
if (transparent)
{
cam.clearFlags = CameraClearFlags.Depth;
cam.backgroundColor = new Color(0f, 0f, 0f, 0f);
}
RenderTexture.active = temporary;
GL.Clear(true, true, new Color(0f, 0f, 0f, 0f));
GL.sRGBWrite = true;
cam.Render();
RenderTexture.active = null;
RenderTexture.active = temporary;
Texture2D texture2D = new Texture2D(temporary.width, temporary.height, TextureFormat.ARGB32, true);
texture2D.ReadPixels(new Rect(0f, 0f, (float)temporary.width, (float)temporary.height), 0, 0, true);
texture2D.filterMode = FilterMode.Trilinear;
texture2D.anisoLevel = 32;
RenderTexture.active = null;
cam.targetTexture = renderTexture;
QualitySettings.antiAliasing = num;
QualitySettings.anisotropicFiltering = anisotropicFiltering;
Texture.SetGlobalAnisotropicFilteringLimits(1, 16);
if (SuperSampleSize != 1)
{
texture2D.Apply();
RenderTexture temporary1 = RenderTexture.GetTemporary(width, height, 24, RenderTextureFormat.ARGB32, RenderTextureReadWrite.sRGB);
RenderTexture.active = temporary1;
GL.Clear(true, true, new Color(0f, 0f, 0f, 0f));
GL.sRGBWrite = true;
Graphics.Blit(texture2D, temporary1);
texture2D.Resize(width, height);
texture2D.ReadPixels(new Rect(0f, 0f, (float)width, (float)height), 0, 0);
RenderTexture.active = null;
texture2D.Apply();
RenderTexture.ReleaseTemporary(temporary1);
}
byte[] pNG = texture2D.EncodeToPNG();
string directoryName = Path.GetDirectoryName(name);
if (!Directory.Exists(directoryName))
{
Directory.CreateDirectory(directoryName);
}
File.WriteAllBytes(name, pNG);
UnityEngine.Object.DestroyImmediate(texture2D, true);
RenderTexture.ReleaseTemporary(temporary);
UnityEngine.Object.DestroyImmediate(gameObject, true);
if (transparent)
{
cam.clearFlags = cameraClearFlag;
cam.backgroundColor = color;
}
GL.sRGBWrite = flag;
}
public void In([FriendlyName("Value", "The value to set on this quality setting.")] AnisotropicFiltering Value)
{
QualitySettings.anisotropicFiltering = Value;
}
public void In([FriendlyName("Value", "The current value for this quality setting level.")] out AnisotropicFiltering Value)
{
Value = QualitySettings.anisotropicFiltering;
}
void Awake()
{
buffer = new CommandBuffer();
uniqueTextureID = Shader.PropertyToID(ReflectionSample);
if (!normalTrans)
{
normalTrans = new GameObject("Normal Trans").transform;
normalTrans.position = transform.position;
normalTrans.rotation = transform.rotation;
normalTrans.SetParent(transform);
}
render = GetComponent <Renderer>();
if (!render || !render.sharedMaterial)
{
Destroy(this);
}
for (int i = 0; i < allMirrors.Length; ++i)
{
allMirrors[i].manager = this;
}
for (int i = 0, length = render.sharedMaterials.Length; i < length; ++i)
{
Material m = render.sharedMaterials[i];
if (!allMats.Contains(m))
{
allMats.Add(m);
}
}
for (int i = 0; i < allMirrors.Length; ++i)
{
Renderer r = allMirrors[i].GetRenderer();
for (int a = 0, length = r.sharedMaterials.Length; a < length; ++a)
{
Material m = r.sharedMaterials[a];
if (!allMats.Contains(m))
{
allMats.Add(m);
}
}
}
switch (renderQuality)
{
case RenderQuality.Default:
postProcessAction = () => reflectionCamera.Render();
break;
case RenderQuality.High:
postProcessAction = () =>
{
billboard = QualitySettings.billboardsFaceCameraPosition;
QualitySettings.billboardsFaceCameraPosition = false;
softParticle = QualitySettings.softParticles;
softVeg = QualitySettings.softVegetation;
QualitySettings.softParticles = false;
QualitySettings.softVegetation = false;
ani = QualitySettings.anisotropicFiltering;
QualitySettings.anisotropicFiltering = AnisotropicFiltering.Disable;
shaR = QualitySettings.shadowResolution;
QualitySettings.shadowResolution = ShadowResolution.High;
reflectionCamera.Render();
QualitySettings.softParticles = softParticle;
QualitySettings.softVegetation = softVeg;
QualitySettings.billboardsFaceCameraPosition = billboard;
QualitySettings.anisotropicFiltering = ani;
QualitySettings.shadowResolution = shaR;
};
break;
case RenderQuality.Medium:
postProcessAction = () =>
{
softParticle = QualitySettings.softParticles;
softVeg = QualitySettings.softVegetation;
QualitySettings.softParticles = false;
QualitySettings.softVegetation = false;
billboard = QualitySettings.billboardsFaceCameraPosition;
QualitySettings.billboardsFaceCameraPosition = false;
shadowQuality = QualitySettings.shadows;
QualitySettings.shadows = ShadowQuality.HardOnly;
ani = QualitySettings.anisotropicFiltering;
QualitySettings.anisotropicFiltering = AnisotropicFiltering.Disable;
shaR = QualitySettings.shadowResolution;
QualitySettings.shadowResolution = ShadowResolution.Low;
reflectionCamera.Render();
QualitySettings.softParticles = softParticle;
QualitySettings.softVegetation = softVeg;
QualitySettings.shadows = shadowQuality;
QualitySettings.billboardsFaceCameraPosition = billboard;
QualitySettings.anisotropicFiltering = ani;
QualitySettings.shadowResolution = shaR;
};
break;
case RenderQuality.Low:
postProcessAction = () =>
{
softParticle = QualitySettings.softParticles;
softVeg = QualitySettings.softVegetation;
QualitySettings.softParticles = false;
QualitySettings.softVegetation = false;
shadowQuality = QualitySettings.shadows;
QualitySettings.shadows = ShadowQuality.Disable;
ani = QualitySettings.anisotropicFiltering;
QualitySettings.anisotropicFiltering = AnisotropicFiltering.Disable;
reflectionCamera.Render();
QualitySettings.softParticles = softParticle;
QualitySettings.softVegetation = softVeg;
QualitySettings.shadows = shadowQuality;
QualitySettings.anisotropicFiltering = ani;
};
break;
case RenderQuality.VeryLow:
postProcessAction = () =>
{
ani = QualitySettings.anisotropicFiltering;
QualitySettings.anisotropicFiltering = AnisotropicFiltering.Disable;
reflectionCamera.Render();
QualitySettings.anisotropicFiltering = ani;
};
break;
}
m_SqrMaxdistance = m_maxDistance * m_maxDistance;
widthHeightRate = (float)Screen.height / (float)Screen.width;
m_ReflectionTexture = new RenderTexture(m_TextureSize, (int)(m_TextureSize * widthHeightRate + 0.5), 24, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Default);
m_ReflectionTexture.name = "ReflectionTex " + GetInstanceID();
m_ReflectionTexture.isPowerOfTwo = true;
m_ReflectionTexture.filterMode = FilterMode.Trilinear;
m_ReflectionTexture.antiAliasing = (int)antiAlias;
GameObject go = new GameObject("MirrorCam", typeof(Camera), typeof(FlareLayer));
//go.hideFlags = HideFlags.HideAndDontSave;
reflectionCamera = go.GetComponent <Camera>();
//mysky = go.AddComponent<Skybox> ();
go.transform.SetParent(normalTrans);
go.transform.localPosition = Vector3.zero;
reflectionCamera.enabled = false;
reflectionCamera.targetTexture = m_ReflectionTexture;
reflectionCamera.cullingMask = ~(1 << 4) & m_ReflectLayers.value;
reflectionCamera.layerCullSpherical = enableSelfCullingDistance;
refT = reflectionCamera.transform;
if (!enableSelfCullingDistance)
{
for (int i = 0, length = layerCullingDistances.Length; i < length; ++i)
{
layerCullingDistances[i] = 0;
}
}
else
{
reflectionCamera.layerCullDistances = layerCullingDistances;
}
reflectionCamera.useOcclusionCulling = false; //Custom Projection Camera should not use occlusionCulling!
SetTexture(m_ReflectionTexture);
buffer.name = "Postprocessing Buffer";
if (addPostProcessingComponent)
{
buffer.GetTemporaryRT(ShaderIDs._TempTex, m_ReflectionTexture.descriptor);
buffer.BlitSRT(BuiltinRenderTextureType.CameraTarget, ShaderIDs._TempTex, EdgeBlurAAMaterial, 0);
buffer.BlitSRT(ShaderIDs._TempTex, BuiltinRenderTextureType.CameraTarget, FXAAMateiral, 0);
buffer.ReleaseTemporaryRT(ShaderIDs._TempTex);
reflectionCamera.AddCommandBuffer(CameraEvent.AfterForwardAlpha, buffer);
}
}
public void DrawMenuSettings(SerializedProperty sett, string label, uint expandSpace = 0)
{
sett.isExpanded = EditorGUILayout.Foldout(sett.isExpanded, label);
if (sett.isExpanded)
{
EditorGUI.indentLevel++;
settingsFileName.stringValue = EditorGUILayout.TextField("File Name", settingsFileName.stringValue);
SerializedProperty volume = sett.FindPropertyRelative("volume");
SerializedProperty shadows = sett.FindPropertyRelative("shadows");
SerializedProperty shadowsQuality = sett.FindPropertyRelative("shadowsQuality");
SerializedProperty antiAliasing = sett.FindPropertyRelative("antiAliasing");
SerializedProperty anisotropicFiltering = sett.FindPropertyRelative("anisotropicFiltering");
SerializedProperty realTimeReflections = sett.FindPropertyRelative("realTimeReflections");
SerializedProperty vSync = sett.FindPropertyRelative("vSync");
SerializedProperty resolution = sett.FindPropertyRelative("resolution");
SerializedProperty fullScreen = sett.FindPropertyRelative("fullScreen");
MenuSettings.Shadow shadowsE = (MenuSettings.Shadow)shadows.enumValueIndex;
MenuSettings.ShadowQuality shadowsQualityE = (MenuSettings.ShadowQuality)shadowsQuality.enumValueIndex;
MenuSettings.AntiAliasing antiAliasingE = (MenuSettings.AntiAliasing)antiAliasing.enumValueIndex;
AnisotropicFiltering AF = (AnisotropicFiltering)anisotropicFiltering.enumValueIndex;
MenuSettings.VSync vSyncE = (MenuSettings.VSync)vSync.enumValueIndex;
volume.floatValue = EditorGUILayout.Slider("Volume", volume.floatValue, 0, 1);
shadowsE = (MenuSettings.Shadow)EditorGUILayout.EnumPopup("Shadows", shadowsE);
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Shadows Quality");
shadowsQualityE = (MenuSettings.ShadowQuality)EditorGUILayout.EnumPopup(shadowsQualityE);
EditorGUILayout.EndHorizontal();
antiAliasingE = (MenuSettings.AntiAliasing)EditorGUILayout.EnumPopup("AntiAliasing", antiAliasingE);
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Anisotropic Filtering");
AF = (AnisotropicFiltering)EditorGUILayout.EnumPopup(AF);
EditorGUILayout.EndHorizontal();
shadows.enumValueIndex = (int)shadowsE;
shadowsQuality.enumValueIndex = (int)shadowsQualityE;
antiAliasing.enumValueIndex = (int)antiAliasingE;
anisotropicFiltering.enumValueIndex = (int)AF;
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("RealTime Reflections");
realTimeReflections.boolValue = EditorGUILayout.Toggle(realTimeReflections.boolValue);
EditorGUILayout.EndHorizontal();
vSyncE = (MenuSettings.VSync)EditorGUILayout.EnumPopup("V-Sync", vSyncE);
vSync.enumValueIndex = (int)vSyncE;
resolution.intValue = EditorGUILayout.IntField("Resolution Index", resolution.intValue);
fullScreen.boolValue = EditorGUILayout.Toggle("Full Screen", fullScreen.boolValue);
EditorGUI.indentLevel--;
InspectorTools.Space(expandSpace);
}
}
public override int GetHashCode()
{
int hash = 1;
if (Name.Length != 0)
{
hash ^= Name.GetHashCode();
}
if (TextureQuality != 0)
{
hash ^= TextureQuality.GetHashCode();
}
if (ShaderLod != 0)
{
hash ^= ShaderLod.GetHashCode();
}
if (DefaultTargetFps != 0)
{
hash ^= DefaultTargetFps.GetHashCode();
}
if (Antialiasing != 0)
{
hash ^= Antialiasing.GetHashCode();
}
if (AnisotropicFiltering != 0)
{
hash ^= AnisotropicFiltering.GetHashCode();
}
if (BillboardsFaceCameraPosition != false)
{
hash ^= BillboardsFaceCameraPosition.GetHashCode();
}
if (RealtimeShadows != 0)
{
hash ^= RealtimeShadows.GetHashCode();
}
if (ArAzimuthBlurring != false)
{
hash ^= ArAzimuthBlurring.GetHashCode();
}
hash ^= GamemodeOverrides.GetHashCode();
if (ArEncounterParticleCap != 0)
{
hash ^= ArEncounterParticleCap.GetHashCode();
}
if (LockedEncounterParticleCap != 0)
{
hash ^= LockedEncounterParticleCap.GetHashCode();
}
if (MenuParticleCap != 0)
{
hash ^= MenuParticleCap.GetHashCode();
}
if (ArAzimuthColorGrading != false)
{
hash ^= ArAzimuthColorGrading.GetHashCode();
}
if (ShadowMapSize != 0)
{
hash ^= ShadowMapSize.GetHashCode();
}
if (EncounterCameraTargetScaling != 0)
{
hash ^= EncounterCameraTargetScaling.GetHashCode();
}
if (AdvancedArCameraResolution != 0)
{
hash ^= AdvancedArCameraResolution.GetHashCode();
}
if (VfxLod != 0)
{
hash ^= VfxLod.GetHashCode();
}
if (ForceSimpleAr != false)
{
hash ^= ForceSimpleAr.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
public void UpdateAnisotropicFiltering(AnisotropicFiltering AF)
{
QualitySettings.anisotropicFiltering = AF;
}
void Death()
{
isDead = true;
AnisotropicFiltering.SetTrigger("Die");
}
private void ResetToDefault()
{
//Default
antiAliasing = QualitySettings.antiAliasing;
anisotropicFilt = QualitySettings.anisotropicFiltering;
textureQuality = QualitySettings.masterTextureLimit;
pixelLightCount = QualitySettings.pixelLightCount;
//Shadow
shadowProjection = QualitySettings.shadowProjection;
maxShadowDistance = QualitySettings.shadowDistance;
shadowCascade = QualitySettings.shadowCascades;
//Other
vSync = QualitySettings.vSyncCount;
particleRaycastBudget = QualitySettings.particleRaycastBudget;
frameRate = Application.targetFrameRate;
LoDLevel = QualitySettings.maximumLODLevel;
LoDBias = QualitySettings.lodBias;
//fog
Configuration.instance.fogClassic = Configuration.defaults.fogClassic;
Configuration.Save();
SetFogClassicOptions();
qData.AddToValues("DONT_REMOVE_THIS", "ELSE_IT_RESETS!");
//Save
Save(saveTag + GetName(new { antiAliasing }), antiAliasing);
float anisoFloat = -1;
if (anisotropicFilt == AnisotropicFiltering.Disable)
{
anisoFloat = 0;
}
if (anisotropicFilt == AnisotropicFiltering.Enable)
{
anisoFloat = 1;
}
if (anisotropicFilt == AnisotropicFiltering.ForceEnable)
{
anisoFloat = 2;
}
Save(saveTag + GetName(new { anisotropicFilt }), anisoFloat);
Save(saveTag + GetName(new { textureQuality }), textureQuality);
Save(saveTag + GetName(new { pixelLightCount }), pixelLightCount);
float shadowProjFloat = -1;
if (shadowProjection == ShadowProjection.CloseFit)
{
shadowProjFloat = 0;
}
if (shadowProjection == ShadowProjection.StableFit)
{
shadowProjFloat = 1;
}
Save(saveTag + GetName(new { shadowProjection }), shadowProjFloat);
Save(saveTag + GetName(new { shadowDistance = maxShadowDistance }), maxShadowDistance);
Save(saveTag + GetName(new { shadowCascade }), shadowCascade);
Save(saveTag + GetName(new { vSync }), vSync);
Save(saveTag + GetName(new { particleRaycastBudget }), particleRaycastBudget);
Save(saveTag + GetName(new { frameRate }), frameRate);
Save(saveTag + GetName(new { LoDLevel }), LoDLevel);
Save(saveTag + GetName(new { LoDBias }), LoDBias);
}
bool InitGrab(int width, int height, int aasamples)
{
blendtable = new MGBlendTable(32, 32, totalSegments, 0.4f, true);
if ( ResUpscale < 1 )
ResUpscale = 1;
if ( AASamples < 1 )
AASamples = 1;
if ( SrcCamera == null )
SrcCamera = Camera.main;
if ( SrcCamera == null )
{
Debug.Log("No Camera set as source and no main camera found in the scene");
return false;
}
CalcDOFInfo(SrcCamera);
if ( OutputFormat == IMGFormat.Tga )
output1 = new byte[(width * ResUpscale) * (height * ResUpscale) * 3];
else
outputjpg = new Color[(width * ResUpscale) * (height * ResUpscale)];
if ( output1 != null || outputjpg != null )
{
filtering = QualitySettings.anisotropicFiltering;
QualitySettings.anisotropicFiltering = FilterMode;
grabtex = new Texture2D(width, height, TextureFormat.RGB24, false);
if ( grabtex != null )
{
accbuf = new Color[width, height];
blendbuf = new Color[width, height];
if ( accbuf != null )
{
float l = (1.0f - Blur) * 0.5f;
float h = 1.0f + ((Blur - 1.0f) * 0.5f);
if ( UseJitter)
{
poisson = new Vector2[aasamples];
sampcount = aasamples;
for ( int i = 0; i < aasamples; i++ )
{
Vector2 pos = new Vector2();
pos.x = Mathf.Lerp(l, h, UnityEngine.Random.value);
pos.y = Mathf.Lerp(l, h, UnityEngine.Random.value);
poisson[i] = pos;
}
}
else
{
int samples = (int)Mathf.Sqrt((float)aasamples);
if ( samples < 1 )
samples = 1;
sampcount = samples * samples;
poisson = new Vector2[samples * samples];
int i = 0;
for ( int ya = 0; ya < samples; ya++ )
{
for ( int xa = 0; xa < samples; xa++ )
{
float xa1 = ((float)xa / (float)samples);
float ya1 = ((float)ya / (float)samples);
Vector2 pos = new Vector2();
pos.x = Mathf.Lerp(l, h, xa1);
pos.y = Mathf.Lerp(l, h, ya1);
poisson[i++] = pos;
}
}
}
return true;
}
}
}
Debug.Log("Cant create a large enough texture, Try lower ResUpscale value");
return false;
}
bool InitGrab(int width, int height, int aasamples)
{
blendtable = new MGBlendTable(32, 32, totalSegments, 0.4f, true);
if (ResUpscale < 1)
{
ResUpscale = 1;
}
if (AASamples < 1)
{
AASamples = 1;
}
if (SrcCamera == null)
{
SrcCamera = Camera.main;
}
if (SrcCamera == null)
{
Debug.Log("No Camera set as source and no main camera found in the scene");
return(false);
}
CalcDOFInfo(SrcCamera);
if (OutputFormat == IMGFormat.Tga)
{
output1 = new byte[(width * ResUpscale) * (height * ResUpscale) * 3];
}
else
{
outputjpg = new Color[(width * ResUpscale) * (height * ResUpscale)];
}
if (output1 != null || outputjpg != null)
{
filtering = QualitySettings.anisotropicFiltering;
QualitySettings.anisotropicFiltering = FilterMode;
grabtex = new Texture2D(width, height, TextureFormat.RGB24, false);
if (grabtex != null)
{
accbuf = new Color[width, height];
blendbuf = new Color[width, height];
if (accbuf != null)
{
float l = (1.0f - Blur) * 0.5f;
float h = 1.0f + ((Blur - 1.0f) * 0.5f);
if (UseJitter)
{
poisson = new Vector2[aasamples];
sampcount = aasamples;
for (int i = 0; i < aasamples; i++)
{
Vector2 pos = new Vector2();
pos.x = Mathf.Lerp(l, h, UnityEngine.Random.value);
pos.y = Mathf.Lerp(l, h, UnityEngine.Random.value);
poisson[i] = pos;
}
}
else
{
int samples = (int)Mathf.Sqrt((float)aasamples);
if (samples < 1)
{
samples = 1;
}
sampcount = samples * samples;
poisson = new Vector2[samples * samples];
int i = 0;
for (int ya = 0; ya < samples; ya++)
{
for (int xa = 0; xa < samples; xa++)
{
float xa1 = ((float)xa / (float)samples);
float ya1 = ((float)ya / (float)samples);
Vector2 pos = new Vector2();
pos.x = Mathf.Lerp(l, h, xa1);
pos.y = Mathf.Lerp(l, h, ya1);
poisson[i++] = pos;
}
}
}
return(true);
}
}
}
Debug.Log("Cant create a large enough texture, Try lower ResUpscale value");
return(false);
}
/*
* private ScreenSpaceAmbientOcclusion sSAOC;
* private ScreenSpaceAmbientObscurance sSAOB;
* private EdgeDetection edgeDetection;
* private CreaseShading creaseShading;
*/
/* Fog */
/*
* private float m_3DFogAmount = 0f;
* private float m_3DFogAmountMax = 1f;
*
* private float m_3DFogStart = 0f;
* private float m_3DFogStartMax = 1f;
*
* private float m_3DFogDistance = 0;
* private float m_3DFogDistanceMax = 100000f;
*
* private float m_3DNoiseStepSize = 0f;
* private float m_3DNoiseStepSizeMax = 120f;
*
* private float m_3DNoiseScale = 0;
* private float m_3DNoiseScaleMax = 1f;
*/
//Game
//private bool useButtons;
//private bool useCollision;
// Use this for initialization
void Start()
{
//Resolution
fullScreen = Screen.fullScreen;
/*
* //Rendering
* antiAliasing = QualitySettings.antiAliasing;
* anisotropicFilt = QualitySettings.anisotropicFiltering;
* textureQuality = QualitySettings.masterTextureLimit;
* pixelLightCount = QualitySettings.pixelLightCount;
* //Shadow
* shadowProjection = QualitySettings.shadowProjection;
* shadowDistance = QualitySettings.shadowDistance;
* shadowCascade = QualitySettings.shadowCascades;
* //Other
* vSync = QualitySettings.vSyncCount;
* particleRaycastBudget = QualitySettings.particleRaycastBudget;
* frameRate = Application.targetFrameRate;
*
* LoDLevel = QualitySettings.maximumLODLevel;
* LoDBias = QualitySettings.lodBias;*/
//FPS
frameUpdateTimer = new Timer(refreshRateMS);
frameUpdateTimer.Elapsed += new ElapsedEventHandler(frameUpdateTimer_Elapsed);
frameUpdateTimer.AutoReset = true;
frameUpdateTimer.Start();
optionWindowRect = new Rect((Screen.width / 2) - (optionWindowRect.width / 2), (Screen.height / 2) - (optionWindowRect.height / 2), optionWindowRect.width, optionWindowRect.height);
cameraBehaviours = Camera.main.GetComponents <MonoBehaviour>() as MonoBehaviour[];
//Get MonoBehaviours here.
foreach (var t in FindObjectsOfType <MonoBehaviour>())
{
var properties = t as RenderProperties;
if (properties != null)
{
this.renderProperties = properties;
}
var properties1 = t as DayNightProperties;
if (properties1 != null)
{
this.dayNightProperties = properties1;
}
var properties2 = t as DayNightCloudsProperties;
if (properties2 != null)
{
this.dayNightCloudsProperties = properties2;
}
var properties3 = t as FogProperties;
if (properties3 != null)
{
this.fogProperties = properties3;
}
}
//m_fogHeight = (float)EUtils.GetFieldValue(renderProperties,"m_fogHeight");
/*
* m_fogHeight = (float)EUtils.GetFieldValue(renderProperties,"m_fogHeight");
* EUtils.SetFieldValue(renderProperties,"m_fogHeight",m_fogHeight);
*
* m_edgeFogDistance = (float)EUtils.GetFieldValue(renderProperties,"m_edgeFogDistance");
* EUtils.SetFieldValue(renderProperties,"m_edgeFogDistance",m_edgeFogDistance);
*
* m_useVolumeFog = (bool)EUtils.GetFieldValue(renderProperties,"m_useVolumeFog");
* EUtils.SetFieldValue(renderProperties,"m_useVolumeFog",m_useVolumeFog);
*
* m_volumeFogDensity = (float)EUtils.GetFieldValue(renderProperties,"m_volumeFogDensity");
* EUtils.SetFieldValue(renderProperties,"m_volumeFogDensity",m_volumeFogDensity);
*
* m_volumeFogStart = (float)EUtils.GetFieldValue(renderProperties,"m_volumeFogStart");
* EUtils.SetFieldValue(renderProperties,"m_volumeFogStart",m_volumeFogStart);
*
* m_volumeFogDistance = (float)EUtils.GetFieldValue(renderProperties,"m_volumeFogDistance");
* EUtils.SetFieldValue(renderProperties,"m_volumeFogDistance",m_volumeFogDistance);
*
* m_pollutionFogIntensity = (float)EUtils.GetFieldValue(renderProperties,"m_pollutionFogIntensity");
* EUtils.SetFieldValue(renderProperties,"m_pollutionFogIntensity",m_pollutionFogIntensity);
*/
/* Fog */
/*
* m_3DFogAmount = (float)EUtils.GetFieldValue(GetCameraBehaviour("FogEffect"),"m_3DFogAmount");
* m_3DFogStart = (float)EUtils.GetFieldValue(GetCameraBehaviour("FogEffect"),"m_3DFogStart");
* m_3DFogDistance = (float)EUtils.GetFieldValue(GetCameraBehaviour("FogEffect"),"m_3DFogDistance");
* m_3DNoiseStepSize = (float)EUtils.GetFieldValue(GetCameraBehaviour("FogEffect"),"m_3DNoiseStepSize");
* m_3DNoiseScale = (float)EUtils.GetFieldValue(GetCameraBehaviour("FogEffect"),"m_3DNoiseScale");
*/
//Added Effects
/*
* sSAOC = Camera.main.gameObject.AddComponent<ScreenSpaceAmbientOcclusion>();
* sSAOB = Camera.main.gameObject.AddComponent<ScreenSpaceAmbientObscurance>();
* edgeDetection = Camera.main.gameObject.AddComponent<EdgeDetection>();
* creaseShading = Camera.main.gameObject.AddComponent<CreaseShading>();
*
* sSAOC.enabled = false;
* sSAOB.enabled = false;
* edgeDetection.enabled = false;
* creaseShading.enabled = false;*/
//QugetFileLoader Alpha.
filePath = Application.persistentDataPath + "\\qMoreOptionsConfig.qgt";
QLoader qLoader = new QLoader(filePath);
qData = qLoader.qData;
if (qData == null)
{
qData = new QData();
}
if (qData.GetValueByKey("DONT_REMOVE_THIS") == null)
{
//OVERRIDE
qData.AddToValues("DONT_REMOVE_THIS", "ELSE_IT_RESETS!");
ResetToDefault();
}
else
{
//Default
antiAliasing = Load(saveTag + GetName(new { antiAliasing }));
//anisotropicFilt = Load(saveTag + GetName (new { anisotropicFilt }));
float anisoFloat = Load(saveTag + GetName(new { anisotropicFilt }));
if (anisoFloat == 0)
{
anisotropicFilt = AnisotropicFiltering.Disable;
}
if (anisoFloat == 1)
{
anisotropicFilt = AnisotropicFiltering.Enable;
}
if (anisoFloat == 2)
{
anisotropicFilt = AnisotropicFiltering.ForceEnable;
}
textureQuality = Load(saveTag + GetName(new { textureQuality }));
pixelLightCount = Load(saveTag + GetName(new { pixelLightCount }));
//Shadow
float shadowProjFloat = Load(saveTag + GetName(new { shadowProjection }));
if (shadowProjFloat == 0)
{
shadowProjection = ShadowProjection.CloseFit;
}
if (shadowProjFloat == 1)
{
shadowProjection = ShadowProjection.StableFit;
}
maxShadowDistance = Load(saveTag + GetName(new { shadowDistance = maxShadowDistance }));
shadowCascade = Load(saveTag + GetName(new { shadowCascade }));
//Other
vSync = Load(saveTag + GetName(new { vSync }));
particleRaycastBudget = Load(saveTag + GetName(new { particleRaycastBudget }));
frameRate = Load(saveTag + GetName(new { frameRate }));
LoDLevel = Load(saveTag + GetName(new { LoDLevel }));
LoDBias = Load(saveTag + GetName(new { LoDBias }));
//Update
QualitySettings.antiAliasing = (int)antiAliasing;
QualitySettings.anisotropicFiltering = anisotropicFilt;
QualitySettings.masterTextureLimit = (int)textureQuality;
QualitySettings.pixelLightCount = (int)pixelLightCount;
//Shadow
QualitySettings.shadowProjection = shadowProjection;
QualitySettings.shadowDistance = maxShadowDistance;
QualitySettings.shadowCascades = (int)shadowCascade;
//Other
QualitySettings.vSyncCount = (int)vSync;
QualitySettings.particleRaycastBudget = (int)particleRaycastBudget;
Application.targetFrameRate = (int)frameRate;
QualitySettings.maximumLODLevel = (int)LoDLevel;
QualitySettings.lodBias = LoDBias;
//Fog
BackupFogClassicOptions();
Configuration.instance.fogClassic = Configuration.defaults.fogClassic;
SetFogClassicOptions();
}
}
