IEnumerator save_AntiAliasing()
{
yield return(new WaitForEndOfFrame());
for (int a = 0; a < pb.Length; a++)
{
AntialiasingModel m = pb [a].profile.antialiasing;
if (antiAliasing.value == 0)
{
m.enabled = false;
PlayerPrefs.SetString("AA", "Off");
}
if (antiAliasing.value == 1)
{
AntialiasingModel.Settings s = pb [a].profile.antialiasing.settings;
m.enabled = true;
s.method = AntialiasingModel.Method.Fxaa;
m.settings = s;
PlayerPrefs.SetString("AA", "FXAA");
}
if (antiAliasing.value == 2)
{
AntialiasingModel.Settings s = pb [a].profile.antialiasing.settings;
m.enabled = true;
s.method = AntialiasingModel.Method.Taa;
m.settings = s;
PlayerPrefs.SetString("AA", "TAA");
}
pb [a].profile.antialiasing = m;
}
}
private void SetCustomSettings()
{
this.lowRenderResolution = GraphicsSettings.INSTANCE.CurrentRenderResolutionQuality == 1;
if (this.lowRenderResolution)
{
this.texture = new RenderTexture((int)(Screen.width * this.renderCoeff), (int)(Screen.height * this.renderCoeff), 0);
RenderTexture.active = this.texture;
}
this.Bloom.enabled = GraphicsSettings.INSTANCE.currentBloom;
this.TargetBloom.enabled = GraphicsSettings.INSTANCE.currentBloom;
if (GraphicsSettings.INSTANCE.currentBloom)
{
this.profile.colorGrading.enabled = true;
this.profile.userLut.enabled = true;
}
this.profile.antialiasing.enabled = GraphicsSettings.INSTANCE.CurrentAntialiasingQuality == 1;
if (this.profile.antialiasing.enabled)
{
AntialiasingModel.Settings settings = this.profile.antialiasing.settings;
settings.method = (QualitySettings.GetQualityLevel() <= 3) ? AntialiasingModel.Method.Fxaa : AntialiasingModel.Method.Taa;
this.profile.antialiasing.settings = settings;
}
this.profile.ambientOcclusion.enabled = GraphicsSettings.INSTANCE.currentAmbientOcclusion;
this.profile.chromaticAberration.enabled = GraphicsSettings.INSTANCE.currentChromaticAberration;
this.profile.grain.enabled = GraphicsSettings.INSTANCE.currentGrain;
this.profile.vignette.enabled = GraphicsSettings.INSTANCE.currentVignette;
}
private void SetDefaultSettings()
{
int qualityLevel = QualitySettings.GetQualityLevel();
if (qualityLevel != 0)
{
this.lowRenderResolution = false;
}
else
{
this.lowRenderResolution = true;
this.texture = new RenderTexture((int)(Screen.width * this.renderCoeff), (int)(Screen.height * this.renderCoeff), 0);
RenderTexture.active = this.texture;
QualitySettings.pixelLightCount = 0;
base.GetComponent <Camera>().hdr = false;
}
this.TargetBloom.enabled = qualityLevel >= 3;
this.Bloom.enabled = qualityLevel >= 3;
this.profile.chromaticAberration.enabled = qualityLevel >= 2;
this.profile.antialiasing.enabled = qualityLevel >= 3;
if (this.profile.antialiasing.enabled)
{
AntialiasingModel.Settings settings = this.profile.antialiasing.settings;
settings.method = (qualityLevel <= 3) ? AntialiasingModel.Method.Fxaa : AntialiasingModel.Method.Taa;
this.profile.antialiasing.settings = settings;
}
this.profile.vignette.enabled = qualityLevel >= 3;
this.profile.ambientOcclusion.enabled = qualityLevel >= 5;
}
public void AntialiasingQuality(int value)
{
AntialiasingModel.Settings s = _profile.antialiasing.settings;
_params.AApreset = value;
switch (value)
{
case 0:
s.fxaaSettings.preset = AntialiasingModel.FxaaPreset.ExtremePerformance;
break;
case 1:
s.fxaaSettings.preset = AntialiasingModel.FxaaPreset.Performance;
break;
case 2:
s.fxaaSettings.preset = AntialiasingModel.FxaaPreset.Default;
break;
case 3:
s.fxaaSettings.preset = AntialiasingModel.FxaaPreset.Quality;
break;
case 4:
s.fxaaSettings.preset = AntialiasingModel.FxaaPreset.ExtremeQuality;
break;
}
_profile.antialiasing.settings = s;
}
void setCameraPostProcessSettings()
{
state.cameras.ToList().ForEach(
obj_state =>
{
// Get object
ObjectState_t internal_object_state = internal_state.getWrapperObject(obj_state.ID, camera_template);
GameObject obj = internal_object_state.gameObj;
// Copy and save postProcessingProfile into internal_object_state.
var postBehaviour = obj.GetComponent <PostProcessingBehaviour>();
internal_object_state.postProcessingProfile = Instantiate(postBehaviour.profile);
postBehaviour.profile = internal_object_state.postProcessingProfile;
// Enable depth if needed.
if (obj_state.isDepth)
{
var debugSettings = internal_object_state.postProcessingProfile.debugViews.settings;
debugSettings.mode = BuiltinDebugViewsModel.Mode.Depth;
debugSettings.depth.scale = state.camDepthScale;
// Save the settings.
internal_object_state.postProcessingProfile.debugViews.settings = debugSettings;
}
else
{
// Set CTAA settings
CTAA_PC AA = obj.GetComponent <CTAA_PC>();
// Check if AA object exists.
if (AA != null)
{
AA.TemporalStability = state.temporalStability;
AA.HdrResponse = state.hdrResponse;
AA.Sharpness = state.sharpness;
AA.AdaptiveEnhance = state.adaptiveEnhance;
AA.TemporalJitterScale = state.temporalJitterScale;
AA.MicroShimmerReduction = state.microShimmerReduction;
AA.StaticStabilityPower = state.staticStabilityPower;
AA.enabled = true;
}
else
{
// If CTAA is not installed on camera, fallback to PostProcessing FXAA.
AntialiasingModel.Settings AASettings = internal_object_state.postProcessingProfile.antialiasing.settings;
AASettings.method = AntialiasingModel.Method.Fxaa;
AASettings.fxaaSettings.preset = AntialiasingModel.FxaaPreset.ExtremeQuality;
// Save the settings.
internal_object_state.postProcessingProfile.antialiasing.settings = AASettings;
}
}
});
//
}
private void OnEnable()
{
PostProcessingBehaviour component = base.GetComponent <PostProcessingBehaviour>();
if (component.profile == null)
{
base.enabled = false;
}
else
{
this.profile = Instantiate <PostProcessingProfile>(component.profile);
component.profile = this.profile;
this.DisableAllEffects(this.profile);
int qualityLevel = QualitySettings.GetQualityLevel();
this.profile.depthOfField.enabled = qualityLevel >= 2;
this.Fog.enabled = qualityLevel >= 2;
this.profile.colorGrading.enabled = true;
ColorGradingModel.Settings settings = this.profile.colorGrading.settings;
this.saturation = (GraphicsSettings.INSTANCE != null) ? GraphicsSettings.INSTANCE.CurrentSaturationLevel : 1f;
settings.basic.saturation = this.saturation;
this.profile.colorGrading.settings = settings;
if ((GraphicsSettings.INSTANCE != null) && GraphicsSettings.INSTANCE.customSettings)
{
this.profile.antialiasing.enabled = GraphicsSettings.INSTANCE.CurrentAntialiasingQuality != 0;
if (this.profile.antialiasing.enabled)
{
AntialiasingModel.Settings settings2 = this.profile.antialiasing.settings;
settings2.method = (qualityLevel <= 3) ? AntialiasingModel.Method.Fxaa : AntialiasingModel.Method.Taa;
this.profile.antialiasing.settings = settings2;
}
this.profile.ambientOcclusion.enabled = GraphicsSettings.INSTANCE.currentAmbientOcclusion;
this.profile.bloom.enabled = GraphicsSettings.INSTANCE.currentBloom;
this.TargetBloom.enabled = GraphicsSettings.INSTANCE.currentBloom;
this.profile.chromaticAberration.enabled = GraphicsSettings.INSTANCE.currentChromaticAberration;
this.profile.grain.enabled = GraphicsSettings.INSTANCE.currentGrain;
this.profile.vignette.enabled = GraphicsSettings.INSTANCE.currentVignette;
}
else
{
this.profile.antialiasing.enabled = qualityLevel >= 2;
if (this.profile.antialiasing.enabled)
{
AntialiasingModel.Settings settings3 = this.profile.antialiasing.settings;
settings3.method = (qualityLevel <= 3) ? AntialiasingModel.Method.Fxaa : AntialiasingModel.Method.Taa;
this.profile.antialiasing.settings = settings3;
}
this.profile.chromaticAberration.enabled = qualityLevel >= 2;
this.profile.bloom.enabled = qualityLevel >= 3;
this.TargetBloom.enabled = qualityLevel >= 3;
this.profile.grain.enabled = qualityLevel >= 3;
this.profile.vignette.enabled = qualityLevel >= 3;
this.profile.ambientOcclusion.enabled = qualityLevel >= 4;
}
}
}
public void Settings()
{
profile.antialiasing.enabled = AAenable.Value;
AntialiasingModel.Settings AAsettings = profile.antialiasing.settings;
AAsettings.method = AAMethod.Value; //AntialiasingModel.Method.Taa;
AAsettings.fxaaSettings.preset = FXAAPreset.Value; //AntialiasingModel.FxaaPreset.ExtremePerformance;
AAsettings.taaSettings.jitterSpread = TAAjittetSpeed.Value;
AAsettings.taaSettings.sharpen = TAAsharpen.Value;
AAsettings.taaSettings.stationaryBlending = TAAstationaryBlending.Value;
AAsettings.taaSettings.motionBlending = TAAmotionBlending.Value;
profile.antialiasing.settings = AAsettings;
profile.ambientOcclusion.enabled = AOenable.Value;
AmbientOcclusionModel.Settings AOsettings = profile.ambientOcclusion.settings;
AOsettings.intensity = AOintensity.Value;
AOsettings.downsampling = AOdownsampling.Value;
AOsettings.forceForwardCompatibility = AOforceForwardCompatibility.Value;
AOsettings.sampleCount = AOsampleCount.Value;//AmbientOcclusionModel.SampleCount.High;
AOsettings.highPrecision = AOhighPrecision.Value;
AOsettings.ambientOnly = AOambientOnly.Value;
AOsettings.radius = AOradius.Value;
profile.ambientOcclusion.settings = AOsettings;
profile.screenSpaceReflection.enabled = SSRenable.Value;
ScreenSpaceReflectionModel.Settings SSRsettings = profile.screenSpaceReflection.settings;
SSRsettings.intensity.reflectionMultiplier = SSRrefMultiplier.Value;
SSRsettings.intensity.fadeDistance = SSRfadeDistance.Value;
SSRsettings.intensity.fresnelFade = SSRfresnelFade.Value;
SSRsettings.intensity.fresnelFadePower = SSRfresnelFadePower.Value;
SSRsettings.reflection.blendType = SSRrefBlendtype.Value;
SSRsettings.reflection.reflectionQuality = SSRrefQuality.Value;
SSRsettings.reflection.maxDistance = SSRmaxDistance.Value;
SSRsettings.reflection.iterationCount = SSRiterationCount.Value;
SSRsettings.reflection.stepSize = SSRstepSize.Value;
SSRsettings.reflection.widthModifier = SSRwidthModifier.Value;
SSRsettings.reflection.reflectionBlur = SSRrefBlur.Value;
SSRsettings.reflection.reflectBackfaces = SSRrefBackfaces.Value;
SSRsettings.screenEdgeMask.intensity = SSRscreenEdgemaskIntensity.Value;
profile.screenSpaceReflection.settings = SSRsettings;
profile.bloom.enabled = Bloomenable.Value;
BloomModel.Settings bloomsetting = profile.bloom.settings;
bloomsetting.bloom.intensity = Bloomintensity.Value;
bloomsetting.bloom.radius = Bloomradius.Value;
bloomsetting.bloom.softKnee = BloomsoftKnee.Value;
bloomsetting.bloom.threshold = Bloomthreshold.Value;
bloomsetting.bloom.antiFlicker = BloomAntiFk.Value;
profile.bloom.settings = bloomsetting;
//Debug.LogError("testtesttest");
}
private void UpdateAntialiasing()
{
try
{
AntialiasingModel.Settings settings = _antialiasingModel.settings;
switch (ModProperties.Instance.ActiveProfile.AntialiasingTechnique)
{
case 0:
_antialiasingModel.enabled = false;
break;
case 1:
_antialiasingModel.enabled = false;
break;
case 2:
settings.method = AntialiasingModel.Method.Fxaa;
AntialiasingModel.FxaaPreset preset = (AntialiasingModel.FxaaPreset)ModProperties.Instance.ActiveProfile.FXAAQuality;
settings.fxaaSettings.preset = preset;
_antialiasingModel.settings = settings;
_antialiasingModel.enabled = true;
break;
case 3:
settings.method = AntialiasingModel.Method.Taa;
settings.taaSettings.jitterSpread = ModProperties.Instance.ActiveProfile.TAAJitterSpread;
settings.taaSettings.sharpen = ModProperties.Instance.ActiveProfile.TAASharpen;
settings.taaSettings.stationaryBlending = ModProperties.Instance.ActiveProfile.TAAStationaryBlending;
settings.taaSettings.motionBlending = ModProperties.Instance.ActiveProfile.TAAMotionBlending;
_antialiasingModel.settings = settings;
_antialiasingModel.enabled = true;
break;
default:
_antialiasingModel.enabled = false;
break;
}
_postProcessingBehaviour.profile.antialiasing.settings = _antialiasingModel.settings;
_postProcessingBehaviour.profile.antialiasing.enabled = _antialiasingModel.enabled;
}
catch (Exception e)
{
Debug.Log("[Render It!] ModManager:UpdateAntialiasing -> Exception: " + e.Message);
}
}
void Start()
{
// Replace the profile with its clone.
var postfx = GetComponent <PostProcessingBehaviour>();
_profile = Instantiate <PostProcessingProfile>(postfx.profile);
postfx.profile = _profile;
// Initialize the public structs with the current profile.
enableAntialiasing = _profile.antialiasing.enabled;
antialiasing = _profile.antialiasing.settings;
enableAmbientOcclusion = _profile.ambientOcclusion.enabled;
ambientOcclusion = _profile.ambientOcclusion.settings;
enableScreenSpaceReflection = _profile.screenSpaceReflection.enabled;
screenSpaceReflection = _profile.screenSpaceReflection.settings;
enableDepthOfField = _profile.depthOfField.enabled;
depthOfField = _profile.depthOfField.settings;
enableMotionBlur = _profile.motionBlur.enabled;
motionBlur = _profile.motionBlur.settings;
enableEyeAdaptation = _profile.eyeAdaptation.enabled;
eyeAdaptation = _profile.eyeAdaptation.settings;
enableBloom = _profile.bloom.enabled;
bloom = _profile.bloom.settings;
enableColorGrading = _profile.colorGrading.enabled;
colorGrading = _profile.colorGrading.settings;
enableUserLut = _profile.userLut.enabled;
userLut = _profile.userLut.settings;
enableChromaticAberration = _profile.chromaticAberration.enabled;
chromaticAberration = _profile.chromaticAberration.settings;
enableGrain = _profile.grain.enabled;
grain = _profile.grain.settings;
enableVignette = _profile.vignette.enabled;
vignette = _profile.vignette.settings;
}
void OnDestroy()
{
BinaryFormatter bf = new BinaryFormatter();
FileStream file = File.Create(Application.persistentDataPath + "/videoSettings.dat");
bf.Serialize(file, _params);
file.Close();
_profile.antialiasing.enabled = true;
AntialiasingModel.Settings s = _profile.antialiasing.settings;
s.fxaaSettings.preset = AntialiasingModel.FxaaPreset.Default;
_profile.antialiasing.settings = s;
_profile.motionBlur.enabled = true;
_profile.ambientOcclusion.enabled = true;
}
//public void Reset()
//{
// OnEnable();
//}
internal void SetProfile(PostProcessingProfile __profile)
{
enableAntialiasing = __profile.antialiasing.enabled;
antialiasing = __profile.antialiasing.settings;
enableAmbientOcclusion = __profile.ambientOcclusion.enabled;
ambientOcclusion = __profile.ambientOcclusion.settings;
enableScreenSpaceReflection = __profile.screenSpaceReflection.enabled;
screenSpaceReflection = __profile.screenSpaceReflection.settings;
enableDepthOfField = __profile.depthOfField.enabled;
depthOfField = __profile.depthOfField.settings;
enableMotionBlur = __profile.motionBlur.enabled;
motionBlur = __profile.motionBlur.settings;
enableEyeAdaptation = __profile.eyeAdaptation.enabled;
eyeAdaptation = __profile.eyeAdaptation.settings;
enableBloom = __profile.bloom.enabled;
bloom = __profile.bloom.settings;
enableColorGrading = __profile.colorGrading.enabled;
colorGrading = __profile.colorGrading.settings;
enableUserLut = __profile.userLut.enabled;
userLut = __profile.userLut.settings;
enableChromaticAberration = __profile.chromaticAberration.enabled;
chromaticAberration = __profile.chromaticAberration.settings;
enableGrain = __profile.grain.enabled;
grain = __profile.grain.settings;
enableVignette = __profile.vignette.enabled;
vignette = __profile.vignette.settings;
enableDither = __profile.dithering.enabled;
enableFog = __profile.fog.enabled;
fog = __profile.fog.settings;
}
private static void WriteAA(List <string> lines, AntialiasingModel.Settings settings)
{
lines.Append("Anti_Aliasing", 1);
lines.Append("{", 1);
switch (settings.method)
{
case AntialiasingModel.Method.Fxaa:
lines.Append("Mode = FXAA", 2);
lines.Append("Quality = " + (int)settings.fxaaSettings.preset, 2);
break;
case AntialiasingModel.Method.Taa:
lines.Append("Mode = TAA", 2);
lines.Append("Jitter = " + settings.taaSettings.jitterSpread, 2);
lines.Append("Blend_Motion = " + settings.taaSettings.motionBlending, 2);
lines.Append("Blend_Stationary = " + settings.taaSettings.stationaryBlending, 2);
lines.Append("Sharpen" + settings.taaSettings.sharpen, 2);
break;
}
lines.Append("}", 1);
}
public void AntiAliasing(float value)
{
AntialiasingModel.Settings settings = postProcessProfile.antialiasing.settings;
string quality = "";
switch ((int)value)
{
case 0:
settings.fxaaSettings.preset = AntialiasingModel.FxaaPreset.ExtremePerformance;
quality = "Extreme Performance";
break;
case 1:
settings.fxaaSettings.preset = AntialiasingModel.FxaaPreset.Performance;
quality = "Performance";
break;
case 2:
settings.fxaaSettings.preset = AntialiasingModel.FxaaPreset.Default;
quality = "Default";
break;
case 3:
settings.fxaaSettings.preset = AntialiasingModel.FxaaPreset.Quality;
quality = "Quality";
break;
case 4:
settings.fxaaSettings.preset = AntialiasingModel.FxaaPreset.ExtremeQuality;
quality = "Extreme Quality";
break;
}
antialiasingSlider.transform.GetChild(4).GetComponent <Text>().text = quality;
postProcessProfile.antialiasing.settings = settings;
PlayerPrefs.SetInt("Antialiasing", (int)value);
}
void SetAntiAliasing(int value)
{
AntialiasingModel aa = cam.GetComponent <PostProcessingBehaviour>().profile.antialiasing;
if (value == 2)
{
aa.enabled = true;
AntialiasingModel.Settings tempSettings = aa.settings;
tempSettings.method = AntialiasingModel.Method.Taa;
aa.settings = tempSettings;
}
else if (value == 1)
{
aa.enabled = true;
AntialiasingModel.Settings tempSettings = aa.settings;
tempSettings.method = AntialiasingModel.Method.Fxaa;
aa.settings = tempSettings;
}
else
{
aa.enabled = false;
}
}
private void Update()
{
if (this.postProcessingProfile)
{
ColorGradingModel.Settings settings = this.postProcessingProfile.colorGrading.settings;
float num = PlayerPreferences.GammaWorldAndDay;
float contrast = PlayerPreferences.Contrast;
if (Clock.Dark || LocalPlayer.IsInCaves)
{
num = PlayerPreferences.GammaCavesAndNight;
}
bool flag = LocalPlayer.Inventory != null && LocalPlayer.Inventory.CurrentView == PlayerInventory.PlayerViews.Pause;
if (flag || float.IsNaN(settings.basic.postExposure) || float.IsInfinity(settings.basic.postExposure) || Mathf.Abs(num - settings.basic.postExposure) < 0.001f)
{
if (!settings.basic.postExposure.Equals(num))
{
settings.basic.postExposure = num;
}
}
else
{
settings.basic.postExposure = Mathf.SmoothDamp(settings.basic.postExposure, num, ref this.gammaVelocity, 3f);
}
if (flag || float.IsNaN(settings.basic.contrast) || float.IsInfinity(settings.basic.contrast) || Mathf.Abs(contrast - settings.basic.contrast) < 0.001f)
{
if (!settings.basic.contrast.Equals(contrast))
{
settings.basic.contrast = contrast;
}
}
else
{
settings.basic.contrast = Mathf.SmoothDamp(settings.basic.contrast, contrast, ref this.contrastVelocity, 1f);
}
this.postProcessingProfile.colorGrading.settings = settings;
}
if (this.farShadowCascade)
{
bool flag2 = TheForestQualitySettings.UserSettings.FarShadowMode == TheForestQualitySettings.FarShadowModes.On && !LocalPlayer.IsInClosedArea;
if (this.farShadowCascade.enableFarShadows != flag2)
{
this.farShadowCascade.enableFarShadows = flag2;
}
}
if (this.postProcessingProfile && PlayerPreferences.ColorGrading >= 0 && PlayerPreferences.ColorGrading < this.AmplifyColorGradients.Length)
{
this.postProcessingProfile.userLut.enabled = true;
UserLutModel.Settings settings2 = this.postProcessingProfile.userLut.settings;
settings2.lut = this.AmplifyColorGradients[PlayerPreferences.ColorGrading];
this.postProcessingProfile.userLut.settings = settings2;
}
if (this.frostEffect)
{
this.frostEffect.enabled = (this.frostEffect.coverage > 0f);
}
if (this.bleedEffect)
{
if (Application.isPlaying)
{
this.bleedEffect.enabled = (BleedBehavior.BloodAmount > 0f);
}
else
{
this.bleedEffect.enabled = (this.bleedEffect.TestingBloodAmount > 0f);
}
}
TheForestQualitySettings.AntiAliasingTechnique antiAliasingTechnique = TheForestQualitySettings.UserSettings.AntiAliasing;
if (SystemInfo.systemMemorySize <= 4096 || PlayerPreferences.LowMemoryMode)
{
antiAliasingTechnique = TheForestQualitySettings.AntiAliasingTechnique.None;
}
if (this.postProcessingProfile)
{
bool flag3 = !ForestVR.Enabled && antiAliasingTechnique != TheForestQualitySettings.AntiAliasingTechnique.None;
this.postProcessingProfile.antialiasing.enabled = flag3;
if (flag3)
{
AntialiasingModel.Settings settings3 = this.postProcessingProfile.antialiasing.settings;
if (antiAliasingTechnique != TheForestQualitySettings.AntiAliasingTechnique.FXAA)
{
if (antiAliasingTechnique == TheForestQualitySettings.AntiAliasingTechnique.TAA)
{
settings3.method = AntialiasingModel.Method.Taa;
}
}
else
{
settings3.method = AntialiasingModel.Method.Fxaa;
}
this.postProcessingProfile.antialiasing.settings = settings3;
}
}
if (this.postProcessingProfile)
{
bool flag4 = !ForestVR.Enabled && !this.SkipMotionBlur && TheForestQualitySettings.UserSettings.MotionBlur != TheForestQualitySettings.MotionBlurQuality.None;
this.postProcessingProfile.motionBlur.enabled = flag4;
if (flag4)
{
MotionBlurModel.Settings settings4 = this.postProcessingProfile.motionBlur.settings;
switch (TheForestQualitySettings.UserSettings.MotionBlur)
{
case TheForestQualitySettings.MotionBlurQuality.Low:
settings4.sampleCount = 4;
break;
case TheForestQualitySettings.MotionBlurQuality.Medium:
settings4.sampleCount = 8;
break;
case TheForestQualitySettings.MotionBlurQuality.High:
settings4.sampleCount = 16;
break;
case TheForestQualitySettings.MotionBlurQuality.Ultra:
settings4.sampleCount = 32;
break;
}
this.postProcessingProfile.motionBlur.settings = settings4;
}
}
if (this.postProcessingProfile)
{
bool flag5 = !ForestVR.Enabled && TheForestQualitySettings.UserSettings.screenSpaceReflection == TheForestQualitySettings.ScreenSpaceReflection.On;
flag5 = (flag5 && LocalPlayer.IsInEndgame);
this.postProcessingProfile.screenSpaceReflection.enabled = flag5;
}
if (this.postProcessingProfile)
{
}
if (this.postProcessingProfile)
{
bool enabled = !ForestVR.Enabled && TheForestQualitySettings.UserSettings.Fg == TheForestQualitySettings.FilmGrain.Normal;
this.postProcessingProfile.grain.enabled = enabled;
}
if (this.postProcessingProfile)
{
bool enabled2 = TheForestQualitySettings.UserSettings.CA == TheForestQualitySettings.ChromaticAberration.Normal;
this.postProcessingProfile.chromaticAberration.enabled = enabled2;
}
if (this.postProcessingProfile)
{
bool enabled3 = TheForestQualitySettings.UserSettings.SEBloom == TheForestQualitySettings.SEBloomTechnique.Normal;
this.postProcessingProfile.bloom.enabled = enabled3;
}
if (Application.isPlaying)
{
if (!this.SunshineAtmosCam)
{
this.SunshineAtmosCam = base.GetComponent <TheForestAtmosphereCamera>();
if (!this.SunshineAtmosCam)
{
this.SunshineAtmosCam = base.gameObject.AddComponent <TheForestAtmosphereCamera>();
}
}
this.SunshineCam.enabled = true;
this.SunshinePP.enabled = true;
if (Sunshine.Instance)
{
Sunshine.Instance.enabled = true;
Sunshine.Instance.ScatterResolution = TheForestQualitySettings.UserSettings.ScatterResolution;
Sunshine.Instance.ScatterSamplingQuality = TheForestQualitySettings.UserSettings.ScatterSamplingQuality;
if (this.SunshineOccluders.value != 0)
{
bool flag6 = TheForestQualitySettings.UserSettings.SunshineOcclusion == TheForestQualitySettings.SunshineOcclusionOn.On || LocalPlayer.IsInCaves;
Sunshine.Instance.Occluders = ((!flag6) ? 0 : this.SunshineOccluders.value);
}
else
{
this.SunshineOccluders = Sunshine.Instance.Occluders;
}
}
}
TheForestQualitySettings.SSAOTechnique ssaotechnique = TheForestQualitySettings.UserSettings.SSAO;
if (SystemInfo.systemMemorySize <= 4096 || PlayerPreferences.LowMemoryMode)
{
ssaotechnique = TheForestQualitySettings.SSAOTechnique.Off;
}
if (this.amplifyOcclusion && (TheForestQualitySettings.UserSettings.SSAOType == TheForestQualitySettings.SSAOTypes.AMPLIFY || !this.postProcessingProfile))
{
this.amplifyOcclusion.enabled = (!ForestVR.Enabled && ssaotechnique != TheForestQualitySettings.SSAOTechnique.Off);
if (this.postProcessingProfile)
{
this.postProcessingProfile.ambientOcclusion.enabled = false;
}
if (ssaotechnique != TheForestQualitySettings.SSAOTechnique.Ultra)
{
if (ssaotechnique != TheForestQualitySettings.SSAOTechnique.High)
{
if (ssaotechnique == TheForestQualitySettings.SSAOTechnique.Low)
{
this.amplifyOcclusion.SampleCount = AmplifyOcclusionBase.SampleCountLevel.Low;
}
}
else
{
this.amplifyOcclusion.SampleCount = AmplifyOcclusionBase.SampleCountLevel.Medium;
}
}
else
{
this.amplifyOcclusion.SampleCount = AmplifyOcclusionBase.SampleCountLevel.High;
}
}
else if (this.postProcessingProfile && (TheForestQualitySettings.UserSettings.SSAOType == TheForestQualitySettings.SSAOTypes.UNITY || !this.amplifyOcclusion))
{
this.postProcessingProfile.ambientOcclusion.enabled = (!ForestVR.Enabled && ssaotechnique != TheForestQualitySettings.SSAOTechnique.Off);
if (this.amplifyOcclusion)
{
this.amplifyOcclusion.enabled = false;
}
AmbientOcclusionModel.Settings settings5 = this.postProcessingProfile.ambientOcclusion.settings;
if (ssaotechnique != TheForestQualitySettings.SSAOTechnique.Ultra)
{
if (ssaotechnique != TheForestQualitySettings.SSAOTechnique.High)
{
if (ssaotechnique == TheForestQualitySettings.SSAOTechnique.Low)
{
settings5.sampleCount = AmbientOcclusionModel.SampleCount.Lowest;
}
}
else
{
settings5.sampleCount = AmbientOcclusionModel.SampleCount.Low;
}
}
else
{
settings5.sampleCount = AmbientOcclusionModel.SampleCount.Medium;
}
this.postProcessingProfile.ambientOcclusion.settings = settings5;
}
if (LocalPlayer.WaterEngine)
{
if (LocalPlayer.IsInClosedArea)
{
Scene.OceanFlat.SetActive(false);
Scene.OceanCeto.SetActive(false);
this.CurrentOceanQuality = (TheForestQualitySettings.OceanQualities)(-1);
}
else if (TheForestQualitySettings.UserSettings.OceanQuality != this.CurrentOceanQuality)
{
this.CurrentOceanQuality = ((!PlayerPreferences.is32bit) ? TheForestQualitySettings.UserSettings.OceanQuality : TheForestQualitySettings.OceanQualities.Flat);
TheForestQualitySettings.OceanQualities oceanQuality = TheForestQualitySettings.UserSettings.OceanQuality;
if (oceanQuality != TheForestQualitySettings.OceanQualities.WaveDisplacementHigh)
{
if (oceanQuality != TheForestQualitySettings.OceanQualities.WaveDisplacementLow)
{
if (oceanQuality == TheForestQualitySettings.OceanQualities.Flat)
{
Scene.OceanFlat.SetActive(true);
Scene.OceanCeto.SetActive(false);
this.waterBlurCeto.enabled = false;
}
}
else
{
Scene.OceanFlat.SetActive(false);
Scene.OceanCeto.SetActive(true);
this.waterBlurCeto.enabled = true;
if (OceanQualitySettings.Instance != null)
{
OceanQualitySettings.Instance.QualityChanged(CETO_QUALITY_SETTING.LOW);
}
}
}
else
{
Scene.OceanFlat.SetActive(false);
Scene.OceanCeto.SetActive(true);
this.waterBlurCeto.enabled = true;
if (OceanQualitySettings.Instance != null)
{
OceanQualitySettings.Instance.QualityChanged(CETO_QUALITY_SETTING.HIGH);
}
}
}
}
}
