1265 lines
48 KiB
C#
1265 lines
48 KiB
C#
// Distant Lands 2024
|
|
// COZY: Stylized Weather 3
|
|
// All code included in this file is protected under the Unity Asset Store Eula
|
|
|
|
using DistantLands.Cozy.Data;
|
|
using System.Collections.Generic;
|
|
using System.Collections;
|
|
using UnityEngine;
|
|
using System;
|
|
using System.Linq;
|
|
using UnityEngine.Rendering;
|
|
using UnityEngine.SceneManagement;
|
|
|
|
|
|
#if UNITY_EDITOR
|
|
using UnityEditor;
|
|
#endif
|
|
|
|
namespace DistantLands.Cozy
|
|
{
|
|
|
|
[ExecuteAlways]
|
|
public class CozyWeather : CozySystem
|
|
{
|
|
|
|
#region Weather
|
|
public float cumulus;
|
|
public float cirrus;
|
|
public float altocumulus;
|
|
public float cirrostratus;
|
|
public float chemtrails;
|
|
public float nimbus;
|
|
public float nimbusHeightEffect;
|
|
public float nimbusVariation;
|
|
public float borderHeight;
|
|
public float borderEffect;
|
|
public float borderVariation;
|
|
public float fogDensity;
|
|
|
|
public float cloudCoverage => cumulus;
|
|
|
|
#endregion
|
|
|
|
#region Atmosphere
|
|
|
|
[Tooltip("Should the atmosphere be set using the physical sun height or the time of day")]
|
|
public bool usePhysicalSunHeight;
|
|
public float sunDirection;
|
|
public float sunPitch;
|
|
public Vector3 moonDirection;
|
|
[ColorUsage(true, true)] public Color skyZenithColor;
|
|
[ColorUsage(true, true)] public Color skyHorizonColor;
|
|
[ColorUsage(true, true)] public Color cloudColor;
|
|
[ColorUsage(true, true)] public Color cloudHighlightColor;
|
|
[ColorUsage(true, true)] public Color highAltitudeCloudColor;
|
|
[ColorUsage(true, true)] public Color sunlightColor;
|
|
[ColorUsage(true, true)] public Color starColor;
|
|
[ColorUsage(true, true)] public Color ambientLightHorizonColor;
|
|
[ColorUsage(true, true)] public Color ambientLightZenithColor;
|
|
public float ambientLightMultiplier;
|
|
public float galaxyIntensity;
|
|
[ColorUsage(true, true)] public Color fogColor1;
|
|
[ColorUsage(true, true)] public Color fogColor2;
|
|
[ColorUsage(true, true)] public Color fogColor3;
|
|
[ColorUsage(true, true)] public Color fogColor4;
|
|
[ColorUsage(true, true)] public Color fogColor5;
|
|
[ColorUsage(true, true)] public Color fogFlareColor;
|
|
[ColorUsage(true, true)] public Color fogMoonFlareColor;
|
|
[ColorUsage(true, true)] public Color fogShadowColor;
|
|
[ColorUsage(true, true)] public Color fogLitColor;
|
|
public float gradientExponent = 0.364f;
|
|
public float sunSize = 0.7f;
|
|
[ColorUsage(true, true)] public Color sunColor;
|
|
[ColorUsage(true, true)] public Color moonColor;
|
|
public float sunFalloff = 43.7f;
|
|
[ColorUsage(true, true)] public Color sunFlareColor;
|
|
public float moonFalloff = 24.4f;
|
|
[ColorUsage(true, true)] public Color moonlightColor;
|
|
[ColorUsage(true, true)] public Color moonFlareColor;
|
|
[ColorUsage(true, true)] public Color galaxy1Color;
|
|
[ColorUsage(true, true)] public Color galaxy2Color;
|
|
[ColorUsage(true, true)] public Color galaxy3Color;
|
|
[ColorUsage(true, true)] public Color lightScatteringColor;
|
|
public float rainbowPosition = 78.7f;
|
|
public float rainbowWidth = 11;
|
|
public float fogStart1 = 2;
|
|
public float fogStart2 = 5;
|
|
public float fogStart3 = 10;
|
|
public float fogStart4 = 30;
|
|
public float fogHeight = 0.85f;
|
|
public float fogDensityMultiplier;
|
|
public float fogLightFlareIntensity = 1;
|
|
public float fogLightFlareFalloff = 21;
|
|
public float fogLightFlareSquish = 1;
|
|
public float fogSmoothness;
|
|
public float fogVariationAmount;
|
|
public Vector3 fogVariationDirection;
|
|
public float fogVariationDistance;
|
|
public float fogVariationScale;
|
|
|
|
public float heightFogIntensity = 0f;
|
|
public float heightFogVariationScale = 150f;
|
|
public float heightFogVariationAmount = 150f;
|
|
public float fogBase = 0f;
|
|
public float heightFogTransition = 0f;
|
|
public float heightFogDistance = 1000f;
|
|
[ColorUsage(true, true)] public Color heightFogColor;
|
|
|
|
[ColorUsage(true, true)] public Color cloudMoonColor;
|
|
public float cloudSunHighlightFalloff = 14.1f;
|
|
public float cloudMoonHighlightFalloff = 22.9f;
|
|
public float cloudWindSpeed = 3;
|
|
public float clippingThreshold = 0.5f;
|
|
public float cloudMainScale = 20;
|
|
public float cloudDetailScale = 2.3f;
|
|
public float cloudDetailAmount = 30;
|
|
public float acScale = 1;
|
|
public float cirroMoveSpeed = 0.5f;
|
|
public float cirrusMoveSpeed = 0.5f;
|
|
public float chemtrailsMoveSpeed = 0.5f;
|
|
[ColorUsage(true, true)] public Color cloudTextureColor = Color.white;
|
|
public float cloudCohesion = 0.75f;
|
|
public float spherize = 0.361f;
|
|
public float shadowDistance = 0.0288f;
|
|
public float cloudThickness = 2f;
|
|
public float textureAmount = 1f;
|
|
public Texture cloudTexture;
|
|
public Texture chemtrailsTexture;
|
|
public Texture cirrusCloudTexture;
|
|
public Texture altocumulusCloudTexture;
|
|
public Texture cirrostratusCloudTexture;
|
|
public Texture starMap;
|
|
public Texture galaxyMap;
|
|
public Texture galaxyStarMap;
|
|
public Texture galaxyVariationMap;
|
|
public Texture lightScatteringMap;
|
|
public Vector3 texturePanDirection;
|
|
public Texture partlyCloudyLuxuryClouds;
|
|
public Texture mostlyCloudyLuxuryClouds;
|
|
public Texture overcastLuxuryClouds;
|
|
public Texture lowBorderLuxuryClouds;
|
|
public Texture highBorderLuxuryClouds;
|
|
public Texture lowNimbusLuxuryClouds;
|
|
public Texture midNimbusLuxuryClouds;
|
|
public Texture highNimbusLuxuryClouds;
|
|
public Texture luxuryVariation;
|
|
|
|
public float rainbowIntensity;
|
|
public bool useRainbow;
|
|
public bool separateSunLightAndTransform;
|
|
public float sunAngle = 0.5f;
|
|
public LightShadows sunlightShadows = LightShadows.Soft;
|
|
public LightShadows moonlightShadows = LightShadows.Soft;
|
|
#if COZY_URP || COZY_HDRP
|
|
public AtmosphereProfile.SRPFlare sunFlare;
|
|
public AtmosphereProfile.SRPFlare moonFlare;
|
|
#endif
|
|
|
|
#endregion
|
|
|
|
#region Filter
|
|
public float filterSaturation;
|
|
public float filterValue;
|
|
public Color filterColor;
|
|
public Color sunFilter;
|
|
public Color cloudFilter;
|
|
|
|
#endregion
|
|
|
|
#region Runtime Variables
|
|
|
|
private float adjustedScale;
|
|
|
|
public enum LockToCameraStyle { useMainCamera, useCustomCamera, DontLockToCamera }
|
|
|
|
[Tooltip("Should the weather sphere always follow the camera and automatically rescale to the scene size?")]
|
|
public LockToCameraStyle lockToCamera;
|
|
public static bool FreezeUpdateInEditMode = false;
|
|
public static bool DisplayGizmos = true;
|
|
public static bool SceneFogRendering = true;
|
|
public static bool Tooltips
|
|
{
|
|
get
|
|
{
|
|
#if UNITY_EDITOR
|
|
return EditorPrefs.GetBool("CZY_Tooltips", true);
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
set
|
|
{
|
|
#if UNITY_EDITOR
|
|
EditorPrefs.SetBool("CZY_Tooltips", value);
|
|
#endif
|
|
}
|
|
}
|
|
public static bool Graphs
|
|
{
|
|
get
|
|
{
|
|
#if UNITY_EDITOR
|
|
return EditorPrefs.GetBool("CZY_Graphs", true);
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
set
|
|
{
|
|
#if UNITY_EDITOR
|
|
EditorPrefs.SetBool("CZY_Graphs", value);
|
|
#endif
|
|
}
|
|
}
|
|
public static bool FollowEditorCamera = true;
|
|
public bool disableSunAtNight = true;
|
|
public bool handleSceneLighting = true;
|
|
public bool dontDestroyOnLoad;
|
|
|
|
#endregion
|
|
|
|
#region References
|
|
|
|
|
|
[SerializeField]
|
|
[Tooltip("Set the color of these particle systems to the star color of the weather system.")]
|
|
private List<ParticleSystem> m_Stars = new List<ParticleSystem>();
|
|
[Tooltip("Set the color of these particle systems to the cloud color of the weather system.")]
|
|
[SerializeField]
|
|
private List<ParticleSystem> m_CloudParticles = new List<ParticleSystem>();
|
|
|
|
|
|
public Light sunLight;
|
|
public Transform sunTransform;
|
|
public bool centerAroundCustomObject;
|
|
public Transform customPivot;
|
|
public MeshRenderer cloudMesh;
|
|
public MeshRenderer skyMesh;
|
|
public MeshRenderer fogMesh;
|
|
public Camera cozyCamera;
|
|
#if COZY_URP || COZY_HDRP
|
|
public LensFlareComponentSRP sunLensFlare;
|
|
#endif
|
|
|
|
|
|
#endregion
|
|
|
|
#region Modules
|
|
|
|
public List<Type> activeModules;
|
|
|
|
public CozyInteractionsModule interactionsModule;
|
|
public CozyClimateModule climateModule;
|
|
public CozyWeatherModule weatherModule;
|
|
public CozyTimeModule timeModule;
|
|
public CozyAtmosphereModule atmosphereModule;
|
|
public CozyWindModule windModule;
|
|
|
|
public delegate void RefreshModules();
|
|
public static event RefreshModules refreshModules;
|
|
|
|
|
|
#endregion
|
|
|
|
#region Events
|
|
|
|
[System.Serializable]
|
|
public class Events
|
|
{
|
|
|
|
public float timeToCheckFor;
|
|
public int currentMinute;
|
|
public int currentHour;
|
|
|
|
public delegate void OnEvening();
|
|
public static event OnEvening onEvening;
|
|
public void RaiseOnEvening() => onEvening?.Invoke();
|
|
public delegate void OnMorning();
|
|
public static event OnMorning onMorning;
|
|
public void RaiseOnMorning() => onMorning?.Invoke();
|
|
public delegate void OnNewHour();
|
|
public static event OnNewHour onNewHour;
|
|
public void RaiseOnNewHour() => onNewHour?.Invoke();
|
|
public delegate void OnMinutePass();
|
|
public static event OnMinutePass onNewMinute;
|
|
public void RaiseOnMinutePass() => onNewMinute?.Invoke();
|
|
public delegate void OnNight();
|
|
public static event OnNight onNight;
|
|
public void RaiseOnNight() => onNight?.Invoke();
|
|
public delegate void OnDay();
|
|
public static event OnDay onDay;
|
|
public void RaiseOnDay() => onDay?.Invoke();
|
|
public delegate void OnDawn();
|
|
public static event OnDawn onDawn;
|
|
public void RaiseOnDawn() => onDawn?.Invoke();
|
|
public delegate void OnAfternoon();
|
|
public static event OnAfternoon onAfternoon;
|
|
public void RaiseOnAfternoon() => onAfternoon?.Invoke();
|
|
public delegate void OnTwilight();
|
|
public static event OnTwilight onTwilight;
|
|
public void RaiseOnTwilight() => onTwilight?.Invoke();
|
|
public delegate void OnWeatherChange();
|
|
public static event OnWeatherChange onWeatherChange;
|
|
public void RaiseOnWeatherChange() => onWeatherChange?.Invoke();
|
|
public delegate void OnDayChange();
|
|
public static event OnDayChange onNewDay;
|
|
public void RaiseOnDayChange() => onNewDay?.Invoke();
|
|
public delegate void OnYearChange();
|
|
public static event OnYearChange onNewYear;
|
|
public void RaiseOnYearChange() => onNewYear?.Invoke();
|
|
|
|
}
|
|
|
|
public Events events;
|
|
|
|
|
|
#endregion
|
|
|
|
#region Triggers
|
|
[Tooltip("The tag that contains all triggers that stop weather FX from playing.")]
|
|
public string cozyTriggerTag = "FX Block Zone";
|
|
|
|
[HideInInspector]
|
|
public List<Collider> cozyTriggers;
|
|
public Dictionary<int, List<Collider>> triggersPerScene = new();
|
|
|
|
#endregion
|
|
|
|
#region Ecosystem
|
|
public List<CozySystem> systems;
|
|
|
|
|
|
#endregion
|
|
|
|
#region FX
|
|
|
|
public Transform audioFXParent;
|
|
public Transform particleFXParent;
|
|
public Transform thunderFXParent;
|
|
public Transform visualFXParent;
|
|
|
|
#endregion
|
|
|
|
#region Execution
|
|
|
|
public delegate void FrameResetDelegate();
|
|
public static event FrameResetDelegate OnFrameReset;
|
|
public void RaiseOnFrameReset()
|
|
{
|
|
OnFrameReset?.Invoke();
|
|
}
|
|
public delegate void UpdateWeatherWeightsDelegate();
|
|
public static event UpdateWeatherWeightsDelegate UpdateWeatherWeights;
|
|
public void RaiseUpdateWeatherWeights() => UpdateWeatherWeights?.Invoke();
|
|
public delegate void UpdateFXWeightsDelegate();
|
|
public static event UpdateFXWeightsDelegate UpdateFXWeights;
|
|
public void RaiseUpdateFXWeights() => UpdateFXWeights?.Invoke();
|
|
public delegate void PropogateVariablesDelegate();
|
|
public static event PropogateVariablesDelegate PropogateVariables;
|
|
public void RaisePropogateVariables() => PropogateVariables?.Invoke();
|
|
public delegate void CozyUpdateLoopDelegate();
|
|
public static event CozyUpdateLoopDelegate CozyUpdateLoop;
|
|
public void RaiseCozyUpdateLoop() => CozyUpdateLoop?.Invoke();
|
|
|
|
#endregion
|
|
|
|
public enum ControlMethod { native, profile }
|
|
|
|
public enum SkyStyle { desktop, mobile, off }
|
|
public SkyStyle skyStyle;
|
|
|
|
public enum CloudStyle
|
|
{
|
|
cozyDesktop,
|
|
cozyMobile,
|
|
soft,
|
|
paintedSkies,
|
|
luxury,
|
|
ghibliDesktop,
|
|
ghibliMobile,
|
|
singleTexture,
|
|
off
|
|
}
|
|
public CloudStyle cloudStyle;
|
|
|
|
public enum FogStyle
|
|
{
|
|
unity,
|
|
stylized,
|
|
heightFog,
|
|
steppedFog,
|
|
// volumetric,
|
|
off
|
|
}
|
|
|
|
public FogStyle fogStyle = FogStyle.stylized;
|
|
public CozyModule overrideWeather;
|
|
|
|
public GameObject moduleHolder;
|
|
public List<CozyModule> modules = new List<CozyModule>();
|
|
public IEnumerable<CozyModule> ActiveAndEnabledModules => modules.Where(module => module.isActiveAndEnabled);
|
|
|
|
public void SetupReferences()
|
|
{
|
|
if (!separateSunLightAndTransform)
|
|
{
|
|
sunLight = GetChild<Light>("Sun Light");
|
|
if (sunLight == null)
|
|
sunLight = GetChild<Light>("Sun");
|
|
|
|
sunTransform = sunLight.transform;
|
|
}
|
|
skyMesh = GetChild("Skydome").GetComponent<MeshRenderer>();
|
|
cloudMesh = GetChild("Foreground Clouds").GetComponent<MeshRenderer>();
|
|
fogMesh = GetChild("Fog").GetComponent<MeshRenderer>();
|
|
audioFXParent = GetChild("Audio FX");
|
|
particleFXParent = GetChild("Particle FX");
|
|
visualFXParent = GetChild("Visual FX");
|
|
thunderFXParent = GetChild("Thunder FX");
|
|
|
|
#if COZY_URP || COZY_HDRP
|
|
if (sunFlare.flare != null)
|
|
if (sunLight.GetComponent<LensFlareComponentSRP>())
|
|
sunLensFlare = sunLight.GetComponent<LensFlareComponentSRP>();
|
|
else
|
|
sunLensFlare = sunLight.gameObject.AddComponent<LensFlareComponentSRP>();
|
|
#endif
|
|
|
|
if (cozyTriggers.Count == 0)
|
|
ResetFXTriggers();
|
|
|
|
if (handleSceneLighting)
|
|
RenderSettings.ambientMode = AmbientMode.Trilight;
|
|
|
|
}
|
|
|
|
private new void OnEnable()
|
|
{
|
|
base.OnEnable();
|
|
SceneManager.sceneLoaded += UpdateOnSceneLoaded;
|
|
SceneManager.sceneUnloaded += UpdateOnSceneUnLoaded;
|
|
#if UNITY_EDITOR
|
|
SceneView.beforeSceneGui += UpdateSkydomePositionAndScale;
|
|
#endif
|
|
}
|
|
|
|
private void OnDisable()
|
|
{
|
|
SceneManager.sceneLoaded -= UpdateOnSceneLoaded;
|
|
SceneManager.sceneUnloaded -= UpdateOnSceneUnLoaded;
|
|
#if UNITY_EDITOR
|
|
SceneView.beforeSceneGui -= UpdateSkydomePositionAndScale;
|
|
#endif
|
|
}
|
|
|
|
private void Awake()
|
|
{
|
|
|
|
SetupReferences();
|
|
ResetModules();
|
|
ResetVariables();
|
|
ResetQuality();
|
|
UpdateShaderVariables();
|
|
CozyShaderIDs.GrabShaderIDs();
|
|
|
|
if (Application.isPlaying)
|
|
{
|
|
if (dontDestroyOnLoad)
|
|
DontDestroyOnLoad(this);
|
|
ResetFXTriggers();
|
|
}
|
|
}
|
|
|
|
public void SetupSystems()
|
|
{
|
|
systems = new List<CozySystem>() { this };
|
|
systems.AddRange(FindObjectsByType<CozySystem>(FindObjectsSortMode.None).Where(x => x != this));
|
|
}
|
|
|
|
public void ResetFXTriggers()
|
|
{
|
|
cozyTriggers.Clear();
|
|
foreach (Collider i in FindObjectsByType<Collider>(FindObjectsSortMode.None))
|
|
{
|
|
if (i.gameObject.tag == cozyTriggerTag)
|
|
{
|
|
cozyTriggers.Add(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void UpdateTriggersInScene(Scene scene)
|
|
{
|
|
var rootGameObjects = scene.GetRootGameObjects();
|
|
|
|
if (!GetBlockZonesFromObjects(rootGameObjects, out var blockZones))
|
|
{
|
|
return;
|
|
}
|
|
|
|
triggersPerScene.Add(scene.handle, blockZones);
|
|
RefreshTriggers();
|
|
}
|
|
|
|
public void RemoveTriggersInScene(Scene scene)
|
|
{
|
|
triggersPerScene.Remove(scene.handle);
|
|
RefreshTriggers();
|
|
}
|
|
|
|
public bool GetBlockZonesFromObjects(IEnumerable<GameObject> gameObjects, out List<Collider> blockZones)
|
|
{
|
|
blockZones = gameObjects
|
|
.SelectMany(item => FindChildrenComponentsByTag<Collider>(item.transform, cozyTriggerTag))
|
|
.ToList();
|
|
|
|
return blockZones.Count > 0;
|
|
}
|
|
|
|
public void RefreshTriggers()
|
|
{
|
|
var colliders = triggersPerScene.Values.SelectMany(trigger => trigger);
|
|
cozyTriggers.Clear();
|
|
cozyTriggers.AddRange(colliders);
|
|
|
|
var cozyParticles = particleFXParent.GetComponentsInChildren<CozyParticles>();
|
|
|
|
foreach (var cozyParticle in cozyParticles)
|
|
{
|
|
cozyParticle.SetupTriggers();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resets all of the material shaders to the shaders in the atmosphere profiles.
|
|
/// </summary>
|
|
public void ResetQuality()
|
|
{
|
|
|
|
SetupReferences();
|
|
|
|
|
|
switch (cloudStyle)
|
|
{
|
|
case CloudStyle.cozyDesktop:
|
|
cloudMesh.sharedMaterial.shader = ((Material)Resources.Load("Materials/Desktop Clouds Reference")).shader;
|
|
break;
|
|
case CloudStyle.cozyMobile:
|
|
cloudMesh.sharedMaterial.shader = ((Material)Resources.Load("Materials/Mobile Clouds Reference")).shader;
|
|
break;
|
|
case CloudStyle.ghibliDesktop:
|
|
cloudMesh.sharedMaterial.shader = ((Material)Resources.Load("Materials/Desktop Ghibli Clouds Reference")).shader;
|
|
break;
|
|
case CloudStyle.ghibliMobile:
|
|
cloudMesh.sharedMaterial.shader = ((Material)Resources.Load("Materials/Mobile Ghibli Clouds Reference")).shader;
|
|
break;
|
|
case CloudStyle.paintedSkies:
|
|
cloudMesh.sharedMaterial.shader = ((Material)Resources.Load("Materials/Painted Clouds Reference")).shader;
|
|
break;
|
|
case CloudStyle.luxury:
|
|
cloudMesh.sharedMaterial.shader = ((Material)Resources.Load("Materials/Luxury Clouds Reference")).shader;
|
|
break;
|
|
case CloudStyle.soft:
|
|
cloudMesh.sharedMaterial.shader = ((Material)Resources.Load("Materials/Soft Clouds Reference")).shader;
|
|
break;
|
|
case CloudStyle.singleTexture:
|
|
cloudMesh.sharedMaterial.shader = ((Material)Resources.Load("Materials/Single Texture Reference")).shader;
|
|
break;
|
|
case CloudStyle.off:
|
|
cloudMesh.sharedMaterial.shader = ((Material)Resources.Load("Materials/Disabled")).shader;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
switch (skyStyle)
|
|
{
|
|
case SkyStyle.desktop:
|
|
skyMesh.sharedMaterial.shader = ((Material)Resources.Load("Materials/Desktop Sky Reference")).shader;
|
|
break;
|
|
case SkyStyle.mobile:
|
|
skyMesh.sharedMaterial.shader = ((Material)Resources.Load("Materials/Mobile Sky Reference")).shader;
|
|
break;
|
|
case SkyStyle.off:
|
|
skyMesh.sharedMaterial.shader = ((Material)Resources.Load("Materials/Disabled")).shader;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
switch (fogStyle)
|
|
{
|
|
case FogStyle.stylized:
|
|
fogMesh.sharedMaterial.shader = ((Material)Resources.Load("Materials/Default Fog Reference")).shader;
|
|
RenderSettings.fog = false;
|
|
break;
|
|
case FogStyle.heightFog:
|
|
fogMesh.sharedMaterial.shader = ((Material)Resources.Load("Materials/Height Fog Reference")).shader;
|
|
RenderSettings.fog = false;
|
|
break;
|
|
// case FogStyle.volumetric:
|
|
// fogMesh.sharedMaterial.shader = ((Material)Resources.Load("Materials/Volumetric Fog Reference")).shader;
|
|
// RenderSettings.fog = false;
|
|
// break;
|
|
case FogStyle.steppedFog:
|
|
fogMesh.sharedMaterial.shader = ((Material)Resources.Load("Materials/Stepped Fog Reference")).shader;
|
|
RenderSettings.fog = false;
|
|
break;
|
|
case FogStyle.unity:
|
|
fogMesh.sharedMaterial.shader = ((Material)Resources.Load("Materials/Disabled")).shader;
|
|
RenderSettings.fog = true;
|
|
break;
|
|
case FogStyle.off:
|
|
fogMesh.sharedMaterial.shader = ((Material)Resources.Load("Materials/Disabled")).shader;
|
|
// RenderSettings.fog = false;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Update is called once per frame
|
|
void Update()
|
|
{
|
|
|
|
RaiseOnFrameReset();
|
|
RaiseUpdateWeatherWeights();
|
|
RaiseUpdateFXWeights();
|
|
RaisePropogateVariables();
|
|
RaiseCozyUpdateLoop();
|
|
|
|
}
|
|
|
|
void LateUpdate()
|
|
{
|
|
if (Application.isPlaying)
|
|
{
|
|
UpdateSkydomePositionAndScale();
|
|
return;
|
|
}
|
|
else if (Application.isFocused)
|
|
UpdateSkydomePositionAndScale();
|
|
}
|
|
|
|
public void UpdateSkydomePositionAndScale()
|
|
{
|
|
if (lockToCamera != LockToCameraStyle.DontLockToCamera || centerAroundCustomObject)
|
|
{
|
|
|
|
if (lockToCamera == LockToCameraStyle.useMainCamera && cozyCamera == null)
|
|
cozyCamera = Camera.main;
|
|
|
|
if (cozyCamera != null)
|
|
{
|
|
adjustedScale = cozyCamera.farClipPlane / 1000;
|
|
transform.GetChild(0).localScale = Vector3.one * adjustedScale;
|
|
}
|
|
|
|
if (centerAroundCustomObject && customPivot)
|
|
transform.position = customPivot.position;
|
|
else if (cozyCamera)
|
|
transform.position = cozyCamera.transform.position;
|
|
}
|
|
}
|
|
|
|
#if UNITY_EDITOR
|
|
public void UpdateSkydomePositionAndScale(SceneView sceneView)
|
|
{
|
|
SceneFogRendering = sceneView.sceneViewState.fogEnabled;
|
|
|
|
if (FreezeUpdateInEditMode || !FollowEditorCamera || Application.isFocused)
|
|
return;
|
|
|
|
if (lockToCamera != LockToCameraStyle.DontLockToCamera)
|
|
{
|
|
if (lockToCamera == LockToCameraStyle.useMainCamera)
|
|
cozyCamera = Camera.main;
|
|
|
|
if (cozyCamera != null)
|
|
{
|
|
if (Application.isPlaying)
|
|
{
|
|
transform.position = cozyCamera.transform.position;
|
|
adjustedScale = cozyCamera.farClipPlane / 1000;
|
|
}
|
|
else if (Camera.current != null)
|
|
{
|
|
transform.position = sceneView.camera.transform.position;
|
|
adjustedScale = sceneView.camera.farClipPlane / 1000;
|
|
|
|
if (GetModule<CozySatelliteModule>(out CozySatelliteModule module))
|
|
{
|
|
if (module.satHolder)
|
|
module.satHolder.position = transform.position;
|
|
}
|
|
}
|
|
|
|
transform.GetChild(0).localScale = Vector3.one * adjustedScale;
|
|
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/// <summary>
|
|
/// Sets the actual global shader variables of the sky dome, fog dome, and cloud dome.
|
|
/// </summary>
|
|
public void UpdateShaderVariables()
|
|
{
|
|
if (CozyShaderIDs.CZY_FogColor1ID == 0)
|
|
{
|
|
CozyShaderIDs.GrabShaderIDs();
|
|
}
|
|
if (FreezeUpdateInEditMode && !Application.isPlaying)
|
|
return;
|
|
|
|
if (fogStyle is FogStyle.stylized or FogStyle.heightFog or FogStyle.steppedFog/** or FogStyle.volumetric*/)
|
|
{
|
|
Shader.SetGlobalColor(CozyShaderIDs.CZY_FogColor1ID, fogColor1);
|
|
Shader.SetGlobalColor(CozyShaderIDs.CZY_FogColor2ID, fogColor2);
|
|
Shader.SetGlobalColor(CozyShaderIDs.CZY_FogColor3ID, fogColor3);
|
|
Shader.SetGlobalColor(CozyShaderIDs.CZY_FogColor4ID, fogColor4);
|
|
Shader.SetGlobalColor(CozyShaderIDs.CZY_FogColor5ID, fogColor5);
|
|
|
|
Shader.SetGlobalColor(CozyShaderIDs.CZY_FogLitColorID, fogShadowColor);
|
|
Shader.SetGlobalColor(CozyShaderIDs.CZY_FogShadowColorID, fogLitColor);
|
|
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_FogColorStart1ID, fogStart1);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_FogColorStart2ID, fogStart2);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_FogColorStart3ID, fogStart3);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_FogColorStart4ID, fogStart4);
|
|
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_FogIntensityID, fogDensity);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_FogOffsetID, fogHeight);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_LightFlareSquishID, fogLightFlareSquish);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_FogSmoothnessID, fogSmoothness);
|
|
#if UNITY_EDITOR
|
|
if (Application.isPlaying)
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_FogDepthMultiplierID, fogDensityMultiplier * fogDensity);
|
|
else
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_FogDepthMultiplierID, fogDensityMultiplier * fogDensity * (SceneFogRendering ? 1 : 0));
|
|
#else
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_FogDepthMultiplierID, fogDensityMultiplier * fogDensity);
|
|
#endif
|
|
Shader.SetGlobalColor(CozyShaderIDs.CZY_LightColorID, fogFlareColor);
|
|
Shader.SetGlobalColor(CozyShaderIDs.CZY_FogMoonFlareColorID, fogMoonFlareColor);
|
|
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_VariationAmountID, fogVariationAmount);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_VariationScaleID, fogVariationScale);
|
|
Shader.SetGlobalVector(CozyShaderIDs.CZY_VariationWindDirectionID, fogVariationDirection);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_VariationDistanceID, fogVariationDistance);
|
|
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_LightFalloffID, fogLightFlareFalloff);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_LightIntensityID, fogLightFlareIntensity);
|
|
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_HeightFogBaseID, fogBase);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_HeightFogBaseVariationScaleID, heightFogVariationScale);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_HeightFogBaseVariationAmountID, heightFogVariationAmount);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_HeightFogTransitionID, heightFogTransition);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_HeightFogDistanceID, heightFogDistance);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_HeightFogIntensityID, heightFogIntensity);
|
|
Shader.SetGlobalColor(CozyShaderIDs.CZY_HeightFogColorID, heightFogColor);
|
|
}
|
|
|
|
Shader.SetGlobalColor(CozyShaderIDs.CZY_FilterColorID, filterColor);
|
|
Shader.SetGlobalColor(CozyShaderIDs.CZY_SunFilterColorID, sunFilter);
|
|
Shader.SetGlobalColor(CozyShaderIDs.CZY_CloudFilterColorID, cloudFilter);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_FilterSaturationID, filterSaturation);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_FilterValueID, filterValue);
|
|
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_CumulusCoverageMultiplierID, cumulus);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_NimbusMultiplierID, nimbus);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_NimbusHeightID, nimbusHeightEffect);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_NimbusVariationID, nimbusVariation);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_BorderHeightID, borderHeight);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_BorderEffectID, borderEffect);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_BorderVariationID, borderVariation);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_AltocumulusMultiplierID, altocumulus);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_CirrostratusMultiplierID, cirrostratus);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_ChemtrailsMultiplierID, chemtrails);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_CirrusMultiplierID, cirrus);
|
|
Shader.SetGlobalTexture(CozyShaderIDs.CZY_CloudTextureID, cloudTexture);
|
|
Shader.SetGlobalTexture(CozyShaderIDs.CZY_ChemtrailsTextureID, chemtrailsTexture);
|
|
Shader.SetGlobalTexture(CozyShaderIDs.CZY_CirrusTextureID, cirrusCloudTexture);
|
|
Shader.SetGlobalTexture(CozyShaderIDs.CZY_CirrostratusTextureID, cirrostratusCloudTexture);
|
|
Shader.SetGlobalTexture(CozyShaderIDs.CZY_AltocumulusTextureID, altocumulusCloudTexture);
|
|
Shader.SetGlobalTexture(CozyShaderIDs.CZY_StarMapID, starMap);
|
|
Shader.SetGlobalTexture(CozyShaderIDs.CZY_GalaxyStarMapID, galaxyStarMap);
|
|
Shader.SetGlobalTexture(CozyShaderIDs.CZY_GalaxyVariationMapID, galaxyVariationMap);
|
|
Shader.SetGlobalTexture(CozyShaderIDs.CZY_LightScatteringMapID, lightScatteringMap);
|
|
Shader.SetGlobalTexture(CozyShaderIDs.CZY_GalaxyMapID, galaxyMap);
|
|
Shader.SetGlobalVector(CozyShaderIDs.CZY_TexturePanDirectionID, texturePanDirection);
|
|
Shader.SetGlobalColor(CozyShaderIDs.CZY_ZenithColorID, skyZenithColor);
|
|
Shader.SetGlobalColor(CozyShaderIDs.CZY_HorizonColorID, skyHorizonColor);
|
|
Shader.SetGlobalColor(CozyShaderIDs.CZY_StarColorID, starColor);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_GalaxyMultiplierID, galaxyIntensity);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_RainbowIntensityID, rainbowIntensity);
|
|
|
|
Shader.SetGlobalTexture(CozyShaderIDs.CZY_PartlyCloudyLuxuryCloudsTextureID, partlyCloudyLuxuryClouds);
|
|
Shader.SetGlobalTexture(CozyShaderIDs.CZY_MostlyCloudyLuxuryCloudsTextureID, mostlyCloudyLuxuryClouds);
|
|
Shader.SetGlobalTexture(CozyShaderIDs.CZY_OvercastLuxuryCloudsTextureID, overcastLuxuryClouds);
|
|
Shader.SetGlobalTexture(CozyShaderIDs.CZY_LowBorderLuxuryCloudsTextureID, lowBorderLuxuryClouds);
|
|
Shader.SetGlobalTexture(CozyShaderIDs.CZY_HighBorderLuxuryCloudsTextureID, highBorderLuxuryClouds);
|
|
Shader.SetGlobalTexture(CozyShaderIDs.CZY_LowNimbusLuxuryCloudsTextureID, lowNimbusLuxuryClouds);
|
|
Shader.SetGlobalTexture(CozyShaderIDs.CZY_MidNimbusLuxuryCloudsTextureID, midNimbusLuxuryClouds);
|
|
Shader.SetGlobalTexture(CozyShaderIDs.CZY_HighNimbusLuxuryCloudsTextureID, highNimbusLuxuryClouds);
|
|
Shader.SetGlobalTexture(CozyShaderIDs.CZY_LuxuryVariationTextureID, luxuryVariation);
|
|
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_PowerID, gradientExponent);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_SunSizeID, sunSize);
|
|
Shader.SetGlobalColor(CozyShaderIDs.CZY_SunColorID, sunColor);
|
|
Shader.SetGlobalColor(CozyShaderIDs.CZY_MoonColorID, moonColor);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_SunHaloFalloffID, sunFalloff);
|
|
Shader.SetGlobalColor(CozyShaderIDs.CZY_SunHaloColorID, sunFlareColor);
|
|
Shader.SetGlobalColor(CozyShaderIDs.CZY_MoonFlareColorID, moonFlareColor);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_MoonFlareFalloffID, moonFalloff);
|
|
Shader.SetGlobalColor(CozyShaderIDs.CZY_GalaxyColor1ID, galaxy1Color);
|
|
Shader.SetGlobalColor(CozyShaderIDs.CZY_GalaxyColor2ID, galaxy2Color);
|
|
Shader.SetGlobalColor(CozyShaderIDs.CZY_GalaxyColor3ID, galaxy3Color);
|
|
Shader.SetGlobalColor(CozyShaderIDs.CZY_LightColumnColorID, lightScatteringColor);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_RainbowSizeID, rainbowPosition);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_RainbowWidthID, rainbowWidth);
|
|
|
|
if (windModule)
|
|
Shader.SetGlobalVector(CozyShaderIDs.CZY_StormDirectionID, windModule.WindDirection);
|
|
else
|
|
Shader.SetGlobalVector(CozyShaderIDs.CZY_StormDirectionID, -Vector3.right);
|
|
|
|
Shader.SetGlobalColor(CozyShaderIDs.CZY_CloudColorID, cloudColor);
|
|
Shader.SetGlobalColor(CozyShaderIDs.CZY_CloudHighlightColorID, cloudHighlightColor);
|
|
Shader.SetGlobalColor(CozyShaderIDs.CZY_AltoCloudColorID, highAltitudeCloudColor);
|
|
Shader.SetGlobalColor(CozyShaderIDs.CZY_CloudTextureColorID, cloudTextureColor);
|
|
Shader.SetGlobalColor(CozyShaderIDs.CZY_CloudMoonColorID, cloudMoonColor);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_SunFlareFalloffID, cloudSunHighlightFalloff);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_CloudMoonFalloffID, cloudMoonHighlightFalloff);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_WindSpeedID, cloudWindSpeed);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_CloudCohesionID, cloudCohesion);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_SpherizeID, spherize);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_ShadowingDistanceID, shadowDistance);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_ClippingThresholdID, clippingThreshold);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_CloudThicknessID, cloudThickness);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_MainCloudScaleID, cloudMainScale);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_DetailScaleID, cloudDetailScale);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_DetailAmountID, cloudDetailAmount);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_TextureAmountID, textureAmount);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_AltocumulusScaleID, acScale);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_CirrostratusMoveSpeedID, cirroMoveSpeed);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_CirrusMoveSpeedID, cirrusMoveSpeed);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_ChemtrailsMoveSpeedID, chemtrailsMoveSpeed);
|
|
Shader.SetGlobalFloat(CozyShaderIDs.CZY_DayPercentageID, modifiedDayPercentage);
|
|
|
|
|
|
if (fogStyle == FogStyle.unity)
|
|
{
|
|
|
|
RenderSettings.fogColor = FilterColor(fogColor5);
|
|
RenderSettings.fogDensity = 0.003f * fogDensity * fogDensityMultiplier;
|
|
|
|
}
|
|
|
|
|
|
sunTransform.parent.eulerAngles = new Vector3(0, sunDirection, sunPitch);
|
|
sunTransform.localEulerAngles = new Vector3((modifiedDayPercentage * 360) - 90, 0, 0);
|
|
Shader.SetGlobalVector(CozyShaderIDs.CZY_SunDirectionID, -sunTransform.forward);
|
|
#if COZY_URP || COZY_HDRP
|
|
if (sunLensFlare)
|
|
{
|
|
sunLensFlare.intensity = sunFlare.flare ? (sunlightColor * sunFilter).grayscale * sunFlare.intensity : 0;
|
|
sunLensFlare.lensFlareData = sunFlare.flare;
|
|
sunLensFlare.allowOffScreen = sunFlare.allowOffscreen;
|
|
sunLensFlare.radialScreenAttenuationCurve = sunFlare.screenAttenuation;
|
|
sunLensFlare.distanceAttenuationCurve = sunFlare.screenAttenuation;
|
|
sunLensFlare.scale = sunFlare.scale;
|
|
sunLensFlare.occlusionRadius = sunFlare.occlusionRadius;
|
|
sunLensFlare.useOcclusion = sunFlare.useOcclusion;
|
|
}
|
|
#endif
|
|
if (handleSceneLighting)
|
|
{
|
|
sunLight.color = sunlightColor * sunFilter;
|
|
if (disableSunAtNight)
|
|
sunLight.enabled = sunLight.color.r + sunLight.color.g + sunLight.color.b > 0;
|
|
}
|
|
else
|
|
{
|
|
sunLight.enabled = false;
|
|
}
|
|
|
|
sunLight.shadows = sunLight.enabled ? sunlightShadows : LightShadows.None;
|
|
|
|
if (climateModule)
|
|
{
|
|
if (useRainbow)
|
|
rainbowIntensity = climateModule.groundwaterAmount * (1 - galaxyIntensity);
|
|
else
|
|
rainbowIntensity = 0;
|
|
}
|
|
|
|
if (handleSceneLighting)
|
|
{
|
|
RenderSettings.sun = sunLight;
|
|
RenderSettings.defaultReflectionMode = DefaultReflectionMode.Custom;
|
|
RenderSettings.ambientMode = AmbientMode.Trilight;
|
|
RenderSettings.ambientSkyColor = ambientLightZenithColor * ambientLightMultiplier;
|
|
RenderSettings.ambientEquatorColor = ambientLightHorizonColor * (1 - (cumulus / 2)) * ambientLightMultiplier;
|
|
RenderSettings.ambientGroundColor = ambientLightHorizonColor * Color.gray * (1 - (cumulus / 2)) * ambientLightMultiplier;
|
|
}
|
|
|
|
SetStarColors(starColor);
|
|
SetCloudColors(cloudColor);
|
|
|
|
|
|
}
|
|
|
|
|
|
public T GetFXRuntimeRef<T>(string name) where T : Component
|
|
{
|
|
if (this == null)
|
|
return null;
|
|
|
|
return GetComponentsInChildren<T>().ToList().Find(x => x.transform.name == name);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the input color filtered by the current weather filter.
|
|
/// </summary>
|
|
public Color FilterColor(Color color)
|
|
{
|
|
float a = color.a;
|
|
Color j;
|
|
|
|
|
|
Color.RGBToHSV(color, out float h, out float s, out float v);
|
|
|
|
s = Mathf.Clamp(s + filterSaturation, 0, 10);
|
|
v = Mathf.Clamp(v + filterValue, 0, 10);
|
|
j = Color.HSVToRGB(h, s, v);
|
|
|
|
j *= filterColor;
|
|
j.a = a;
|
|
|
|
return j;
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Statically sets variables. Only used on awake or in the editor.
|
|
/// </summary>
|
|
public void ResetVariables()
|
|
{
|
|
rainbowIntensity = climateModule ? useRainbow ? climateModule.groundwaterAmount * (1 - starColor.a) : 0 : 0;
|
|
|
|
ambientLightHorizonColor = FilterColor(ambientLightHorizonColor);
|
|
ambientLightZenithColor = FilterColor(ambientLightZenithColor);
|
|
|
|
}
|
|
|
|
public float dayPercentage
|
|
{
|
|
get
|
|
{
|
|
float dayPercent = sunAngle;
|
|
|
|
if (timeModule)
|
|
{
|
|
dayPercent = timeModule.currentTime;
|
|
}
|
|
|
|
return dayPercent;
|
|
}
|
|
}
|
|
public float yearPercentage
|
|
{
|
|
get
|
|
{
|
|
float yearPercentage = 0.5f;
|
|
|
|
if (timeModule)
|
|
{
|
|
yearPercentage = timeModule.yearPercentage;
|
|
}
|
|
|
|
return yearPercentage;
|
|
}
|
|
}
|
|
public float modifiedDayPercentage
|
|
{
|
|
get
|
|
{
|
|
float dayPercent = sunAngle;
|
|
|
|
if (timeModule)
|
|
{
|
|
dayPercent = timeModule.modifiedDayPercentage;
|
|
}
|
|
|
|
return dayPercent;
|
|
}
|
|
}
|
|
|
|
|
|
#region Modules
|
|
|
|
/// <summary>
|
|
/// Makes sure that all module connections are setup properly. Run this after adding or removing a module.
|
|
/// </summary>
|
|
public void ResetModules()
|
|
{
|
|
|
|
moduleHolder = GetChild("Modules").gameObject;
|
|
modules = moduleHolder.GetComponents<CozyModule>().ToList();
|
|
|
|
if (!interactionsModule)
|
|
interactionsModule = GetModule<CozyInteractionsModule>();
|
|
|
|
if (!timeModule)
|
|
timeModule = GetModule<CozyTimeModule>();
|
|
|
|
if (!weatherModule)
|
|
weatherModule = GetModule<CozyWeatherModule>();
|
|
|
|
modules.RemoveAll(x => x == null);
|
|
|
|
refreshModules?.Invoke();
|
|
|
|
}
|
|
|
|
public void InitializeModule(Type module)
|
|
{
|
|
|
|
if (GetModule(module))
|
|
{
|
|
Debug.LogWarning($"Cannot add {module.Name} because the current COZY instance already contains this module.");
|
|
return;
|
|
}
|
|
|
|
CozyModule newModule = (CozyModule)moduleHolder.AddComponent(module);
|
|
if (!newModule.CheckIfModuleCanBeAdded(out string warning))
|
|
{
|
|
Debug.LogWarning($"Cannot add {module.Name} due to a conflict with {warning}.");
|
|
DestroyImmediate(newModule);
|
|
return;
|
|
}
|
|
|
|
modules.Add(newModule);
|
|
ResetModules();
|
|
|
|
}
|
|
|
|
public void ResetModule(CozyModule module)
|
|
{
|
|
StartCoroutine(ResetModuleRoutine(module));
|
|
}
|
|
|
|
public IEnumerator ResetModuleRoutine(CozyModule module)
|
|
{
|
|
|
|
Type savedType = module.GetType();
|
|
|
|
if (!module.CheckIfModuleCanBeRemoved(out string warning))
|
|
{
|
|
Debug.LogWarning($"Module cannot be reset as it has dependencies on the weather sphere. Please remove the {warning} before resetting this module!");
|
|
yield break;
|
|
}
|
|
modules.Remove(module);
|
|
DestroyImmediate(module);
|
|
ResetModules();
|
|
|
|
yield return null;
|
|
|
|
CozyModule newModule = (CozyModule)moduleHolder.AddComponent(savedType);
|
|
|
|
modules.Add(newModule);
|
|
ResetModules();
|
|
|
|
}
|
|
|
|
public void DeintitializeModule(CozyModule module)
|
|
{
|
|
if (!module.CheckIfModuleCanBeRemoved(out string warning))
|
|
{
|
|
Debug.LogWarning($"Module cannot be removed as it has dependencies on the weather sphere. Please remove the {warning} before removing this module!");
|
|
return;
|
|
}
|
|
modules.Remove(module);
|
|
DestroyImmediate(module);
|
|
ResetModules();
|
|
|
|
|
|
}
|
|
|
|
public T GetModule<T>() where T : CozyModule
|
|
{
|
|
Type type = typeof(T);
|
|
|
|
return moduleHolder.GetComponent(type) ? moduleHolder.GetComponent(type) as T : null;
|
|
}
|
|
public T GetModule<T>(out T module) where T : CozyModule
|
|
{
|
|
Type type = typeof(T);
|
|
|
|
module = moduleHolder.GetComponent(type) ? moduleHolder.GetComponent(type) as T : null;
|
|
|
|
return module;
|
|
}
|
|
|
|
public CozyModule GetModule(Type type)
|
|
{
|
|
|
|
return moduleHolder.GetComponent(type) ? moduleHolder.GetComponent(type) as CozyModule : null;
|
|
}
|
|
|
|
public void UpdateOnSceneLoaded(Scene scene, LoadSceneMode mode)
|
|
{
|
|
UpdateTriggersInScene(scene);
|
|
|
|
foreach (var module in ActiveAndEnabledModules)
|
|
{
|
|
module.OnSceneLoaded();
|
|
}
|
|
}
|
|
|
|
public void UpdateOnSceneUnLoaded(Scene scene)
|
|
{
|
|
RemoveTriggersInScene(scene);
|
|
|
|
foreach (var module in ActiveAndEnabledModules)
|
|
{
|
|
module.OnSceneUnloaded();
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Generic
|
|
|
|
public Transform GetChild(string name)
|
|
{
|
|
|
|
foreach (Transform i in transform.GetComponentsInChildren<Transform>())
|
|
{
|
|
if (i.name == name)
|
|
return i;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
public T GetChild<T>(string name) where T : Component
|
|
{
|
|
|
|
foreach (T i in transform.GetComponentsInChildren<T>())
|
|
{
|
|
if (i.name == name)
|
|
return i;
|
|
}
|
|
|
|
return default;
|
|
}
|
|
|
|
public List<T> FindChildrenComponentsByTag<T>(Transform parentTransform, string tag)
|
|
where T : Component
|
|
{
|
|
var components = new List<T>();
|
|
|
|
foreach (Transform child in parentTransform)
|
|
{
|
|
if (child && child.CompareTag(tag))
|
|
{
|
|
var component = child.GetComponent<T>();
|
|
|
|
if (component)
|
|
{
|
|
components.Add(component);
|
|
}
|
|
}
|
|
|
|
components.AddRange(FindChildrenComponentsByTag<T>(child, tag));
|
|
}
|
|
|
|
return components;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the current instance of Cozy in the scene. Returns null if no weather sphere is found.
|
|
/// </summary>
|
|
public static CozyWeather instance
|
|
{
|
|
|
|
get
|
|
{
|
|
if (cachedInstance)
|
|
return cachedInstance;
|
|
|
|
cachedInstance = FindObjectOfType<CozyWeather>();
|
|
return cachedInstance;
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
private static CozyWeather cachedInstance;
|
|
|
|
/// <summary>
|
|
/// Sets the colors of the star particle systems.
|
|
/// </summary>
|
|
private void SetStarColors(Color color)
|
|
{
|
|
|
|
if (m_Stars.Count == 0)
|
|
return;
|
|
|
|
foreach (ParticleSystem i in m_Stars)
|
|
{
|
|
|
|
if (i == null)
|
|
continue;
|
|
|
|
ParticleSystem.MainModule j = i.main;
|
|
j.startColor = color;
|
|
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the colors of the cloud particle systems.
|
|
/// </summary>
|
|
private void SetCloudColors(Color color)
|
|
{
|
|
if (m_CloudParticles.Count == 0)
|
|
return;
|
|
|
|
foreach (ParticleSystem i in m_CloudParticles)
|
|
{
|
|
if (i == null)
|
|
continue;
|
|
|
|
ParticleSystem.MainModule j = i.main;
|
|
j.startColor = color;
|
|
|
|
ParticleSystem.TrailModule k = i.trails;
|
|
k.colorOverLifetime = color;
|
|
|
|
}
|
|
}
|
|
|
|
public void SetStyle(SkyStyle style)
|
|
{
|
|
skyStyle = style;
|
|
}
|
|
|
|
public void SetStyle(FogStyle style)
|
|
{
|
|
fogStyle = style;
|
|
}
|
|
|
|
public void SetStyle(CloudStyle style)
|
|
{
|
|
cloudStyle = style;
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
}
|
|
} |