public void applySettings()
{
try {
PostProcessingBehaviour postProcessing = Camera.main.gameObject.GetComponent <PostProcessingBehaviour> ();
postProcessing.profile.ambientOcclusion.settings = m_settings.aoModel.settings;
postProcessing.profile.ambientOcclusion.enabled = m_settings.aoModel.enabled;
postProcessing.profile.antialiasing.settings = m_settings.aaModel.settings;
postProcessing.profile.antialiasing.enabled = m_settings.aaModel.enabled;
postProcessing.profile.bloom.settings = m_settings.bloomModel.settings;
postProcessing.profile.bloom.enabled = m_settings.bloomModel.enabled;
SunShafts sunshafts = Camera.main.gameObject.GetComponent <SunShafts> ();
sunshafts.enabled = m_settings.sunshaftsSettings.enabled;
sunshafts.sunShaftIntensity = m_settings.sunshaftsSettings.sunShaftIntensity;
sunshafts.height = m_settings.sunshaftsSettings.height;
sunshafts.sunShaftBlurRadius = m_settings.sunshaftsSettings.sunShaftBlurRadius;
sunshafts.sunColor = m_settings.sunshaftsSettings.sunColor;
sunshafts.sunThreshold = m_settings.sunshaftsSettings.sunThreshold;
sunshafts.maxRadius = m_settings.sunshaftsSettings.maxRadius;
postProcessing.profile.grain.settings = m_settings.grainModel.settings;
postProcessing.profile.grain.enabled = m_settings.grainModel.enabled;
} catch (Exception) {
Utils.log("Unable to enable post processing effects");
}
}
//
static SunShaftsDef()
{
if (sunShaftsEffect == null)
{
sunShaftsEffect = Util.GetComponentVar <SunShafts, SunShaftsDef>(sunShaftsEffect);
}
useDepthTexture = false;
resolution = SunShaftsResolution.Normal;
screenBlendMode = ShaftsScreenBlendMode.Screen;
sunColor = Color.white;
maxRadius = 0.75f;
radialBlurIterations = 2;
sunShaftBlurRadius = 2.5f;
sunShaftIntensity = 1.15f;
useSkyBoxAlpha = 0.75f;
texSunColor = new Texture2D(1, 1);
texSunColor.SetPixel(0, 0, Color.white);
texSunColor.Apply();
drag = new DragManager();
sunTransform = drag.goDrag.transform;
}
void Start()
{
objetoSomSub = new GameObject();
objetoSomSub.AddComponent(typeof(AudioSource));
objetoSomSub.GetComponent <AudioSource> ().loop = true;
objetoSomSub.transform.localPosition = new Vector3(0, 0, 0);
objetoSomSub.GetComponent <AudioSource> ().clip = somSubmerso;
objetoSomSub.transform.parent = transform;
objetoSomSub.SetActive(false);
//
_fisheye = GetComponent <Fisheye> ();
_blur = GetComponent <Blur> ();
_edge = GetComponent <EdgeDetection> ();
_vortex = GetComponent <Vortex> ();
//
GetComponent <SphereCollider> ().radius = 0.005f;
GetComponent <SphereCollider> ().isTrigger = false;
GetComponent <Rigidbody> ().isKinematic = true;
GetComponent <Camera> ().nearClipPlane = 0.01f;
//
_blur.iterations = 5 - DistanciaDeVisib;
_blur.blurSpread = 1 - (Visibilidade / 10);
//
_vortex.radius = new Vector2(1, 1);
_vortex.center = new Vector2(0.5f, 0.5f);
//
_edge.mode = EdgeDetection.EdgeDetectMode.TriangleLuminance;
_edge.lumThreshold = 0;
_edge.sampleDist = 0;
_edge.edgesOnly = intensidadeCor;
_edge.edgesOnlyBgColor = corAgua;
//
_blur.enabled = false;
_fisheye.enabled = false;
_edge.enabled = false;
_vortex.enabled = false;
//
planoGotas = GameObject.CreatePrimitive(PrimitiveType.Plane);
Destroy(planoGotas.GetComponent <MeshCollider> ());
planoGotas.transform.localScale = new Vector3(0.02f, 0.02f, 0.02f);
planoGotas.transform.parent = transform;
planoGotas.transform.localPosition = new Vector3(0, 0, 0.05f);
planoGotas.transform.localEulerAngles = new Vector3(90, 180, 0);
planoGotas.GetComponent <Renderer>().material.shader = Shader.Find("FX/Glass/Stained BumpDistort");
planoGotas.GetComponent <Renderer> ().material.SetTexture("_BumpMap", TexturaPingos);
planoGotas.GetComponent <Renderer> ().material.SetFloat("_BumpAmt", 0);
//
if (GetComponent <SunShafts> () != null)
{
temSunShafts = true;
_sunShafts = GetComponent <SunShafts> ();
intSolInicial = _sunShafts.sunShaftIntensity;
}
else
{
temSunShafts = false;
}
//
_audSourc = GetComponent <AudioSource> ();
}
void InitDayNight()
{
if (_sunShaft == null)
{
_sunShaft = GetComponent <SunShafts>();
_camera = GetComponent <Camera>();
}
}
void Update()
{
SunShafts shafts = GetComponent <SunShafts>();
float phase = Time.timeSinceLevelLoad * pulseFrequency * Mathf.PI * 2;
float t = (Mathf.Sin(phase) + 1.0f) / 2.0f;
shafts.maxRadius = minRadius + t * (maxRadius - minRadius);
}
void Awake()
{
m_Bloom = Camera.main.GetComponent <BloomOptimized>();
m_Depth = Camera.main.GetComponent <DepthOfField>();
m_SSAO = Camera.main.GetComponent <ScreenSpaceAmbientOcclusion>();
m_SunShafts = Camera.main.GetComponent <SunShafts>();
m_CCC = Camera.main.GetComponent <ColorCorrectionCurves>();
}
// Token: 0x06000409 RID: 1033 RVA: 0x00020FA8 File Offset: 0x0001F1A8
public void SetSunShafts(bool enabled)
{
SunShafts component = base.GetComponent <SunShafts>();
if (component != null)
{
component.enabled = enabled;
}
}
public void Start()
{
PostProcessingBehaviour postProcessing = Camera.main.gameObject.GetComponent <PostProcessingBehaviour> ();
if (postProcessing == null)
{
postProcessing = Camera.main.gameObject.AddComponent <PostProcessingBehaviour> ();
if (!postProcessing.profile)
{
postProcessing.profile = new PostProcessingProfile();
}
}
SunShafts sunshafts = Camera.main.GetComponent <SunShafts> ();
if (sunshafts == null)
{
sunshafts = Camera.main.gameObject.AddComponent <SunShafts> ();
sunshafts.sunTransform = new GameObject().transform;
}
postProcessing.enabled = true;
LoadConfig();
applySettings();
m_window = Camera.main.gameObject.GetComponent <SettingsWindow> ();
if (m_window == null)
{
m_window = Camera.main.gameObject.AddComponent <SettingsWindow> ();
Utils.log("Window created");
}
/* var dof = Camera.main.GetComponent<UnityStandardAssets.ImageEffects.DepthOfField> ();
* if (dof != null) {
* Utils.log ("Disabling Vanilla DepthOfField");
* dof.enabled = false;
* }*/
var grain = Camera.main.GetComponent <ColossalFramework.FilmGrainEffect> ();
if (grain != null)
{
Utils.log("Disabling Vanilla Grain");
grain.enabled = false;
}
var bloom = Camera.main.GetComponent <UnityStandardAssets.ImageEffects.Bloom> ();
if (bloom != null)
{
bloom.enabled = true;
}
}
// Use this for initialization
void Start()
{
v = GetComponent <Vortex>();
v.enabled = false;
mb = GetComponent <MotionBlur>();
mb.enabled = false;
ss = GetComponent <SunShafts>();
p = GameObject.FindGameObjectWithTag("Player").GetComponent <Character>();
}
void Start()
{
player = FindObjectOfType <Player>();
theLight = FindObjectOfType <TheLight>();
blur = GetComponent <Blur>();
bloom = GetComponent <Bloom>();
twirl = GetComponent <Twirl>();
camera = GetComponent <Camera>();
shafts = GetComponent <SunShafts>();
motionBlur = GetComponent <CameraMotionBlur>();
}
// Use this for initialization
void Start()
{
fogDensity = RenderSettings.fogDensity;
//skydome = GameObject.FindGameObjectWithTag ("SkyDome").GetComponent<Sky> ();
//skydomeLight = skydome.m_sunIntensity;
colorCurve = Camera.main.GetComponent<ColorCorrectionCurves> ();
toneMapper = Camera.main.GetComponent<Tonemapping> ();
sunShafts = Camera.main.GetComponent<SunShafts> ();
sunShaftIntens = sunShafts.sunShaftIntensity;
colorSat = colorCurve.saturation;
toneExp = toneMapper.exposureAdjustment;
}
void Awake()
{
Services.DrugCameraEffects = this;
sun = this.GetComponent<SunShafts>();
noiseEffect = this.GetComponent<NoiseEffect>();
vortexEffect = this.GetComponent<VortexEffect>();
blur = this.GetComponent<Blur>();
trailRenderer = GameObject.Find("John").GetComponent<TrailRenderer>();
Services.GameState.PlayerState.WeedChangedEvent += HandleWeedChangedEvent;
}
void Start()
{
m_cam = Camera.main;
m_sunShafts = m_cam.GetComponent<SunShafts>();
m_bloom = m_cam.GetComponent<Bloom>();
m_motionBlur = m_cam.GetComponent<CameraMotionBlur>();
m_antiAliasing = m_cam.GetComponent<AntiAliasing>();
m_colorGrading = m_cam.GetComponent<TonemappingColorGrading>();
m_defaultGrading = m_colorGrading.colorGrading;
GameController.GameOver += OnGameOver;
}
// Use this for initialization
void Start()
{
singleton = this;
vaca = this.GetComponentInChildren <VignetteAndChromaticAberration>();
ss = this.GetComponentInChildren <SunShafts>();
MB = this.GetComponentInChildren <MotionBlur>();
if (GameController.postproces)
{
SetYesPostproces();
}
else
{
SetNoPostproces();
}
}
void OnEnable()
{
cam = Camera.main;
SunShafts = cam.gameObject.AddComponent<SunShafts>();
SunShafts.sunShaftIntensity = SunShuftsIntensity;
var target = new GameObject("SunShaftTarget");
SunShafts.sunTransform = target.transform;
target.transform.parent = cam.transform;
target.transform.localPosition = SunShaftTargetPosition;
SunShafts.screenBlendMode = SunShuftsScreenBlendMode;
SunShafts.sunShaftsShader = Shader.Find("Hidden/SunShaftsComposite");
SunShafts.simpleClearShader = Shader.Find("Hidden/SimpleClear");
var underwater = cam.gameObject.AddComponent<Underwater>();
underwater.UnderwaterLevel = transform.position.y;
underwater.FogColor = FogColor;
underwater.FogDensity = FogDensity;
}
public static void InitMemberByInstance(SunShafts sunShafts)
{
useDepthTexture = false;
resolution = sunShafts.resolution;
screenBlendMode = sunShafts.screenBlendMode;
sunTransform = sunShafts.sunTransform;
sunColor = sunShafts.sunColor;
maxRadius = sunShafts.maxRadius;
radialBlurIterations = sunShafts.radialBlurIterations;
sunShaftBlurRadius = sunShafts.sunShaftBlurRadius;
sunShaftIntensity = sunShafts.sunShaftIntensity;
useSkyBoxAlpha = sunShafts.useSkyBoxAlpha;
texSunColor.SetPixel(0, 0, sunColor);
texSunColor.Apply();
}
void OnEnable()
{
cam = Camera.main;
SunShafts = cam.gameObject.AddComponent <SunShafts>();
SunShafts.sunShaftIntensity = SunShuftsIntensity;
var target = new GameObject("SunShaftTarget");
SunShafts.sunTransform = target.transform;
target.transform.parent = cam.transform;
target.transform.localPosition = SunShaftTargetPosition;
SunShafts.screenBlendMode = SunShuftsScreenBlendMode;
SunShafts.sunShaftsShader = Shader.Find("Hidden/SunShaftsComposite");
SunShafts.simpleClearShader = Shader.Find("Hidden/SimpleClear");
var underwater = cam.gameObject.AddComponent <Underwater>();
underwater.UnderwaterLevel = transform.position.y;
underwater.FogColor = FogColor;
underwater.FogDensity = FogDensity;
}
private void Start()
{
if (Application.platform == RuntimePlatform.Android || Application.platform == RuntimePlatform.IPhonePlayer)
{
SunShafts sunshafts = Camera.main.GetComponent <SunShafts>();
sunshafts.enabled = false;
BloomOptimized bloom = Camera.main.GetComponent <BloomOptimized>();
bloom.enabled = false;
}
if (PlayerPrefs.GetInt("WatchedIntro", 0) == 1)
{
LoadSceneGame();
}
else
{
Cursor.SetCursor(Utils.TextureFromSprite(DefaultCursorSprite), Vector2.zero, CursorMode.ForceSoftware);
StartCoroutine(IntroCR());
}
}
void Awake()
{
if (Application.platform == RuntimePlatform.Android || Application.platform == RuntimePlatform.IPhonePlayer)
{
SunShafts sunshafts = Camera.main.GetComponent <SunShafts>();
sunshafts.enabled = false;
BloomOptimized bloom = Camera.main.GetComponent <BloomOptimized>();
bloom.enabled = false;
}
AwakeLevelManagement();
AwakeHelpManagement();
Spells.Add(SpellType.Kraken, new Spell(SpellType.Kraken, 10, true));
Spells.Add(SpellType.Alruana, new Spell(SpellType.Alruana, 8, true));
Spells.Add(SpellType.Dracula, new Spell(SpellType.Dracula, 3, false));
Spells.Add(SpellType.Tornado, new Spell(SpellType.Tornado, 10000, false));
DefaultCursorTex = Utils.TextureFromSprite(DefaultCursorSprite);
SetDefaultCursor();
AwakeAudio();
}
public void Destroy()
{
SaveConfig();
/*var dof = Camera.main.GetComponent<UnityStandardAssets.ImageEffects.DepthOfField> ();
* if (dof != null) {
* dof.enabled = true;
* }*/
var grain = Camera.main.GetComponent <ColossalFramework.FilmGrainEffect> ();
if (grain != null)
{
grain.enabled = true;
}
var bloom = Camera.main.GetComponent <UnityStandardAssets.ImageEffects.Bloom> ();
if (bloom != null)
{
bloom.enabled = true;
}
PostProcessingBehaviour postProcessing = Camera.main.gameObject.GetComponent <PostProcessingBehaviour> ();
if (postProcessing != null)
{
UnityEngine.Object.Destroy(postProcessing);
}
SunShafts sunshafts = Camera.main.gameObject.GetComponent <SunShafts> ();
if (sunshafts != null)
{
UnityEngine.Object.Destroy(sunshafts);
}
}
public void Apply()
{
Executor.Sky.SkyColor = SkyColor;
Executor.Sky.FogColorA = FogBrightColor;
Executor.Sky.FogColorB = FogDarkColor;
Executor.Sky.FogHeight = FogHeight;
RenderSettings.fogMode = FogMode.Linear;
RenderSettings.fogEndDistance = Mathf.Min(FogEndDistance, Executor.Settings.MaxFogEndDistance);
float u = RenderSettings.fogEndDistance / FogEndDistance;
RenderSettings.fogStartDistance = FogStartDistance * u;
if (Executor.Underwater <= 0)
{
if (Executor.Settings.MainCamera != null)
{
Vector3 pos = Executor.Settings.MainCamera.transform.forward;
pos.y = 0;
RenderSettings.fogColor = Executor.Sky.FogColorAtPoint(pos, Executor.SunDirection, FogSkyInterpolator) * FogIntensity;
}
else
{
RenderSettings.fogColor = (FogDarkColor * 0.7f + FogBrightColor * 0.3f) * FogIntensity;
}
}
else
{
RenderSettings.fogColor = WaterDepthColor;
}
Executor.Sky.UnityFogColor = RenderSettings.fogColor;
Executor.Sky.SunBloomColor = SunGlowColor;
Executor.Sky.SunPower = SunGlowPower;
Executor.Sky.SunColor = SunBodyColor;
Executor.Sky.SunSize = SunBodySize;
Executor.Sky.Overcast = SkyOvercast;
Executor.Sky.Apply();
Executor.Sun.SunLight.color = SunLightColor;
Executor.Sun.SunLight.intensity = SunLightIntensity < SunlightIntensityBase ? SunlightIntensityBase : SunLightIntensity;
Executor.SunCloudLayer.Color1 = CloudBrightColor1;
Executor.SunCloudLayer.Color2 = CloudBrightColor2;
Executor.SunCloudLayer.Color3 = CloudDarkColor1;
Executor.SunCloudLayer.Color4 = CloudDarkColor2;
Executor.RainCloudLayer.Color1 = CloudBrightColor1;
Executor.RainCloudLayer.Color2 = CloudBrightColor2;
Executor.RainCloudLayer.Color3 = CloudDarkColor1;
Executor.RainCloudLayer.Color4 = CloudDarkColor2;
Executor.RainCloudLayer.LayerMat.SetFloat("_CloudDensity", RainCloudDensity);
Executor.SunCloudLayer.LayerMat.SetFloat("_CloudThreshold", Mathf.Max(RainCloudThreshold, 1.0f));
Executor.RainCloudLayer.LayerMat.SetFloat("_CloudThreshold", RainCloudThreshold);
Executor.SunCloudLayer.LayerMat.SetFloat("_Overcast", RainCloudOvercast * 0.7f + 0.3f);
Executor.RainCloudLayer.LayerMat.SetFloat("_Overcast", RainCloudOvercast);
Executor.RainCloudLayer.LayerMat.SetFloat("_CloudTile", 7.5f);
Material watermat = Executor.Settings.WaterMaterial;
if (watermat != null)
{
if (!string.IsNullOrEmpty(Executor.Settings.WaterDepthColorProp))
{
watermat.SetColor(Executor.Settings.WaterDepthColorProp, WaterDepthColor);
}
if (!string.IsNullOrEmpty(Executor.Settings.WaterReflectionColorProp))
{
watermat.SetColor(Executor.Settings.WaterReflectionColorProp, WaterReflectionColor);
}
if (!string.IsNullOrEmpty(Executor.Settings.WaterFresnelColorProp))
{
watermat.SetColor(Executor.Settings.WaterFresnelColorProp, WaterFresnelColor);
}
if (!string.IsNullOrEmpty(Executor.Settings.WaterSpecularColorProp))
{
watermat.SetColor(Executor.Settings.WaterSpecularColorProp, WaterSpecularColor);
}
if (!string.IsNullOrEmpty(Executor.Settings.WaterFoamColorProp))
{
watermat.SetColor(Executor.Settings.WaterFoamColorProp, WaterFoamColor);
}
if (!string.IsNullOrEmpty(Executor.Settings.WaterDepthDensityProp))
{
watermat.SetVector(Executor.Settings.WaterDepthDensityProp, new Vector4(WaterDepthDensity, 0.1f, Mathf.Max(0.5f, Executor.UnderwaterDensity - 1), 0f));
}
if (!string.IsNullOrEmpty(Executor.Settings.WaterReflectionBlendProp))
{
watermat.SetFloat(Executor.Settings.WaterReflectionBlendProp, Mathf.Lerp(1f, WaterReflectionBlend, Executor.WaterReflectionMasterBlend));
}
if (!string.IsNullOrEmpty(Executor.Settings.WaterSunLightDirProp))
{
watermat.SetVector(Executor.Settings.WaterSunLightDirProp, -Executor.SunDirection);
}
}
Executor.Sun.SunLight.shadowStrength = ShadowStrength;
RenderSettings.ambientMode = UnityEngine.Rendering.AmbientMode.Trilight;
RenderSettings.ambientSkyColor = AmbientSkyColor;
RenderSettings.ambientEquatorColor = AmbientEquatorColor;
RenderSettings.ambientGroundColor = AmbientGroundColor;
RenderSettings.ambientIntensity = AmbientIntensity;
if (Executor.Settings.MainCamera != null)
{
SunShafts ss = Executor.Settings.MainCamera.GetComponent <SunShafts>();
if (ss != null)
{
ss.sunTransform = Executor.Sun.SunLight.transform;
ss.sunColor = SunShaftColor;
ss.sunShaftIntensity = SunShaftIntensity;
}
Bloom bloom = Executor.Settings.MainCamera.GetComponent <Bloom>();
if (bloom != null)
{
bloom.bloomIntensity = BloomIntensity;
bloom.bloomThreshold = BloomThreshold;
}
BlurOptimized blur = Executor.Settings.MainCamera.GetComponent <BlurOptimized>();
GlobalFog gf = Executor.Settings.MainCamera.GetComponent <GlobalFog>();
if (blur != null)
{
blur.enabled = Executor.Underwater > 0;
}
if (gf != null)
{
gf.enabled = Executor.Underwater > 0;
}
}
Executor.UpdateCameraEffects();
}
void Start()
{
sunShafts = GetComponent<SunShafts>();
}
private void UpdatePostProcess()
{
foreach (Camera cam in Camera.allCameras)
{
SMAA defAntiAlias = cam.GetComponent <SMAA>();
Bloom b = cam.GetComponent <Bloom>();
BloomAndFlares baf = cam.GetComponent <BloomAndFlares>();
ContrastEnhance ce = cam.GetComponent <ContrastEnhance>();
MotionBlur mb = cam.GetComponent <MotionBlur>();
WeaponDepthOfField wdof = cam.GetComponent <WeaponDepthOfField>();
SunShafts ss = cam.GetComponent <SunShafts>();
AmplifyOcclusionEffect ao = cam.GetComponent <AmplifyOcclusionEffect>();
ColorCorrection ccc = cam.GetComponent <ColorCorrection>();
if (defAntiAlias)
{
defAntiAlias.enabled = (antiAliasing == 1);
}
if (wdof)
{
wdof.enabled = (wDepthOfField == 1);
}
bool bloomBool = (bloom == 1);
if (baf)
{
baf.enabled = bloomBool;
}
if (b)
{
b.enabled = bloomBool;
}
if (ss)
{
ss.enabled = (sunShafts == 1);
}
if (mb)
{
mb.enabled = (motionBlur == 1);
}
bool ssaoBool = (SSAO == 1);
if (ao)
{
ao.enabled = ssaoBool;
}
bool ccBool = (colorCorrection == 1);
if (ccc)
{
ccc.enabled = ccBool;
}
if (ce)
{
ce.enabled = ccBool;
}
}
lastPP = Time.unscaledTime;
cameraCount = Camera.allCameras.Length;
}
void Start()
{
sunShafts = GetComponent <SunShafts>();
}
public static void InitExtra(SunShafts sunshafts)
{
sunshafts.useDepthTexture = false;
sunshafts.sunTransform = sunTransform;
}
void Start ()
{
uniStormSun = GameObject.Find("SunGlow");
sunShaftScript = GetComponent<Camera>().GetComponent<SunShafts>();
sunShaftScript.sunTransform = uniStormSun.transform;
}
//Gets all our needed components on Start
void GetAllComponents()
{
//Renderer Components
heavyCloudsLayer1Component = heavyCloudsLayer1.GetComponent<Renderer>();
lightClouds2Component = lightClouds2.GetComponent<Renderer>();
lightClouds3Component = lightClouds3.GetComponent<Renderer>();
lightClouds4Component = lightClouds4.GetComponent<Renderer>();
lightClouds5Component = lightClouds5.GetComponent<Renderer>();
highClouds1Component = highClouds1.GetComponent<Renderer>();
highClouds2Component = highClouds2.GetComponent<Renderer>();
mostlyCloudyCloudsComponent = mostlyCloudyClouds.GetComponent<Renderer>();
heavyCloudsComponent = heavyClouds.GetComponent<Renderer>();;
starSphereComponent = starSphere.GetComponent<Renderer>();
lightClouds1Component = lightClouds1.GetComponent<Renderer>();
lightClouds1aComponent = lightClouds1a.GetComponent<Renderer>();
heavyCloudsLayerLightComponent = heavyCloudsLayerLight.GetComponent<Renderer>();
partlyCloudyClouds1Component = partlyCloudyClouds1.GetComponent<Renderer>();
partlyCloudyClouds2Component = partlyCloudyClouds2.GetComponent<Renderer>();
mostlyCloudyClouds1Component = mostlyCloudyClouds1.GetComponent<Renderer>();
mostlyCloudyClouds2Component = mostlyCloudyClouds2.GetComponent<Renderer>();
moonObjectComponent = moonObject.GetComponent<Renderer>();
//Light Component
sunComponent = sun.GetComponent<Light>();
lightSourceComponent = lightSource.GetComponent<Light>();
moonComponent = moon.GetComponent<Light>();
//Sound Components
soundComponent = GetComponent<AudioSource>();
rainSoundComponent = rainSound.GetComponent<AudioSource>();
windSoundComponent = windSound.GetComponent<AudioSource>();
windSnowSoundComponent = windSnowSound.GetComponent<AudioSource>();
//Particle Components
mistFogComponent = mistFog.GetComponent<ParticleEmitter>();
//Other
cameraObjectComponent = cameraObject.GetComponent<Camera>();
//fogScript = cameraObjectComponent.GetComponent<GlobalFog>();
sunShaftScript = cameraObjectComponent.GetComponent<SunShafts>();
/*
if (fogScript == null)
{
Debug.LogError("Please apply a C# Global Fog Script to your camera GameObject.");
}
*/
if (sunShaftScript == null)
{
Debug.LogError("Please apply a C# Sun Shaft Script to your camera GameObject.");
}
}
void Refresh()
{
parser.Clear();
if (parser.DoesExist(IniFiles.CONFIG))
{
parser.Load(IniFiles.CONFIG);
}
else
{
gs.Create();
parser.Load(IniFiles.CONFIG);
}
DepthOfField34 dof = gameObject.GetComponent <DepthOfField34>();
Bloom blf = gameObject.GetComponent <Bloom>();
AmbientObscurance ssao = gameObject.GetComponent <AmbientObscurance>();
SunShafts sunshaft = gameObject.GetComponent <SunShafts>();
NoiseAndGrain nag = gameObject.GetComponent <NoiseAndGrain>();
EdgeDetectEffectNormals edn = gameObject.GetComponent <EdgeDetectEffectNormals>();
Vignetting vig = gameObject.GetComponent <Vignetting>();
if (bool.Parse(parser.Get("fx_enable")))
{
if (bool.Parse(parser.Get("fx_dof")))
{
dof.enabled = true;
dof.resolution = DofResolution.High;
dof.quality = bool.Parse(parser.Get("fx_dof_foreground")) ? Dof34QualitySetting.BackgroundAndForeground : Dof34QualitySetting.OnlyBackground;
dof.bokeh = bool.Parse(parser.Get("fx_dof_bokeh")) ? true : false;
dof.focalPoint = float.Parse(parser.Get("fx_dof_focaldistance"));
dof.smoothness = float.Parse(parser.Get("fx_dof_smoothness"));
dof.focalSize = float.Parse(parser.Get("fx_dof_focalSize"));
dof.visualize = bool.Parse(parser.Get("fx_dof_visualizeFocus"));
switch (parser.Get("fx_dof_blurriness"))
{
case "0":
dof.bluriness = DofBlurriness.Low;
break;
case "1":
dof.bluriness = DofBlurriness.High;
break;
case "2":
dof.bluriness = DofBlurriness.VeryHigh;
break;
default:
dof.bluriness = DofBlurriness.High;
break;
}
dof.maxBlurSpread = float.Parse(parser.Get("fx_dof_blurSpread"));
dof.foregroundBlurExtrude = float.Parse(parser.Get("fx_dof_foregroundSize"));
switch (parser.Get("fx_dof_bokeh_destination"))
{
case "0":
dof.bokehDestination = BokehDestination.Background;
break;
case "1":
dof.bokehDestination = BokehDestination.BackgroundAndForeground;
break;
case "2":
dof.bokehDestination = BokehDestination.Foreground;
break;
default:
dof.bokehDestination = BokehDestination.Background;
break;
}
dof.bokehIntensity = float.Parse(parser.Get("fx_dof_bokeh_intensity"));
dof.bokehThreshholdLuminance = float.Parse(parser.Get("fx_dof_bokeh_minLuminance"));
dof.bokehThreshholdContrast = float.Parse(parser.Get("fx_dof_bokeh_minContrast"));
dof.bokehDownsample = int.Parse(parser.Get("fx_dof_bokeh_DownSample"));
dof.bokehScale = float.Parse(parser.Get("fx_dof_bokeh_sizeScale"));
}
else
{
dof.enabled = false;
}
// SSAO
if (bool.Parse(parser.Get("fx_SSAO")))
{
ssao.enabled = true;
ssao.intensity = float.Parse(parser.Get("fx_SSAO_intensity"));
ssao.radius = float.Parse(parser.Get("fx_SSAO_radius"));
ssao.blurIterations = int.Parse(parser.Get("fx_SSAO_blurIterations"));
ssao.blurFilterDistance = float.Parse(parser.Get("fx_SSAO_blurFilterDistance"));
ssao.downsample = int.Parse(parser.Get("fx_SSAO_downsample"));
}
else
{
ssao.enabled = false;
}
// NOISE GRAIN
nag.enabled = bool.Parse(parser.Get("fx_noisegrain")) ? true : false;
nag.intensityMultiplier = float.Parse(parser.Get("fx_noisegrain_intensity"));
// BLOOM
if (bool.Parse(parser.Get("fx_bloom")))
{
blf.enabled = true;
switch (parser.Get("fx_bloom_quality"))
{
case "0":
blf.quality = Bloom.BloomQuality.Cheap;
break;
case "1":
blf.quality = Bloom.BloomQuality.High;
break;
default:
blf.quality = Bloom.BloomQuality.High;
break;
}
switch (parser.Get("fx_bloom_mode"))
{
case "0":
blf.tweakMode = Bloom.TweakMode.Basic;
break;
case "1":
blf.tweakMode = Bloom.TweakMode.Complex;
break;
default:
blf.tweakMode = Bloom.TweakMode.Complex;
break;
}
switch (parser.Get("fx_bloom_blendMode"))
{
case "0":
blf.screenBlendMode = Bloom.BloomScreenBlendMode.Screen;
break;
case "1":
blf.screenBlendMode = Bloom.BloomScreenBlendMode.Add;
break;
default:
blf.screenBlendMode = Bloom.BloomScreenBlendMode.Add;
break;
}
blf.hdr = bool.Parse(parser.Get("fx_bloom_hdr")) ? Bloom.HDRBloomMode.On : Bloom.HDRBloomMode.Off;
blf.bloomIntensity = float.Parse(parser.Get("fx_bloom_intensity"));
blf.bloomThreshhold = float.Parse(parser.Get("fx_bloom_threshhold"));
blf.bloomBlurIterations = int.Parse(parser.Get("fx_bloom_blurIterations"));
blf.blurWidth = float.Parse(parser.Get("fx_bloom_sampleDistance"));
switch (parser.Get("fx_bloom_lensFlareMode"))
{
case "0":
blf.lensflareMode = Bloom.LensFlareStyle.Ghosting;
break;
case "1":
blf.lensflareMode = Bloom.LensFlareStyle.Anamorphic;
break;
case "2":
blf.lensflareMode = Bloom.LensFlareStyle.Combined;
break;
default:
blf.lensflareMode = Bloom.LensFlareStyle.Ghosting;
break;
}
blf.lensflareIntensity = float.Parse(parser.Get("fx_bloom_LFlocalIntensity"));
blf.lensflareThreshhold = float.Parse(parser.Get("fx_bloom_LFthreshhold"));
}
else
{
blf.enabled = false;
}
// Sunshafts
if (bool.Parse(parser.Get("fx_sunshaft")))
{
sunshaft.enabled = true;
sunshaft.useDepthTexture = bool.Parse(parser.Get("fx_sunshaft_zBuffer"));
switch (parser.Get("fx_sunshaft_resolution"))
{
case "0":
sunshaft.resolution = SunShaftsResolution.Low;
break;
case "1":
sunshaft.resolution = SunShaftsResolution.Normal;
break;
case "2":
sunshaft.resolution = SunShaftsResolution.High;
break;
default:
sunshaft.resolution = SunShaftsResolution.Normal;
break;
}
switch (parser.Get("fx_sunshaft_blendMode"))
{
case "0":
sunshaft.screenBlendMode = ShaftsScreenBlendMode.Add;
break;
case "1":
sunshaft.screenBlendMode = ShaftsScreenBlendMode.Screen;
break;
default:
sunshaft.screenBlendMode = ShaftsScreenBlendMode.Screen;
break;
}
sunshaft.maxRadius = float.Parse(parser.Get("fx_sunshaft_distFalloff"));
sunshaft.sunShaftBlurRadius = float.Parse(parser.Get("fx_sunshaft_blurSize"));
sunshaft.radialBlurIterations = int.Parse(parser.Get("fx_sunshaft_blurIterations"));
sunshaft.sunShaftIntensity = float.Parse(parser.Get("fx_sunshaft_intensity"));
sunshaft.useSkyBoxAlpha = float.Parse(parser.Get("fx_sunshaft_alphaMask"));
}
else
{
sunshaft.enabled = false;
}
// Edge detect
edn.enabled = bool.Parse(parser.Get("fx_edgeDetect")) ? true : false;
// Vignetting
if (bool.Parse(parser.Get("fx_vignetting")))
{
vig.enabled = true;
vig.intensity = float.Parse(parser.Get("fx_vignetting_intensity"));
vig.blurSpread = float.Parse(parser.Get("fx_vignetting_blurredCornors"));
vig.chromaticAberration = float.Parse(parser.Get("fx_vignetting_aberration"));
}
else
{
vig.enabled = false;
}
}
else
{
dof.enabled = false;
ssao.enabled = false;
nag.enabled = false;
blf.enabled = false;
sunshaft.enabled = false;
edn.enabled = false;
vig.enabled = false;
}
}
void Start()
{
uniStormSun = GameObject.Find("SunGlow");
sunShaftScript = GetComponent <Camera>().GetComponent <SunShafts>();
sunShaftScript.sunTransform = uniStormSun.transform;
}
//<summary>
//Initializes the state at start
//Grabs the default values and stores them into the appropriate variables
//</summary>
void Start()
{
//Cache referenced components on camera object
bloom = gameObjects.mainCamera.GetComponent <Bloom>();
globalFog = gameObjects.mainCamera.GetComponent <GlobalFog>();
blur = gameObjects.mainCamera.GetComponent <BlurOptimized>();
vignette = gameObjects.mainCamera.GetComponent <VignetteAndChromaticAberration>();
noiseAndGrain = gameObjects.mainCamera.GetComponent <NoiseAndGrain>();
sunShafts = gameObjects.mainCamera.GetComponent <SunShafts>();
waterLensAudio = gameObjects.waterLens.GetComponent <AudioSource>();
airLensAudio = gameObjects.airLens.GetComponent <AudioSource>();
audioComp = GetComponent <AudioSource>();
cameraAudio = gameObjects.mainCamera.GetComponent <AudioSource>();
bubbleBehaviour = gameObjects.bubble.GetComponent <AQUAS_BubbleBehaviour>();
//Set initially active lenses
gameObjects.airLens.SetActive(true);
gameObjects.waterLens.SetActive(false);
//Assign materials
//waterLensMaterial = gameObjects.waterLens.GetComponent<Renderer> ().material;
airLensMaterial = gameObjects.airLens.GetComponent <Renderer> ().material;
waterPlaneMaterial = gameObjects.waterPlanes[0].GetComponent <Renderer> ().material;
t = wetLens.wetTime + wetLens.dryingTime;
t2 = 0;
bubbleSpawnTimer = 0;
//Initialize default values for ---
//--- global fog
defaultFog = RenderSettings.fog;
defaultFogDensity = RenderSettings.fogDensity;
defaultFogColor = RenderSettings.fogColor;
/*if (globalFog != null)
* {
* globalFog.enabled = defaultFog;
* }*/
//--- Some water parameters
defaultFoamContrast = waterPlaneMaterial.GetFloat("_FoamContrast");
defaultSpecularity = waterPlaneMaterial.GetFloat("_Specular");
if (waterPlaneMaterial.HasProperty("_Refraction"))
{
defaultRefraction = waterPlaneMaterial.GetFloat("_Refraction");
}
//--- image effects (if attached to the camera)
if (bloom != null)
{
defaultBloomIntensity = bloom.bloomIntensity;
}
if (sunShafts != null)
{
defaultSunShaftsEnabled = sunShafts.enabled;
}
if (bloom != null)
{
defaultBloomEnabled = bloom.enabled;
}
if (blur != null)
{
defaultBlurEnabled = blur.enabled;
}
if (vignette != null)
{
defaultVignetteEnabled = vignette.enabled;
}
if (noiseAndGrain != null)
{
defaultNoiseEnabled = noiseAndGrain.enabled;
}
audioComp.clip = soundEffects.sounds[0];
audioComp.loop = true;
audioComp.Stop();
airLensAudio.clip = soundEffects.sounds[1];
airLensAudio.loop = false;
airLensAudio.Stop();
waterLensAudio.clip = soundEffects.sounds[2];
waterLensAudio.loop = false;
waterLensAudio.Stop();
//Check if Tenkoku is in the scene
if (GameObject.Find("Tenkoku DynamicSky") != null)
{
tenkokuObj = GameObject.Find("Tenkoku DynamicSky");
}
}
// Token: 0x06000A30 RID: 2608 RVA: 0x00049EFC File Offset: 0x000480FC
private void SetEnv(EnvSetup env, float dayInt, float nightInt, float morningInt, float eveningInt, float dt)
{
Camera mainCamera = Utils.GetMainCamera();
if (mainCamera == null)
{
return;
}
this.m_dirLight.transform.rotation = Quaternion.Euler(-90f + env.m_sunAngle, 0f, 0f) * Quaternion.Euler(0f, -90f, 0f) * Quaternion.Euler(-90f + 360f * this.m_smoothDayFraction, 0f, 0f);
Vector3 v = -this.m_dirLight.transform.forward;
this.m_dirLight.intensity = env.m_lightIntensityDay * dayInt;
this.m_dirLight.intensity += env.m_lightIntensityNight * nightInt;
if (nightInt > 0f)
{
this.m_dirLight.transform.rotation = this.m_dirLight.transform.rotation * Quaternion.Euler(180f, 0f, 0f);
}
this.m_dirLight.transform.position = mainCamera.transform.position - this.m_dirLight.transform.forward * 3000f;
this.m_dirLight.color = new Color(0f, 0f, 0f, 0f);
this.m_dirLight.color += env.m_sunColorNight * nightInt;
if (dayInt > 0f)
{
this.m_dirLight.color += env.m_sunColorDay * dayInt;
this.m_dirLight.color += env.m_sunColorMorning * morningInt;
this.m_dirLight.color += env.m_sunColorEvening * eveningInt;
}
RenderSettings.fogColor = new Color(0f, 0f, 0f, 0f);
RenderSettings.fogColor += env.m_fogColorNight * nightInt;
RenderSettings.fogColor += env.m_fogColorDay * dayInt;
RenderSettings.fogColor += env.m_fogColorMorning * morningInt;
RenderSettings.fogColor += env.m_fogColorEvening * eveningInt;
this.m_sunFogColor = new Color(0f, 0f, 0f, 0f);
this.m_sunFogColor += env.m_fogColorSunNight * nightInt;
if (dayInt > 0f)
{
this.m_sunFogColor += env.m_fogColorSunDay * dayInt;
this.m_sunFogColor += env.m_fogColorSunMorning * morningInt;
this.m_sunFogColor += env.m_fogColorSunEvening * eveningInt;
}
this.m_sunFogColor = Color.Lerp(RenderSettings.fogColor, this.m_sunFogColor, Mathf.Clamp01(Mathf.Max(nightInt, dayInt) * 3f));
RenderSettings.fogDensity = 0f;
RenderSettings.fogDensity += env.m_fogDensityNight * nightInt;
RenderSettings.fogDensity += env.m_fogDensityDay * dayInt;
RenderSettings.fogDensity += env.m_fogDensityMorning * morningInt;
RenderSettings.fogDensity += env.m_fogDensityEvening * eveningInt;
RenderSettings.ambientMode = AmbientMode.Flat;
RenderSettings.ambientLight = Color.Lerp(env.m_ambColorNight, env.m_ambColorDay, dayInt);
SunShafts component = mainCamera.GetComponent <SunShafts>();
if (component)
{
component.sunColor = this.m_dirLight.color;
}
if (env.m_envObject != this.m_currentEnvObject)
{
if (this.m_currentEnvObject)
{
this.m_currentEnvObject.SetActive(false);
this.m_currentEnvObject = null;
}
if (env.m_envObject)
{
this.m_currentEnvObject = env.m_envObject;
this.m_currentEnvObject.SetActive(true);
}
}
if (env.m_psystems != this.m_currentPSystems)
{
if (this.m_currentPSystems != null)
{
this.SetParticleArrayEnabled(this.m_currentPSystems, false);
this.m_currentPSystems = null;
}
if (env.m_psystems != null && (!env.m_psystemsOutsideOnly || (Player.m_localPlayer && !Player.m_localPlayer.InShelter())))
{
this.SetParticleArrayEnabled(env.m_psystems, true);
this.m_currentPSystems = env.m_psystems;
}
}
this.m_clouds.material.SetFloat(this._Rain, env.m_rainCloudAlpha);
if (env.m_ambientLoop)
{
AudioMan.instance.QueueAmbientLoop(env.m_ambientLoop, env.m_ambientVol);
}
else
{
AudioMan.instance.StopAmbientLoop();
}
Shader.SetGlobalVector(this._SkyboxSunDir, v);
Shader.SetGlobalVector(this._SkyboxSunDir, v);
Shader.SetGlobalVector(this._SunDir, -this.m_dirLight.transform.forward);
Shader.SetGlobalColor(this._SunFogColor, this.m_sunFogColor);
Shader.SetGlobalColor(this._SunColor, this.m_dirLight.color * this.m_dirLight.intensity);
Shader.SetGlobalColor(this._AmbientColor, RenderSettings.ambientLight);
float num = Shader.GetGlobalFloat(this._Wet);
num = Mathf.MoveTowards(num, env.m_isWet ? 1f : 0f, dt / this.m_wetTransitionDuration);
Shader.SetGlobalFloat(this._Wet, num);
}
void Update()
{
if (Input.GetKeyDown(KeyCode.Escape))
{
if (ShowPM == true)
{
HidePM();
HideOM();
}
else if (ShowPM == false)
{
DrawPM();
}
}
if (ShowPM == true)
{
PauseMenuGroup.SetActive(true);
}
else
{
PauseMenuGroup.SetActive(false);
}
if (ShowOM == true)
{
OptionsMenuGroup.SetActive(true);
}
else
{
OptionsMenuGroup.SetActive(false);
}
if (ShowOM == false)
{
GeneralGroup.SetActive(false);
GraphicsGroup.SetActive(false);
SoundGroup.SetActive(false);
ControlsGroup.SetActive(false);
}
Toggle FT = FogToggler.transform.gameObject.GetComponent <Toggle>();
if (FT.isOn == true)
{
RenderSettings.fog = true;
}
else
{
RenderSettings.fog = false;
}
SunShafts SS = MainCam.transform.gameObject.GetComponent <SunShafts>();
Toggle SST = SunShaftsToggler.transform.gameObject.GetComponent <Toggle>();
if (SST.isOn == true)
{
SS.enabled = true;
}
else
{
SS.enabled = false;
}
SENaturalBloomAndDirtyLens NBAL = MainCam.transform.gameObject.GetComponent <SENaturalBloomAndDirtyLens>();
Toggle NBALT = NaturalBloomAndLensToggler.transform.gameObject.GetComponent <Toggle>();
if (NBALT.isOn == true)
{
NBAL.enabled = true;
}
else
{
NBAL.enabled = false;
}
}
// Use this for initialization
void Start()
{
manager = GameObject.FindWithTag("GameController");
if (numberOfCameras > 3)
{
cameras = GameObject.FindGameObjectsWithTag("MainCamera");
}
else
{
cameras = new GameObject[numberOfCameras];
if (numberOfCameras == 3)
{
cameras[0] = startCamera;
cameras[1] = secondCamera;
cameras[2] = lastCamera;
}
else if (numberOfCameras == 1)
{
cameras[0] = startCamera;
}
Grays = new List <Grayscale>();
Sepias = new List <SepiaTone>();
Blooms = new List <Bloom>();
Fogs = new List <GlobalFog>();
Antis = new List <Antialiasing>();
DOFs = new List <DepthOfField>();
Fishes = new List <Fisheye>();
Shafts = new List <SunShafts>();
foreach (var item in cameras)
{
item.AddComponent <Grayscale>();
Grayscale gs = item.GetComponent <Grayscale>();
Grayscale mgs = manager.GetComponent <Grayscale>();
gs.shader = mgs.shader;
gs.rampOffset = mgs.rampOffset;
Grays.Add(gs);
item.AddComponent <SepiaTone>();
SepiaTone st = item.GetComponent <SepiaTone>();
st.shader = manager.GetComponent <SepiaTone>().shader;
Sepias.Add(st);
item.AddComponent <Bloom>();
//print(name + " " + item.name);
Bloom bm = item.GetComponent <Bloom>();
Bloom mbm = manager.GetComponent <Bloom>();
bm.blurAndFlaresShader = mbm.blurAndFlaresShader;
bm.brightPassFilterShader = mbm.brightPassFilterShader;
bm.lensFlareShader = mbm.lensFlareShader;
bm.screenBlendShader = mbm.screenBlendShader;
bm.bloomThreshold = mbm.bloomThreshold;
bm.bloomIntensity = mbm.bloomIntensity;
Blooms.Add(bm);
item.AddComponent <GlobalFog>();
GlobalFog gf = item.GetComponent <GlobalFog>();
GlobalFog mgf = manager.GetComponent <GlobalFog>();
gf.fogShader = mgf.fogShader;
gf.excludeFarPixels = mgf.excludeFarPixels;
gf.height = mgf.height;
gf.heightDensity = mgf.heightDensity;
gf.startDistance = mgf.startDistance;
Fogs.Add(gf);
item.AddComponent <Antialiasing>();
Antialiasing ai = item.GetComponent <Antialiasing>();
Antialiasing mai = manager.GetComponent <Antialiasing>();
ai.shaderFXAAIII = mai.shaderFXAAIII;
ai.ssaaShader = mai.ssaaShader;
ai.edgeSharpness = mai.edgeSharpness;
ai.shaderFXAAII = mai.shaderFXAAII;
ai.shaderFXAAPreset2 = mai.shaderFXAAPreset2;
ai.shaderFXAAPreset3 = mai.shaderFXAAPreset3;
ai.dlaaShader = mai.dlaaShader;
ai.nfaaShader = mai.nfaaShader;
Antis.Add(ai);
item.AddComponent <DepthOfField>();
DepthOfField dof = item.GetComponent <DepthOfField>();
DepthOfField mdof = manager.GetComponent <DepthOfField>();
dof.dofHdrShader = mdof.dofHdrShader;
dof.dx11BokehShader = mdof.dx11BokehShader;
dof.focalSize = mdof.focalSize;
dof.aperture = mdof.aperture;
dof.focalTransform = transform;
DOFs.Add(dof);
item.AddComponent <Fisheye>();
Fisheye fe = item.GetComponent <Fisheye>();
Fisheye mfe = manager.GetComponent <Fisheye>();
fe.fishEyeShader = mfe.fishEyeShader;
fe.strengthX = mfe.strengthX;
fe.strengthY = mfe.strengthY;
Fishes.Add(fe);
item.AddComponent <SunShafts>();
SunShafts ss = item.GetComponent <SunShafts>();
SunShafts mss = manager.GetComponent <SunShafts>();
ss.simpleClearShader = mss.simpleClearShader;
ss.sunShaftsShader = mss.sunShaftsShader;
ss.sunShaftIntensity = mss.sunShaftIntensity;
ss.radialBlurIterations = mss.radialBlurIterations;
ss.maxRadius = mss.maxRadius;
ss.radialBlurIterations = mss.radialBlurIterations;
ss.resolution = mss.resolution;
ss.screenBlendMode = mss.screenBlendMode;
ss.sunColor = mss.sunColor;
ss.sunShaftBlurRadius = mss.sunShaftBlurRadius;
ss.sunThreshold = mss.sunThreshold;
ss.sunTransform = mss.sunTransform;
ss.useDepthTexture = mss.useDepthTexture;
Shafts.Add(ss);
}
foreach (Grayscale item in Grays)
{
item.enabled = false;
}
foreach (SepiaTone item in Sepias)
{
item.enabled = false;
}
foreach (Bloom item in Blooms)
{
item.enabled = false;
}
foreach (GlobalFog item in Fogs)
{
item.enabled = false;
}
foreach (DepthOfField item in DOFs)
{
item.enabled = false;
}
foreach (Antialiasing item in Antis)
{
item.enabled = false;
}
foreach (Fisheye item in Fishes)
{
item.enabled = false;
}
foreach (SunShafts item in Shafts)
{
item.enabled = false;
}
}
curentKeyIndex = 0;
if (SceneManager.GetActiveScene().buildIndex != 0)
{
setTop();
}
}
void OnGUI()
{
if (glow == null)
{
GameObject temp = GameObject.Find("Glowing");
if (temp != null)
{
glow = temp;
}
}
if (earth == null)
{
GameObject temp = GameObject.Find("Sphere");
if (temp != null)
{
earth = temp;
}
}
if (sun == null)
{
GameObject temp = GameObject.Find("Sun");
if (temp != null)
{
sun = temp;
}
}
GUI.Box(new Rect(10, 10, 220, 170), "Настройки эффектов");
GUI.Box(new Rect(10, 190, 220, 200), "Инструкции");
GUI.Label(new Rect(20, 240, 200, 40), "Левая кнопка мыши - вращение планеты");
GUI.Label(new Rect(20, 280, 200, 40), "Колесико мыши - масштаб камеры");
GUI.Label(new Rect(20, 320, 200, 40), "ESC - выход из программы");
bool newToggle = GUI.Toggle(new Rect(20, 40, 180, 20), sound, "Звук");
if (newToggle != sound)
{
sound = newToggle;
if (sound)
{
AudioListener.pause = false;
}
else
{
AudioListener.pause = true;
}
}
newToggle = GUI.Toggle(new Rect(20, 60, 180, 20), shining, "Свечение атмосферы");
if (newToggle != shining)
{
shining = newToggle;
if (shining)
{
glow.SetActive(true);
}
else
{
glow.SetActive(false);
}
}
newToggle = GUI.Toggle(new Rect(20, 80, 180, 20), clouds, "Облака");
if (newToggle != clouds)
{
clouds = newToggle;
if (clouds)
{
earth.renderer.materials[1].SetFloat("_Visibility", 1);
}
else
{
earth.renderer.materials[1].SetFloat("_Visibility", 0);
}
}
newToggle = GUI.Toggle(new Rect(20, 100, 180, 20), dirtyCamera, "Грязная камера");
if (newToggle != dirtyCamera)
{
dirtyCamera = newToggle;
if (dirtyCamera)
{
glareFxClassic flare = GetComponent <glareFxClassic>();
flare.enabled = true;
}
else
{
glareFxClassic flare = GetComponent <glareFxClassic>();
flare.enabled = false;
}
}
newToggle = GUI.Toggle(new Rect(20, 120, 180, 20), sunAmbient, "Солнечные лучи");
if (newToggle != sunAmbient)
{
sunAmbient = newToggle;
if (sunAmbient)
{
SunShafts shafts = GetComponent <SunShafts>();
shafts.enabled = true;
}
else
{
SunShafts shafts = GetComponent <SunShafts>();
shafts.enabled = false;
}
}
newToggle = GUI.Toggle(new Rect(20, 140, 180, 20), planetSpin, "Вращение планеты");
if (newToggle != planetSpin)
{
planetSpin = newToggle;
if (planetSpin)
{
TurnAround temp = sun.GetComponent <TurnAround>();
SU_Planet temp1 = earth.GetComponent <SU_Planet>();
temp.enabled = true;
temp1.enabled = true;
}
else
{
TurnAround temp = sun.GetComponent <TurnAround>();
SU_Planet temp1 = earth.GetComponent <SU_Planet>();
temp.enabled = false;
temp1.enabled = false;
}
}
}
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
if (!renderingData.cameraData.postProcessEnabled)
{
return;
}
var stack = VolumeManager.instance.stack;
m_SunShafts = stack.GetComponent <SunShafts>();
if (m_SunShafts == null)
{
return;
}
if (!m_SunShafts.IsActive())
{
return;
}
if (sunShaftsMaterial == null)
{
return;
}
var cmd = CommandBufferPool.Get(k_RenderTag);
if (RenderSettings.sun == null)
{
return;
}
Vector3 vSun;
bool positiveZ = UpdateSun(renderingData.cameraData.camera, out vSun);
int divider = 4;
if (m_SunShafts.resolution == SunShaftsResolution.Normal)
{
divider = 2;
}
if (!positiveZ)
{
return;
}
float sradius = m_SunShafts.sunShaftBlurRadius.value;
RenderTextureDescriptor desc = renderingData.cameraData.cameraTargetDescriptor;
var material = sunShaftsMaterial;
var destination = currentTarget;
cmd.SetGlobalTexture(MainTexId, destination);
cmd.GetTemporaryRT(TempTargetId, desc.width, desc.height, 0, FilterMode.Bilinear, desc.colorFormat);
cmd.Blit(destination, TempTargetId);
int rtW = desc.width / divider;
int rtH = desc.height / divider;
RenderTexture lrColorB;
RenderTexture lrDepthBuffer = RenderTexture.GetTemporary(rtW, rtH, 0, desc.colorFormat);
// mask out everything except the skybox
// we have 2 methods, one of which requires depth buffer support, the other one is just comparing images
material.SetVector("_SunPosition", new Vector4(vSun.x, vSun.y, vSun.z, m_SunShafts.maxRadius.value));
cmd.Blit(TempTargetId, lrDepthBuffer, material, 2);
// paint a small black small border to get rid of clamping problems
//DrawBorder(lrDepthBuffer, Color.clear);
// radial blur:
m_SunShafts.radialBlurIterations.value = Mathf.Clamp(m_SunShafts.radialBlurIterations.value, 1, 4);
int iter = m_SunShafts.radialBlurIterations.value;
float ofs = sradius * (1.0f / 768.0f);
material.SetVector("_BlurRadius4", new Vector4(ofs, ofs, 0.0f, 0.0f));
material.SetVector("_SunPosition", new Vector4(vSun.x, vSun.y, vSun.z, m_SunShafts.maxRadius.value));
for (int it2 = 0; it2 < iter; it2++)
{
// each iteration takes 2 * 6 samples
// we update _BlurRadius each time to cheaply get a very smooth look
lrColorB = RenderTexture.GetTemporary(rtW, rtH, 0, desc.colorFormat);
cmd.Blit(lrDepthBuffer, lrColorB, material, 1);
RenderTexture.ReleaseTemporary(lrDepthBuffer);
ofs = sradius * (((it2 * 2.0f + 1.0f) * 6.0f)) / 768.0f;
material.SetVector("_BlurRadius4", new Vector4(ofs, ofs, 0.0f, 0.0f));
lrDepthBuffer = RenderTexture.GetTemporary(rtW, rtH, 0, desc.colorFormat);
cmd.Blit(lrColorB, lrDepthBuffer, material, 1);
RenderTexture.ReleaseTemporary(lrColorB);
ofs = sradius * (((it2 * 2.0f + 2.0f) * 6.0f)) / 768.0f;
material.SetVector("_BlurRadius4", new Vector4(ofs, ofs, 0.0f, 0.0f));
}
if (m_SunShafts.lastBlur.value)
{
lrColorB = RenderTexture.GetTemporary(rtW, rtH, 0, desc.colorFormat);
cmd.Blit(lrDepthBuffer, lrColorB, material, 5);
RenderTexture.ReleaseTemporary(lrDepthBuffer);
lrDepthBuffer = RenderTexture.GetTemporary(rtW, rtH, 0, desc.colorFormat);
cmd.Blit(lrColorB, lrDepthBuffer, material, 6);
RenderTexture.ReleaseTemporary(lrColorB);
}
// put together:
material.SetTexture("_ColorBuffer", lrDepthBuffer);
cmd.Blit(TempTargetId, destination, material, (m_SunShafts.screenBlendMode == ShaftsScreenBlendMode.Screen) ? 0 : 4);
RenderTexture.ReleaseTemporary(lrDepthBuffer);
cmd.ReleaseTemporaryRT(TempTargetId);
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
