fix:风机初始化代码提交

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Base.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c99ea6cc0d13f90479d9672cdcb7dd2d
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Base/EnviroBaseInspector.cs

@@ -0,0 +1,234 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine; 
+using UnityEditor;
+using System;
+using System.Linq;
+using UnityEditor.Build;
+
+public class EnviroBaseInspector : Editor
+{
+    public SerializedObject serializedObj;
+    public GUIStyle boxStyle;
+    public GUIStyle boxStyleModified;
+    public GUIStyle wrapStyle;
+    public GUIStyle headerStyle;
+    public GUIStyle headerStyleMid;
+    public GUIStyle headerFoldout;
+    public GUIStyle popUpStyle;
+    public GUIStyle integrationBox;
+    public GUIStyle helpButton;
+    public bool showHelpBox;
+
+    public Color baseModuleColor = new Color(0.0f, 0.0f, 0.5f, 1f);
+    public Color categoryModuleColor = new Color(0.5f, 0.5f, 0.0f, 1f);
+    public Color thirdPartyModuleColor = new Color(0.0f, 0.5f, 0.5f, 1f);
+
+    public void SetupGUIStyles()
+    {
+        if (boxStyle == null)
+        {
+            boxStyle = new GUIStyle(GUI.skin.box);
+            boxStyle.normal.textColor = GUI.skin.label.normal.textColor;
+            boxStyle.fontStyle = FontStyle.Bold;
+            boxStyle.alignment = TextAnchor.UpperLeft;
+        }
+
+        if (boxStyleModified == null)
+        {
+            boxStyleModified = new GUIStyle(EditorStyles.helpBox);
+            boxStyleModified.normal.textColor = GUI.skin.label.normal.textColor;
+            boxStyleModified.fontStyle = FontStyle.Bold;
+            boxStyleModified.fontSize = 11;
+            boxStyleModified.alignment = TextAnchor.UpperLeft;
+        }
+
+        if (integrationBox == null)
+        {
+            integrationBox = new GUIStyle(EditorStyles.helpBox);
+            integrationBox.fontStyle = FontStyle.Bold;
+            integrationBox.fontSize = 11;
+        }
+
+        if (wrapStyle == null)
+        {
+            wrapStyle = new GUIStyle(GUI.skin.label);
+            wrapStyle.fontStyle = FontStyle.Normal;
+            wrapStyle.wordWrap = true;
+        }
+
+        if (headerStyle == null)
+        {
+            headerStyle = new GUIStyle(GUI.skin.label);
+            headerStyle.fontStyle = FontStyle.Bold;
+            headerStyle.alignment = TextAnchor.UpperLeft;
+        }
+
+        if (headerStyleMid == null)
+        {
+            headerStyleMid = new GUIStyle(GUI.skin.label);
+            headerStyleMid.fontStyle = FontStyle.Bold;
+            headerStyleMid.alignment = TextAnchor.MiddleCenter;
+        }
+
+        if (headerFoldout == null)
+        {
+            headerFoldout = new GUIStyle(EditorStyles.foldout);
+            headerFoldout.fontStyle = FontStyle.Bold;
+        }
+
+        if (popUpStyle == null)
+        {
+            popUpStyle = new GUIStyle(EditorStyles.popup);
+            popUpStyle.alignment = TextAnchor.MiddleCenter;
+            popUpStyle.fixedHeight = 20f;
+            popUpStyle.fontStyle = FontStyle.Bold;
+        }
+
+        if (helpButton == null)
+        {
+            helpButton = new GUIStyle(EditorStyles.miniButtonRight);
+            //helpButton.alignment = TextAnchor.UpperRight;
+            helpButton.margin = new RectOffset(100, 0, 0, 0);
+
+        }
+    }
+
+    public void RenderHelpBoxButton()
+    {
+        //Help Box Button
+        EditorGUILayout.BeginHorizontal();
+        GUILayout.FlexibleSpace();
+        if (GUILayout.Button("?", EditorStyles.miniButton, GUILayout.Width(20), GUILayout.Height(20)))
+        {
+            if (showHelpBox)
+                showHelpBox = false;
+            else
+                showHelpBox = true;
+        }
+        EditorGUILayout.EndHorizontal();
+        //End Help Box Button
+    }
+
+    public void RenderHelpBox(string content)
+    {
+        // GUILayout.BeginVertical("",EditorStyles.helpBox);
+        GUILayout.Label(content, EditorStyles.helpBox);
+    }
+
+    public void RenderIntegrationTextBox(string content)
+    {
+        // GUILayout.BeginVertical("",EditorStyles.helpBox);
+        GUILayout.Label(content, integrationBox);
+    }
+
+    public void RenderDisableInputBox()
+    {
+        if (Enviro.EnviroManager.instance != null)
+        {
+            if (Enviro.EnviroManager.instance.Weather != null && Enviro.EnviroManager.instance.Quality != null)
+            {
+                //both
+                GUILayout.Label("Some settings are controlled from weather and quality modules!", EditorStyles.helpBox);
+            }
+            else if (Enviro.EnviroManager.instance.Weather != null && Enviro.EnviroManager.instance.Quality == null)
+            {
+                //Weather Only
+                GUILayout.Label("Some settings are controlled from weather modules!", EditorStyles.helpBox);
+            }
+            else if (Enviro.EnviroManager.instance.Weather == null && Enviro.EnviroManager.instance.Quality != null)
+            {
+                // Quality Only
+                GUILayout.Label("Some settings are controlled from quality modules!", EditorStyles.helpBox);
+            }
+            else
+            {
+                //Show Nothing
+            }
+
+        }
+    }
+
+    public void ApplyChanges()
+    {
+        if (EditorGUI.EndChangeCheck())
+        {
+            serializedObj.ApplyModifiedProperties();
+        }
+    }
+
+    public static void AddDefineSymbol(string symbol)
+    {
+        var targets = Enum.GetValues(typeof(BuildTargetGroup))
+            .Cast<BuildTargetGroup>()
+            .Where(x => x != BuildTargetGroup.Unknown)
+            .Where(x => !IsObsolete(x));
+
+        foreach (var target in targets)
+        {
+#if UNITY_6000_0_OR_NEWER
+            var namedTarget = NamedBuildTarget.FromBuildTargetGroup(target);
+            var defines = PlayerSettings.GetScriptingDefineSymbols(namedTarget).Trim();
+#else
+            var defines = PlayerSettings.GetScriptingDefineSymbolsForGroup(target).Trim();
+#endif
+
+            var list = defines.Split(new[] { ';', ' ' }, StringSplitOptions.RemoveEmptyEntries)
+                .ToList();
+
+            if (list.Contains(symbol))
+                continue;
+
+            list.Add(symbol);
+            defines = string.Join(";", list);
+
+#if UNITY_6000_0_OR_NEWER
+            PlayerSettings.SetScriptingDefineSymbols(namedTarget, defines);
+#else
+            PlayerSettings.SetScriptingDefineSymbolsForGroup(target, defines);
+#endif
+        }
+    }
+
+    private static bool IsObsolete(BuildTargetGroup group)
+    {
+        var field = typeof(BuildTargetGroup).GetField(group.ToString());
+        if (field == null)
+            return false;
+
+        var attrs = field.GetCustomAttributes(typeof(ObsoleteAttribute), false);
+        return attrs != null && attrs.Length > 0;
+    }
+
+    public static void RemoveDefineSymbol(string symbol)
+    {
+        var targets = Enum.GetValues(typeof(BuildTargetGroup))
+            .Cast<BuildTargetGroup>()
+            .Where(x => x != BuildTargetGroup.Unknown)
+            .Where(x => !IsObsolete(x));
+
+        foreach (var target in targets)
+        {
+#if UNITY_6000_0_OR_NEWER
+            var namedTarget = NamedBuildTarget.FromBuildTargetGroup(target);
+            var defines = PlayerSettings.GetScriptingDefineSymbols(namedTarget).Trim();
+#else
+            var defines = PlayerSettings.GetScriptingDefineSymbolsForGroup(target).Trim();
+#endif
+            var list = defines.Split(new[] { ';', ' ' }, StringSplitOptions.RemoveEmptyEntries)
+                .ToList();
+
+            if (list.Contains(symbol))
+            {
+                list.RemoveAll(s => s == symbol);
+                defines = string.Join(";", list);
+
+#if UNITY_6000_0_OR_NEWER
+                PlayerSettings.SetScriptingDefineSymbols(namedTarget, defines);
+#else
+                PlayerSettings.SetScriptingDefineSymbolsForGroup(target, defines);
+#endif
+            }
+        }
+    }
+}

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Base/EnviroBaseInspector.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 26dd26530f29ea04ebc5387cdebeebb8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 236601
+  packageName: Enviro 3 - Sky and Weather
+  packageVersion: 3.1.2
+  assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Base/EnviroBaseInspector.cs
+  uploadId: 660896

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Base/EnviroDefineSymbol.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Linq;
+using UnityEditor;
+using UnityEditor.Build;
+ 
+[InitializeOnLoad]
+sealed class EnviroDefineSymbol
+{
+    const string k_Define = "ENVIRO_3";
+
+    static EnviroDefineSymbol()
+{
+    var targets = Enum.GetValues(typeof(BuildTargetGroup))
+        .Cast<BuildTargetGroup>()
+        .Where(x => x != BuildTargetGroup.Unknown)
+        .Where(x => !IsObsolete(x));
+
+    foreach (var target in targets)
+    {
+#if UNITY_6000_0_OR_NEWER
+        var namedTarget = NamedBuildTarget.FromBuildTargetGroup(target);
+        var defines = PlayerSettings.GetScriptingDefineSymbols(namedTarget).Trim();
+#else
+        var defines = PlayerSettings.GetScriptingDefineSymbolsForGroup(target).Trim();
+#endif
+
+        var list = defines.Split(new[] { ';', ' ' }, StringSplitOptions.RemoveEmptyEntries)
+            .ToList();
+
+        if (list.Contains(k_Define))
+            continue;
+
+        list.Add(k_Define);
+        defines = string.Join(";", list);
+
+#if UNITY_6000_0_OR_NEWER
+        PlayerSettings.SetScriptingDefineSymbols(namedTarget, defines);
+#else
+        PlayerSettings.SetScriptingDefineSymbolsForGroup(target, defines);
+#endif
+    }
+}
+
+    static bool IsObsolete(BuildTargetGroup group)
+    {
+        var attrs = typeof(BuildTargetGroup)
+            .GetField(group.ToString())
+            .GetCustomAttributes(typeof(ObsoleteAttribute), false);
+
+        return attrs != null && attrs.Length > 0;
+    } 
+}

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Base/EnviroDefineSymbol.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: acd2282461352664089464b90bd1f257
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 236601
+  packageName: Enviro 3 - Sky and Weather
+  packageVersion: 3.1.2
+  assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Base/EnviroDefineSymbol.cs
+  uploadId: 660896

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Base/EnviroEditorUtilities.cs

@@ -0,0 +1 @@
+

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Base/EnviroEditorUtilities.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 774b18065cd193747aafe1db9db10291
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 236601
+  packageName: Enviro 3 - Sky and Weather
+  packageVersion: 3.1.2
+  assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Base/EnviroEditorUtilities.cs
+  uploadId: 660896

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Base/EnviroEffectRemovalZoneEditor.cs

@@ -0,0 +1,124 @@
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEditorInternal;
+
+namespace Enviro
+{
+    [CustomEditor(typeof(Enviro.EnviroEffectRemovalZone))]
+    public class EnviroEffectRemovalZoneEditor : Editor {
+
+        GUIStyle boxStyle;
+        GUIStyle boxStyleModified;
+        GUIStyle wrapStyle;
+        GUIStyle wrapStyle2;
+        GUIStyle clearStyle;
+
+        Enviro.EnviroEffectRemovalZone myTarget;
+
+        private Color boxColor1;
+
+        SerializedObject serializedObj;
+
+        private SerializedProperty type, density, radius, stretch, feather, size;
+
+        void OnEnable()
+        {
+            myTarget = (Enviro.EnviroEffectRemovalZone)target;
+            serializedObj = new SerializedObject (myTarget);
+            boxColor1 = new Color(0.95f, 0.95f, 0.95f,1f);
+            type = serializedObj.FindProperty("type"); 
+            density = serializedObj.FindProperty("density"); 
+            radius = serializedObj.FindProperty("radius"); 
+            stretch = serializedObj.FindProperty("stretch"); 
+            feather = serializedObj.FindProperty("feather"); 
+            size = serializedObj.FindProperty("size"); 
+        }
+
+        public override void OnInspectorGUI ()
+        {
+            
+            //Set up the box style
+            if (boxStyle == null)
+            {
+                boxStyle = new GUIStyle(GUI.skin.box);
+                boxStyle.normal.textColor = GUI.skin.label.normal.textColor;
+                boxStyle.fontStyle = FontStyle.Bold;
+                boxStyle.alignment = TextAnchor.UpperLeft;
+            }
+
+            if (boxStyleModified == null)
+            {
+                boxStyleModified = new GUIStyle(EditorStyles.helpBox);
+                boxStyleModified.normal.textColor = GUI.skin.label.normal.textColor;
+                boxStyleModified.fontStyle = FontStyle.Bold;
+                boxStyleModified.fontSize = 11;
+                boxStyleModified.alignment = TextAnchor.UpperLeft;
+            }
+
+            //Setup the wrap style
+            if (wrapStyle == null)
+            {
+                wrapStyle = new GUIStyle(GUI.skin.label);
+                wrapStyle.fontStyle = FontStyle.Bold;
+                wrapStyle.wordWrap = true;
+            }
+
+            if (wrapStyle2 == null)
+            {
+                wrapStyle2 = new GUIStyle(GUI.skin.label);
+                wrapStyle2.fontStyle = FontStyle.Normal;
+                wrapStyle2.wordWrap = true;
+            }
+
+            if (clearStyle == null) {
+                clearStyle = new GUIStyle(GUI.skin.label);
+                clearStyle.normal.textColor = GUI.skin.label.normal.textColor;
+                clearStyle.fontStyle = FontStyle.Bold;
+                clearStyle.alignment = TextAnchor.UpperRight;
+            }
+
+
+            GUILayout.BeginVertical(" Enviro - Effect Removal Zone", boxStyle);
+            GUILayout.Space(30);
+            GUI.backgroundColor = boxColor1;
+            GUILayout.BeginVertical("Information", boxStyleModified);
+            GUI.backgroundColor = Color.white;
+            GUILayout.Space(20);
+            EditorGUILayout.LabelField("Use this component to hide fog and weather particles for example for indoor areas.", wrapStyle2);
+            GUILayout.EndVertical();
+            GUI.backgroundColor = boxColor1;
+            GUILayout.BeginVertical("", boxStyleModified);
+            GUI.backgroundColor = Color.white;
+            GUILayout.Space(20);
+            ///////
+            EditorGUI.BeginChangeCheck();
+            EditorGUILayout.PropertyField(type);
+            GUILayout.Space(5);
+            EditorGUILayout.PropertyField(density);
+            EditorGUILayout.PropertyField(feather);
+            GUILayout.Space(5);
+            if(myTarget.type == Enviro.EnviroEffectRemovalZone.Mode.Spherical)
+            {   
+                EditorGUILayout.PropertyField(radius);
+                EditorGUILayout.PropertyField(stretch);
+            }   
+            else
+            {
+                EditorGUILayout.PropertyField(size);
+            }
+            
+            if (EditorGUI.EndChangeCheck ()) 
+            {
+			    serializedObj.ApplyModifiedProperties ();
+		    }
+          
+            ///////
+            GUILayout.EndVertical();
+            
+            // END
+            EditorGUILayout.EndVertical ();
+        }
+    }
+}

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Base/EnviroEffectRemovalZoneEditor.cs.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: e6f1253382157204b968392ce8d09f83
+timeCreated: 1497912081
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 236601
+  packageName: Enviro 3 - Sky and Weather
+  packageVersion: 3.1.2
+  assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Base/EnviroEffectRemovalZoneEditor.cs
+  uploadId: 660896

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Base/EnviroExternalWindow.cs

@@ -0,0 +1,134 @@
+using UnityEditor;
+using UnityEngine;
+
+public class EnviroExternalWindow : EditorWindow
+{
+    private Editor currentTimeModuleEditor, currentSkyModuleEditor, currentLightingModuleEditor, currentFogModuleEditor, currentVolumetricCloudModuleEditor,currentFlatCloudModuleEditor,currentWeatherModuleEditor,currentAuroraModuleEditor,currentLightningModuleEditor, currentAudioModuleEditor,currentEnvironmentModuleEditor,currentEffectsModuleEditor ,currentQualityModuleEditor,currentEventModuleEditor ;   
+    private Vector2 scrollPosition = Vector2.zero;
+    // Add menu item named "My Window" to the Window menu
+    [MenuItem("Window/Enviro/Enviro Window")]
+    public static void ShowWindow()
+    {
+        //Show existing window instance. If one doesn't exist, make one.
+        EditorWindow.GetWindow(typeof(EnviroExternalWindow));
+    }
+    
+    void OnGUI()
+    {
+        if (Enviro.EnviroManager.instance == null)
+        {
+            GUILayout.Label ("Enviro 3 not in Scene. Please use this window in a Scene with Enviro 3.", EditorStyles.boldLabel);
+            return;
+        }
+
+        GUILayout.Label ("Enviro 3", EditorStyles.boldLabel);
+
+        scrollPosition = GUILayout.BeginScrollView(scrollPosition, false, false,  GUILayout.Width(400),  GUILayout.Height(600)); 
+
+            if(Enviro.EnviroManager.instance.Time != null)
+            {
+                if(currentTimeModuleEditor == null)
+                currentTimeModuleEditor = Editor.CreateEditor(Enviro.EnviroManager.instance.Time);
+
+                currentTimeModuleEditor.OnInspectorGUI();
+            }
+
+            if(Enviro.EnviroManager.instance.Lighting != null)
+                {
+                    if(currentLightingModuleEditor == null)
+                    currentLightingModuleEditor = Editor.CreateEditor(Enviro.EnviroManager.instance.Lighting);
+
+                    currentLightingModuleEditor.OnInspectorGUI();
+                } 
+
+                if(Enviro.EnviroManager.instance.Sky != null)
+                {
+                    if(currentSkyModuleEditor == null)
+                    currentSkyModuleEditor = Editor.CreateEditor(Enviro.EnviroManager.instance.Sky);
+
+                    currentSkyModuleEditor.OnInspectorGUI();
+                } 
+
+                if(Enviro.EnviroManager.instance.Fog != null)
+                {
+                    if(currentFogModuleEditor == null)
+                    currentFogModuleEditor = Editor.CreateEditor(Enviro.EnviroManager.instance.Fog);
+
+                    currentFogModuleEditor.OnInspectorGUI();
+                } 
+
+                if(Enviro.EnviroManager.instance.VolumetricClouds != null)
+                {
+                    if(currentVolumetricCloudModuleEditor == null)
+                    currentVolumetricCloudModuleEditor = Editor.CreateEditor(Enviro.EnviroManager.instance.VolumetricClouds);
+
+                    currentVolumetricCloudModuleEditor.OnInspectorGUI();
+                } 
+         
+                if(Enviro.EnviroManager.instance.FlatClouds != null)
+                {
+                    if(currentFlatCloudModuleEditor == null)
+                    currentFlatCloudModuleEditor = Editor.CreateEditor(Enviro.EnviroManager.instance.FlatClouds);
+
+                    currentFlatCloudModuleEditor.OnInspectorGUI();
+                } 
+
+                if(Enviro.EnviroManager.instance.Aurora != null)
+                {
+                    if(currentAuroraModuleEditor == null)
+                    currentAuroraModuleEditor = Editor.CreateEditor(Enviro.EnviroManager.instance.Aurora);
+
+                    currentAuroraModuleEditor.OnInspectorGUI();
+                } 
+
+                if(Enviro.EnviroManager.instance.Lightning != null)
+                {
+                    if(currentLightningModuleEditor == null)
+                    currentLightningModuleEditor = Editor.CreateEditor(Enviro.EnviroManager.instance.Lightning);
+
+                    currentLightningModuleEditor.OnInspectorGUI();
+                } 
+
+                if(Enviro.EnviroManager.instance.Environment != null)
+                {
+                    if(currentEnvironmentModuleEditor == null)
+                    currentEnvironmentModuleEditor = Editor.CreateEditor(Enviro.EnviroManager.instance.Environment);
+
+                    currentEnvironmentModuleEditor.OnInspectorGUI();
+                } 
+
+                if(Enviro.EnviroManager.instance.Weather != null)
+                {
+                    if(currentWeatherModuleEditor == null)
+                    currentWeatherModuleEditor = Editor.CreateEditor(Enviro.EnviroManager.instance.Weather);
+
+                    currentWeatherModuleEditor.OnInspectorGUI();
+                } 
+
+                if(Enviro.EnviroManager.instance.Audio != null) 
+                {
+                    if(currentAudioModuleEditor == null)
+                    currentAudioModuleEditor = Editor.CreateEditor(Enviro.EnviroManager.instance.Audio);
+
+                    currentAudioModuleEditor.OnInspectorGUI();
+                } 
+
+                if(Enviro.EnviroManager.instance.Effects != null)
+                {
+                    if(currentEffectsModuleEditor == null)
+                    currentEffectsModuleEditor = Editor.CreateEditor(Enviro.EnviroManager.instance.Effects);
+
+                    currentEffectsModuleEditor.OnInspectorGUI();
+                } 
+    
+                if(Enviro.EnviroManager.instance.Quality != null)
+                {
+                    if(currentQualityModuleEditor == null)
+                    currentQualityModuleEditor = Editor.CreateEditor(Enviro.EnviroManager.instance.Quality);
+
+                    currentQualityModuleEditor.OnInspectorGUI();
+                }
+
+        GUILayout.EndScrollView();
+    }
+}

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Base/EnviroExternalWindow.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 052eb9141011c8e4f841010cd4af5146
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 236601
+  packageName: Enviro 3 - Sky and Weather
+  packageVersion: 3.1.2
+  assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Base/EnviroExternalWindow.cs
+  uploadId: 660896

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Base/EnviroManagerInspector.cs

@@ -0,0 +1,575 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+
+namespace Enviro{
+    [CustomEditor(typeof(EnviroManager))]
+    public class EnviroManagerInspector : EnviroBaseInspector
+    {
+        private EnviroManager myTarget;
+
+        private Editor currentTimeModuleEditor, currentSkyModuleEditor, currentLightingModuleEditor, currentReflectionsModuleEditor, currentFogModuleEditor, currentVolumetricCloudModuleEditor,currentFlatCloudModuleEditor,currentWeatherModuleEditor,currentAuroraModuleEditor,currentLightningModuleEditor, currentAudioModuleEditor,currentEnvironmentModuleEditor,currentEffectsModuleEditor ,currentQualityModuleEditor;
+        private SerializedProperty configuration, modules, Camera, CameraTag, dontDestroyOnLoad ,worldAnchor ,optionalFollowTransform;
+        private SerializedProperty sunRotationX,sunRotationY,moonRotationX,moonRotationY,dayNightSwitch;
+        //Events
+        private SerializedProperty onHourPassedActions, onDayPassedActions, onYearPassedActions, onWeatherChangedActions, onSeasonChangedActions, onNightActions, onDayActions;
+
+        void OnEnable()
+        {
+            myTarget = (EnviroManager)target;
+            serializedObj = new SerializedObject(myTarget);
+            configuration = serializedObj.FindProperty("configuration");
+            Camera = serializedObj.FindProperty("Camera");
+            CameraTag = serializedObj.FindProperty("CameraTag");
+            dontDestroyOnLoad = serializedObj.FindProperty("dontDestroyOnLoad");
+            sunRotationX = serializedObj.FindProperty("sunRotationX");
+            sunRotationY = serializedObj.FindProperty("sunRotationY");
+            moonRotationX = serializedObj.FindProperty("moonRotationX");
+            moonRotationY = serializedObj.FindProperty("moonRotationY");
+            dayNightSwitch = serializedObj.FindProperty("dayNightSwitch");
+            worldAnchor = serializedObj.FindProperty("Objects.worldAnchor");
+            optionalFollowTransform = serializedObj.FindProperty("optionalFollowTransform");
+            //Events
+            onHourPassedActions = serializedObj.FindProperty("Events.onHourPassedActions");
+            onDayPassedActions = serializedObj.FindProperty("Events.onDayPassedActions");
+            onYearPassedActions = serializedObj.FindProperty("Events.onYearPassedActions");
+            onWeatherChangedActions = serializedObj.FindProperty("Events.onWeatherChangedActions");
+            onSeasonChangedActions = serializedObj.FindProperty("Events.onSeasonChangedActions");
+            onNightActions = serializedObj.FindProperty("Events.onNightActions");
+            onDayActions = serializedObj.FindProperty("Events.onDayActions");
+        }
+
+        public override void OnInspectorGUI()
+        {
+            SetupGUIStyles();
+
+            GUILayout.BeginVertical("", boxStyle);
+            GUILayout.Label("Enviro - Sky and Weather Manager",headerStyleMid);
+            GUILayout.Space(5);
+            GUILayout.Label("Version: " + myTarget.version, headerStyleMid);
+
+
+            //Help Box Button
+            //RenderHelpBoxButton();
+
+           // if(showHelpBox)
+           // RenderHelpBox("This is a help text test!");
+
+            GUILayout.EndVertical();
+
+            GUILayout.BeginVertical("",boxStyle);
+            myTarget.showSetup = GUILayout.Toggle(myTarget.showSetup, "Setup", headerFoldout);
+
+            EditorGUI.BeginChangeCheck();
+
+            if(myTarget.showSetup)
+            {
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUILayout.Label("Camera Setup", headerStyle);
+
+               // GUILayout.Space(10);
+               // GUILayout.Label("Main Camera", headerStyle);
+                EditorGUILayout.PropertyField(Camera);
+
+                if(myTarget.Camera == null)
+                   CameraTag.stringValue = EditorGUILayout.TagField("Camera Tag", CameraTag.stringValue);
+
+                GUILayout.Space(10);
+                GUILayout.Label("Additional Cameras", headerStyle);
+                GUILayout.Space(5);
+                if (GUILayout.Button ("Add"))
+                {
+                        myTarget.Cameras.Add (new EnviroCameras());
+                }
+                GUILayout.Space(5);
+                for (int i = 0; i < myTarget.Cameras.Count; i++)
+                {
+                    GUILayout.BeginVertical("", boxStyleModified);
+                    myTarget.Cameras[i].camera = (Camera)EditorGUILayout.ObjectField ("Camera", myTarget.Cameras[i].camera, typeof(Camera), true);
+                    myTarget.Cameras[i].quality = (EnviroQuality)EditorGUILayout.ObjectField ("Quality", myTarget.Cameras[i].quality, typeof(EnviroQuality), true);
+                    myTarget.Cameras[i].resetMatrix = EditorGUILayout.Toggle("Reset Matrix",  myTarget.Cameras[i].resetMatrix);
+                    
+                    if (GUILayout.Button ("Remove"))
+                    {
+                        myTarget.Cameras.RemoveAt (i);
+                    }
+
+                    GUILayout.EndVertical(); 
+                }
+                GUILayout.EndVertical();
+
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUILayout.Label("General Setup", headerStyle);
+                EditorGUILayout.PropertyField(dontDestroyOnLoad);
+                EditorGUILayout.PropertyField(worldAnchor);
+                EditorGUILayout.PropertyField(optionalFollowTransform);
+                GUILayout.EndVertical();
+
+                GUILayout.BeginVertical("", boxStyleModified);
+
+    #if ENVIRO_HDRP
+                GUILayout.Label("Render Pipeline:   HDRP", headerStyle);
+    #elif ENVIRO_URP
+                GUILayout.Label("Render Pipeline:   URP", headerStyle);
+    #else
+                GUILayout.Label("Render Pipeline:   Legacy", headerStyle);
+    #endif
+
+                GUILayout.Space(10);
+    #if !ENVIRO_HDRP
+                if (GUILayout.Button("Activate HDRP Support"))
+                    {
+                        AddDefineSymbol("ENVIRO_HDRP");
+                        RemoveDefineSymbol("ENVIRO_URP");
+                    }
+    #endif
+
+    #if !ENVIRO_URP
+                    if (GUILayout.Button("Activate URP Support"))
+                    {
+                        AddDefineSymbol("ENVIRO_URP");
+                        RemoveDefineSymbol("ENVIRO_HDRP");
+                    }
+    #endif
+
+    #if ENVIRO_URP || ENVIRO_HDRP
+                if (GUILayout.Button("Activate Legacy Support"))
+                    {
+                        RemoveDefineSymbol("ENVIRO_URP");
+                        RemoveDefineSymbol("ENVIRO_HDRP");
+                    }
+    #endif
+                GUILayout.EndVertical();
+            }
+            GUILayout.EndVertical();
+
+            GUILayout.BeginVertical("", boxStyle);
+            myTarget.showModules = GUILayout.Toggle(myTarget.showModules, "Modules", headerFoldout);
+            if(myTarget.showModules)
+            {
+
+            if(myTarget.configuration == null)
+            {
+                GUILayout.Label("Please assign or create a new configuration.");
+                EditorGUILayout.PropertyField(configuration);
+                    if(GUILayout.Button("Create new Configuration"))
+                    {
+                        myTarget.configuration = EnviroConfigurationCreation.CreateMyAsset();
+                        serializedObj.Update();
+                    }
+            }
+            else if (myTarget.version != myTarget.configuration.version)
+            {
+                EditorGUILayout.PropertyField(configuration);
+                if(GUILayout.Button("Update Configuration!"))
+                {
+                     myTarget.UpdateConfiguration(myTarget.configuration.version);  
+                }
+            }
+            else
+            {
+                GUILayout.BeginVertical("", boxStyleModified);
+
+                if(!Application.isPlaying)
+                EditorGUILayout.PropertyField(configuration);
+                  if(GUILayout.Button("Save all Modules"))
+                    {
+                        myTarget.SaveAllModules();
+                    }
+                if(GUILayout.Button("Load all Modules"))
+                    {
+                        myTarget.LoadAllModules();
+                    }
+
+                GUILayout.EndVertical();
+
+                GUILayout.BeginVertical("", wrapStyle);
+                GUILayout.BeginHorizontal("", headerStyle);
+
+                EditorGUI.BeginDisabledGroup(myTarget.Time != null);
+                if(GUILayout.Button("Time"))
+                {
+                    if (myTarget.Time == null)
+                    myTarget.AddModule(EnviroManager.ModuleType.Time);
+                }
+                EditorGUI.EndDisabledGroup();
+
+                EditorGUI.BeginDisabledGroup(myTarget.Sky != null);
+                if(GUILayout.Button("Sky"))
+                {
+                    if (myTarget.Sky == null)
+                    myTarget.AddModule(EnviroManager.ModuleType.Sky);
+                }
+                EditorGUI.EndDisabledGroup();
+
+                EditorGUI.BeginDisabledGroup(myTarget.Lighting != null);
+                if(GUILayout.Button("Lighting"))
+                {
+                    if (myTarget.Lighting == null)
+                    myTarget.AddModule(EnviroManager.ModuleType.Lighting);
+                }
+                EditorGUI.EndDisabledGroup();
+
+                EditorGUI.BeginDisabledGroup(myTarget.Reflections != null);
+                if(GUILayout.Button("Reflections"))
+                {
+                    if (myTarget.Reflections == null)
+                    myTarget.AddModule(EnviroManager.ModuleType.Reflections);
+                }
+                EditorGUI.EndDisabledGroup();
+
+                EditorGUI.BeginDisabledGroup(myTarget.Fog != null);
+                if(GUILayout.Button("Fog"))
+                {
+                    if (myTarget.Fog == null)
+                    myTarget.AddModule(EnviroManager.ModuleType.Fog);
+                }
+                EditorGUI.EndDisabledGroup();
+
+                EditorGUI.BeginDisabledGroup(myTarget.VolumetricClouds != null);
+                if(GUILayout.Button("Volumetric Clouds"))
+                { 
+                    if (myTarget.VolumetricClouds == null)
+                    myTarget.AddModule(EnviroManager.ModuleType.VolumetricClouds);
+                }
+                EditorGUI.EndDisabledGroup();
+
+                EditorGUI.BeginDisabledGroup(myTarget.FlatClouds != null);
+                if(GUILayout.Button("Flat Clouds"))
+                {
+                    if (myTarget.FlatClouds == null)
+                    myTarget.AddModule(EnviroManager.ModuleType.FlatClouds);
+                }
+                EditorGUI.EndDisabledGroup();
+
+                EditorGUI.BeginDisabledGroup(myTarget.Aurora != null);
+                if(GUILayout.Button("Aurora"))
+                {
+                    if (myTarget.Aurora == null)
+                    myTarget.AddModule(EnviroManager.ModuleType.Aurora);
+                }
+                EditorGUI.EndDisabledGroup();
+
+                GUILayout.EndHorizontal();
+
+                //////////////////////////////////////
+
+                GUILayout.BeginHorizontal("", headerStyle);
+
+
+                EditorGUI.BeginDisabledGroup(myTarget.Environment != null);
+                if(GUILayout.Button("Environment"))
+                {
+                    if (myTarget.Environment == null)
+                    myTarget.AddModule(EnviroManager.ModuleType.Environment);
+                }
+                EditorGUI.EndDisabledGroup();
+
+                EditorGUI.BeginDisabledGroup(myTarget.Lightning != null);
+                if(GUILayout.Button("Lightning"))
+                {
+                    if (myTarget.Lightning == null)
+                    myTarget.AddModule(EnviroManager.ModuleType.Lightning);
+                }
+                EditorGUI.EndDisabledGroup();
+
+
+                EditorGUI.BeginDisabledGroup(myTarget.Weather != null);
+                if(GUILayout.Button("Weather"))
+                {
+                    if (myTarget.Weather == null)
+                    myTarget.AddModule(EnviroManager.ModuleType.Weather);
+                }
+                EditorGUI.EndDisabledGroup();
+
+
+                EditorGUI.BeginDisabledGroup(myTarget.Audio != null);
+                if(GUILayout.Button("Audio"))
+                {
+                    if (myTarget.Audio == null)
+                    myTarget.AddModule(EnviroManager.ModuleType.Audio);
+                }
+                EditorGUI.EndDisabledGroup();
+
+                EditorGUI.BeginDisabledGroup(myTarget.Effects != null);
+                if(GUILayout.Button("Effects"))
+                {
+                    if (myTarget.Effects == null)
+                    myTarget.AddModule(EnviroManager.ModuleType.Effects);
+                }
+                EditorGUI.EndDisabledGroup();
+
+                EditorGUI.BeginDisabledGroup(myTarget.Quality != null);
+                if(GUILayout.Button("Quality"))
+                {
+                    if (myTarget.Quality == null)
+                    myTarget.AddModule(EnviroManager.ModuleType.Quality);
+                }
+                EditorGUI.EndDisabledGroup();
+
+                GUILayout.EndHorizontal();
+                GUILayout.EndVertical();
+
+
+    /////////Modules Start
+                GUILayout.Space(10);
+                if(myTarget.Time != null)
+                {
+                    if(currentTimeModuleEditor == null)
+                    currentTimeModuleEditor = Editor.CreateEditor(myTarget.Time);
+                    currentTimeModuleEditor.OnInspectorGUI();
+                }
+                else
+                {
+
+                    GUI.backgroundColor = baseModuleColor;
+                    GUILayout.BeginVertical("",boxStyleModified);
+                    GUI.backgroundColor = Color.white;
+                    EditorGUILayout.BeginHorizontal();
+                    myTarget.showNonTimeControls = GUILayout.Toggle(myTarget.showNonTimeControls, "Sun and Moon Controls", headerFoldout);
+                    EditorGUILayout.EndHorizontal();
+                    if(myTarget.showNonTimeControls)
+                    {
+                        EditorGUILayout.LabelField("This module will control your sun and moon position when no time module is used.");
+                        //serializedObj.UpdateIfRequiredOrScript ();
+                        //EditorGUI.BeginChangeCheck();
+                        GUI.backgroundColor = categoryModuleColor;
+                        GUILayout.BeginVertical("",boxStyleModified);
+                        GUI.backgroundColor = Color.white;
+
+                        EditorGUILayout.PropertyField(sunRotationX);
+                        EditorGUILayout.PropertyField(sunRotationY);
+                        EditorGUILayout.PropertyField(moonRotationX);
+                        EditorGUILayout.PropertyField(moonRotationY);
+                        GUILayout.Space(5);
+                        EditorGUILayout.PropertyField(dayNightSwitch);
+                        GUILayout.EndVertical();
+                    }
+                    GUILayout.EndVertical();
+
+                    if(myTarget.showNonTimeControls)
+                    GUILayout.Space(10);
+                }
+
+                if(myTarget.Lighting != null)
+                {
+                    if(currentLightingModuleEditor == null)
+                    currentLightingModuleEditor = Editor.CreateEditor(myTarget.Lighting);
+
+                    currentLightingModuleEditor.OnInspectorGUI();
+                }
+
+                if(myTarget.Reflections != null)
+                {
+                    if(currentReflectionsModuleEditor == null)
+                    currentReflectionsModuleEditor = Editor.CreateEditor(myTarget.Reflections);
+
+                    currentReflectionsModuleEditor.OnInspectorGUI();
+                }
+
+                if(myTarget.Sky != null)
+                {
+                    if(currentSkyModuleEditor == null)
+                    currentSkyModuleEditor = Editor.CreateEditor(myTarget.Sky);
+
+                    currentSkyModuleEditor.OnInspectorGUI();
+                }
+
+                if(myTarget.Fog != null)
+                {
+                    if(currentFogModuleEditor == null)
+                    currentFogModuleEditor = Editor.CreateEditor(myTarget.Fog);
+
+                    currentFogModuleEditor.OnInspectorGUI();
+                }
+
+                if(myTarget.VolumetricClouds != null)
+                {
+                    if(currentVolumetricCloudModuleEditor == null)
+                    currentVolumetricCloudModuleEditor = Editor.CreateEditor(myTarget.VolumetricClouds);
+
+                    currentVolumetricCloudModuleEditor.OnInspectorGUI();
+                }
+
+                if(myTarget.FlatClouds != null)
+                {
+                    if(currentFlatCloudModuleEditor == null)
+                    currentFlatCloudModuleEditor = Editor.CreateEditor(myTarget.FlatClouds);
+
+                    currentFlatCloudModuleEditor.OnInspectorGUI();
+                }
+
+                if(myTarget.Aurora != null)
+                {
+                    if(currentAuroraModuleEditor == null)
+                    currentAuroraModuleEditor = Editor.CreateEditor(myTarget.Aurora);
+
+                    currentAuroraModuleEditor.OnInspectorGUI();
+                }
+
+                if(myTarget.Lightning != null)
+                {
+                    if(currentLightningModuleEditor == null)
+                    currentLightningModuleEditor = Editor.CreateEditor(myTarget.Lightning);
+
+                    currentLightningModuleEditor.OnInspectorGUI();
+                }
+
+                if(myTarget.Environment != null)
+                {
+                    if(currentEnvironmentModuleEditor == null)
+                    currentEnvironmentModuleEditor = Editor.CreateEditor(myTarget.Environment);
+
+                    currentEnvironmentModuleEditor.OnInspectorGUI();
+                }
+
+                if(myTarget.Weather != null)
+                {
+                    if(currentWeatherModuleEditor == null)
+                    currentWeatherModuleEditor = Editor.CreateEditor(myTarget.Weather);
+
+                    currentWeatherModuleEditor.OnInspectorGUI();
+                }
+
+                if(myTarget.Audio != null)
+                {
+                    if(currentAudioModuleEditor == null)
+                    currentAudioModuleEditor = Editor.CreateEditor(myTarget.Audio);
+
+                    currentAudioModuleEditor.OnInspectorGUI();
+                }
+
+                if(myTarget.Effects != null)
+                {
+                    if(currentEffectsModuleEditor == null)
+                    currentEffectsModuleEditor = Editor.CreateEditor(myTarget.Effects);
+
+                    currentEffectsModuleEditor.OnInspectorGUI();
+                }
+
+                if(myTarget.Quality != null)
+                {
+                    if(currentQualityModuleEditor == null)
+                    currentQualityModuleEditor = Editor.CreateEditor(myTarget.Quality);
+
+                    currentQualityModuleEditor.OnInspectorGUI();
+                }
+            }
+            }
+            GUILayout.EndVertical();
+
+            //Modules End
+
+            GUILayout.BeginVertical("",boxStyle);
+            myTarget.showEvents = GUILayout.Toggle(myTarget.showEvents, "Events", headerFoldout);
+
+            if(myTarget.showEvents)
+            {
+                GUI.backgroundColor = thirdPartyModuleColor;
+                GUILayout.BeginVertical("", boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                GUILayout.Space(5);
+                EditorGUILayout.PropertyField(onHourPassedActions);
+                EditorGUILayout.PropertyField(onDayPassedActions);
+                EditorGUILayout.PropertyField(onYearPassedActions);
+                GUILayout.Space(5);
+                EditorGUILayout.PropertyField(onWeatherChangedActions);
+                EditorGUILayout.PropertyField(onSeasonChangedActions);
+                GUILayout.Space(5);
+                EditorGUILayout.PropertyField(onDayActions);
+                EditorGUILayout.PropertyField(onNightActions);
+                GUILayout.EndVertical();
+            }
+            GUILayout.EndVertical();
+
+            GUILayout.BeginVertical("",boxStyle);
+            myTarget.showThirdParty = GUILayout.Toggle(myTarget.showThirdParty, "Third Party Support", headerFoldout);
+
+            if(myTarget.showThirdParty)
+            {
+                GUILayout.Space(5);
+
+                //WAPI
+                GUI.backgroundColor = thirdPartyModuleColor;
+                GUILayout.BeginVertical("World Manager API", boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                GUILayout.Space(20);
+#if WORLDAPI_PRESENT
+
+                //GUILayout.Label("World Manager API detected!", headerStyle);
+                //GUILayout.Space(5);
+                RenderIntegrationTextBox("You can add support for WAPI from the ('Components' -> 'Enviro 3' -> 'Integrations' -> 'WAPI') menu.");
+#else
+                GUILayout.Label("World Manager API no found!", headerStyle);
+#endif
+                GUILayout.EndVertical();
+
+                //MicroSplat
+                GUI.backgroundColor = thirdPartyModuleColor;
+                GUILayout.BeginVertical("MicroSplat", boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                GUILayout.Space(20);
+                RenderIntegrationTextBox("You can add support for MicroSplat and Better Lit Shaders from the ('Components' -> 'Enviro 3' -> 'Integrations' -> 'Microsplat') menu.");
+                GUILayout.EndVertical();
+                //////////
+
+                //Mirror
+                GUI.backgroundColor = thirdPartyModuleColor;
+                GUILayout.BeginVertical("Mirror Networking", boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                GUILayout.Space(20);
+#if ENVIRO_MIRROR_SUPPORT
+                //GUILayout.Label("Mirror Networking support activated.", headerStyle);
+                //GUILayout.Space(5);
+                RenderIntegrationTextBox("Please add the 'Mirror Server' component to a new GameObject in your scene. ('Components' -> 'Enviro 3' -> 'Integrations' -> 'Mirror Server')");
+                RenderIntegrationTextBox("Please add the 'Mirror Player' component to your player prefab. ('Components' -> 'Enviro 3' -> 'Integrations' -> 'Mirror Player')");
+                GUILayout.Space(10);
+                if (GUILayout.Button("Deactivate Mirror Support"))
+                {
+                    RemoveDefineSymbol("ENVIRO_MIRROR_SUPPORT");
+                }
+#else
+                if (GUILayout.Button("Activate Mirror Support"))
+                {
+                    AddDefineSymbol("ENVIRO_MIRROR_SUPPORT");
+                }
+                if (GUILayout.Button("Deactivate Mirror Support"))
+                {
+                    RemoveDefineSymbol("ENVIRO_MIRROR_SUPPORT");
+                }
+#endif
+                GUILayout.EndVertical();
+                //////////
+
+                //Photon
+                GUI.backgroundColor = thirdPartyModuleColor;
+                GUILayout.BeginVertical("Photon PUN Networking", boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                GUILayout.Space(20);
+#if ENVIRO_PHOTON_SUPPORT
+                RenderIntegrationTextBox("Please add the 'Photon Integration' component to a new GameObject in your scene. ('Components' -> 'Enviro 3' -> 'Integrations' -> 'Photon Integration')");
+                GUILayout.Space(10);
+                if (GUILayout.Button("Deactivate Photon Support"))
+                {
+                    RemoveDefineSymbol("ENVIRO_PHOTON_SUPPORT");
+                }
+#else
+                if (GUILayout.Button("Activate Photon Support"))
+                {
+                    AddDefineSymbol("ENVIRO_PHOTON_SUPPORT");
+                }
+                if (GUILayout.Button("Deactivate Photon Support"))
+                {
+                    RemoveDefineSymbol("ENVIRO_PHOTON_SUPPORT");
+                }
+#endif
+                GUILayout.EndVertical();
+                //////////
+
+            }
+            GUILayout.EndVertical();
+            ApplyChanges();
+        }
+    }
+}

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Base/EnviroManagerInspector.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 62d831ecb648e7b48a72bbfd06e4e0df
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 236601
+  packageName: Enviro 3 - Sky and Weather
+  packageVersion: 3.1.2
+  assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Base/EnviroManagerInspector.cs
+  uploadId: 660896

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Base/EnviroModuleEditor.cs

@@ -0,0 +1,63 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+
+namespace Enviro
+{
+
+ [CustomEditor(typeof(EnviroModule))] 
+ public class EnviroModuleEditor : EnviroBaseInspector
+ { 
+    public SerializedProperty preset;
+ 
+    public virtual void OnEnable() 
+    {
+        //SetupGUIStyles (); 
+    }
+
+    public void SetActiveGUIColor(bool active)
+    {
+        if(active)
+        GUI.backgroundColor = new Color(1f,1f,2f,1f);
+    }
+
+    public void UnsetActiveGUIColor()
+    {
+        GUI.backgroundColor = Color.white;
+    }
+    
+    public void DisableInputStart()
+    {
+        if(EnviroManager.instance != null && EnviroManager.instance.Weather != null)
+        {
+            if(EnviroManager.instance.Weather.targetWeatherType != null)
+                EditorGUI.BeginDisabledGroup(true);
+        }
+    }
+
+    public void DisableInputEnd()
+    {
+        EditorGUI.EndDisabledGroup();
+    }
+
+    public void DisableInputStartQuality()
+    {
+        if(EnviroManager.instance != null && EnviroManager.instance.Quality != null)
+        {
+            if(EnviroManager.instance.Quality.Settings.defaultQuality != null)
+                EditorGUI.BeginDisabledGroup(true);
+        }
+    }
+
+    public void DisableInputEndQuality()
+    {
+        EditorGUI.EndDisabledGroup();
+    }
+
+    public override void OnInspectorGUI()
+    {
+         SetupGUIStyles (); 
+    }
+ }
+}

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Base/EnviroModuleEditor.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 35f984cbe14c3484188df7a318f6c5e2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 236601
+  packageName: Enviro 3 - Sky and Weather
+  packageVersion: 3.1.2
+  assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Base/EnviroModuleEditor.cs
+  uploadId: 660896

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Base/EnviroShaderStripper.cs

@@ -0,0 +1,91 @@
+using System.Collections.Generic;
+using UnityEditor.Build;
+using UnityEditor.Rendering;
+using UnityEngine;
+using UnityEngine.Rendering; 
+
+namespace Enviro
+{
+public class ShaderStripper : IPreprocessShaders
+{
+		private const string LOG_FILE_PATH = "Library/Shader Compilation Results.txt";
+
+		private static readonly ShaderKeyword[] SKIPPED_VARIANTS = new ShaderKeyword[]
+		{
+			new ShaderKeyword( "ENVIROHDRP" ),
+			new ShaderKeyword( "ENVIROURP" ),
+		};
+
+		public int callbackOrder { get { return 0; } }
+
+		public void OnProcessShader( Shader shader, ShaderSnippetData snippet, IList<ShaderCompilerData> data )
+		{
+			string shaderName = shader.name;
+ 
+		//URP Shader
+		#if !ENVIRO_URP
+			if(shaderName == "Hidden/EnviroBlitThrough")
+				data.Clear();
+
+			if(shaderName == "Hidden/VolumetricsURP")
+				data.Clear();
+		#endif 
+
+		//URP 17+ Shader
+		#if !ENVIRO_URP || !UNITY_6000_0_OR_NEWER
+		if(shaderName == "Hidden/EnviroBlitThroughURP17")
+			data.Clear();
+
+		if(shaderName == "Hidden/EnviroBlurURP")
+			data.Clear();
+
+		if(shaderName == "Hidden/EnviroHeightFogURP")
+			data.Clear();
+
+		if(shaderName == "Hidden/EnviroApplyShadowsURP")
+			data.Clear();
+
+		if(shaderName == "Hidden/EnviroVolumetricCloudsBlendURP")
+			data.Clear();
+		
+		if(shaderName == "Hidden/EnviroVolumetricCloudsDepthURP")
+			data.Clear();
+
+		if(shaderName == "Hidden/EnviroCloudsRaymarchURP")
+			data.Clear();
+
+		if(shaderName == "Hidden/EnviroVolumetricCloudsReprojectURP")
+			data.Clear();
+
+		#endif
+
+		//HDRP Shaders
+		#if !ENVIRO_HDRP
+			if(shaderName == "Hidden/Enviro/BlitTroughHDRP")
+				data.Clear();
+	
+			if(shaderName == "Hidden/EnviroApplyShadowsHDRP")
+				data.Clear();
+
+			if(shaderName == "Hidden/EnviroCloudsRaymarchHDRP")
+				data.Clear();
+
+			if(shaderName == "Hidden/EnviroVolumetricCloudsBlendHDRP")
+				data.Clear();
+
+			if(shaderName == "Hidden/EnviroVolumetricCloudsDepthHDRP")
+				data.Clear();
+
+			if(shaderName == "Hidden/EnviroVolumetricCloudsReprojectHDRP")
+				data.Clear();
+
+			if(shaderName == "Hidden/EnviroHeightFogHDRP")
+				data.Clear();
+
+			if(shaderName == "Enviro/HDRP/Sky")
+				data.Clear();
+		#endif
+		}
+	}
+}
+

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Base/EnviroShaderStripper.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 53a2b3d33a037bc4d9b491ff07a1219f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 236601
+  packageName: Enviro 3 - Sky and Weather
+  packageVersion: 3.1.2
+  assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Base/EnviroShaderStripper.cs
+  uploadId: 660896

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Enviro3.Editor.asmdef

@@ -0,0 +1,20 @@
+{
+    "name": "Enviro3.Editor",
+    "rootNamespace": "",
+    "references": [
+        "GUID:8990947d903fec847b19d9f51781afb1",
+        "GUID:78bd2ddd6e276394a9615c203e574844",
+        "GUID:3eae0364be2026648bf74846acb8a731"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": true,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Enviro3.Editor.asmdef.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 1605a13bd7f9c6240b939a8bbd2372da
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 236601
+  packageName: Enviro 3 - Sky and Weather
+  packageVersion: 3.1.2
+  assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Enviro3.Editor.asmdef
+  uploadId: 660896

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4fceefebbb9ce594d8259c1b28e7de0d
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Audio.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d476ee05b8aa92d44b11aea5a52cb60a
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Audio/EnviroAudioModuleEditor.cs

@@ -0,0 +1,295 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+
+namespace Enviro
+{
+    [CustomEditor(typeof(EnviroAudioModule))]
+    public class EnviroAudioModuleEditor : EnviroModuleEditor
+    {   
+        private EnviroAudioModule myTarget; 
+
+        //Properties
+      //  private SerializedProperty someProp;  
+      
+        //On Enable
+        public override void OnEnable()
+        {
+            if(!target)
+                return; 
+
+            myTarget = (EnviroAudioModule)target;
+            serializedObj = new SerializedObject(myTarget);
+            preset = serializedObj.FindProperty("preset");
+        } 
+        public override void OnInspectorGUI()
+        {
+            if(!target)
+                return; 
+
+            base.OnInspectorGUI();
+
+            GUI.backgroundColor = baseModuleColor;
+            GUILayout.BeginVertical("",boxStyleModified);
+            GUI.backgroundColor = Color.white;
+            EditorGUILayout.BeginHorizontal();
+            myTarget.showModuleInspector = GUILayout.Toggle(myTarget.showModuleInspector, "Audio", headerFoldout);
+            
+            GUILayout.FlexibleSpace();
+            if(GUILayout.Button("x", EditorStyles.miniButtonRight,GUILayout.Width(18), GUILayout.Height(18)))
+            {
+                EnviroManager.instance.RemoveModule(EnviroManager.ModuleType.Audio);
+                DestroyImmediate(this);
+                return;
+            } 
+            
+            EditorGUILayout.EndHorizontal();
+            
+            if(myTarget.showModuleInspector)
+            {
+                serializedObj.UpdateIfRequiredOrScript ();
+                EditorGUI.BeginChangeCheck(); 
+
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+
+                myTarget.showAudioControls = GUILayout.Toggle(myTarget.showAudioControls, "Audio Controls", headerFoldout);              
+                if(myTarget.showAudioControls)
+                { 
+                     myTarget.Settings.ambientMasterVolume = EditorGUILayout.Slider ("Ambient Master Volume", myTarget.Settings.ambientMasterVolume,0f,1f);
+                     myTarget.Settings.weatherMasterVolume = EditorGUILayout.Slider ("Weather Master Volume", myTarget.Settings.weatherMasterVolume,0f,1f);
+                     myTarget.Settings.thunderMasterVolume = EditorGUILayout.Slider ("Thunder Master Volume", myTarget.Settings.thunderMasterVolume,0f,1f);
+                }
+                GUILayout.EndVertical ();
+
+                //Ambient Clips Setup
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+
+                myTarget.showAmbientSetupControls = GUILayout.Toggle(myTarget.showAmbientSetupControls, "Ambient Sounds", headerFoldout);              
+                if(myTarget.showAmbientSetupControls)
+                {
+                    GUILayout.Space(10);
+                    if (!Application.isPlaying) 
+                    {
+                        if (GUILayout.Button ("Add")) 
+                        {
+                            myTarget.Settings.ambientClips.Add (new EnviroAudioClip ());
+                        }
+                    } 
+                    else
+                        EditorGUILayout.LabelField ("Can't add effects in runtime!");
+
+                    if (GUILayout.Button ("Apply Changes")) 
+                    {
+                        myTarget.CreateAudio();
+                    }
+ 
+                    GUILayout.Space(10);
+                    
+                    for (int i = 0; i < myTarget.Settings.ambientClips.Count; i++) 
+                    {      
+                        GUILayout.BeginVertical ("", boxStyleModified);
+                        EditorGUILayout.BeginHorizontal();
+                        myTarget.Settings.ambientClips[i].showEditor = GUILayout.Toggle(myTarget.Settings.ambientClips[i].showEditor, myTarget.Settings.ambientClips[i].name, headerFoldout);
+                        GUILayout.FlexibleSpace();
+                        if(GUILayout.Button("x", EditorStyles.miniButtonRight,GUILayout.Width(18), GUILayout.Height(18)))
+                        { 
+                            myTarget.Settings.ambientClips.Remove (myTarget.Settings.ambientClips[i]);
+                            return;
+                        }           
+                        EditorGUILayout.EndHorizontal();
+
+                        if(myTarget.Settings.ambientClips[i].showEditor)
+                        {
+                        Undo.RecordObject(target, "Ambient Audio Changed");
+                        myTarget.Settings.ambientClips[i].name = EditorGUILayout.TextField ("Audio Name", myTarget.Settings.ambientClips[i].name);
+                        myTarget.Settings.ambientClips[i].audioClip = (AudioClip)EditorGUILayout.ObjectField ("Audio Clip", myTarget.Settings.ambientClips[i].audioClip, typeof(AudioClip), true);
+                        myTarget.Settings.ambientClips[i].audioMixerGroup = (UnityEngine.Audio.AudioMixerGroup)EditorGUILayout.ObjectField ("Audio Mixer Group", myTarget.Settings.ambientClips[i].audioMixerGroup, typeof(UnityEngine.Audio.AudioMixerGroup), true);
+                        GUILayout.Space(5);
+                        myTarget.Settings.ambientClips[i].playBackType = (EnviroAudioClip.PlayBackType)EditorGUILayout.EnumPopup("Playback Type", myTarget.Settings.ambientClips[i].playBackType);
+                        
+                        if(myTarget.Settings.ambientClips[i].playBackType == EnviroAudioClip.PlayBackType.BasedOnSun || myTarget.Settings.ambientClips[i].playBackType == EnviroAudioClip.PlayBackType.BasedOnMoon)
+                           {
+                           myTarget.Settings.ambientClips[i].volumeCurve = EditorGUILayout.CurveField ("Volume", myTarget.Settings.ambientClips [i].volumeCurve);
+                           myTarget.Settings.ambientClips[i].volume = EditorGUILayout.Slider ("Volume Modifier", myTarget.Settings.ambientClips [i].volume,0f,1f);
+                           }
+                        else
+                           myTarget.Settings.ambientClips[i].volume = EditorGUILayout.Slider ("Volume", myTarget.Settings.ambientClips [i].volume,0f,1f);
+                        
+                        myTarget.Settings.ambientClips[i].loop = EditorGUILayout.Toggle("Loop",myTarget.Settings.ambientClips[i].loop);
+                             
+                        } 
+                        GUILayout.EndVertical ();
+                    }
+
+                }
+                GUILayout.EndVertical();
+
+                //Weather sounds
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                
+                myTarget.showWeatherSetupControls = GUILayout.Toggle(myTarget.showWeatherSetupControls, "Weather Sounds", headerFoldout);              
+                if(myTarget.showWeatherSetupControls)
+                {
+                    GUILayout.Space(10);
+                    if (!Application.isPlaying) 
+                    {
+                        if (GUILayout.Button ("Add")) 
+                        {
+                            myTarget.Settings.weatherClips.Add (new EnviroAudioClip ());
+                        }
+                    } 
+                    else
+                        EditorGUILayout.LabelField ("Can't add effects in runtime!");
+
+                    if (GUILayout.Button ("Apply Changes")) 
+                    {
+                        myTarget.CreateAudio();
+                    }
+
+                    GUILayout.Space(10);
+                    
+                    for (int i = 0; i < myTarget.Settings.weatherClips.Count; i++) 
+                    {        
+                        GUILayout.BeginVertical ("", boxStyleModified);
+                        EditorGUILayout.BeginHorizontal();
+                        myTarget.Settings.weatherClips[i].showEditor = GUILayout.Toggle(myTarget.Settings.weatherClips[i].showEditor, myTarget.Settings.weatherClips[i].name, headerFoldout);
+                        GUILayout.FlexibleSpace();
+                        if(GUILayout.Button("x", EditorStyles.miniButtonRight,GUILayout.Width(18), GUILayout.Height(18)))
+                        { 
+                            myTarget.Settings.weatherClips.Remove (myTarget.Settings.weatherClips[i]);
+                            return;
+                        }           
+                        EditorGUILayout.EndHorizontal();
+
+                        if(myTarget.Settings.weatherClips[i].showEditor)
+                        {
+                        Undo.RecordObject(target, "Weather Audio Changed");
+                        myTarget.Settings.weatherClips[i].name = EditorGUILayout.TextField ("Audio Name", myTarget.Settings.weatherClips[i].name);
+                        myTarget.Settings.weatherClips[i].audioClip = (AudioClip)EditorGUILayout.ObjectField ("Audio Clip", myTarget.Settings.weatherClips[i].audioClip, typeof(AudioClip), true);
+                        myTarget.Settings.weatherClips[i].audioMixerGroup = (UnityEngine.Audio.AudioMixerGroup)EditorGUILayout.ObjectField ("Audio Mixer Group", myTarget.Settings.weatherClips[i].audioMixerGroup, typeof(UnityEngine.Audio.AudioMixerGroup), true);
+                        GUILayout.Space(5); 
+                        myTarget.Settings.weatherClips[i].playBackType = (EnviroAudioClip.PlayBackType)EditorGUILayout.EnumPopup("Playback Type", myTarget.Settings.weatherClips[i].playBackType);
+                        
+                       if(myTarget.Settings.weatherClips[i].playBackType == EnviroAudioClip.PlayBackType.BasedOnSun || myTarget.Settings.weatherClips[i].playBackType == EnviroAudioClip.PlayBackType.BasedOnMoon)
+                           {
+                           myTarget.Settings.weatherClips[i].volumeCurve = EditorGUILayout.CurveField ("Volume", myTarget.Settings.weatherClips [i].volumeCurve);
+                           myTarget.Settings.weatherClips[i].volume = EditorGUILayout.Slider ("Volume Modifier", myTarget.Settings.weatherClips [i].volume,0f,1f);
+                           }
+                        else
+                           myTarget.Settings.weatherClips[i].volume = EditorGUILayout.Slider ("Volume", myTarget.Settings.weatherClips [i].volume,0f,1f);
+                        
+                        myTarget.Settings.weatherClips[i].loop = EditorGUILayout.Toggle("Loop",myTarget.Settings.weatherClips[i].loop);
+                             
+                        } 
+                        GUILayout.EndVertical ();
+                    }
+
+                }
+                GUILayout.EndVertical();
+
+                //Thunder sounds
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                
+                myTarget.showThunderSetupControls = GUILayout.Toggle(myTarget.showThunderSetupControls, "Thunder Sounds", headerFoldout);              
+                if(myTarget.showThunderSetupControls)
+                {
+                    GUILayout.Space(10);
+                    if (!Application.isPlaying) 
+                    {
+                        if (GUILayout.Button ("Add")) 
+                        {
+                            myTarget.Settings.thunderClips.Add (new EnviroAudioClip ());
+                        }
+                    }  
+                    else
+                        EditorGUILayout.LabelField ("Can't add effects in runtime!");
+
+                    if (GUILayout.Button ("Apply Changes")) 
+                    {
+                        myTarget.CreateAudio();
+                    }
+
+                    GUILayout.Space(10);
+                    
+                    for (int i = 0; i < myTarget.Settings.thunderClips.Count; i++) 
+                    {         
+                        GUILayout.BeginVertical ("", boxStyleModified);
+                        EditorGUILayout.BeginHorizontal();
+                        myTarget.Settings.thunderClips[i].showEditor = GUILayout.Toggle(myTarget.Settings.thunderClips[i].showEditor, myTarget.Settings.thunderClips[i].name, headerFoldout);
+                        
+                        GUILayout.FlexibleSpace();
+                        if(GUILayout.Button("x", EditorStyles.miniButtonRight,GUILayout.Width(18), GUILayout.Height(18)))
+                        { 
+                            myTarget.Settings.thunderClips.Remove (myTarget.Settings.thunderClips[i]);
+                            return;
+                        }           
+                        EditorGUILayout.EndHorizontal();
+
+                        if(myTarget.Settings.thunderClips[i].showEditor)
+                        {
+                        Undo.RecordObject(target, "Thunder Audio Changed");
+                        myTarget.Settings.thunderClips[i].name = EditorGUILayout.TextField ("Audio Name", myTarget.Settings.thunderClips[i].name);
+                        myTarget.Settings.thunderClips[i].audioClip = (AudioClip)EditorGUILayout.ObjectField ("Audio Clip", myTarget.Settings.thunderClips[i].audioClip, typeof(AudioClip), true);
+                        myTarget.Settings.thunderClips[i].audioMixerGroup = (UnityEngine.Audio.AudioMixerGroup)EditorGUILayout.ObjectField ("Audio Mixer Group", myTarget.Settings.thunderClips[i].audioMixerGroup, typeof(UnityEngine.Audio.AudioMixerGroup), true);
+                        GUILayout.Space(5);                   
+                        myTarget.Settings.thunderClips[i].volume = EditorGUILayout.Slider ("Volume", myTarget.Settings.thunderClips [i].volume,0f,1f);                            
+                        } 
+                        GUILayout.EndVertical ();
+                    }
+
+                }
+                GUILayout.EndVertical();
+              
+               /// Save Load
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showSaveLoad = GUILayout.Toggle(myTarget.showSaveLoad, "Save/Load", headerFoldout);
+                
+                if(myTarget.showSaveLoad)
+                {
+                    EditorGUILayout.PropertyField(preset);
+
+                    GUILayout.BeginHorizontal("",wrapStyle);
+
+                    if(myTarget.preset != null)
+                    {
+                        if(GUILayout.Button("Load"))
+                        {
+                            myTarget.LoadModuleValues();
+                        }
+                        if(GUILayout.Button("Save"))
+                        {
+                            myTarget.SaveModuleValues(myTarget.preset);
+                        }
+                    }
+                    if(GUILayout.Button("Save As New"))
+                    {
+                        myTarget.SaveModuleValues();
+                    }
+                    GUILayout.EndHorizontal();
+
+    
+                }
+                GUILayout.EndVertical();
+                /// Save Load End
+
+                ApplyChanges ();
+                EditorUtility.SetDirty (target);
+            }
+            GUILayout.EndVertical();
+
+            if(myTarget.showModuleInspector)
+             GUILayout.Space(20);
+        }
+    }
+}

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Audio/EnviroAudioModuleEditor.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 59f338439f9177d46907c827060487e7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 236601
+  packageName: Enviro 3 - Sky and Weather
+  packageVersion: 3.1.2
+  assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Audio/EnviroAudioModuleEditor.cs
+  uploadId: 660896

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Aurora.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 6a27e4971a4b9a64abc225608ae1d275
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Aurora/EnviroAuroraModuleEditor.cs

@@ -0,0 +1,154 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+
+namespace Enviro
+{
+    [CustomEditor(typeof(EnviroAuroraModule))]
+    public class EnviroAuroraModuleEditor : EnviroModuleEditor
+    {  
+        private EnviroAuroraModule myTarget; 
+
+        //Properties
+        private SerializedProperty useAurora,auroraIntensity,auroraIntensityModifier, auroraColor, auroraBrightness, auroraContrast, auroraHeight, auroraScale, auroraSteps, auroraLayer1Settings, auroraLayer2Settings, auroraColorshiftSettings, auroraSpeed,
+        aurora_layer_1, aurora_layer_2, aurora_colorshift;
+
+
+        //On Enable
+        public override void OnEnable()
+        {
+            base.OnEnable();
+
+            if(!target)
+                return;
+
+            myTarget = (EnviroAuroraModule)target;
+            serializedObj = new SerializedObject(myTarget);
+            preset = serializedObj.FindProperty("preset");
+            
+            useAurora = serializedObj.FindProperty("Settings.useAurora");
+            auroraIntensity = serializedObj.FindProperty("Settings.auroraIntensity");
+            auroraIntensityModifier = serializedObj.FindProperty("Settings.auroraIntensityModifier");
+            auroraColor = serializedObj.FindProperty("Settings.auroraColor");
+            auroraBrightness = serializedObj.FindProperty("Settings.auroraBrightness");
+            auroraContrast = serializedObj.FindProperty("Settings.auroraContrast");
+            auroraHeight = serializedObj.FindProperty("Settings.auroraHeight");
+            auroraScale = serializedObj.FindProperty("Settings.auroraScale");
+            auroraSteps = serializedObj.FindProperty("Settings.auroraSteps");
+            auroraLayer1Settings = serializedObj.FindProperty("Settings.auroraLayer1Settings");
+            auroraLayer2Settings = serializedObj.FindProperty("Settings.auroraLayer2Settings");
+            auroraColorshiftSettings = serializedObj.FindProperty("Settings.auroraColorshiftSettings");
+            auroraSpeed = serializedObj.FindProperty("Settings.auroraSpeed");
+            aurora_layer_1 = serializedObj.FindProperty("Settings.aurora_layer_1");
+            aurora_layer_2 = serializedObj.FindProperty("Settings.aurora_layer_2");
+            aurora_colorshift = serializedObj.FindProperty("Settings.aurora_colorshift");
+        } 
+
+        public override void OnInspectorGUI()
+        {
+            if(!target)
+                return;
+            
+            base.OnInspectorGUI();
+
+            GUI.backgroundColor = baseModuleColor;
+            GUILayout.BeginVertical("",boxStyleModified);
+            GUI.backgroundColor = Color.white;
+            EditorGUILayout.BeginHorizontal();
+            myTarget.showModuleInspector = GUILayout.Toggle(myTarget.showModuleInspector, "Aurora", headerFoldout);
+            
+            GUILayout.FlexibleSpace();
+            if(GUILayout.Button("x", EditorStyles.miniButtonRight,GUILayout.Width(18), GUILayout.Height(18)))
+            {
+                EnviroManager.instance.RemoveModule(EnviroManager.ModuleType.Aurora); //Add Remove
+                DestroyImmediate(this);
+                return; 
+            }  
+            
+            EditorGUILayout.EndHorizontal();
+            
+            if(myTarget.showModuleInspector)
+            {
+                RenderDisableInputBox();
+                serializedObj.UpdateIfRequiredOrScript ();
+                EditorGUI.BeginChangeCheck();
+                
+                // Set Values
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showAuroraControls = GUILayout.Toggle(myTarget.showAuroraControls, "Aurora Controls", headerFoldout);               
+                if(myTarget.showAuroraControls)
+                {  
+                    GUILayout.Space(5);
+                    DisableInputStartQuality();
+                    EditorGUILayout.PropertyField(useAurora);
+                    DisableInputEndQuality();
+                    GUILayout.Space(5);
+                    DisableInputStart();
+                    EditorGUILayout.PropertyField(auroraIntensityModifier);
+                    DisableInputEnd();
+                    EditorGUILayout.PropertyField(auroraIntensity);
+                    EditorGUILayout.PropertyField(auroraColor);
+                    EditorGUILayout.PropertyField(auroraBrightness);
+                    EditorGUILayout.PropertyField(auroraContrast);
+                    EditorGUILayout.PropertyField(auroraHeight); 
+                    EditorGUILayout.PropertyField(auroraScale);
+                    EditorGUILayout.PropertyField(auroraSteps); 
+                    EditorGUILayout.PropertyField(auroraLayer1Settings);
+                    EditorGUILayout.PropertyField(auroraLayer2Settings);
+                    EditorGUILayout.PropertyField(auroraColorshiftSettings);
+                    EditorGUILayout.PropertyField(auroraSpeed);
+
+                    EditorGUILayout.PropertyField(aurora_layer_1);
+                    EditorGUILayout.PropertyField(aurora_layer_2);
+                    EditorGUILayout.PropertyField(aurora_colorshift);
+                }
+                GUILayout.EndVertical();
+
+
+                // Save Load
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showSaveLoad = GUILayout.Toggle(myTarget.showSaveLoad, "Save/Load", headerFoldout);
+                
+                if(myTarget.showSaveLoad)
+                {
+                    EditorGUILayout.PropertyField(preset);
+
+                    GUILayout.BeginHorizontal("",wrapStyle);
+
+                    if(myTarget.preset != null)
+                    {
+                        if(GUILayout.Button("Load"))
+                        {
+                            myTarget.LoadModuleValues();
+                        }
+                        if(GUILayout.Button("Save"))
+                        {
+                            myTarget.SaveModuleValues(myTarget.preset);
+                        }
+                    }
+                    if(GUILayout.Button("Save As New"))
+                    {
+                        myTarget.SaveModuleValues();
+                    }
+
+                    GUILayout.EndHorizontal();
+
+     
+                }
+                GUILayout.EndVertical();
+                /// Save Load End
+                
+                ApplyChanges ();
+            }
+            GUILayout.EndVertical();
+
+            if(myTarget.showModuleInspector)
+             GUILayout.Space(20);
+        }
+    }
+}

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Aurora/EnviroAuroraModuleEditor.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: fbae4b13cc60cee41bf8708c9f392fa1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 236601
+  packageName: Enviro 3 - Sky and Weather
+  packageVersion: 3.1.2
+  assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Aurora/EnviroAuroraModuleEditor.cs
+  uploadId: 660896

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Default.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4ce822fed9cd5b14da7f99e1e3b7ef14
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Default/EnviroDefaultModuleEditor.cs

@@ -0,0 +1,114 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+
+namespace Enviro
+{
+    [CustomEditor(typeof(EnviroDefaultModule))]
+    public class EnviroDefaultModuleEditor : EnviroModuleEditor
+    {  
+        private EnviroDefaultModule myTarget; 
+
+        //Properties
+        private SerializedProperty frontColorGradient0;
+
+
+        //On Enable
+        public override void OnEnable()
+        {
+            base.OnEnable();
+
+            if(!target)
+                return;
+
+            myTarget = (EnviroDefaultModule)target;
+            serializedObj = new SerializedObject(myTarget);
+            preset = serializedObj.FindProperty("preset");
+        } 
+
+        public override void OnInspectorGUI()
+        {
+            if(!target)
+                return;
+
+            base.OnInspectorGUI();
+            
+            GUI.backgroundColor = new Color(0.7f,0.7f,0.7f,1f);
+            GUILayout.BeginVertical("",boxStyleModified);
+            GUI.backgroundColor = Color.white;
+            EditorGUILayout.BeginHorizontal();
+            myTarget.showModuleInspector = GUILayout.Toggle(myTarget.showModuleInspector, "Default Module", headerFoldout);
+            
+            GUILayout.FlexibleSpace();
+            if(GUILayout.Button("x", EditorStyles.miniButtonRight,GUILayout.Width(18), GUILayout.Height(18)))
+            {
+                EnviroManager.instance.RemoveModule(EnviroManager.ModuleType.Time); //Add Remove
+                DestroyImmediate(this);
+                return;
+            } 
+            
+            EditorGUILayout.EndHorizontal();
+            
+            if(myTarget.showModuleInspector)
+            {
+                EditorGUILayout.LabelField("This module will control your.");
+                serializedObj.UpdateIfRequiredOrScript ();
+                EditorGUI.BeginChangeCheck();
+                
+                // Set Values
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showDefaultControls = GUILayout.Toggle(myTarget.showDefaultControls, "Default Controls", headerFoldout);               
+                if(myTarget.showDefaultControls)
+                {
+                    GUILayout.Space(10);
+                }
+                GUILayout.EndVertical();
+
+
+                // Save Load
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showSaveLoad = GUILayout.Toggle(myTarget.showSaveLoad, "Save/Load", headerFoldout);
+                
+                if(myTarget.showSaveLoad)
+                {
+                    EditorGUILayout.PropertyField(preset);
+
+                    GUILayout.BeginHorizontal("",wrapStyle);
+
+                    if(myTarget.preset != null)
+                    {
+                        if(GUILayout.Button("Load"))
+                        {
+                            myTarget.LoadModuleValues();
+                        }
+                        if(GUILayout.Button("Save"))
+                        {
+                            myTarget.SaveModuleValues(myTarget.preset);
+                        }
+                    }
+                    if(GUILayout.Button("Save As New"))
+                    {
+                        myTarget.SaveModuleValues();
+                    }
+
+                    GUILayout.EndHorizontal();
+
+     
+                }
+                GUILayout.EndVertical();
+                /// Save Load End
+                
+                ApplyChanges ();
+            }
+            GUILayout.EndVertical();
+
+            if(myTarget.showModuleInspector)
+             GUILayout.Space(20);
+        }
+    }
+}

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Default/EnviroDefaultModuleEditor.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: c8c89e9fa66b6294984772a640e46cf0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 236601
+  packageName: Enviro 3 - Sky and Weather
+  packageVersion: 3.1.2
+  assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Default/EnviroDefaultModuleEditor.cs
+  uploadId: 660896

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Effects.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c623a3f8593c11f419641e1ad5443aa4
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Effects/EnviroEffectsModuleEditor.cs

@@ -0,0 +1,184 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+
+namespace Enviro
+{
+    [CustomEditor(typeof(EnviroEffectsModule))]
+    public class EnviroEffectsModuleEditor : EnviroModuleEditor
+    {  
+        private EnviroEffectsModule myTarget; 
+
+        private SerializedProperty particeEmissionRateModifier , enviroEffectSystemType;
+      
+        //On Enable
+        public override void OnEnable()
+        {
+            if(!target)
+                return; 
+
+            myTarget = (EnviroEffectsModule)target;
+            serializedObj = new SerializedObject(myTarget);
+            preset = serializedObj.FindProperty("preset");
+            particeEmissionRateModifier = serializedObj.FindProperty("Settings.particeEmissionRateModifier");
+            enviroEffectSystemType = serializedObj.FindProperty("Settings.enviroEffectSystemType");
+        
+        }
+
+        public override void OnInspectorGUI()
+        {
+            if(!target)
+                return;
+
+            base.OnInspectorGUI();
+
+            GUI.backgroundColor = baseModuleColor;
+            GUILayout.BeginVertical("",boxStyleModified);
+            GUI.backgroundColor = Color.white;
+            EditorGUILayout.BeginHorizontal();
+            myTarget.showModuleInspector = GUILayout.Toggle(myTarget.showModuleInspector, "Effects", headerFoldout);
+            
+            GUILayout.FlexibleSpace();
+            if(GUILayout.Button("x", EditorStyles.miniButtonRight,GUILayout.Width(18), GUILayout.Height(18)))
+            {
+                EnviroManager.instance.RemoveModule(EnviroManager.ModuleType.Effects);
+                DestroyImmediate(this);
+                return;
+            } 
+             
+            EditorGUILayout.EndHorizontal();
+            
+            if(myTarget.showModuleInspector)
+            {
+                RenderDisableInputBox();
+                serializedObj.UpdateIfRequiredOrScript ();
+                EditorGUI.BeginChangeCheck();
+
+      
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);  
+                GUI.backgroundColor = Color.white;
+
+                 GUILayout.Label("General", headerStyle);
+
+#if ENVIRO_VFXGRAPH
+                if (GUILayout.Button("Deactivate VFX Graph Support"))
+                {
+                    RemoveDefineSymbol("ENVIRO_VFXGRAPH");
+                }      
+#else
+                if (GUILayout.Button("Activate VFX Graph Support"))
+                {
+                    AddDefineSymbol("ENVIRO_VFXGRAPH");
+                }
+#endif
+#if ENVIRO_VFXGRAPH
+                EditorGUILayout.PropertyField(enviroEffectSystemType);     
+#endif 
+                GUILayout.Space(5);
+                DisableInputStartQuality();
+                EditorGUILayout.PropertyField(particeEmissionRateModifier);        
+                DisableInputEndQuality();  
+                GUILayout.EndVertical();
+
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);  
+                GUI.backgroundColor = Color.white;
+
+                myTarget.showSetupControls = GUILayout.Toggle(myTarget.showSetupControls, "Setup", headerFoldout);              
+                if(myTarget.showSetupControls)
+                { 
+                    GUILayout.Space(10);
+                    if (!Application.isPlaying) 
+                    {
+                        if (GUILayout.Button ("Add")) 
+                        {
+                            myTarget.Settings.effectTypes.Add (new EnviroEffectTypes ());
+                        }
+                    } 
+                    else
+                        EditorGUILayout.LabelField ("Can't add effects in runtime!");
+
+                    if (GUILayout.Button ("Apply Changes")) 
+                    {
+                        myTarget.CreateEffects();
+                    }
+
+                    GUILayout.Space(10);
+                    
+                    for (int i = 0; i < myTarget.Settings.effectTypes.Count; i++) 
+                    {      
+                        GUILayout.BeginVertical (myTarget.Settings.effectTypes[i].name, boxStyleModified);
+                        GUILayout.Space(15);
+                        Undo.RecordObject(target, "Effect Setup Changed");
+                        myTarget.Settings.effectTypes[i].name = EditorGUILayout.TextField ("Effect Name", myTarget.Settings.effectTypes[i].name);
+                        myTarget.Settings.effectTypes [i].emissionRate = EditorGUILayout.Slider("Emission", myTarget.Settings.effectTypes [i].emissionRate,0f,1f);
+                        GUILayout.Space(15); 
+                        GUILayout.Label("Particle System", headerStyle);
+                        myTarget.Settings.effectTypes[i].prefab = (GameObject)EditorGUILayout.ObjectField ("Effect Prefab", myTarget.Settings.effectTypes[i].prefab, typeof(GameObject), true);
+                        myTarget.Settings.effectTypes [i].localPositionOffset = EditorGUILayout.Vector3Field ("Position Offset", myTarget.Settings.effectTypes [i].localPositionOffset);
+                        myTarget.Settings.effectTypes [i].localRotationOffset = EditorGUILayout.Vector3Field ("Rotation Offset", myTarget.Settings.effectTypes [i].localRotationOffset);
+                        myTarget.Settings.effectTypes [i].maxEmission = EditorGUILayout.FloatField ("Maximum Emission", myTarget.Settings.effectTypes [i].maxEmission);
+                        #if ENVIRO_VFXGRAPH
+                        GUILayout.Space(15);
+                        GUILayout.Label("VFX Graph", headerStyle);
+                        myTarget.Settings.effectTypes[i].prefabVFXGraph = (GameObject)EditorGUILayout.ObjectField ("Effect Prefab", myTarget.Settings.effectTypes[i].prefabVFXGraph, typeof(GameObject), true);
+                        myTarget.Settings.effectTypes [i].localPositionOffsetVFXGraph = EditorGUILayout.Vector3Field ("Position Offset", myTarget.Settings.effectTypes [i].localPositionOffsetVFXGraph);
+                        myTarget.Settings.effectTypes [i].localRotationOffsetVFXGraph = EditorGUILayout.Vector3Field ("Rotation Offset", myTarget.Settings.effectTypes [i].localRotationOffsetVFXGraph);
+                        myTarget.Settings.effectTypes [i].maxEmissionVFXGraph = EditorGUILayout.FloatField ("Maximum Emission", myTarget.Settings.effectTypes [i].maxEmissionVFXGraph);    
+                        GUILayout.Space(10);
+                        #endif 
+ 
+                        if (GUILayout.Button ("Remove")) 
+                        {
+                            myTarget.Settings.effectTypes.Remove (myTarget.Settings.effectTypes[i]);
+                        }
+                        GUILayout.EndVertical ();
+                    }
+
+                }
+                GUILayout.EndVertical();
+               
+                /// Save Load
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showSaveLoad = GUILayout.Toggle(myTarget.showSaveLoad, "Save/Load", headerFoldout);
+                
+                if(myTarget.showSaveLoad)
+                {
+                    EditorGUILayout.PropertyField(preset);
+
+                    GUILayout.BeginHorizontal("",wrapStyle);
+
+                    if(myTarget.preset != null)
+                    {
+                        if(GUILayout.Button("Load"))
+                        {
+                            myTarget.LoadModuleValues();
+                        }
+                        if(GUILayout.Button("Save"))
+                        {
+                            myTarget.SaveModuleValues(myTarget.preset);
+                        }
+                    }
+                    if(GUILayout.Button("Save As New"))
+                    {
+                        myTarget.SaveModuleValues();
+                    }
+                    GUILayout.EndHorizontal();
+                }
+                GUILayout.EndVertical();
+                /// Save Load End
+
+                ApplyChanges (); 
+                EditorUtility.SetDirty (target);
+            }
+            GUILayout.EndVertical();
+
+        if(myTarget.showModuleInspector)
+            GUILayout.Space(20);
+        }
+    }
+}

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Effects/EnviroEffectsModuleEditor.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 0bd5bd4ff7f1acd408bcdb9e7901bb87
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 236601
+  packageName: Enviro 3 - Sky and Weather
+  packageVersion: 3.1.2
+  assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Effects/EnviroEffectsModuleEditor.cs
+  uploadId: 660896

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Environment.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f7280648026bfa3458acdad35aea928e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Environment/EnviroEnvironmentModuleEditor.cs

@@ -0,0 +1,228 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+
+namespace Enviro
+{
+    [CustomEditor(typeof(EnviroEnvironmentModule))]
+    public class EnviroEnvironmentModuleEditor : EnviroModuleEditor
+    {  
+        private EnviroEnvironmentModule myTarget; 
+
+        //Properties Seasons
+        private SerializedProperty season, changeSeason, springStart, springEnd, summerStart, summerEnd, autumnStart, autumnEnd, winterStart, winterEnd;
+        //Properties Temperature
+        private SerializedProperty springBaseTemperature, summerBaseTemperature, autumnBaseTemperature, winterBaseTemperature, temperatureWeatherMod, temperature, temperatureChangingSpeed;
+        //Properties Weather State
+        private SerializedProperty wetness, snow, wetnessTarget, snowTarget, wetnessAccumulationSpeed, wetnessDrySpeed, snowAccumulationSpeed, snowMeltSpeed ,snowMeltingTresholdTemperature;
+        //Properties Wind
+        private SerializedProperty windDirectionX,windDirectionY,windSpeed,windTurbulence;
+
+        //On Enable
+        public override void OnEnable()
+        {
+            base.OnEnable();
+
+            if(!target)
+                return;
+
+            myTarget = (EnviroEnvironmentModule)target;
+            serializedObj = new SerializedObject(myTarget);
+            preset = serializedObj.FindProperty("preset");
+
+            season = serializedObj.FindProperty("Settings.season");
+            changeSeason = serializedObj.FindProperty("Settings.changeSeason");
+            springStart = serializedObj.FindProperty("Settings.springStart");
+            springEnd = serializedObj.FindProperty("Settings.springEnd");
+            summerStart = serializedObj.FindProperty("Settings.summerStart");
+            summerEnd = serializedObj.FindProperty("Settings.summerEnd");
+            autumnStart = serializedObj.FindProperty("Settings.autumnStart");
+            autumnEnd = serializedObj.FindProperty("Settings.autumnEnd");
+            winterStart = serializedObj.FindProperty("Settings.winterStart");
+            winterEnd = serializedObj.FindProperty("Settings.winterEnd");
+
+            springBaseTemperature = serializedObj.FindProperty("Settings.springBaseTemperature");
+            summerBaseTemperature = serializedObj.FindProperty("Settings.summerBaseTemperature");
+            autumnBaseTemperature = serializedObj.FindProperty("Settings.autumnBaseTemperature");
+            winterBaseTemperature = serializedObj.FindProperty("Settings.winterBaseTemperature");
+            temperatureWeatherMod = serializedObj.FindProperty("Settings.temperatureWeatherMod");
+            temperature = serializedObj.FindProperty("Settings.temperature");
+            temperatureChangingSpeed = serializedObj.FindProperty("Settings.temperatureChangingSpeed");
+
+            wetness = serializedObj.FindProperty("Settings.wetness");
+            snow = serializedObj.FindProperty("Settings.snow");
+            wetnessTarget = serializedObj.FindProperty("Settings.wetnessTarget");
+            snowTarget = serializedObj.FindProperty("Settings.snowTarget");
+            wetnessAccumulationSpeed = serializedObj.FindProperty("Settings.wetnessAccumulationSpeed");
+            wetnessDrySpeed = serializedObj.FindProperty("Settings.wetnessDrySpeed");
+            snowAccumulationSpeed = serializedObj.FindProperty("Settings.snowAccumulationSpeed");
+            snowMeltSpeed = serializedObj.FindProperty("Settings.snowMeltSpeed");
+            snowMeltingTresholdTemperature = serializedObj.FindProperty("Settings.snowMeltingTresholdTemperature"); 
+
+            windDirectionX = serializedObj.FindProperty("Settings.windDirectionX"); 
+            windDirectionY = serializedObj.FindProperty("Settings.windDirectionY"); 
+            windSpeed = serializedObj.FindProperty("Settings.windSpeed"); 
+            windTurbulence = serializedObj.FindProperty("Settings.windTurbulence");           
+        } 
+
+        public override void OnInspectorGUI()
+        {
+            if(!target)
+                return;
+
+            base.OnInspectorGUI();
+            
+            GUI.backgroundColor = baseModuleColor;
+            GUILayout.BeginVertical("",boxStyleModified);
+            GUI.backgroundColor = Color.white;
+            EditorGUILayout.BeginHorizontal();
+            myTarget.showModuleInspector = GUILayout.Toggle(myTarget.showModuleInspector, "Environment", headerFoldout);
+            
+            GUILayout.FlexibleSpace();
+            if(GUILayout.Button("x", EditorStyles.miniButtonRight,GUILayout.Width(18), GUILayout.Height(18)))
+            {
+                EnviroManager.instance.RemoveModule(EnviroManager.ModuleType.Environment); //Add Remove
+                DestroyImmediate(this);
+                return;
+            } 
+            
+            EditorGUILayout.EndHorizontal();
+            
+            if(myTarget.showModuleInspector) 
+            {
+                RenderDisableInputBox();
+                serializedObj.UpdateIfRequiredOrScript ();
+                EditorGUI.BeginChangeCheck();
+                
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showSeasonControls = GUILayout.Toggle(myTarget.showSeasonControls, "Season Controls", headerFoldout);               
+                if(myTarget.showSeasonControls)
+                {
+                   
+                   GUILayout.Space(5);   
+                   EditorGUILayout.PropertyField(season);
+                   EditorGUILayout.PropertyField(changeSeason);
+                   GUILayout.Space(10);
+                   EditorGUILayout.PropertyField(springStart);
+                   EditorGUILayout.PropertyField(springEnd);
+                   GUILayout.Space(5);
+                   EditorGUILayout.PropertyField(summerStart);
+                   EditorGUILayout.PropertyField(summerEnd);
+                   GUILayout.Space(5);
+                   EditorGUILayout.PropertyField(autumnStart);
+                   EditorGUILayout.PropertyField(autumnEnd);
+                   GUILayout.Space(5);
+                   EditorGUILayout.PropertyField(winterStart);
+                   EditorGUILayout.PropertyField(winterEnd); 
+                }
+                GUILayout.EndVertical();
+
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showTemperatureControls = GUILayout.Toggle(myTarget.showTemperatureControls, "Temperature Controls", headerFoldout);               
+                if(myTarget.showTemperatureControls)
+                {
+                   GUILayout.Space(5);      
+                   EditorGUILayout.PropertyField(temperature);
+                   DisableInputStart();
+                   EditorGUILayout.PropertyField(temperatureWeatherMod);
+                   DisableInputEnd();
+                   EditorGUILayout.PropertyField(temperatureChangingSpeed);
+                   GUILayout.Space(10);
+                   EditorGUILayout.PropertyField(springBaseTemperature);
+                   EditorGUILayout.PropertyField(summerBaseTemperature);
+                   EditorGUILayout.PropertyField(autumnBaseTemperature);
+                   EditorGUILayout.PropertyField(winterBaseTemperature);
+                }
+                GUILayout.EndVertical();
+
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showWeatherStateControls = GUILayout.Toggle(myTarget.showWeatherStateControls, "Weather State Controls", headerFoldout);               
+                if(myTarget.showWeatherStateControls)
+                {
+                   GUILayout.Space(5);     
+                   EditorGUILayout.PropertyField(wetness);
+                   EditorGUILayout.PropertyField(snow);
+                   GUILayout.Space(5);
+                   DisableInputStart();
+                   EditorGUILayout.PropertyField(wetnessTarget);
+                   EditorGUILayout.PropertyField(snowTarget);
+                   DisableInputEnd();
+                   GUILayout.Space(10);
+                   EditorGUILayout.PropertyField(wetnessAccumulationSpeed);
+                   EditorGUILayout.PropertyField(wetnessDrySpeed);
+                   GUILayout.Space(5);
+                   EditorGUILayout.PropertyField(snowAccumulationSpeed);
+                   EditorGUILayout.PropertyField(snowMeltSpeed);
+                   EditorGUILayout.PropertyField(snowMeltingTresholdTemperature);
+                }
+                GUILayout.EndVertical();
+
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showWindControls = GUILayout.Toggle(myTarget.showWindControls, "Wind Controls", headerFoldout);               
+                if(myTarget.showWindControls)
+                {
+                   GUILayout.Space(5);
+                   DisableInputStart();  
+                   EditorGUILayout.PropertyField(windDirectionX); 
+                   EditorGUILayout.PropertyField(windDirectionY);
+                   GUILayout.Space(5);
+                   EditorGUILayout.PropertyField(windSpeed);
+                   EditorGUILayout.PropertyField(windTurbulence);
+                   DisableInputEnd();
+                }
+                GUILayout.EndVertical();
+
+
+                // Save Load
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showSaveLoad = GUILayout.Toggle(myTarget.showSaveLoad, "Save/Load", headerFoldout);
+                
+                if(myTarget.showSaveLoad)
+                {
+                    EditorGUILayout.PropertyField(preset);
+
+                    GUILayout.BeginHorizontal("",wrapStyle);
+
+                    if(myTarget.preset != null)
+                    {
+                        if(GUILayout.Button("Load"))
+                        {
+                            myTarget.LoadModuleValues();
+                        }
+                        if(GUILayout.Button("Save"))
+                        {
+                            myTarget.SaveModuleValues(myTarget.preset);
+                        }
+                    }
+                    if(GUILayout.Button("Save As New"))
+                    {
+                        myTarget.SaveModuleValues();
+                    }
+
+                    GUILayout.EndHorizontal();
+
+     
+                }
+                GUILayout.EndVertical();
+                /// Save Load End
+                
+                ApplyChanges ();
+            }
+            GUILayout.EndVertical();
+
+            if(myTarget.showModuleInspector)
+             GUILayout.Space(20);
+        }
+    }
+}

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Environment/EnviroEnvironmentModuleEditor.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: d5eaece25dc327941a713b463887d2a1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 236601
+  packageName: Enviro 3 - Sky and Weather
+  packageVersion: 3.1.2
+  assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Environment/EnviroEnvironmentModuleEditor.cs
+  uploadId: 660896

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Events.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 84c8cd084973e924e8df37a6036d9300
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Events/EnviroEventModuleEditor.cs

@@ -0,0 +1 @@
+//Depricated

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Events/EnviroEventModuleEditor.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 235106b3b1b86bd498e52941c4cd4299
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 236601
+  packageName: Enviro 3 - Sky and Weather
+  packageVersion: 3.1.2
+  assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Events/EnviroEventModuleEditor.cs
+  uploadId: 660896

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/FlatClouds.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e3bcae60d5ee107419abc8ee41788144
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/FlatClouds/EnviroFlatCloudsModuleEditor.cs

@@ -0,0 +1,208 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+
+namespace Enviro
+{
+    [CustomEditor(typeof(EnviroFlatCloudsModule))]
+    public class EnviroFlatCloudsModuleEditor : EnviroModuleEditor
+    {  
+        private EnviroFlatCloudsModule myTarget; 
+
+        //Properties Cirrus
+        private SerializedProperty useCirrusClouds,cirrusCloudsTex, cirrusCloudsAlpha,cirrusCloudsCoverage, cirrusCloudsColorPower, cirrusCloudsColor, cirrusCloudsWindIntensity;
+
+        //Properties 2D
+        private SerializedProperty useFlatClouds, flatCloudsBaseTex, flatCloudsDetailTex, flatCloudsLightColor, flatCloudsAmbientColor, flatCloudsLightIntensity, flatCloudsAmbientIntensity, 
+        flatCloudsShadowIntensity, flatCloudsHGPhase, flatCloudsCoverage, flatCloudsDensity, flatCloudsAltitude, flatCloudsShadowSteps, flatCloudsBaseTiling, flatCloudsDetailTiling, flatCloudsWindIntensity,flatCloudsDetailWindIntensity;
+
+        //On Enable
+        public override void OnEnable()
+        {
+            base.OnEnable();
+
+            if(!target)
+                return;
+
+            myTarget = (EnviroFlatCloudsModule)target;
+            serializedObj = new SerializedObject(myTarget);
+            preset = serializedObj.FindProperty("preset");
+
+            useCirrusClouds = serializedObj.FindProperty("settings.useCirrusClouds");
+            cirrusCloudsTex = serializedObj.FindProperty("settings.cirrusCloudsTex");
+            cirrusCloudsAlpha = serializedObj.FindProperty("settings.cirrusCloudsAlpha");
+            cirrusCloudsCoverage = serializedObj.FindProperty("settings.cirrusCloudsCoverage");
+            cirrusCloudsColorPower = serializedObj.FindProperty("settings.cirrusCloudsColorPower");
+            cirrusCloudsColor = serializedObj.FindProperty("settings.cirrusCloudsColor");
+            cirrusCloudsWindIntensity = serializedObj.FindProperty("settings.cirrusCloudsWindIntensity");
+
+            //2D Clouds
+            useFlatClouds = serializedObj.FindProperty("settings.useFlatClouds");
+            flatCloudsBaseTex = serializedObj.FindProperty("settings.flatCloudsBaseTex");
+            flatCloudsDetailTex = serializedObj.FindProperty("settings.flatCloudsDetailTex");
+            flatCloudsLightColor  = serializedObj.FindProperty("settings.flatCloudsLightColor");
+            flatCloudsAmbientColor = serializedObj.FindProperty("settings.flatCloudsAmbientColor"); 
+            flatCloudsLightIntensity = serializedObj.FindProperty("settings.flatCloudsLightIntensity"); 
+            flatCloudsAmbientIntensity = serializedObj.FindProperty("settings.flatCloudsAmbientIntensity");
+            flatCloudsShadowIntensity = serializedObj.FindProperty("settings.flatCloudsShadowIntensity");
+            flatCloudsHGPhase = serializedObj.FindProperty("settings.flatCloudsHGPhase");
+            flatCloudsCoverage = serializedObj.FindProperty("settings.flatCloudsCoverage");
+            flatCloudsDensity = serializedObj.FindProperty("settings.flatCloudsDensity");
+            flatCloudsAltitude  = serializedObj.FindProperty("settings.flatCloudsAltitude");
+            flatCloudsShadowSteps  = serializedObj.FindProperty("settings.flatCloudsShadowSteps");
+            flatCloudsBaseTiling = serializedObj.FindProperty("settings.flatCloudsBaseTiling");
+            flatCloudsDetailTiling = serializedObj.FindProperty("settings.flatCloudsDetailTiling");
+            flatCloudsWindIntensity = serializedObj.FindProperty("settings.flatCloudsWindIntensity");
+            flatCloudsDetailWindIntensity = serializedObj.FindProperty("settings.flatCloudsDetailWindIntensity");
+
+        } 
+
+        public override void OnInspectorGUI()
+        {
+            if(!target)
+                return;
+
+             base.OnInspectorGUI();
+
+            GUI.backgroundColor = baseModuleColor;
+            GUILayout.BeginVertical("",boxStyleModified);
+            GUI.backgroundColor = Color.white;
+            EditorGUILayout.BeginHorizontal();
+            myTarget.showModuleInspector = GUILayout.Toggle(myTarget.showModuleInspector, "Flat Clouds", headerFoldout);
+             
+            GUILayout.FlexibleSpace();
+            if(GUILayout.Button("x", EditorStyles.miniButtonRight,GUILayout.Width(18), GUILayout.Height(18)))
+            {
+                EnviroManager.instance.RemoveModule(EnviroManager.ModuleType.FlatClouds); 
+                DestroyImmediate(this);
+                return;
+            }  
+            
+            EditorGUILayout.EndHorizontal();
+            
+            if(myTarget.showModuleInspector)
+            { 
+                RenderDisableInputBox();
+                serializedObj.UpdateIfRequiredOrScript ();
+                EditorGUI.BeginChangeCheck();
+                
+                // Cirrus Clouds
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showCirrusCloudsControls = GUILayout.Toggle(myTarget.showCirrusCloudsControls, "Cirrus Clouds", headerFoldout);               
+                if(myTarget.showCirrusCloudsControls)
+                {
+                    GUILayout.Space(10);
+                    DisableInputStartQuality();
+                    EditorGUILayout.PropertyField(useCirrusClouds);
+                    DisableInputEndQuality();
+                    EditorGUILayout.PropertyField(cirrusCloudsTex);
+                    DisableInputStart();
+                    EditorGUILayout.PropertyField(cirrusCloudsAlpha);
+                    EditorGUILayout.PropertyField(cirrusCloudsCoverage);              
+                    EditorGUILayout.PropertyField(cirrusCloudsColorPower);
+                    DisableInputEnd();
+                    EditorGUILayout.PropertyField(cirrusCloudsColor);
+                    GUILayout.Space(5);
+                    EditorGUILayout.PropertyField(cirrusCloudsWindIntensity);
+                    
+                } 
+                GUILayout.EndVertical();
+
+                if( myTarget.showCirrusCloudsControls)
+                    GUILayout.Space(10);
+
+                // 2D Clouds
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.show2DCloudsControls = GUILayout.Toggle(myTarget.show2DCloudsControls, "2D Clouds", headerFoldout);               
+                if(myTarget.show2DCloudsControls)
+                {
+                    GUILayout.Space(10);
+                    DisableInputStartQuality();
+                    EditorGUILayout.PropertyField(useFlatClouds);
+                    DisableInputEndQuality();
+                    GUILayout.Space(5);
+                    EditorGUILayout.PropertyField(flatCloudsBaseTex);
+                    EditorGUILayout.PropertyField(flatCloudsBaseTiling);
+                    EditorGUILayout.PropertyField(flatCloudsDetailTex);
+                    EditorGUILayout.PropertyField(flatCloudsDetailTiling);
+                    GUILayout.Space(5);
+                    EditorGUILayout.PropertyField(flatCloudsLightColor);
+                    DisableInputStart();
+                    EditorGUILayout.PropertyField(flatCloudsLightIntensity);
+                    DisableInputEnd();
+                    EditorGUILayout.PropertyField(flatCloudsAmbientColor);
+                    DisableInputStart();
+                    EditorGUILayout.PropertyField(flatCloudsAmbientIntensity); 
+                    GUILayout.Space(5); 
+                    EditorGUILayout.PropertyField(flatCloudsShadowIntensity);  
+                    DisableInputEnd();   
+                    DisableInputStartQuality(); 
+                    EditorGUILayout.PropertyField(flatCloudsShadowSteps);
+                    DisableInputEndQuality();
+                    EditorGUILayout.PropertyField(flatCloudsHGPhase);
+                    GUILayout.Space(5);
+                    DisableInputStart();
+                    EditorGUILayout.PropertyField(flatCloudsCoverage);
+                    EditorGUILayout.PropertyField(flatCloudsDensity);
+                    DisableInputEnd();
+                    EditorGUILayout.PropertyField(flatCloudsAltitude);        
+                    GUILayout.Space(5);
+                    EditorGUILayout.PropertyField(flatCloudsWindIntensity);
+                    EditorGUILayout.PropertyField(flatCloudsDetailWindIntensity);
+                }  
+                GUILayout.EndVertical();
+
+                   if( myTarget.show2DCloudsControls)
+                    GUILayout.Space(10);
+
+
+
+                // Save Load
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showSaveLoad = GUILayout.Toggle(myTarget.showSaveLoad, "Save/Load", headerFoldout);
+                
+                if(myTarget.showSaveLoad)
+                {
+                    EditorGUILayout.PropertyField(preset);
+
+                    GUILayout.BeginHorizontal("",wrapStyle);
+
+                    if(myTarget.preset != null)
+                    {
+                        if(GUILayout.Button("Load"))
+                        {
+                            myTarget.LoadModuleValues();
+                        }
+                        if(GUILayout.Button("Save"))
+                        {
+                            myTarget.SaveModuleValues(myTarget.preset);
+                        }
+                    }
+                    if(GUILayout.Button("Save As New"))
+                    {
+                        myTarget.SaveModuleValues();
+                    }
+
+                    GUILayout.EndHorizontal();
+
+     
+                }
+                GUILayout.EndVertical();
+                /// Save Load End
+                
+                ApplyChanges ();
+            }
+            GUILayout.EndVertical();
+ 
+            if(myTarget.showModuleInspector)
+             GUILayout.Space(20);
+        }
+    }
+}

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/FlatClouds/EnviroFlatCloudsModuleEditor.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 18c5c2ecb92a5f64eb1a9272a33fd4ec
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 236601
+  packageName: Enviro 3 - Sky and Weather
+  packageVersion: 3.1.2
+  assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/FlatClouds/EnviroFlatCloudsModuleEditor.cs
+  uploadId: 660896

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Fog.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 2e15a8e9123b53747bb3d5a7a79ee2f7
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Fog/EnviroFogModuleEditor.cs

@@ -0,0 +1,333 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+
+namespace Enviro
+{
+    [CustomEditor(typeof(EnviroFogModule))]
+    public class EnviroFogModuleEditor : EnviroModuleEditor
+    {  
+        private EnviroFogModule myTarget; 
+
+        //Properties
+        private SerializedProperty fog, volumetrics, ditheringTex, quality, steps, scattering,scatteringMultiplier, extinction, anistropy, maxRange,maxRangePointSpot, noiseIntensity, noiseScale, windDirection, noise;
+        private SerializedProperty fogQualityMode,globalFogHeight, fogDensity, fogHeightFalloff, fogHeight, fogDensity2, fogHeightFalloff2, fogHeight2, fogMaxOpacity, startDistance, fogColorBlend,fogColorMod,ambientColorGradient,blockScattering;
+        private SerializedProperty unityFog, unityFogDensity, unityFogColor, unityFogMode, unityFogStartDistance, unityFogEndDistance;
+    
+    #if ENVIRO_HDRP
+        private SerializedProperty controlHDRPFog, fogAttenuationDistance, baseHeight, maxHeight, fogColorTint;
+        private SerializedProperty controlHDRPVolumetrics, volumetricsColorTint, ambientDimmer, directLightMultiplier, directLightShadowdimmer;
+    #endif
+        public override void OnEnable()
+        {
+            if(!target)
+                return;
+
+            myTarget = (EnviroFogModule)target;
+            serializedObj = new SerializedObject(myTarget);
+            preset = serializedObj.FindProperty("preset");
+
+            //Volumetrics
+            volumetrics = serializedObj.FindProperty("Settings.volumetrics");
+            quality = serializedObj.FindProperty("Settings.quality");
+            steps = serializedObj.FindProperty("Settings.steps");
+            scattering = serializedObj.FindProperty("Settings.scattering");
+            scatteringMultiplier = serializedObj.FindProperty("Settings.scatteringMultiplier"); 
+            extinction = serializedObj.FindProperty("Settings.extinction");
+            anistropy = serializedObj.FindProperty("Settings.anistropy");
+            maxRange = serializedObj.FindProperty("Settings.maxRange");
+            maxRangePointSpot = serializedObj.FindProperty("Settings.maxRangePointSpot");
+            noiseIntensity = serializedObj.FindProperty("Settings.noiseIntensity");
+            noiseScale = serializedObj.FindProperty("Settings.noiseScale");
+            windDirection= serializedObj.FindProperty("Settings.windDirection");
+            noise = serializedObj.FindProperty("Settings.noise");
+            ditheringTex = serializedObj.FindProperty("Settings.ditheringTex");
+
+            //Height Fog
+            fog = serializedObj.FindProperty("Settings.fog");
+            fogQualityMode = serializedObj.FindProperty("Settings.fogQualityMode");
+            globalFogHeight = serializedObj.FindProperty("Settings.globalFogHeight");
+            fogDensity = serializedObj.FindProperty("Settings.fogDensity");
+            fogHeightFalloff = serializedObj.FindProperty("Settings.fogHeightFalloff");
+            fogHeight = serializedObj.FindProperty("Settings.fogHeight");
+            fogDensity2 = serializedObj.FindProperty("Settings.fogDensity2");
+            fogHeightFalloff2 = serializedObj.FindProperty("Settings.fogHeightFalloff2");
+            fogHeight2 = serializedObj.FindProperty("Settings.fogHeight2");
+            fogMaxOpacity = serializedObj.FindProperty("Settings.fogMaxOpacity");
+            startDistance = serializedObj.FindProperty("Settings.startDistance");
+            fogColorBlend = serializedObj.FindProperty("Settings.fogColorBlend");
+            ambientColorGradient = serializedObj.FindProperty("Settings.ambientColorGradient");
+            fogColorMod = serializedObj.FindProperty("Settings.fogColorMod");
+            blockScattering = serializedObj.FindProperty("Settings.blockScattering");
+
+            //HDRP
+  #if ENVIRO_HDRP
+            controlHDRPFog = serializedObj.FindProperty("Settings.controlHDRPFog");
+            fogAttenuationDistance = serializedObj.FindProperty("Settings.fogAttenuationDistance");
+            baseHeight = serializedObj.FindProperty("Settings.baseHeight");
+            maxHeight = serializedObj.FindProperty("Settings.maxHeight");
+            fogColorTint= serializedObj.FindProperty("Settings.fogColorTint");
+
+            controlHDRPVolumetrics= serializedObj.FindProperty("Settings.controlHDRPVolumetrics");
+            volumetricsColorTint = serializedObj.FindProperty("Settings.volumetricsColorTint");
+            ambientDimmer = serializedObj.FindProperty("Settings.ambientDimmer");
+            directLightMultiplier = serializedObj.FindProperty("Settings.directLightMultiplier");
+            directLightShadowdimmer = serializedObj.FindProperty("Settings.directLightShadowdimmer");
+  #endif
+
+        unityFog = serializedObj.FindProperty("Settings.unityFog");
+        unityFogDensity = serializedObj.FindProperty("Settings.unityFogDensity");
+        unityFogColor = serializedObj.FindProperty("Settings.unityFogColor");
+        unityFogMode = serializedObj.FindProperty("Settings.unityFogMode");
+        unityFogStartDistance = serializedObj.FindProperty("Settings.unityFogStartDistance");
+        unityFogEndDistance = serializedObj.FindProperty("Settings.unityFogEndDistance");
+        } 
+
+        public override void OnInspectorGUI()
+        {
+            if(!target)
+                return;
+
+            base.OnInspectorGUI();
+
+            GUI.backgroundColor = baseModuleColor;
+            GUILayout.BeginVertical("",boxStyleModified);
+            GUI.backgroundColor = Color.white;
+            EditorGUILayout.BeginHorizontal();
+            myTarget.showModuleInspector = GUILayout.Toggle(myTarget.showModuleInspector, "Fog", headerFoldout);
+            
+            GUILayout.FlexibleSpace();
+            if(GUILayout.Button("x", EditorStyles.miniButtonRight,GUILayout.Width(18), GUILayout.Height(18)))
+            {
+                EnviroManager.instance.RemoveModule(EnviroManager.ModuleType.Fog); //Add Remove
+                DestroyImmediate(this);
+                return;
+            } 
+            
+            EditorGUILayout.EndHorizontal();
+            
+            if(myTarget.showModuleInspector)
+            {
+                RenderDisableInputBox();
+                serializedObj.UpdateIfRequiredOrScript ();
+                EditorGUI.BeginChangeCheck();
+                
+                // Enviro Fog
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showFogControls = GUILayout.Toggle(myTarget.showFogControls, "Fog Controls", headerFoldout);               
+                if(myTarget.showFogControls)
+                { 
+                    GUILayout.Space(5);
+                    DisableInputStartQuality();
+                    EditorGUILayout.PropertyField(fog);
+                    EditorGUILayout.PropertyField(fogQualityMode); 
+                    DisableInputEndQuality();
+                    GUILayout.Space(5);
+                    if(myTarget.Settings.fog)
+                    {
+                    EditorGUILayout.LabelField("Global",headerStyle);
+                    EditorGUILayout.PropertyField( globalFogHeight); 
+                    GUILayout.Space(5);
+                    DisableInputStart();
+                    EditorGUILayout.LabelField("Fog Layer 1",headerStyle);
+                    GUILayout.Space(5);
+                    EditorGUILayout.PropertyField(fogDensity);
+                    EditorGUILayout.PropertyField(fogHeightFalloff);
+                    EditorGUILayout.PropertyField(fogHeight);
+                    GUILayout.Space(10);
+
+                    if(myTarget.Settings.fogQualityMode == EnviroFogSettings.FogQualityMode.Normal)               
+                    {
+                        EditorGUILayout.LabelField("Fog Layer 2",headerStyle);
+                        GUILayout.Space(5);
+                        EditorGUILayout.PropertyField(fogDensity2);
+                        EditorGUILayout.PropertyField(fogHeightFalloff2);
+                        EditorGUILayout.PropertyField(fogHeight2);
+                        GUILayout.Space(10);
+                    }
+                
+                    DisableInputEnd();
+
+                    EditorGUILayout.LabelField("Opacity and Distance",headerStyle);
+                    GUILayout.Space(5);
+                    EditorGUILayout.PropertyField(fogMaxOpacity);
+                    EditorGUILayout.PropertyField(startDistance);
+                    GUILayout.Space(10);       
+                    EditorGUILayout.LabelField("Color",headerStyle);
+                    GUILayout.Space(5);                   
+                    EditorGUILayout.PropertyField(blockScattering);
+                    DisableInputStart();
+                    EditorGUILayout.PropertyField(fogColorBlend);
+                    EditorGUILayout.PropertyField(fogColorMod);        
+                    DisableInputEnd();         
+                    EditorGUILayout.PropertyField(ambientColorGradient);                        
+                    GUILayout.Space(10); 
+                    }                 
+                }
+                GUILayout.EndVertical();
+
+                //HDRP Fog
+            #if ENVIRO_HDRP
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showHDRPFogControls = GUILayout.Toggle(myTarget.showHDRPFogControls, "HDRP Fog Controls", headerFoldout);               
+                if(myTarget.showHDRPFogControls)
+                { 
+                    GUILayout.Space(5);
+                    EditorGUILayout.PropertyField(controlHDRPFog);
+                    GUILayout.Space(5);
+                    if(myTarget.Settings.controlHDRPFog)
+                    {
+                    EditorGUILayout.LabelField("Density",headerStyle);
+                    DisableInputStart();
+                    EditorGUILayout.PropertyField(fogAttenuationDistance); 
+                    EditorGUILayout.PropertyField(baseHeight); 
+                    EditorGUILayout.PropertyField(maxHeight);
+                    DisableInputEnd();
+                    GUILayout.Space(5);
+                    EditorGUILayout.LabelField("Color",headerStyle);
+                    EditorGUILayout.PropertyField(fogColorTint);         
+                    }                 
+                }
+                GUILayout.EndVertical();
+            #else 
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showUnityFogControls = GUILayout.Toggle(myTarget.showUnityFogControls, "Unity Fog Controls", headerFoldout);               
+                if(myTarget.showUnityFogControls)
+                {  
+                    GUILayout.Space(5);
+                    DisableInputStartQuality();
+                    EditorGUILayout.PropertyField(unityFog);
+                    DisableInputEndQuality();
+
+                    GUILayout.Space(5);
+                    if(myTarget.Settings.unityFog)
+                    {  
+                        EditorGUILayout.LabelField("Density",headerStyle);
+                       
+                        EditorGUILayout.PropertyField(unityFogMode);
+                         
+                        DisableInputStart();
+                        if(myTarget.Settings.unityFogMode == FogMode.Linear)
+                        {
+                        EditorGUILayout.PropertyField(unityFogStartDistance); 
+                        EditorGUILayout.PropertyField(unityFogEndDistance); 
+                        }
+                        else
+                        {
+                        EditorGUILayout.PropertyField(unityFogDensity); 
+                        }
+                        DisableInputEnd();
+                        GUILayout.Space(5);
+                        EditorGUILayout.LabelField("Color",headerStyle);
+                        EditorGUILayout.PropertyField(unityFogColor);         
+                    }                 
+                }
+                GUILayout.EndVertical();
+
+            #endif
+
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showVolumetricsControls = GUILayout.Toggle(myTarget.showVolumetricsControls, "Volumetrics Controls", headerFoldout);               
+                if(myTarget.showVolumetricsControls)
+                { 
+                    GUILayout.Space(5);
+        #if !ENVIRO_HDRP
+                    DisableInputStartQuality();
+                    EditorGUILayout.PropertyField(volumetrics);
+                    DisableInputEndQuality();
+                    GUILayout.Space(5);
+                    if(myTarget.Settings.volumetrics && myTarget.Settings.fog)
+                    {
+                        DisableInputStartQuality();
+                        EditorGUILayout.PropertyField(quality);
+                        EditorGUILayout.PropertyField(steps);
+                        DisableInputEndQuality();
+                        DisableInputStart();
+                        EditorGUILayout.PropertyField(scattering);
+                         DisableInputEnd();
+                        EditorGUILayout.PropertyField(scatteringMultiplier);
+                         DisableInputStart();             
+                        EditorGUILayout.PropertyField(extinction);
+                    
+                        EditorGUILayout.PropertyField(anistropy);
+                        DisableInputEnd();
+                        EditorGUILayout.PropertyField(maxRange);
+                        EditorGUILayout.PropertyField(maxRangePointSpot);     
+                        //EditorGUILayout.PropertyField(noiseIntensity);
+                        //EditorGUILayout.PropertyField(noiseScale);
+                        //EditorGUILayout.PropertyField(windDirection);
+                        //EditorGUILayout.PropertyField(noise);
+                        EditorGUILayout.PropertyField(ditheringTex);            
+                    } 
+
+        #else       
+                    EditorGUILayout.PropertyField(controlHDRPVolumetrics);
+                    GUILayout.Space(5);
+                    if(myTarget.Settings.controlHDRPVolumetrics && myTarget.Settings.controlHDRPFog)
+                    {
+                        EditorGUILayout.LabelField("Global",headerStyle);
+                        EditorGUILayout.PropertyField(volumetricsColorTint);
+                        DisableInputStart();
+                        EditorGUILayout.PropertyField(ambientDimmer);
+                        DisableInputEnd();
+                        GUILayout.Space(5);
+                        EditorGUILayout.LabelField("Directional Lights",headerStyle);
+                        DisableInputStart();
+                        EditorGUILayout.PropertyField(directLightMultiplier);
+                        EditorGUILayout.PropertyField(directLightShadowdimmer);
+                        DisableInputEnd();
+                    }
+        #endif 
+                }
+                GUILayout.EndVertical();
+
+                /// Save Load
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showSaveLoad = GUILayout.Toggle(myTarget.showSaveLoad, "Save/Load", headerFoldout);
+                
+                if(myTarget.showSaveLoad)
+                {
+                    EditorGUILayout.PropertyField(preset);
+
+                    GUILayout.BeginHorizontal("",wrapStyle);
+
+                    if(myTarget.preset != null)
+                    {
+                        if(GUILayout.Button("Load"))
+                        {
+                            myTarget.LoadModuleValues();
+                        }
+                        if(GUILayout.Button("Save"))
+                        {
+                            myTarget.SaveModuleValues(myTarget.preset);
+                        }
+                    }
+                    if(GUILayout.Button("Save As New"))
+                    {
+                        myTarget.SaveModuleValues();
+                    }
+                    GUILayout.EndHorizontal();
+                }
+                GUILayout.EndVertical();
+                /// Save Load End
+                
+                ApplyChanges ();
+            }
+            GUILayout.EndVertical();
+
+            if(myTarget.showModuleInspector)
+             GUILayout.Space(20);
+        }
+    }
+}

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Fog/EnviroFogModuleEditor.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 454cdd748aabaaa44b31175b871c45d4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 236601
+  packageName: Enviro 3 - Sky and Weather
+  packageVersion: 3.1.2
+  assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Fog/EnviroFogModuleEditor.cs
+  uploadId: 660896

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Lighting.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 886b44e9d95c8964b82e502d6dd8ab9c
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Lighting/EnviroLightingModuleEditor.cs

@@ -0,0 +1,261 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+
+namespace Enviro
+{
+    [CustomEditor(typeof(EnviroLightingModule))]
+    public class EnviroLightingModuleEditor : EnviroModuleEditor
+    {  
+        private EnviroLightingModule myTarget; 
+
+        //Properties 
+        //Direct Lighting
+        private SerializedProperty updateIntervallFrames,directLightIntensityModifier,sunIntensityCurve, moonIntensityCurve, sunColorGradient, moonColorGradient, lightingMode;  
+        //Ambient Lighting
+        private SerializedProperty shadowIntensity, ambientIntensityModifier,ambientMode, ambientUpdateIntervall,ambientUpdateEveryFrame, ambientSkyColorGradient, ambientEquatorColorGradient, ambientGroundColorGradient, ambientIntensityCurve;
+       
+#if ENVIRO_HDRP
+        private SerializedProperty  lightIntensityHDRP ,lightColorTemperatureHDRP,ambientColorTintHDRP, controlExposure, sceneExposure, controlIndirectLighting, diffuseIndirectIntensity, reflectionIndirectIntensity;
+#endif
+        //On Enable
+        public override void OnEnable()
+        {
+            
+            if(!target)
+                return; 
+ 
+            base.OnEnable();
+
+            myTarget = (EnviroLightingModule)target;
+            serializedObj = new SerializedObject(myTarget);
+            preset = serializedObj.FindProperty("preset");
+            //Direct Lighting
+            updateIntervallFrames = serializedObj.FindProperty("Settings.updateIntervallFrames");      
+            lightingMode = serializedObj.FindProperty("Settings.lightingMode");      
+            sunIntensityCurve = serializedObj.FindProperty("Settings.sunIntensityCurve");      
+            moonIntensityCurve = serializedObj.FindProperty("Settings.moonIntensityCurve");         
+            sunColorGradient = serializedObj.FindProperty("Settings.sunColorGradient");       
+            moonColorGradient = serializedObj.FindProperty("Settings.moonColorGradient");      
+            directLightIntensityModifier = serializedObj.FindProperty("Settings.directLightIntensityModifier");
+            shadowIntensity = serializedObj.FindProperty("Settings.shadowIntensity");
+            //Ambient Lighting
+            ambientMode = serializedObj.FindProperty("Settings.ambientMode");
+            ambientSkyColorGradient = serializedObj.FindProperty("Settings.ambientSkyColorGradient");          
+            ambientEquatorColorGradient = serializedObj.FindProperty("Settings.ambientEquatorColorGradient");          
+            ambientGroundColorGradient = serializedObj.FindProperty("Settings.ambientGroundColorGradient");          
+            ambientIntensityCurve = serializedObj.FindProperty("Settings.ambientIntensityCurve");
+            ambientIntensityModifier = serializedObj.FindProperty("Settings.ambientIntensityModifier");
+            ambientUpdateIntervall = serializedObj.FindProperty("Settings.ambientUpdateIntervall");
+            ambientUpdateEveryFrame = serializedObj.FindProperty("Settings.ambientUpdateEveryFrame");
+            #if ENVIRO_HDRP
+            lightIntensityHDRP = serializedObj.FindProperty("Settings.lightIntensityHDRP");
+            lightColorTemperatureHDRP = serializedObj.FindProperty("Settings.lightColorTemperatureHDRP");
+            ambientColorTintHDRP = serializedObj.FindProperty("Settings.ambientColorTintHDRP");
+            controlExposure = serializedObj.FindProperty("Settings.controlExposure");
+            sceneExposure = serializedObj.FindProperty("Settings.sceneExposure");
+            controlIndirectLighting = serializedObj.FindProperty("Settings.controlIndirectLighting");
+            diffuseIndirectIntensity = serializedObj.FindProperty("Settings.diffuseIndirectIntensity");
+            reflectionIndirectIntensity = serializedObj.FindProperty("Settings.reflectionIndirectIntensity");
+            #endif
+        } 
+/*
+
+*/
+        public override void OnInspectorGUI()
+        {
+            if(!target)
+                return;
+
+            base.OnInspectorGUI();
+
+            GUI.backgroundColor = new Color(0.0f,0.0f,0.5f,1f);
+            GUILayout.BeginVertical("",boxStyleModified);
+            GUI.backgroundColor = Color.white;
+            EditorGUILayout.BeginHorizontal();
+            myTarget.showModuleInspector = GUILayout.Toggle(myTarget.showModuleInspector, "Lighting", headerFoldout);
+            
+            GUILayout.FlexibleSpace();
+            if(GUILayout.Button("x", EditorStyles.miniButtonRight,GUILayout.Width(18), GUILayout.Height(18)))
+            {
+                EnviroManager.instance.RemoveModule(EnviroManager.ModuleType.Lighting);
+                DestroyImmediate(this);
+                return;
+            } 
+            
+            EditorGUILayout.EndHorizontal();
+            
+            if(myTarget.showModuleInspector)
+            {
+                RenderDisableInputBox();
+                serializedObj.UpdateIfRequiredOrScript ();
+                EditorGUI.BeginChangeCheck();
+
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showDirectLightingControls = GUILayout.Toggle(myTarget.showDirectLightingControls, "Direct Lighting Controls", headerFoldout);              
+                if(myTarget.showDirectLightingControls)
+                {
+                    GUILayout.Space(10);
+                    myTarget.Settings.setDirectLighting = EditorGUILayout.BeginToggleGroup("Set Direct Lighting",myTarget.Settings.setDirectLighting);
+                    EditorGUILayout.PropertyField(lightingMode);
+                    if (GUILayout.Button("Apply Lighting Mode Changes"))
+                    {
+                        myTarget.ApplyLightingChanges();
+                    }
+                    GUILayout.Space(10);
+                    
+                    EditorGUILayout.LabelField("Lighting Updates",headerStyle);
+                    EditorGUILayout.PropertyField(updateIntervallFrames);
+                     GUILayout.Space(5);
+                    EditorGUILayout.LabelField("Light Intensity",headerStyle);
+                  
+                    EditorGUILayout.PropertyField(sunIntensityCurve);
+                    EditorGUILayout.PropertyField(moonIntensityCurve);
+                    #if ENVIRO_HDRP
+                    EditorGUILayout.PropertyField(lightIntensityHDRP);
+                    #endif
+                    DisableInputStart();
+                    EditorGUILayout.PropertyField(directLightIntensityModifier);
+                    EditorGUILayout.PropertyField(shadowIntensity);    
+                    DisableInputEnd();
+                    GUILayout.Space(10);
+                    EditorGUILayout.LabelField("Light Color",headerStyle);
+             
+                    EditorGUILayout.PropertyField(sunColorGradient);
+                    EditorGUILayout.PropertyField(moonColorGradient);
+          
+                    #if ENVIRO_HDRP
+                    EditorGUILayout.PropertyField(lightColorTemperatureHDRP);
+                    #endif 
+                    #if ENVIRO_HDRP
+                    GUILayout.Space(10);
+                    EditorGUILayout.LabelField("Exposure",headerStyle);
+                    EditorGUILayout.PropertyField(controlExposure);
+                    EditorGUILayout.PropertyField(sceneExposure);
+                    #endif
+                    EditorGUILayout.EndToggleGroup();
+                }
+                GUILayout.EndVertical();
+
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showAmbientLightingControls = GUILayout.Toggle(myTarget.showAmbientLightingControls, "Ambient Lighting Controls", headerFoldout);              
+                if(myTarget.showAmbientLightingControls)
+                {
+                    GUILayout.Space(10);
+
+                    myTarget.Settings.setAmbientLighting = EditorGUILayout.BeginToggleGroup("Set Ambient Lighting",myTarget.Settings.setAmbientLighting);           
+               #if !ENVIRO_HDRP 
+                    EditorGUILayout.PropertyField(ambientMode);
+                    GUILayout.Space(10); 
+                        if(myTarget.Settings.ambientMode == UnityEngine.Rendering.AmbientMode.Flat)
+                        {
+                            EditorGUILayout.LabelField("Ambient Color",headerStyle);
+                            EditorGUILayout.PropertyField(ambientSkyColorGradient);
+                            GUILayout.Space(5); 
+                            EditorGUILayout.LabelField("Ambient Updates",headerStyle);
+                            EditorGUILayout.PropertyField(ambientUpdateEveryFrame);  
+                            if (!myTarget.Settings.ambientUpdateEveryFrame)
+                            EditorGUILayout.PropertyField(ambientUpdateIntervall);  
+                            GUILayout.Space(5); 
+                            EditorGUILayout.LabelField("Ambient Intensity",headerStyle);
+                            EditorGUILayout.PropertyField(ambientIntensityCurve);
+                            DisableInputStart();
+                            EditorGUILayout.PropertyField(ambientIntensityModifier);
+                            DisableInputEnd();
+              
+                        }
+                        else if(myTarget.Settings.ambientMode == UnityEngine.Rendering.AmbientMode.Trilight)
+                        {
+                            EditorGUILayout.LabelField("Ambient Color",headerStyle);
+                            EditorGUILayout.PropertyField(ambientSkyColorGradient);
+                            EditorGUILayout.PropertyField(ambientEquatorColorGradient);
+                            EditorGUILayout.PropertyField(ambientGroundColorGradient);
+                            GUILayout.Space(5); 
+                            EditorGUILayout.LabelField("Ambient Updates",headerStyle);
+                            EditorGUILayout.PropertyField(ambientUpdateEveryFrame);  
+                            if (!myTarget.Settings.ambientUpdateEveryFrame)
+                            EditorGUILayout.PropertyField(ambientUpdateIntervall);  
+                            GUILayout.Space(5); 
+                            EditorGUILayout.LabelField("Ambient Intensity",headerStyle);
+                            EditorGUILayout.PropertyField(ambientIntensityCurve);
+                            DisableInputStart();
+                            EditorGUILayout.PropertyField(ambientIntensityModifier);
+                            DisableInputEnd();
+                
+                        }
+                        else 
+                        {
+                             EditorGUILayout.LabelField("Ambient Updates",headerStyle);
+                             EditorGUILayout.PropertyField(ambientUpdateEveryFrame);  
+                             if (!myTarget.Settings.ambientUpdateEveryFrame)
+                             EditorGUILayout.PropertyField(ambientUpdateIntervall);  
+                             GUILayout.Space(5); 
+                             EditorGUILayout.LabelField("Ambient Intensity",headerStyle);
+                             EditorGUILayout.PropertyField(ambientIntensityCurve);
+                             DisableInputStart();
+                             EditorGUILayout.PropertyField(ambientIntensityModifier);
+                             DisableInputEnd();
+                        }             
+                #else
+                GUILayout.Space(5);
+                EditorGUILayout.PropertyField(controlIndirectLighting);
+                if(myTarget.Settings.controlIndirectLighting)
+                {
+                    EditorGUILayout.PropertyField(diffuseIndirectIntensity);
+                    EditorGUILayout.PropertyField(reflectionIndirectIntensity);
+                }
+                GUILayout.Space(5);
+    
+                    EditorGUILayout.LabelField("Indirect Color",headerStyle);
+                    EditorGUILayout.PropertyField(ambientColorTintHDRP);    
+      
+                #endif   
+                 
+                    EditorGUILayout.EndToggleGroup();
+                }
+                GUILayout.EndVertical();
+
+                /// Save Load
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showSaveLoad = GUILayout.Toggle(myTarget.showSaveLoad, "Save/Load", headerFoldout);
+                
+                if(myTarget.showSaveLoad)
+                {
+                    EditorGUILayout.PropertyField(preset);
+                    GUILayout.BeginHorizontal("",wrapStyle);
+                    if(myTarget.preset != null)
+                    {
+                        if(GUILayout.Button("Load"))
+                        {
+                            myTarget.LoadModuleValues();
+                        }
+                        if(GUILayout.Button("Save"))
+                        {
+                            myTarget.SaveModuleValues(myTarget.preset);
+                        }
+                    }
+                    if(GUILayout.Button("Save As New"))
+                    {
+                        myTarget.SaveModuleValues();
+                    }
+                    GUILayout.EndHorizontal();
+                }
+                GUILayout.EndVertical();
+                /// Save Load End
+
+                ApplyChanges ();
+            }
+            GUILayout.EndVertical();
+
+            if(myTarget.showModuleInspector)
+             GUILayout.Space(20);
+        }
+    }
+}

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Lighting/EnviroLightingModuleEditor.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 337b469fc189e6d45a1807d1529b3fe3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 236601
+  packageName: Enviro 3 - Sky and Weather
+  packageVersion: 3.1.2
+  assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Lighting/EnviroLightingModuleEditor.cs
+  uploadId: 660896

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Lightning.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 07425510989886e4d8c50208d13e434e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Lightning/EnviroLightningModuleEditor.cs

@@ -0,0 +1,138 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+
+namespace Enviro
+{
+    [CustomEditor(typeof(EnviroLightningModule))]
+    public class EnviroLightningModuleEditor : EnviroModuleEditor
+    {  
+        private EnviroLightningModule myTarget; 
+
+        //Properties
+        private SerializedProperty prefab, lightningStorm,randomLightingDelay, randomSpawnRange, randomTargetRange,cloudsLightningRadius ,cloudsLightningDuration;
+
+
+        //On Enable
+        public override void OnEnable()
+        {
+            base.OnEnable();
+
+            if(!target)
+                return;
+
+            myTarget = (EnviroLightningModule)target;
+            serializedObj = new SerializedObject(myTarget);
+            preset = serializedObj.FindProperty("preset");
+            prefab = serializedObj.FindProperty("Settings.prefab"); 
+            lightningStorm = serializedObj.FindProperty("Settings.lightningStorm");  
+            randomLightingDelay = serializedObj.FindProperty("Settings.randomLightingDelay"); 
+            randomSpawnRange = serializedObj.FindProperty("Settings.randomSpawnRange"); 
+            randomTargetRange = serializedObj.FindProperty("Settings.randomTargetRange");
+            cloudsLightningRadius = serializedObj.FindProperty("Settings.cloudsLightningRadius");
+            cloudsLightningDuration = serializedObj.FindProperty("Settings.cloudsLightningDuration");
+        } 
+
+        public override void OnInspectorGUI()
+        {
+            if(!target)
+                return;
+
+            base.OnInspectorGUI();
+            
+            GUI.backgroundColor = baseModuleColor;
+            GUILayout.BeginVertical("",boxStyleModified);
+            GUI.backgroundColor = Color.white;
+            EditorGUILayout.BeginHorizontal();
+            myTarget.showModuleInspector = GUILayout.Toggle(myTarget.showModuleInspector, "Lightning", headerFoldout);
+            
+            GUILayout.FlexibleSpace();
+            if(GUILayout.Button("x", EditorStyles.miniButtonRight,GUILayout.Width(18), GUILayout.Height(18)))
+            {
+                EnviroManager.instance.RemoveModule(EnviroManager.ModuleType.Lightning); //Add Remove
+                DestroyImmediate(this);
+                return;
+            } 
+            
+            EditorGUILayout.EndHorizontal();
+            
+            if(myTarget.showModuleInspector)
+            {
+                RenderDisableInputBox(); 
+                serializedObj.UpdateIfRequiredOrScript ();
+                EditorGUI.BeginChangeCheck();
+                
+                // Set Values
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showLightningControls = GUILayout.Toggle(myTarget.showLightningControls, "Lightning Controls", headerFoldout);               
+                if(myTarget.showLightningControls)
+                {
+                    GUILayout.Space(10);
+                    DisableInputStart();
+                    EditorGUILayout.PropertyField(lightningStorm);
+                    DisableInputEnd();
+                    GUILayout.Space(5);
+                    EditorGUILayout.PropertyField(prefab);      
+                    GUILayout.Space(5);
+                    EditorGUILayout.LabelField("Random Lighting Storm", headerStyle);
+                    DisableInputStart();
+                    EditorGUILayout.PropertyField(randomLightingDelay);
+                    DisableInputEnd();
+                    EditorGUILayout.PropertyField(randomSpawnRange);
+                    EditorGUILayout.PropertyField(randomTargetRange);
+                    GUILayout.Space(5);
+                    EditorGUILayout.LabelField("Volumetric Clouds", headerStyle);
+                    EditorGUILayout.PropertyField(cloudsLightningRadius);
+                    EditorGUILayout.PropertyField(cloudsLightningDuration);
+                    
+                }
+                GUILayout.EndVertical();
+
+
+                // Save Load
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showSaveLoad = GUILayout.Toggle(myTarget.showSaveLoad, "Save/Load", headerFoldout);
+                
+                if(myTarget.showSaveLoad)
+                {
+                    EditorGUILayout.PropertyField(preset);
+
+                    GUILayout.BeginHorizontal("",wrapStyle);
+
+                    if(myTarget.preset != null)
+                    {
+                        if(GUILayout.Button("Load"))
+                        {
+                            myTarget.LoadModuleValues();
+                        }
+                        if(GUILayout.Button("Save"))
+                        {
+                            myTarget.SaveModuleValues(myTarget.preset);
+                        }
+                    }
+                    if(GUILayout.Button("Save As New"))
+                    {
+                        myTarget.SaveModuleValues();
+                    }
+
+                    GUILayout.EndHorizontal();
+
+     
+                }
+                GUILayout.EndVertical();
+                /// Save Load End
+                
+                ApplyChanges ();
+            }
+            GUILayout.EndVertical();
+
+            if(myTarget.showModuleInspector)
+             GUILayout.Space(20);
+        }
+    }
+}

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Lightning/EnviroLightningModuleEditor.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 9555c8222b7957043b2ac73b7cf4343c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 236601
+  packageName: Enviro 3 - Sky and Weather
+  packageVersion: 3.1.2
+  assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Lightning/EnviroLightningModuleEditor.cs
+  uploadId: 660896

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Quality.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: be04c97f7be93cc46ae826efc9ebf06a
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Quality/EnviroQualityModuleEditor.cs

@@ -0,0 +1,267 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+
+namespace Enviro
+{
+    [CustomEditor(typeof(EnviroQualityModule))]
+    public class EnviroQualityModuleEditor : EnviroModuleEditor
+    {  
+        private EnviroQualityModule myTarget; 
+
+        private int controlID = -101;
+
+        //Properties Cirrus
+       // private SerializedProperty useCirrusClouds;
+
+        //On Enable
+        public override void OnEnable()
+        {
+            base.OnEnable();
+
+            if(!target)
+                return;
+
+            myTarget = (EnviroQualityModule)target;
+            serializedObj = new SerializedObject(myTarget);
+            preset = serializedObj.FindProperty("preset");
+
+            //useCirrusClouds = serializedObj.FindProperty("settings.useCirrusClouds");
+        }  
+
+        public override void OnInspectorGUI()
+        {
+            if(!target)
+                return;
+
+             base.OnInspectorGUI();
+
+            GUI.backgroundColor = baseModuleColor;
+            GUILayout.BeginVertical("",boxStyleModified);
+            GUI.backgroundColor = Color.white;
+            EditorGUILayout.BeginHorizontal();
+            myTarget.showModuleInspector = GUILayout.Toggle(myTarget.showModuleInspector, "Quality", headerFoldout);
+             
+            GUILayout.FlexibleSpace();
+            if(GUILayout.Button("x", EditorStyles.miniButtonRight,GUILayout.Width(18), GUILayout.Height(18)))
+            {
+                EnviroManager.instance.RemoveModule(EnviroManager.ModuleType.Quality); 
+                DestroyImmediate(this);
+                return;
+            }  
+            
+            EditorGUILayout.EndHorizontal();
+            
+            if(myTarget.showModuleInspector)
+            {
+                serializedObj.UpdateIfRequiredOrScript ();
+                EditorGUI.BeginChangeCheck();
+
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                Object selectedObject = null;
+                         
+                if(GUILayout.Button("Add"))
+                {
+                   controlID = EditorGUIUtility.GetControlID (FocusType.Passive);
+                   EditorGUIUtility.ShowObjectPicker<EnviroQuality>(null,false,"",controlID);
+                }
+
+                string commandName = Event.current.commandName;
+
+                if (commandName == "ObjectSelectorClosed" && EditorGUIUtility.GetObjectPickerControlID() == controlID) 
+                {
+                    selectedObject = EditorGUIUtility.GetObjectPickerObject ();
+                    
+                    bool add = true;
+                    
+                    for (int i = 0; i < myTarget.Settings.Qualities.Count; i++)
+                    {
+                        if((EnviroQuality)selectedObject == myTarget.Settings.Qualities[i])
+                        add = false; 
+                    }
+
+                    if(add)
+                      myTarget.Settings.Qualities.Add((EnviroQuality)selectedObject);
+
+                      controlID = -101;
+                }
+
+                if(GUILayout.Button("Create New"))
+                {
+                   myTarget.CreateNewQuality();
+                } 
+
+                myTarget.CleanupQualityList();
+                
+                for (int i = 0; i < myTarget.Settings.Qualities.Count; i++) 
+                    {       
+                        EnviroQuality q =  myTarget.Settings.Qualities[i];
+                        
+                        if(q == myTarget.Settings.defaultQuality)
+                        GUI.backgroundColor = new Color(0.0f,0.5f,0.0f,1f);      
+                        GUILayout.BeginVertical("",boxStyleModified);
+                        GUI.backgroundColor = Color.white;
+
+                        EditorGUILayout.BeginHorizontal();
+                        q.showEditor = GUILayout.Toggle(q.showEditor, q.name, headerFoldout);
+                        GUILayout.FlexibleSpace();
+
+                        if(q != myTarget.Settings.defaultQuality)
+                        {
+                            if(GUILayout.Button("Set Default", EditorStyles.miniButtonRight,GUILayout.Width(75), GUILayout.Height(18)))
+                            {
+                                myTarget.Settings.defaultQuality = q;
+                                EditorUtility.SetDirty(q);
+                            } 
+                        }
+                        if(GUILayout.Button("x", EditorStyles.miniButtonRight,GUILayout.Width(18), GUILayout.Height(18)))
+                        {
+                            myTarget.RemoveQuality(q);
+                        } 
+                                 
+                        EditorGUILayout.EndHorizontal(); 
+
+                        if(q.showEditor)
+                        {
+                            GUILayout.BeginVertical("",boxStyleModified);
+                            
+                            EnviroQuality quality = myTarget.Settings.Qualities[i];
+
+                            q.showSky = GUILayout.Toggle(q.showSky, "Skybox", headerFoldout);
+                           
+                            if(q.showSky)
+                            {
+                                Undo.RecordObject(quality, "Quality Skybox Changed");
+                                quality.skyOverride.skyMode = (EnviroSky.SkyMode)EditorGUILayout.EnumPopup("Skybox Mode",  quality.skyOverride.skyMode);
+    
+                            }  
+                            GUILayout.EndVertical();
+
+                             GUILayout.BeginVertical("",boxStyleModified);
+                            q.showVolumeClouds = GUILayout.Toggle(q.showVolumeClouds, "Volumetric Clouds", headerFoldout);
+                           
+                            if(q.showVolumeClouds)
+                            {
+                                Undo.RecordObject(quality, "Quality Clouds Changed");
+                                quality.volumetricCloudsOverride.volumetricClouds = EditorGUILayout.Toggle("Volumetric Clouds",  quality.volumetricCloudsOverride.volumetricClouds);
+                                quality.volumetricCloudsOverride.downsampling = EditorGUILayout.IntSlider("Downsampling",  quality.volumetricCloudsOverride.downsampling, 1,6);
+                                quality.volumetricCloudsOverride.stepsLayer1 = EditorGUILayout.IntSlider("Steps Layer 1",  quality.volumetricCloudsOverride.stepsLayer1, 32,256);
+                                GUILayout.Space(5); 
+                                quality.volumetricCloudsOverride.blueNoiseIntensity = EditorGUILayout.Slider("Blue Noise Intensity",  quality.volumetricCloudsOverride.blueNoiseIntensity, 0f,2f);
+                                quality.volumetricCloudsOverride.reprojectionBlendTime = EditorGUILayout.Slider("Reprojection Blending",  quality.volumetricCloudsOverride.reprojectionBlendTime, 0f,10f);
+                                quality.volumetricCloudsOverride.lodDistance = EditorGUILayout.Slider("LOD",  quality.volumetricCloudsOverride.lodDistance, 0f,1f); 
+                                GUILayout.Space(5); 
+                                quality.volumetricCloudsOverride.lightningSupport = EditorGUILayout.Toggle("Lightning Support",  quality.volumetricCloudsOverride.lightningSupport);
+                                quality.volumetricCloudsOverride.variableBottomNoise = EditorGUILayout.Toggle("Variable Bottom Noise",  quality.volumetricCloudsOverride.variableBottomNoise);
+                            }  
+                            GUILayout.EndVertical();
+ 
+                            GUILayout.BeginVertical("",boxStyleModified);
+                            q.showFog = GUILayout.Toggle(q.showFog, "Fog", headerFoldout);
+                           
+                            if(q.showFog)
+                            {  
+                                Undo.RecordObject(quality, "Quality Fog Changed");
+                                quality.fogOverride.fog = EditorGUILayout.Toggle("Fog",  quality.fogOverride.fog);
+                                quality.fogOverride.fogQualityMode = (EnviroFogSettings.FogQualityMode)EditorGUILayout.EnumPopup("Fog Quality Mode", quality.fogOverride.fogQualityMode);
+                                quality.fogOverride.volumetrics = EditorGUILayout.Toggle("Volumetrics",  quality.fogOverride.volumetrics); 
+                            #if !ENVIRO_HDRP
+                                quality.fogOverride.unityFog = EditorGUILayout.Toggle("Unity Fog",  quality.fogOverride.unityFog);
+                            #endif
+                                quality.fogOverride.quality = (EnviroFogSettings.Quality)EditorGUILayout.EnumPopup("Quality",quality.fogOverride.quality);
+                                quality.fogOverride.steps = EditorGUILayout.IntSlider("Steps",  quality.fogOverride.steps, 16,96);
+                            }      
+                            GUILayout.EndVertical();  
+
+                            GUILayout.BeginVertical("",boxStyleModified);
+                            q.showFlatClouds = GUILayout.Toggle(q.showFlatClouds, "Flat Clouds", headerFoldout);
+                           
+                            if(q.showFlatClouds)
+                            {  
+                                Undo.RecordObject(quality, "Quality FlatClouds Changed");
+                                quality.flatCloudsOverride.flatClouds = EditorGUILayout.Toggle("Flat Clouds",   quality.flatCloudsOverride.flatClouds);
+                                quality.flatCloudsOverride.flatCloudsShadowSteps = EditorGUILayout.IntSlider("Flat Clouds Shadow Steps",   quality.flatCloudsOverride.flatCloudsShadowSteps,1,12);
+                                quality.flatCloudsOverride.cirrusClouds = EditorGUILayout.Toggle("Cirrus Clouds",   quality.flatCloudsOverride.cirrusClouds);
+                            }      
+                            GUILayout.EndVertical();  
+
+                            GUILayout.BeginVertical("",boxStyleModified);
+                            q.showAurora = GUILayout.Toggle(q.showAurora, "Aurora", headerFoldout);
+                           
+                            if(q.showAurora)
+                            {  
+                                Undo.RecordObject(quality, "Quality Aurora Changed");
+                                quality.auroraOverride.aurora = EditorGUILayout.Toggle("Aurora",   quality.auroraOverride.aurora);
+                                quality.auroraOverride.steps = EditorGUILayout.IntSlider("Steps",  quality.auroraOverride.steps, 6,32);
+                            }      
+                            GUILayout.EndVertical();
+
+
+                            GUILayout.BeginVertical("",boxStyleModified);
+                            q.showEffects = GUILayout.Toggle(q.showEffects, "Effects", headerFoldout);
+                           
+                            if(q.showEffects)
+                            {  
+                                Undo.RecordObject(quality, "Quality Effects Changed");
+                                quality.effectsOverride.particeEmissionRateModifier = EditorGUILayout.Slider("Particle Emission Rate Modifier",  quality.effectsOverride.particeEmissionRateModifier, 0f,2f);
+                            }      
+                            GUILayout.EndVertical();
+
+
+                            EditorUtility.SetDirty(quality);                                  
+                        }                
+                        GUILayout.EndVertical(); 
+                        if(q.showEditor)                           
+                          GUILayout.Space(10);   
+                    }
+                GUILayout.EndVertical(); 
+
+                GUILayout.Space(10);
+
+                // Save Load
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showSaveLoad = GUILayout.Toggle(myTarget.showSaveLoad, "Save/Load", headerFoldout);
+                
+                if(myTarget.showSaveLoad)
+                {
+                    EditorGUILayout.PropertyField(preset);
+
+                    GUILayout.BeginHorizontal("",wrapStyle);
+
+                    if(myTarget.preset != null)
+                    {
+                        if(GUILayout.Button("Load"))
+                        {
+                            myTarget.LoadModuleValues();
+                        }
+                        if(GUILayout.Button("Save"))
+                        {
+                            myTarget.SaveModuleValues(myTarget.preset);
+                        }
+                    }
+                    if(GUILayout.Button("Save As New"))
+                    {
+                        myTarget.SaveModuleValues();
+                    }
+
+                    GUILayout.EndHorizontal();
+
+     
+                }
+                GUILayout.EndVertical();
+                /// Save Load End
+                
+                ApplyChanges ();
+            }
+            GUILayout.EndVertical();
+ 
+            if(myTarget.showModuleInspector)
+             GUILayout.Space(20);
+        }
+    }
+}

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Quality/EnviroQualityModuleEditor.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: cc98e8b13297a35408322f655fe5abb6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 236601
+  packageName: Enviro 3 - Sky and Weather
+  packageVersion: 3.1.2
+  assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Quality/EnviroQualityModuleEditor.cs
+  uploadId: 660896

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Reflections.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b0f53f8de342bb042b976169c7fc74c4
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Reflections/EnviroReflectionProbeEditor.cs

@@ -0,0 +1,138 @@
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEditorInternal;
+
+namespace Enviro
+{
+    [CustomEditor(typeof(Enviro.EnviroReflectionProbe))]
+    public class EnviroReflectionProbeEditor : Editor {
+
+        GUIStyle boxStyle;
+        GUIStyle boxStyleModified;
+        GUIStyle wrapStyle;
+        GUIStyle wrapStyle2;
+        GUIStyle clearStyle;
+
+        Enviro.EnviroReflectionProbe myTarget;
+
+        public bool showAudio = false;
+        public bool showFog = false;
+        public bool showSeason = false;
+        public bool showClouds = false;
+        public bool showGeneral = false;
+        public bool showPostProcessing = false;
+        public bool showThirdParty = false;
+
+        private Color boxColor1;
+
+        SerializedObject serializedObj;
+
+        void OnEnable()
+        {
+            myTarget = (Enviro.EnviroReflectionProbe)target;
+            serializedObj = new SerializedObject (myTarget);
+            boxColor1 = new Color(0.95f, 0.95f, 0.95f,1f);
+        }
+
+        public override void OnInspectorGUI ()
+        {
+            myTarget = (Enviro.EnviroReflectionProbe)target;
+            serializedObj.UpdateIfRequiredOrScript ();
+
+            //Set up the box style
+            if (boxStyle == null)
+            {
+                boxStyle = new GUIStyle(GUI.skin.box);
+                boxStyle.normal.textColor = GUI.skin.label.normal.textColor;
+                boxStyle.fontStyle = FontStyle.Bold;
+                boxStyle.alignment = TextAnchor.UpperLeft;
+            }
+
+            if (boxStyleModified == null)
+            {
+                boxStyleModified = new GUIStyle(EditorStyles.helpBox);
+                boxStyleModified.normal.textColor = GUI.skin.label.normal.textColor;
+                boxStyleModified.fontStyle = FontStyle.Bold;
+                boxStyleModified.fontSize = 11;
+                boxStyleModified.alignment = TextAnchor.UpperLeft;
+            }
+
+            //Setup the wrap style
+            if (wrapStyle == null)
+            {
+                wrapStyle = new GUIStyle(GUI.skin.label);
+                wrapStyle.fontStyle = FontStyle.Bold;
+                wrapStyle.wordWrap = true;
+            }
+
+            if (wrapStyle2 == null)
+            {
+                wrapStyle2 = new GUIStyle(GUI.skin.label);
+                wrapStyle2.fontStyle = FontStyle.Normal;
+                wrapStyle2.wordWrap = true;
+            }
+
+            if (clearStyle == null) {
+                clearStyle = new GUIStyle(GUI.skin.label);
+                clearStyle.normal.textColor = GUI.skin.label.normal.textColor;
+                clearStyle.fontStyle = FontStyle.Bold;
+                clearStyle.alignment = TextAnchor.UpperRight;
+            }
+
+
+            GUILayout.BeginVertical(" Enviro - Reflection Probe", boxStyle);
+            GUILayout.Space(30);
+            GUI.backgroundColor = boxColor1;
+            GUILayout.BeginVertical("Information", boxStyleModified);
+            GUI.backgroundColor = Color.white;
+            GUILayout.Space(20);
+            EditorGUILayout.LabelField("Use this component to update your realtime reflection probes with Enviro Sky. You also can enable the 'Custom Rendering' to have enviro effects in your reflection probes!", wrapStyle2);
+            EditorGUILayout.LabelField("Please enable 'Standalone Probe' if you use this component on your own places reflection probes.", wrapStyle2);      
+            GUILayout.EndVertical();
+            GUI.backgroundColor = boxColor1;
+            GUILayout.BeginVertical("Setup", boxStyleModified);
+            GUI.backgroundColor = Color.white;
+            GUILayout.Space(20);
+            myTarget.standalone = EditorGUILayout.Toggle("Standalone Probe", myTarget.standalone);
+        
+            if (myTarget.standalone)
+            {
+                GUILayout.Space(10);
+    #if ENVIRO_HD
+                GUI.backgroundColor = boxColor1;
+                GUILayout.BeginVertical("Enviro Effects Rendering", boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                GUILayout.Space(20);
+                myTarget.customRendering = EditorGUILayout.Toggle("Render Enviro Effects", myTarget.customRendering);
+
+                if(myTarget.customRendering)
+                {
+                    EditorGUI.BeginChangeCheck();
+                    //myTarget.useFog = EditorGUILayout.Toggle("Use Fog", myTarget.useFog);
+                    if (EditorGUI.EndChangeCheck())
+                    {
+                        serializedObj.ApplyModifiedProperties();
+                    }
+                }
+                GUILayout.EndVertical();
+    #endif
+                GUI.backgroundColor = boxColor1;
+                GUILayout.BeginVertical("Update Settings", boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                GUILayout.Space(20);
+            myTarget.reflectionsUpdateTreshhold = EditorGUILayout.FloatField("Update Treshold in GameTime Hours", myTarget.reflectionsUpdateTreshhold);
+            if (myTarget.customRendering)
+            {
+                myTarget.useTimeSlicing = EditorGUILayout.Toggle("Use Time-Slicing", myTarget.useTimeSlicing);
+            }
+            GUILayout.EndVertical();
+            }
+            GUILayout.EndVertical();
+            // END
+            EditorGUILayout.EndVertical ();
+            EditorUtility.SetDirty (target);
+        }
+    }
+}

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Reflections/EnviroReflectionProbeEditor.cs.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: 4aeda5365286a2a46ab4f47403442a01
+timeCreated: 1497912081
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 236601
+  packageName: Enviro 3 - Sky and Weather
+  packageVersion: 3.1.2
+  assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Reflections/EnviroReflectionProbeEditor.cs
+  uploadId: 660896

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Reflections/EnviroReflectionsModuleEditor.cs

@@ -0,0 +1,157 @@
+using UnityEngine;
+using UnityEditor;
+
+namespace Enviro
+{
+    [CustomEditor(typeof(EnviroReflectionsModule))]
+    public class EnviroReflectionsModuleEditor : EnviroModuleEditor
+    {
+        private EnviroReflectionsModule myTarget;
+
+        //Properties
+        //Reflection Probe
+        private SerializedProperty globalReflections, customRendering, customRenderingTimeSlicing, globalReflectionTimeSlicingMode, globalReflectionsUpdateOnGameTime, globalReflectionsUpdateOnPosition, globalReflectionsIntensity, globalReflectionsTimeTreshold, globalReflectionsPositionTreshold, globalReflectionsScale, globalReflectionResolution, globalReflectionLayers, updateDefaultEnvironmentReflections;
+
+        //On Enable
+        public override void OnEnable()
+        {
+
+            if(!target)
+                return;
+
+            base.OnEnable();
+
+            myTarget = (EnviroReflectionsModule)target;
+            serializedObj = new SerializedObject(myTarget);
+            preset = serializedObj.FindProperty("preset");
+            //Reflection Probe
+            globalReflections = serializedObj.FindProperty("Settings.globalReflections"); 
+            updateDefaultEnvironmentReflections = serializedObj.FindProperty("Settings.updateDefaultEnvironmentReflections"); 
+            customRendering = serializedObj.FindProperty("Settings.customRendering"); 
+            customRenderingTimeSlicing = serializedObj.FindProperty("Settings.customRenderingTimeSlicing"); 
+            globalReflectionTimeSlicingMode = serializedObj.FindProperty("Settings.globalReflectionTimeSlicingMode");
+            globalReflectionsUpdateOnGameTime = serializedObj.FindProperty("Settings.globalReflectionsUpdateOnGameTime");
+            globalReflectionsUpdateOnPosition = serializedObj.FindProperty("Settings.globalReflectionsUpdateOnPosition");
+            globalReflectionsIntensity = serializedObj.FindProperty("Settings.globalReflectionsIntensity");
+            globalReflectionsTimeTreshold = serializedObj.FindProperty("Settings.globalReflectionsTimeTreshold");
+            globalReflectionsPositionTreshold = serializedObj.FindProperty("Settings.globalReflectionsPositionTreshold");
+            globalReflectionsScale = serializedObj.FindProperty("Settings.globalReflectionsScale");
+            globalReflectionResolution = serializedObj.FindProperty("Settings.globalReflectionResolution");
+            globalReflectionLayers = serializedObj.FindProperty("Settings.globalReflectionLayers");
+        }
+/*
+
+*/
+        public override void OnInspectorGUI()
+        {
+            if(!target)
+                return;
+
+            base.OnInspectorGUI();
+
+            GUI.backgroundColor = new Color(0.0f,0.0f,0.5f,1f);
+            GUILayout.BeginVertical("",boxStyleModified);
+            GUI.backgroundColor = Color.white;
+            EditorGUILayout.BeginHorizontal();
+            myTarget.showModuleInspector = GUILayout.Toggle(myTarget.showModuleInspector, "Reflections", headerFoldout);
+
+            GUILayout.FlexibleSpace();
+            if(GUILayout.Button("x", EditorStyles.miniButtonRight,GUILayout.Width(18), GUILayout.Height(18)))
+            {
+                EnviroManager.instance.RemoveModule(EnviroManager.ModuleType.Reflections);
+                DestroyImmediate(this);
+                return;
+            }
+
+            EditorGUILayout.EndHorizontal();
+
+            if(myTarget.showModuleInspector)
+            {
+                //RenderDisableInputBox();
+                serializedObj.UpdateIfRequiredOrScript ();
+                EditorGUI.BeginChangeCheck();
+
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showReflectionControls = GUILayout.Toggle(myTarget.showReflectionControls, "Reflection Controls", headerFoldout);
+                if(myTarget.showReflectionControls)
+                {
+                    EditorGUILayout.PropertyField(globalReflections);
+                    GUILayout.Space(5);
+                    EditorGUILayout.PropertyField(globalReflectionsIntensity);
+#if !ENVIRO_HDRP
+                    EditorGUILayout.PropertyField(globalReflectionResolution);
+#endif
+                    EditorGUILayout.PropertyField(globalReflectionLayers);
+                    EditorGUILayout.PropertyField(globalReflectionsScale);
+#if !ENVIRO_HDRP
+
+#if ENVIRO_URP
+                    EditorGUILayout.PropertyField(updateDefaultEnvironmentReflections);
+                    GUILayout.Space(5);
+                    EditorGUILayout.PropertyField(globalReflectionTimeSlicingMode);
+#else
+                    GUILayout.Space(5);
+                    EditorGUILayout.PropertyField(updateDefaultEnvironmentReflections);
+                    GUILayout.Space(5);
+                    EditorGUILayout.PropertyField(customRendering);
+
+                    if (myTarget.Settings.customRendering)
+                        EditorGUILayout.PropertyField(customRenderingTimeSlicing);
+                    else
+                        EditorGUILayout.PropertyField(globalReflectionTimeSlicingMode);
+#endif
+#endif
+
+                    GUILayout.Space(10);
+                    EditorGUILayout.PropertyField(globalReflectionsUpdateOnGameTime);
+                    if(myTarget.Settings.globalReflectionsUpdateOnGameTime)
+                    EditorGUILayout.PropertyField(globalReflectionsTimeTreshold);
+                        GUILayout.Space(5);
+                    EditorGUILayout.PropertyField(globalReflectionsUpdateOnPosition);
+                    if(myTarget.Settings.globalReflectionsUpdateOnPosition)
+                    EditorGUILayout.PropertyField(globalReflectionsPositionTreshold);
+                }
+                GUILayout.EndVertical();
+
+
+                /// Save Load
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showSaveLoad = GUILayout.Toggle(myTarget.showSaveLoad, "Save/Load", headerFoldout);
+
+                if(myTarget.showSaveLoad)
+                {
+                    EditorGUILayout.PropertyField(preset);
+                    GUILayout.BeginHorizontal("",wrapStyle);
+                    if(myTarget.preset != null)
+                    {
+                        if(GUILayout.Button("Load"))
+                        {
+                            myTarget.LoadModuleValues();
+                        }
+                        if(GUILayout.Button("Save"))
+                        {
+                            myTarget.SaveModuleValues(myTarget.preset);
+                        }
+                    }
+                    if(GUILayout.Button("Save As New"))
+                    {
+                        myTarget.SaveModuleValues();
+                    }
+                    GUILayout.EndHorizontal();
+                }
+                GUILayout.EndVertical();
+                /// Save Load End
+
+                ApplyChanges ();
+            }
+            GUILayout.EndVertical();
+
+            if(myTarget.showModuleInspector)
+             GUILayout.Space(20);
+        }
+    }
+}

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Reflections/EnviroReflectionsModuleEditor.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 97b7cead2ccaee54e80b6be7d7273231
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 236601
+  packageName: Enviro 3 - Sky and Weather
+  packageVersion: 3.1.2
+  assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Reflections/EnviroReflectionsModuleEditor.cs
+  uploadId: 660896

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Sky.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d300f2de6c9bdc7439d6e8dc1de9d4c1
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Sky/EnviroHDRPSkySettingsEditor.cs

@@ -0,0 +1,28 @@
+#if ENVIRO_HDRP
+using UnityEditor.Rendering;
+using UnityEngine.Rendering.HighDefinition;
+
+namespace UnityEditor.Rendering.HighDefinition
+{
+    [CanEditMultipleObjects]
+    [VolumeComponentEditor(typeof(EnviroHDRPSky))]
+    class EnviroSkyLiteSettingsEditor : SkySettingsEditor
+    {
+
+        public override void OnEnable()
+        {
+            base.OnEnable();
+
+            m_CommonUIElementsMask = (uint)SkySettingsUIElement.UpdateMode | (uint)SkySettingsUIElement.SkyIntensity;
+
+            var o = new PropertyFetcher<EnviroHDRPSky>(serializedObject);
+        }
+
+        public override void OnInspectorGUI()
+        {
+            base.CommonSkySettingsGUI();
+        }
+    }
+}
+#endif
+

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Sky/EnviroHDRPSkySettingsEditor.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: c1d9a9fb7ae61354994b910a2795c674
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 236601
+  packageName: Enviro 3 - Sky and Weather
+  packageVersion: 3.1.2
+  assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Sky/EnviroHDRPSkySettingsEditor.cs
+  uploadId: 660896

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Sky/EnviroSkyModuleEditor.cs

@@ -0,0 +1,306 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+
+namespace Enviro
+{
+    [CustomEditor(typeof(EnviroSkyModule))]
+    public class EnviroSkyModuleEditor : EnviroModuleEditor
+    {  
+        private EnviroSkyModule myTarget; 
+
+        //Properties
+        private SerializedProperty forcedSkyboxSetup, skyMode;
+        private SerializedProperty frontColorGradient0,frontColorGradient1,frontColorGradient2,frontColorGradient3,frontColorGradient4,frontColorGradient5;  
+        private SerializedProperty frontColor0,frontColor1,frontColor2,frontColor3,frontColor4,frontColor5;  
+        private SerializedProperty sunDiscColorGradient, moonColorGradient, moonGlowColorGradient;
+        private SerializedProperty sunDiscColor, moonColor, moonGlowColor, skyColorTint,skyColorExponent,mieScatteringMultiplier;
+        private SerializedProperty backColorGradient0,backColorGradient1,backColorGradient2,backColorGradient3,backColorGradient4,backColorGradient5;
+        private SerializedProperty backColor0,backColor1,backColor2,backColor3,backColor4,backColor5;
+        private SerializedProperty distribution0,distribution1,distribution2,distribution3;
+        private SerializedProperty starsTex,starsTwinklingTex, galaxyTex, sunTex, moonTex, moonGlowTex;
+
+        private SerializedProperty mieScatteringIntensityCurve, moonGlowIntensityCurve, starIntensityCurve, galaxyIntensityCurve;
+        private SerializedProperty intensity,intensityCurve, mieScatteringIntensity,sunScale, moonScale, moonGlowScale, moonMode, moonPhase, starsTwinklingSpeed;
+
+#if ENVIRO_HDRP
+        private SerializedProperty skyExposureHDRP,skyAmbientModeHDRP;
+#endif
+        //On Enable
+        public override void OnEnable()
+        {
+            if(!target)
+                return;
+
+            myTarget = (EnviroSkyModule)target;
+            serializedObj = new SerializedObject(myTarget);
+            preset = serializedObj.FindProperty("preset");
+
+            forcedSkyboxSetup = serializedObj.FindProperty("Settings.forcedSkyboxSetup");
+            skyMode = serializedObj.FindProperty("Settings.skyMode"); 
+            // Front Colors
+            frontColorGradient0 = serializedObj.FindProperty("Settings.frontColorGradient0");
+            frontColorGradient1 = serializedObj.FindProperty("Settings.frontColorGradient1");
+            frontColorGradient2 = serializedObj.FindProperty("Settings.frontColorGradient2");
+            frontColorGradient3 = serializedObj.FindProperty("Settings.frontColorGradient3");
+            frontColorGradient4 = serializedObj.FindProperty("Settings.frontColorGradient4");
+            frontColorGradient5 = serializedObj.FindProperty("Settings.frontColorGradient5");
+
+            // Back Colors
+            backColorGradient0 = serializedObj.FindProperty("Settings.backColorGradient0");
+            backColorGradient1 = serializedObj.FindProperty("Settings.backColorGradient1");
+            backColorGradient2 = serializedObj.FindProperty("Settings.backColorGradient2");
+            backColorGradient3 = serializedObj.FindProperty("Settings.backColorGradient3");
+            backColorGradient4 = serializedObj.FindProperty("Settings.backColorGradient4");
+            backColorGradient5 = serializedObj.FindProperty("Settings.backColorGradient5");
+
+            skyColorTint = serializedObj.FindProperty("Settings.skyColorTint");
+            skyColorExponent = serializedObj.FindProperty("Settings.skyColorTint");
+            mieScatteringMultiplier = serializedObj.FindProperty("Settings.mieScatteringMultiplier");
+
+            //Sund and Moon Colors 
+            sunDiscColorGradient = serializedObj.FindProperty("Settings.sunDiscColorGradient"); 
+            moonColorGradient = serializedObj.FindProperty("Settings.moonColorGradient"); 
+            moonGlowColorGradient = serializedObj.FindProperty("Settings.moonGlowColorGradient");
+            //Distribution
+            distribution0 = serializedObj.FindProperty("Settings.distribution0");
+            distribution1 = serializedObj.FindProperty("Settings.distribution1");
+            distribution2 = serializedObj.FindProperty("Settings.distribution2");
+            distribution3 = serializedObj.FindProperty("Settings.distribution3");
+
+            //Textures
+            starsTex = serializedObj.FindProperty("Settings.starsTex");
+            starsTwinklingTex = serializedObj.FindProperty("Settings.starsTwinklingTex");
+            galaxyTex = serializedObj.FindProperty("Settings.galaxyTex");
+            sunTex = serializedObj.FindProperty("Settings.sunTex"); 
+            moonTex = serializedObj.FindProperty("Settings.moonTex");
+            moonGlowTex = serializedObj.FindProperty("Settings.moonGlowTex");
+            moonMode = serializedObj.FindProperty("Settings.moonMode"); 
+            //Intensity
+            mieScatteringIntensityCurve = serializedObj.FindProperty("Settings.mieScatteringIntensityCurve");
+            moonGlowIntensityCurve = serializedObj.FindProperty("Settings.moonGlowIntensityCurve");
+            starIntensityCurve = serializedObj.FindProperty("Settings.starIntensityCurve");
+            galaxyIntensityCurve = serializedObj.FindProperty("Settings.galaxyIntensityCurve");
+            intensity = serializedObj.FindProperty("Settings.intensity");
+            intensityCurve = serializedObj.FindProperty("Settings.intensityCurve");
+            sunScale = serializedObj.FindProperty("Settings.sunScale");
+            moonScale = serializedObj.FindProperty("Settings.moonScale");
+            moonPhase = serializedObj.FindProperty("Settings.moonPhase"); 
+            starsTwinklingSpeed  = serializedObj.FindProperty("Settings.starsTwinklingSpeed"); 
+           // moonGlowScale = serializedObj.FindProperty("skySettings.moonGlowScale");
+           #if ENVIRO_HDRP
+             skyExposureHDRP = serializedObj.FindProperty("Settings.skyExposureHDRP");
+             skyAmbientModeHDRP = serializedObj.FindProperty("Settings.skyAmbientModeHDRP");
+           #endif
+        } 
+ 
+        public override void OnInspectorGUI()
+        {
+            if(!target)
+                return;
+
+            base.OnInspectorGUI();
+
+            GUI.backgroundColor = baseModuleColor;
+            GUILayout.BeginVertical("",boxStyleModified);
+            GUI.backgroundColor = Color.white;
+            EditorGUILayout.BeginHorizontal();
+            myTarget.showModuleInspector = GUILayout.Toggle(myTarget.showModuleInspector, "Sky", headerFoldout);
+            
+            GUILayout.FlexibleSpace();
+            if(GUILayout.Button("x", EditorStyles.miniButtonRight,GUILayout.Width(18), GUILayout.Height(18)))
+            {
+                EnviroManager.instance.RemoveModule(EnviroManager.ModuleType.Sky); //Add Remove
+                DestroyImmediate(this);
+                return;
+            } 
+            
+            EditorGUILayout.EndHorizontal();
+            
+            if(myTarget.showModuleInspector)
+            {
+                //EditorGUILayout.LabelField("This module will control your skybox.");
+                serializedObj.UpdateIfRequiredOrScript ();
+                EditorGUI.BeginChangeCheck();
+                
+                // Sky Color Controls
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showSkyControls = GUILayout.Toggle(myTarget.showSkyControls, "Sky Controls", headerFoldout);               
+                if(myTarget.showSkyControls)
+                {
+                    GUILayout.Space(10);
+                    EditorGUILayout.LabelField("General",headerStyle);
+                    EditorGUILayout.PropertyField(skyMode);   
+                    EditorGUILayout.PropertyField(forcedSkyboxSetup);       
+                    GUILayout.Space(10);
+                    if(myTarget.Settings.skyMode == EnviroSky.SkyMode.Normal)
+                    {
+                    EditorGUILayout.LabelField("Ground Color",headerStyle);
+                    EditorGUILayout.PropertyField(frontColorGradient0);
+                    EditorGUILayout.PropertyField(backColorGradient0);
+                    }
+                    GUILayout.Space(5);
+                    EditorGUILayout.LabelField("Horizon Colors",headerStyle);
+                    EditorGUILayout.PropertyField(frontColorGradient1);
+                    EditorGUILayout.PropertyField(backColorGradient1);
+                    GUILayout.Space(5);
+                    EditorGUILayout.PropertyField(frontColorGradient2);
+                    EditorGUILayout.PropertyField(backColorGradient2);
+
+                    if(myTarget.Settings.skyMode == EnviroSky.SkyMode.Normal)
+                    {
+                    GUILayout.Space(5);   
+                    EditorGUILayout.PropertyField(frontColorGradient3);
+                    EditorGUILayout.PropertyField(backColorGradient3);
+                    GUILayout.Space(5);   
+                    EditorGUILayout.PropertyField(frontColorGradient4);
+                    EditorGUILayout.PropertyField(backColorGradient4);
+                    }
+                    GUILayout.Space(5);
+                    EditorGUILayout.LabelField("Top Color",headerStyle);
+                    EditorGUILayout.PropertyField(frontColorGradient5);
+                    EditorGUILayout.PropertyField(backColorGradient5);
+                    GUILayout.Space(5);
+                    EditorGUILayout.LabelField("Tint",headerStyle);
+                    EditorGUILayout.PropertyField(skyColorTint);
+                    GUILayout.Space(5);
+                    EditorGUILayout.LabelField("Distribution",headerStyle);
+                    EditorGUILayout.PropertyField(distribution0);
+                    EditorGUILayout.PropertyField(distribution1);
+                    if(myTarget.Settings.skyMode == EnviroSky.SkyMode.Normal)
+                    {
+                    EditorGUILayout.PropertyField(distribution2);
+                    EditorGUILayout.PropertyField(distribution3);
+                    }
+                    GUILayout.Space(5);
+                    EditorGUILayout.LabelField("Intensity",headerStyle);
+                    EditorGUILayout.PropertyField(intensity);
+                    EditorGUILayout.PropertyField(intensityCurve);
+                    DisableInputStart();
+                    EditorGUILayout.PropertyField(skyColorExponent);      
+                    DisableInputEnd();
+                    GUILayout.Space(5);  
+                    EditorGUILayout.PropertyField(mieScatteringIntensityCurve);
+                    DisableInputStart();
+                    EditorGUILayout.PropertyField(mieScatteringMultiplier);
+                    DisableInputEnd();
+            #if ENVIRO_HDRP
+                     GUILayout.Space(5);
+                     EditorGUILayout.LabelField("HDRP Settings",headerStyle);
+                     EditorGUILayout.PropertyField(skyAmbientModeHDRP);   
+                     EditorGUILayout.PropertyField(skyExposureHDRP);
+            #endif
+                } 
+                GUILayout.EndVertical();
+
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showSkySunControls = GUILayout.Toggle(myTarget.showSkySunControls, "Sun Controls", headerFoldout);               
+                if(myTarget.showSkySunControls)
+                {
+                    GUILayout.Space(10);
+                    EditorGUILayout.LabelField("Textures",headerStyle);
+                    EditorGUILayout.PropertyField(sunTex);
+                    GUILayout.Space(5);
+                    EditorGUILayout.LabelField("Color",headerStyle);
+                    EditorGUILayout.PropertyField(sunDiscColorGradient);
+                    GUILayout.Space(5);
+                    EditorGUILayout.LabelField("Scale",headerStyle);
+                    EditorGUILayout.PropertyField(sunScale);
+                } 
+                GUILayout.EndVertical();
+
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showSkyMoonControls = GUILayout.Toggle(myTarget.showSkyMoonControls, "Moon Controls", headerFoldout);               
+                if(myTarget.showSkyMoonControls)
+                {
+                    GUILayout.Space(10);          
+                    EditorGUILayout.PropertyField(moonMode);
+                    if(myTarget.Settings.moonMode != EnviroSky.MoonMode.Simple)
+                       EditorGUI.BeginDisabledGroup(true);
+                    EditorGUILayout.PropertyField(moonPhase);    
+
+                    if(myTarget.Settings.moonMode != EnviroSky.MoonMode.Simple)
+                       EditorGUI.EndDisabledGroup();  
+                    GUILayout.Space(5);
+                    EditorGUILayout.LabelField("Textures",headerStyle);
+                    EditorGUILayout.PropertyField(moonTex);
+                    GUILayout.Space(5);
+                    EditorGUILayout.LabelField("Color",headerStyle);
+                    EditorGUILayout.PropertyField(moonColorGradient);
+                    GUILayout.Space(5);
+                    EditorGUILayout.LabelField("Scale",headerStyle);
+                    EditorGUILayout.PropertyField(moonScale);
+                } 
+                GUILayout.EndVertical();
+
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showSkyStarsControls = GUILayout.Toggle(myTarget.showSkyStarsControls, "Stars and Galaxy Controls", headerFoldout);               
+                if(myTarget.showSkyStarsControls)
+                {
+                    GUILayout.Space(10);
+                    EditorGUILayout.LabelField("Textures",headerStyle);
+                    EditorGUILayout.PropertyField(starsTex);
+                    EditorGUILayout.PropertyField(starsTwinklingTex);  
+                    if(myTarget.Settings.skyMode == EnviroSky.SkyMode.Normal)            
+                    EditorGUILayout.PropertyField(galaxyTex);
+                    GUILayout.Space(5);
+                    EditorGUILayout.LabelField("Intensity",headerStyle);
+                    EditorGUILayout.PropertyField(starIntensityCurve);
+                    if(myTarget.Settings.skyMode == EnviroSky.SkyMode.Normal)
+                    EditorGUILayout.PropertyField(galaxyIntensityCurve);
+                    EditorGUILayout.PropertyField(starsTwinklingSpeed);
+
+                } 
+                GUILayout.EndVertical();
+
+ 
+                /// Save Load
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showSaveLoad = GUILayout.Toggle(myTarget.showSaveLoad, "Save/Load", headerFoldout);
+                
+                if(myTarget.showSaveLoad)
+                {
+                    EditorGUILayout.PropertyField(preset);
+
+                    GUILayout.BeginHorizontal("",wrapStyle);
+
+                    if(myTarget.preset != null)
+                    {
+                        if(GUILayout.Button("Load"))
+                        {
+                            myTarget.LoadModuleValues();
+                        }
+                        if(GUILayout.Button("Save"))
+                        {
+                            myTarget.SaveModuleValues(myTarget.preset);
+                        }
+                    }
+                    if(GUILayout.Button("Save As New"))
+                    {
+                        myTarget.SaveModuleValues();
+                    }
+                    GUILayout.EndHorizontal();
+                }
+                GUILayout.EndVertical();
+                /// Save Load End
+                
+                ApplyChanges ();
+            }
+            GUILayout.EndVertical();
+
+            if(myTarget.showModuleInspector)
+             GUILayout.Space(20);
+        }
+    }
+}

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Sky/EnviroSkyModuleEditor.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 8f2892b5607eaa24995afaece87a3243
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 236601
+  packageName: Enviro 3 - Sky and Weather
+  packageVersion: 3.1.2
+  assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Sky/EnviroSkyModuleEditor.cs
+  uploadId: 660896

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Time.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 7bb454a3567462349ae64d0e07c0d13f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Time/EnviroTimeModuleEditor.cs

@@ -0,0 +1,202 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+
+namespace Enviro
+{
+    [CustomEditor(typeof(EnviroTimeModule))]
+    public class EnviroTimeModuleEditor : EnviroModuleEditor
+    {  
+        private EnviroTimeModule myTarget; 
+
+        //Properties
+        private SerializedProperty simulate,latitude,longitude,utcOffset,cycleLengthInMinutes,dayLengthModifier,nightLengthModifier,calenderType,daysInMonth,monthsInYear,customSunOffset,customSunRotation;  
+
+        //On Enable
+        public override void OnEnable()
+        {
+            if(!target)
+                return;
+
+            myTarget = (EnviroTimeModule)target;
+            serializedObj = new SerializedObject(myTarget);
+            preset = serializedObj.FindProperty("preset");
+            simulate = serializedObj.FindProperty("Settings.simulate"); 
+            latitude = serializedObj.FindProperty("Settings.latitude");
+            longitude = serializedObj.FindProperty("Settings.longitude");
+            utcOffset = serializedObj.FindProperty("Settings.utcOffset");
+            calenderType = serializedObj.FindProperty("Settings.calenderType");
+            daysInMonth = serializedObj.FindProperty("Settings.daysInMonth");
+            monthsInYear = serializedObj.FindProperty("Settings.monthsInYear");
+
+            customSunOffset = serializedObj.FindProperty("Settings.customSunOffset");
+            customSunRotation = serializedObj.FindProperty("Settings.customSunRotation");
+ 
+            cycleLengthInMinutes = serializedObj.FindProperty("Settings.cycleLengthInMinutes");
+            dayLengthModifier = serializedObj.FindProperty("Settings.dayLengthModifier");
+            nightLengthModifier = serializedObj.FindProperty("Settings.nightLengthModifier");
+        } 
+
+        public override void OnInspectorGUI()
+        {
+            if(!target)
+                return;
+
+            base.OnInspectorGUI();
+
+            GUI.backgroundColor = baseModuleColor;
+            GUILayout.BeginVertical("",boxStyleModified);
+            GUI.backgroundColor = Color.white;
+            EditorGUILayout.BeginHorizontal();
+            myTarget.showModuleInspector = GUILayout.Toggle(myTarget.showModuleInspector, "Time", headerFoldout);
+            
+            GUILayout.FlexibleSpace();
+            if(GUILayout.Button("x", EditorStyles.miniButtonRight,GUILayout.Width(18), GUILayout.Height(18)))
+            {
+                EnviroManager.instance.RemoveModule(EnviroManager.ModuleType.Time);
+                DestroyImmediate(this);
+                return;
+            } 
+            
+            EditorGUILayout.EndHorizontal();
+            
+            if(myTarget.showModuleInspector)
+            {
+                //EditorGUILayout.LabelField("This module will control the time of day.");
+                serializedObj.UpdateIfRequiredOrScript ();
+                EditorGUI.BeginChangeCheck();
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showTimeControls = GUILayout.Toggle(myTarget.showTimeControls, "Time Controls", headerFoldout);
+                    
+                if(myTarget.showTimeControls)
+                {   
+                    EditorGUI.BeginChangeCheck();
+                    GUILayout.Space(10); 
+                    EditorGUILayout.LabelField("Time", headerStyle);
+   
+
+                    int secT,minT,hoursT,daysT,monthsT,yearsT = 0;
+
+                    secT = EditorGUILayout.IntSlider("Second", myTarget.seconds,0,60);
+                    minT = EditorGUILayout.IntSlider("Minute", myTarget.minutes,0,60);
+                    hoursT = EditorGUILayout.IntSlider("Hour", myTarget.hours,0,24);
+                    GUILayout.Space(10);
+                    EditorGUILayout.LabelField("Date", headerStyle);
+                    EditorGUILayout.PropertyField(calenderType);
+                     if(myTarget.Settings.calenderType == EnviroTime.CalenderType.Custom)
+                     {
+                        daysT =  EditorGUILayout.IntSlider("Day", myTarget.days,1,myTarget.Settings.daysInMonth);
+                        monthsT = EditorGUILayout.IntSlider("Month", myTarget.months,1,myTarget.Settings.monthsInYear);
+                     }
+                     else
+                     {
+                        daysT = EditorGUILayout.IntSlider("Day", myTarget.days,1,31);
+                        monthsT = EditorGUILayout.IntSlider("Month", myTarget.months,1,12);
+                     }
+
+                    yearsT = EditorGUILayout.IntSlider("Year", myTarget.years,1,3000);
+                    if (EditorGUI.EndChangeCheck())
+                    {
+                        Undo.RecordObject(target, "Time Changed");
+                        myTarget.seconds = secT;
+                        myTarget.minutes = minT; 
+                        myTarget.hours = hoursT;
+                        myTarget.days = daysT;
+                        myTarget.months = monthsT;
+                        myTarget.years = yearsT;
+                        EditorUtility.SetDirty(myTarget);
+                    }
+                    if(myTarget.Settings.calenderType == EnviroTime.CalenderType.Custom)
+                    {
+                        GUILayout.Space(10);
+                        EditorGUILayout.LabelField("Custom Calender Settings", headerStyle);
+                        EditorGUILayout.PropertyField(daysInMonth);
+                        EditorGUILayout.PropertyField(monthsInYear);
+                        GUILayout.Space(10);
+                        EditorGUILayout.PropertyField(customSunOffset); 
+                        EditorGUILayout.PropertyField(customSunRotation);
+                    }
+                    GUILayout.Space(10);
+                    EditorGUILayout.LabelField("Progression", headerStyle);
+                    EditorGUILayout.PropertyField(simulate);
+                    EditorGUILayout.PropertyField(cycleLengthInMinutes);
+                    EditorGUILayout.PropertyField(dayLengthModifier);
+                    EditorGUILayout.PropertyField(nightLengthModifier);  
+                    GUILayout.Space(5);
+                    if(EnviroManager.instance != null)
+                       EnviroManager.instance.dayNightSwitch = EditorGUILayout.Slider("Day Night Switch",EnviroManager.instance.dayNightSwitch,0.2f,0.7f);                               
+                    
+                    Repaint();
+                }  
+                GUILayout.EndVertical();
+
+                if(myTarget.showTimeControls)
+                    GUILayout.Space(10);
+                if(myTarget.Settings.calenderType == EnviroTime.CalenderType.Realistic)
+                {
+                    GUI.backgroundColor = categoryModuleColor;
+                    GUILayout.BeginVertical("",boxStyleModified);
+                    GUI.backgroundColor = Color.white;
+                    myTarget.showLocationControls = GUILayout.Toggle(myTarget.showLocationControls, "Location Controls", headerFoldout);            
+                    if(myTarget.showLocationControls)
+                    {
+                        EditorGUILayout.PropertyField(latitude);
+                        EditorGUILayout.PropertyField(longitude);            
+                        EditorGUILayout.PropertyField(utcOffset);
+                    }  
+                    GUILayout.EndVertical();
+                }
+                
+                if(myTarget.showLocationControls)
+                    GUILayout.Space(10);
+
+                if(!Application.isPlaying) 
+                    myTarget.UpdateModule();
+
+
+                /// Save Load
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showSaveLoad = GUILayout.Toggle(myTarget.showSaveLoad, "Save/Load", headerFoldout);
+                
+                if(myTarget.showSaveLoad)
+                {
+                    EditorGUILayout.PropertyField(preset);
+                    GUILayout.BeginHorizontal("",wrapStyle);
+
+                    if(myTarget.preset != null)
+                    {
+                        if(GUILayout.Button("Load"))
+                        {
+                            myTarget.LoadModuleValues();
+                        }
+                        if(GUILayout.Button("Save"))
+                        {
+                            myTarget.SaveModuleValues(myTarget.preset);
+                        }
+                    }
+                    if(GUILayout.Button("Save As New"))
+                    {
+                        myTarget.SaveModuleValues();
+                    }
+                    GUILayout.EndHorizontal();
+                }
+                GUILayout.EndVertical();
+                /// Save Load End
+
+                if(myTarget.showSaveLoad)
+                    GUILayout.Space(10);
+
+                ApplyChanges ();
+            }
+            GUILayout.EndVertical();
+
+            if(myTarget.showModuleInspector)
+             GUILayout.Space(20);
+        }
+    }
+}

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Time/EnviroTimeModuleEditor.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 51ca99ab126b78f428a1e19a8ea12830
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 236601
+  packageName: Enviro 3 - Sky and Weather
+  packageVersion: 3.1.2
+  assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Time/EnviroTimeModuleEditor.cs
+  uploadId: 660896

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Volumetric Clouds.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9a32d98e6d133ce469de89d8c6ca7074
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Volumetric Clouds/EnviroCloudsModuleEditor.cs

@@ -0,0 +1,342 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+
+namespace Enviro 
+{
+    [CustomEditor(typeof(EnviroVolumetricCloudsModule))]
+    public class EnviroCloudsModuleEditor : EnviroModuleEditor
+    {  
+        private EnviroVolumetricCloudsModule myTarget; 
+        private SerializedProperty customWeatherMap,depthBlending,depthTest,sunLightColorGradient,moonLightColorGradient, ambientColorGradient,ambientLighIntensity,cloudShadows, cloudShadowsIntensity,
+        
+        noise, detailNoise, curlTex, blueNoise,bottomsOffsetNoise, cloudsWorldScale,maxRenderDistance, atmosphereColorSaturateDistance, cloudsTravelSpeed;
+        //Properties Layer 1
+        private SerializedProperty bottomCloudsHeightLayer1,topCloudsHeightLayer1,densityLayer1,densitySmoothnessLayer1, coverageLayer1,worleyFreq1Layer1, worleyFreq2Layer1, dilateCoverageLayer1, dilateTypeLayer1,cloudsTypeModifierLayer1, locationOffsetLayer1,
+        scatteringIntensityLayer1, silverLiningSpreadLayer1, directIndirectBalance,exposure, baseNoiseMultiplierLayer1,detailNoiseMultiplierLayer1,
+        curlIntensityLayer1, lightStepModifierLayer1, lightAbsorbtionLayer1,baseNoiseUVLayer1, detailNoiseUVLayer1,rampShapeLayer1,edgeHighlightStrength,
+        baseErosionIntensityLayer1, detailErosionIntensityLayer1, multiScatterStrengthLayer1, multiScatterFalloffLayer1,ambientFloorLayer1,cloudTypeShapingLayer1, bottomShapeLayer1,midShapeLayer1,topShapeLayer1,topLayerLayer1,silverLiningIntensityLayer1;
+    
+        //Properties Quality
+        private SerializedProperty volumetricClouds,lightningSupport,variableBottomNoise, downsampling, stepsLayer1, blueNoiseIntensity, reprojectionBlendTime, lodDistance;
+
+        private SerializedProperty windSpeedModifierLayer1, windUpwardsLayer1, cloudsWindDirectionXModifierLayer1, cloudsWindDirectionYModifierLayer1;
+     
+        //On Enable
+        public override void OnEnable()
+        {
+            if(!target)
+                return;
+
+            myTarget = (EnviroVolumetricCloudsModule)target;
+            serializedObj = new SerializedObject(myTarget);
+            preset = serializedObj.FindProperty("preset");
+
+            ambientColorGradient = serializedObj.FindProperty("settingsGlobal.ambientColorGradient");
+            ambientLighIntensity = serializedObj.FindProperty("settingsGlobal.ambientLighIntensity"); 
+            sunLightColorGradient = serializedObj.FindProperty("settingsGlobal.sunLightColorGradient");
+            moonLightColorGradient = serializedObj.FindProperty("settingsGlobal.moonLightColorGradient");
+            depthBlending = serializedObj.FindProperty("settingsGlobal.depthBlending"); 
+            depthTest = serializedObj.FindProperty("settingsGlobal.depthTest"); 
+            cloudShadows = serializedObj.FindProperty("settingsGlobal.cloudShadows");      
+            cloudShadowsIntensity = serializedObj.FindProperty("settingsGlobal.cloudShadowsIntensity"); 
+            noise = serializedObj.FindProperty("settingsGlobal.noise"); 
+            detailNoise = serializedObj.FindProperty("settingsGlobal.detailNoise"); 
+            curlTex = serializedObj.FindProperty("settingsGlobal.curlTex"); 
+            bottomsOffsetNoise = serializedObj.FindProperty("settingsGlobal.bottomsOffsetNoise"); 
+            blueNoise = serializedObj.FindProperty("settingsGlobal.blueNoise"); 
+            cloudsWorldScale = serializedObj.FindProperty("settingsGlobal.cloudsWorldScale"); 
+            maxRenderDistance = serializedObj.FindProperty("settingsGlobal.maxRenderDistance"); 
+            atmosphereColorSaturateDistance = serializedObj.FindProperty("settingsGlobal.atmosphereColorSaturateDistance");         
+            cloudsTravelSpeed = serializedObj.FindProperty("settingsGlobal.cloudsTravelSpeed");      
+            customWeatherMap = serializedObj.FindProperty("settingsGlobal.customWeatherMap");          
+             
+            //Quality
+            volumetricClouds = serializedObj.FindProperty("settingsQuality.volumetricClouds"); 
+            lightningSupport = serializedObj.FindProperty("settingsQuality.lightningSupport"); 
+            variableBottomNoise = serializedObj.FindProperty("settingsQuality.variableBottomNoise"); 
+            
+            downsampling = serializedObj.FindProperty("settingsQuality.downsampling"); 
+            stepsLayer1 = serializedObj.FindProperty("settingsQuality.stepsLayer1"); 
+            blueNoiseIntensity = serializedObj.FindProperty("settingsQuality.blueNoiseIntensity"); 
+            reprojectionBlendTime = serializedObj.FindProperty("settingsQuality.reprojectionBlendTime"); 
+            lodDistance = serializedObj.FindProperty("settingsQuality.lodDistance"); 
+
+            //Layer 1
+            bottomCloudsHeightLayer1 = serializedObj.FindProperty("settingsVolume.bottomCloudsHeight"); 
+            topCloudsHeightLayer1 = serializedObj.FindProperty("settingsVolume.topCloudsHeight");           
+            coverageLayer1 = serializedObj.FindProperty("settingsVolume.coverage"); 
+            worleyFreq1Layer1 = serializedObj.FindProperty("settingsVolume.worleyFreq1"); 
+            worleyFreq2Layer1 = serializedObj.FindProperty("settingsVolume.worleyFreq2"); 
+            dilateCoverageLayer1 = serializedObj.FindProperty("settingsVolume.dilateCoverage"); 
+            dilateTypeLayer1 = serializedObj.FindProperty("settingsVolume.dilateType"); 
+            cloudsTypeModifierLayer1 = serializedObj.FindProperty("settingsVolume.cloudsTypeModifier"); 
+            locationOffsetLayer1 = serializedObj.FindProperty("settingsVolume.locationOffset"); 
+            densityLayer1 = serializedObj.FindProperty("settingsVolume.density");  
+            rampShapeLayer1 = serializedObj.FindProperty("settingsVolume.rampShape");  
+            densitySmoothnessLayer1 = serializedObj.FindProperty("settingsVolume.densitySmoothness");  
+            scatteringIntensityLayer1 = serializedObj.FindProperty("settingsVolume.scatteringIntensity");  
+            silverLiningSpreadLayer1 = serializedObj.FindProperty("settingsVolume.silverLiningSpread"); 
+            silverLiningIntensityLayer1 = serializedObj.FindProperty("settingsVolume.silverLiningIntensity"); 
+            edgeHighlightStrength = serializedObj.FindProperty("settingsVolume.edgeHighlightStrength"); 
+            baseNoiseMultiplierLayer1 = serializedObj.FindProperty("settingsVolume.baseNoiseMultiplier"); 
+            detailNoiseMultiplierLayer1= serializedObj.FindProperty("settingsVolume.detailNoiseMultiplier"); 
+            directIndirectBalance = serializedObj.FindProperty("settingsVolume.directIndirectBalance");  
+            exposure = serializedObj.FindProperty("settingsVolume.exposure");  
+            curlIntensityLayer1 = serializedObj.FindProperty("settingsVolume.curlIntensity");  
+            lightStepModifierLayer1 = serializedObj.FindProperty("settingsVolume.lightStepModifier");  
+            lightAbsorbtionLayer1 = serializedObj.FindProperty("settingsVolume.absorbtion");
+            baseNoiseUVLayer1 = serializedObj.FindProperty("settingsVolume.baseNoiseUV");
+            detailNoiseUVLayer1 = serializedObj.FindProperty("settingsVolume.detailNoiseUV");
+            baseErosionIntensityLayer1 = serializedObj.FindProperty("settingsVolume.baseErosionIntensity");
+            detailErosionIntensityLayer1 = serializedObj.FindProperty("settingsVolume.detailErosionIntensity");
+            multiScatterStrengthLayer1 = serializedObj.FindProperty("settingsVolume.multiScatterStrength");
+            multiScatterFalloffLayer1 = serializedObj.FindProperty("settingsVolume.multiScatterFalloff");
+            ambientFloorLayer1 = serializedObj.FindProperty("settingsVolume.ambientFloor");
+            cloudTypeShapingLayer1 = serializedObj.FindProperty("settingsVolume.cloudTypeShaping");
+            bottomShapeLayer1 = serializedObj.FindProperty("settingsVolume.bottomShape");
+            midShapeLayer1 = serializedObj.FindProperty("settingsVolume.midShape");
+            topShapeLayer1 = serializedObj.FindProperty("settingsVolume.topShape");
+            topLayerLayer1 = serializedObj.FindProperty("settingsVolume.topLayer");
+            windSpeedModifierLayer1 = serializedObj.FindProperty("settingsVolume.windSpeedModifier"); 
+            windUpwardsLayer1 = serializedObj.FindProperty("settingsVolume.windUpwards"); 
+            cloudsWindDirectionXModifierLayer1 = serializedObj.FindProperty("settingsVolume.cloudsWindDirectionXModifier"); 
+            cloudsWindDirectionYModifierLayer1 = serializedObj.FindProperty("settingsVolume.cloudsWindDirectionYModifier"); 
+        } 
+
+        public override void OnInspectorGUI()
+        {
+            if(!target)
+                return;
+
+            base.OnInspectorGUI();
+
+            GUI.backgroundColor = baseModuleColor;
+            GUILayout.BeginVertical("",boxStyleModified);
+            GUI.backgroundColor = Color.white;
+            EditorGUILayout.BeginHorizontal();
+            myTarget.showModuleInspector = GUILayout.Toggle(myTarget.showModuleInspector, "Volumetric Clouds", headerFoldout);
+            
+  
+            GUILayout.FlexibleSpace();
+            if(GUILayout.Button("x", EditorStyles.miniButtonRight,GUILayout.Width(18), GUILayout.Height(18)))
+            {
+                EnviroManager.instance.RemoveModule(EnviroManager.ModuleType.VolumetricClouds);
+                DestroyImmediate(this);
+                return;
+            }                      
+            EditorGUILayout.EndHorizontal();
+            
+            if(myTarget.showModuleInspector)
+            {
+                RenderDisableInputBox();
+                serializedObj.UpdateIfRequiredOrScript ();
+                EditorGUI.BeginChangeCheck();
+
+
+                GUILayout.Space(10);
+
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showGlobalControls = GUILayout.Toggle(myTarget.showGlobalControls, "Global Settings", headerFoldout);            
+                if(myTarget.showGlobalControls)
+                { 
+                    GUILayout.Space(5);
+                    GUILayout.Label("Quality", headerStyle);
+                    DisableInputStartQuality();
+                    EditorGUILayout.PropertyField(volumetricClouds);
+                    GUILayout.Space(5);
+                    EditorGUILayout.PropertyField(lightningSupport);
+                    EditorGUILayout.PropertyField(variableBottomNoise);              
+                    DisableInputEndQuality(); 
+                    EditorGUILayout.PropertyField(depthBlending);
+                    if(!myTarget.settingsGlobal.depthBlending)
+                       EditorGUILayout.PropertyField(depthTest);
+                    DisableInputStartQuality();
+                    GUILayout.Space(5);
+                    EditorGUILayout.PropertyField(downsampling);          
+                    GUILayout.Space(5);
+                    EditorGUILayout.PropertyField(stepsLayer1);
+                    GUILayout.Space(5);
+                    EditorGUILayout.PropertyField(blueNoiseIntensity);
+                    EditorGUILayout.PropertyField(reprojectionBlendTime);
+                    GUILayout.Space(5);
+                    EditorGUILayout.PropertyField(lodDistance);
+                    DisableInputEndQuality();
+                    EditorGUILayout.PropertyField(maxRenderDistance);      
+                    EditorGUILayout.PropertyField(cloudsWorldScale); 
+                    EditorGUILayout.PropertyField(customWeatherMap);                  
+                    GUILayout.Space(10);
+                    GUILayout.Label("Textures", headerStyle);
+                    EditorGUILayout.PropertyField(noise);
+                    EditorGUILayout.PropertyField(detailNoise); 
+                    EditorGUILayout.PropertyField(curlTex);
+                    EditorGUILayout.PropertyField(bottomsOffsetNoise);            
+                    EditorGUILayout.PropertyField(blueNoise);
+                    GUILayout.Space(10);
+                    GUILayout.Label("Lighting", headerStyle);
+                    EditorGUILayout.PropertyField(sunLightColorGradient);
+                    EditorGUILayout.PropertyField(moonLightColorGradient);
+                    EditorGUILayout.PropertyField(ambientColorGradient);
+                    DisableInputStart();
+                    EditorGUILayout.PropertyField(ambientLighIntensity);
+                    DisableInputEnd();
+                    EditorGUILayout.PropertyField(atmosphereColorSaturateDistance);
+                    GUILayout.Space(10);
+                    GUILayout.Label("Wind", headerStyle);
+                    EditorGUILayout.PropertyField(cloudsTravelSpeed);                 
+                    GUILayout.Space(10);
+                    GUILayout.Label("Shadows", headerStyle);
+                    EditorGUILayout.PropertyField(cloudShadows);
+                    EditorGUILayout.PropertyField(cloudShadowsIntensity);
+                    
+                }
+                GUILayout.EndVertical();
+                
+                //Layer 1
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showVolumeSettings = GUILayout.Toggle(myTarget.showVolumeSettings, "Volume Settings", headerFoldout);            
+                if(myTarget.showVolumeSettings)
+                {
+                    //Coverage
+                    GUILayout.BeginVertical("",boxStyleModified);
+                    myTarget.showCoverageControls = GUILayout.Toggle(myTarget.showCoverageControls, "Coverage", headerFoldout);
+                    
+                    if(myTarget.showCoverageControls)
+                    {                          
+                        EditorGUILayout.PropertyField(bottomCloudsHeightLayer1);
+                        EditorGUILayout.PropertyField(topCloudsHeightLayer1);
+
+                        GUILayout.Space(10);
+                        DisableInputStart();
+                        EditorGUILayout.PropertyField(coverageLayer1);
+                        DisableInputEnd();
+                        EditorGUILayout.PropertyField(worleyFreq1Layer1);
+                        EditorGUILayout.PropertyField(worleyFreq2Layer1);
+                        DisableInputStart();
+                        EditorGUILayout.PropertyField(dilateCoverageLayer1);
+                        EditorGUILayout.PropertyField(dilateTypeLayer1);
+                        EditorGUILayout.PropertyField(cloudsTypeModifierLayer1);                  
+                        EditorGUILayout.PropertyField(cloudTypeShapingLayer1);                                 
+                        EditorGUILayout.PropertyField(bottomShapeLayer1);    
+                        EditorGUILayout.PropertyField(midShapeLayer1);    
+                        EditorGUILayout.PropertyField(topShapeLayer1); 
+                        EditorGUILayout.PropertyField(rampShapeLayer1);                   
+                        EditorGUILayout.PropertyField(topLayerLayer1);
+                        DisableInputEnd(); 
+         
+                        EditorGUILayout.PropertyField(locationOffsetLayer1);
+                    }
+                    GUILayout.EndVertical(); 
+
+                    //Lighting
+                    GUILayout.BeginVertical("",boxStyleModified);
+                    myTarget.showLightingControls = GUILayout.Toggle(myTarget.showLightingControls, "Lighting", headerFoldout);
+                    
+                    if(myTarget.showLightingControls)
+                    {
+                        DisableInputStart();
+                        EditorGUILayout.PropertyField(exposure);    
+                        GUILayout.Space(5);   
+                        EditorGUILayout.PropertyField(scatteringIntensityLayer1);              
+                        EditorGUILayout.PropertyField(multiScatterStrengthLayer1); 
+                        EditorGUILayout.PropertyField(multiScatterFalloffLayer1); 
+                        EditorGUILayout.PropertyField(ambientFloorLayer1);               
+                        GUILayout.Space(10);       
+                        EditorGUILayout.PropertyField(silverLiningIntensityLayer1);   
+                        EditorGUILayout.PropertyField(silverLiningSpreadLayer1);  
+                        EditorGUILayout.PropertyField(edgeHighlightStrength);                                           
+                        EditorGUILayout.PropertyField(directIndirectBalance); 
+                    
+                        GUILayout.Space(10);
+                        EditorGUILayout.PropertyField(lightAbsorbtionLayer1);  
+                        DisableInputEnd(); 
+                        EditorGUILayout.PropertyField(lightStepModifierLayer1);   
+                    }
+                    GUILayout.EndVertical(); 
+
+                    //Density
+                    GUILayout.BeginVertical("",boxStyleModified);
+                    myTarget.showDensityControls = GUILayout.Toggle(myTarget.showDensityControls, "Density", headerFoldout);
+                    
+                    if(myTarget.showDensityControls)
+                    {
+                        DisableInputStart();
+                        EditorGUILayout.PropertyField(densityLayer1); 
+                        EditorGUILayout.PropertyField(densitySmoothnessLayer1);            
+                        DisableInputEnd();   
+                        EditorGUILayout.PropertyField(baseNoiseUVLayer1);   
+                        EditorGUILayout.PropertyField(detailNoiseUVLayer1);
+                        DisableInputStart();
+                        EditorGUILayout.PropertyField(baseErosionIntensityLayer1);
+                        EditorGUILayout.PropertyField(baseNoiseMultiplierLayer1);            
+                        EditorGUILayout.PropertyField(detailErosionIntensityLayer1);
+                        EditorGUILayout.PropertyField(detailNoiseMultiplierLayer1);  
+                        EditorGUILayout.PropertyField(curlIntensityLayer1);  
+                        DisableInputEnd();    
+                    }
+                    GUILayout.EndVertical();    
+
+                    //Wind
+                    GUILayout.BeginVertical("",boxStyleModified);
+                    myTarget.showWindControls = GUILayout.Toggle(myTarget.showWindControls, "Wind", headerFoldout);
+                    
+                    if(myTarget.showWindControls)
+                    {
+                        EditorGUILayout.PropertyField(windSpeedModifierLayer1);
+                        EditorGUILayout.PropertyField(windUpwardsLayer1);
+                        GUILayout.Space(5);
+                        EditorGUILayout.PropertyField(cloudsWindDirectionXModifierLayer1);    
+                        EditorGUILayout.PropertyField(cloudsWindDirectionYModifierLayer1);    
+                    }
+                    GUILayout.EndVertical();   
+                }
+                GUILayout.EndVertical(); 
+                //Layer End
+
+         
+                /// Save Load
+                  GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showSaveLoad = GUILayout.Toggle(myTarget.showSaveLoad, "Save/Load", headerFoldout);
+                
+                if(myTarget.showSaveLoad)
+                {
+                    EditorGUILayout.PropertyField(preset);
+                    GUILayout.BeginHorizontal("",wrapStyle);
+
+                    if(myTarget.preset != null)
+                    {
+                        if(GUILayout.Button("Load"))
+                        {
+                            myTarget.LoadModuleValues();
+                        }
+                        if(GUILayout.Button("Save"))
+                        {
+                            myTarget.SaveModuleValues(myTarget.preset);
+                        }
+                    }
+                    if(GUILayout.Button("Save As New"))
+                    {
+                        myTarget.SaveModuleValues();
+                    }
+                    GUILayout.EndHorizontal();
+                }
+                GUILayout.EndVertical();
+                /// Save Load End
+
+                //Apply
+                ApplyChanges ();
+            }
+            GUILayout.EndVertical();
+
+            if(myTarget.showModuleInspector)
+             GUILayout.Space(20);
+        }
+    }
+}

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Volumetric Clouds/EnviroCloudsModuleEditor.cs.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: 81de08cdcfbc7a944a9cbf13fc409264
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 236601
+  packageName: Enviro 3 - Sky and Weather
+  packageVersion: 3.1.2
+  assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Volumetric
+    Clouds/EnviroCloudsModuleEditor.cs
+  uploadId: 660896

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Weather.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 03dcf99b6e322324b8c3557339ead275
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Weather/EnviroWeatherModuleEditor.cs

@@ -0,0 +1,634 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+
+namespace Enviro
+{
+    [CustomEditor(typeof(EnviroWeatherModule))]
+    public class EnviroWeatherModuleEditor : EnviroModuleEditor
+    {  
+        private EnviroWeatherModule myTarget; 
+
+
+        //Properties
+        private SerializedProperty cloudsTransitionSpeed,fogTransitionSpeed,skyTransitionSpeed, lightingTransitionSpeed,effectsTransitionSpeed,auroraTransitionSpeed,environmentTransitionSpeed,audioTransitionSpeed;  
+        private SerializedProperty globalAutoWeatherChange;
+
+        private int controlID = -100;
+        //On Enable
+        public override void OnEnable()
+        { 
+            if(!target)
+                return; 
+
+            myTarget = (EnviroWeatherModule)target;
+            serializedObj = new SerializedObject(myTarget);
+            preset = serializedObj.FindProperty("preset");
+            cloudsTransitionSpeed = serializedObj.FindProperty("Settings.cloudsTransitionSpeed");
+            fogTransitionSpeed = serializedObj.FindProperty("Settings.fogTransitionSpeed");
+            lightingTransitionSpeed = serializedObj.FindProperty("Settings.lightingTransitionSpeed");
+            skyTransitionSpeed = serializedObj.FindProperty("Settings.skyTransitionSpeed"); 
+            effectsTransitionSpeed = serializedObj.FindProperty("Settings.effectsTransitionSpeed");
+            auroraTransitionSpeed = serializedObj.FindProperty("Settings.auroraTransitionSpeed"); 
+            audioTransitionSpeed = serializedObj.FindProperty("Settings.audioTransitionSpeed");
+            environmentTransitionSpeed = serializedObj.FindProperty("Settings.environmentTransitionSpeed");
+            globalAutoWeatherChange = serializedObj.FindProperty("globalAutoWeatherChange"); 
+        } 
+        public override void OnInspectorGUI()
+        {
+            if(!target)
+                return;
+
+            base.OnInspectorGUI();
+
+            GUI.backgroundColor = baseModuleColor;
+            GUILayout.BeginVertical("",boxStyleModified);
+            GUI.backgroundColor = Color.white;
+            EditorGUILayout.BeginHorizontal();
+            myTarget.showModuleInspector = GUILayout.Toggle(myTarget.showModuleInspector, "Weather", headerFoldout);
+            
+            GUILayout.FlexibleSpace();
+            if(GUILayout.Button("x", EditorStyles.miniButtonRight,GUILayout.Width(18), GUILayout.Height(18)))
+            {
+                EnviroManager.instance.RemoveModule(EnviroManager.ModuleType.Weather);
+                DestroyImmediate(this);
+                return;
+            } 
+            
+            EditorGUILayout.EndHorizontal();
+            
+            if(myTarget.showModuleInspector) 
+            {
+                serializedObj.UpdateIfRequiredOrScript ();
+                EditorGUI.BeginChangeCheck();
+
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showWeatherPresetsControls = GUILayout.Toggle(myTarget.showWeatherPresetsControls, "Weather Preset Controls", headerFoldout);               
+                if(myTarget.showWeatherPresetsControls)
+                {
+                GUILayout.Space(5);
+                
+                Object selectedObject = null;
+
+                if(GUILayout.Button("Add"))
+                {
+                   controlID = EditorGUIUtility.GetControlID (FocusType.Passive);
+                   EditorGUIUtility.ShowObjectPicker<EnviroWeatherType>(null,false,"",controlID);
+                }
+ 
+                string commandName = Event.current.commandName;
+
+                if (commandName == "ObjectSelectorClosed" && EditorGUIUtility.GetObjectPickerControlID() == controlID) 
+                {
+            
+                        selectedObject = EditorGUIUtility.GetObjectPickerObject ();
+                        
+                        bool add = true;
+                        
+                        for (int i = 0; i < myTarget.Settings.weatherTypes.Count; i++)
+                        {
+                            if((EnviroWeatherType)selectedObject == myTarget.Settings.weatherTypes[i])
+                            add = false;
+                        }
+
+                        if(add)
+                        {
+                        myTarget.Settings.weatherTypes.Add((EnviroWeatherType)selectedObject);
+                        EditorUtility.SetDirty(myTarget);
+                        }
+                        
+                    controlID = -100;
+                }
+
+                if(GUILayout.Button("Create New"))
+                {
+                   myTarget.CreateNewWeatherType();
+                } 
+
+
+                GUILayout.Space(15);
+                //Make sure that we remove old empty entries where user deleted the scriptable object.
+                myTarget.CleanupList();
+ 
+                for (int i = 0; i < myTarget.Settings.weatherTypes.Count; i++) 
+                    {      
+                          EnviroWeatherType curWT = myTarget.Settings.weatherTypes[i];
+
+                          if(curWT == myTarget.targetWeatherType)
+                             GUI.backgroundColor = new Color(0.0f,0.5f,0.0f,1f);
+
+                            GUILayout.BeginVertical ("", boxStyleModified);
+                            GUI.backgroundColor = Color.white;
+
+                            EditorGUILayout.BeginHorizontal();
+                            curWT.showEditor = GUILayout.Toggle(curWT.showEditor, curWT.name, headerFoldout);
+                            GUILayout.FlexibleSpace();
+                            if(curWT != myTarget.targetWeatherType)
+                            {
+                                if(GUILayout.Button("Set Active", EditorStyles.miniButtonRight,GUILayout.Width(70), GUILayout.Height(18)))
+                                {
+                                    if(EnviroManager.instance != null)
+                                    {
+                                        myTarget.ChangeWeather(curWT);
+                                        EditorUtility.SetDirty(myTarget);
+                                    }
+                                } 
+                            } 
+
+                            if(GUILayout.Button("x", EditorStyles.miniButtonRight,GUILayout.Width(18), GUILayout.Height(18)))
+                            {
+                                myTarget.RemoveWeatherType(curWT);
+                                EditorUtility.SetDirty(myTarget);
+                            } 
+                            
+                            EditorGUILayout.EndHorizontal();
+                            //GUILayout.Space(15);
+                            if(curWT.showEditor)
+                            {
+                                Undo.RecordObject(curWT, "WeatherPreset Changed");
+                                curWT.name = EditorGUILayout.TextField ("Name", curWT.name);
+
+                                //Lighting
+                                if(EnviroManager.instance == null || EnviroManager.instance.Lighting != null)
+                                {
+                                GUILayout.BeginVertical ("", boxStyleModified);
+                                curWT.showLightingControls = GUILayout.Toggle(curWT.showLightingControls, "Lighting", headerFoldout);
+                                
+                                if(curWT.showLightingControls)
+                                {
+                                    GUILayout.Space(5);
+                                    curWT.lightingOverride.directLightIntensityModifier = EditorGUILayout.Slider("Direct Light Intensity", curWT.lightingOverride.directLightIntensityModifier,0f,2f);
+                                    curWT.lightingOverride.ambientIntensityModifier = EditorGUILayout.Slider("Ambient Light Intensity", curWT.lightingOverride.ambientIntensityModifier,0f,2f);
+                                    curWT.lightingOverride.shadowIntensity = EditorGUILayout.Slider("Shadow Intensity", curWT.lightingOverride.shadowIntensity,0f,1f); 
+                               
+                                }
+                                GUILayout.EndVertical();
+                                }
+
+                                //Sky
+                                if(EnviroManager.instance == null || EnviroManager.instance.Sky != null)
+                                { 
+                                GUILayout.BeginVertical ("", boxStyleModified);
+                                curWT.showSkyControls = GUILayout.Toggle(curWT.showSkyControls, "Sky", headerFoldout);
+                                
+                                if(curWT.showSkyControls)
+                                {
+                                    GUILayout.Space(5);
+                                    GUIContent colorTitle = new GUIContent();
+                                    colorTitle.text = "Color Tint"; 
+                                    colorTitle.tooltip = "Sets a color tint for skybox";
+                                    curWT.skyOverride.skyColorTint = EditorGUILayout.ColorField(colorTitle, curWT.skyOverride.skyColorTint,true,false,true);                 
+                                    curWT.skyOverride.skyColorExponent = EditorGUILayout.Slider("Color Exponent", curWT.skyOverride.skyColorExponent,0f,2f);
+                                    curWT.skyOverride.mieScatteringMultiplier = EditorGUILayout.Slider("Mie Scattering Multiplier", curWT.skyOverride.mieScatteringMultiplier,0f,2f);
+                                
+                                
+                                }
+                                GUILayout.EndVertical();
+                                }
+
+                                //Volumetric Clouds
+                                if(EnviroManager.instance == null || EnviroManager.instance.VolumetricClouds != null)
+                                {     
+                                GUILayout.BeginVertical ("", boxStyleModified);
+                                curWT.showCloudControls = GUILayout.Toggle(curWT.showCloudControls, "Volumetric Clouds", headerFoldout);
+                                if(curWT.showCloudControls)
+                                {
+                                    GUILayout.Space(5);
+                                    GUILayout.BeginVertical ("", boxStyleModified);
+                                    EditorGUILayout.LabelField("Coverage", headerStyle);
+                                    curWT.cloudsOverride.coverage = EditorGUILayout.Slider("Coverage", curWT.cloudsOverride.coverage,-1f,1f);
+                                    curWT.cloudsOverride.dilateCoverage = EditorGUILayout.Slider("Dilate Coverage", curWT.cloudsOverride.dilateCoverage,0f,1f);
+                                    GUILayout.Space(10);
+                                    EditorGUILayout.LabelField("Type Shaping", headerStyle);
+                                    curWT.cloudsOverride.dilateType = EditorGUILayout.Slider("Dilate Type", curWT.cloudsOverride.dilateType,0f,1f);                   
+                                    curWT.cloudsOverride.typeModifier = EditorGUILayout.Slider("Type Modifier", curWT.cloudsOverride.typeModifier,0f,1f);
+                                    curWT.cloudsOverride.cloudTypeShaping = EditorGUILayout.Slider("Type Influence", curWT.cloudsOverride.cloudTypeShaping,0f,1f);
+                                    GUILayout.Space(10); 
+                                    EditorGUILayout.LabelField("Segment Shaping", headerStyle);
+                                    curWT.cloudsOverride.bottomShape = EditorGUILayout.Slider("Bottom Shape", curWT.cloudsOverride.bottomShape,-5f,5f);
+                                    curWT.cloudsOverride.midShape = EditorGUILayout.Slider("Mid Shape", curWT.cloudsOverride.midShape,-5f,5f);
+                                    curWT.cloudsOverride.topShape = EditorGUILayout.Slider("Top Shape", curWT.cloudsOverride.topShape,-5f,5f);
+                                    curWT.cloudsOverride.rampShape = EditorGUILayout.Slider("Ramp Shape", curWT.cloudsOverride.rampShape,0f,2f);
+                                    GUILayout.Space(5);
+                                    curWT.cloudsOverride.topLayer = EditorGUILayout.Slider("Top Layer", curWT.cloudsOverride.topLayer,0f,2f);
+                                    GUILayout.Space(10);
+                                    EditorGUILayout.LabelField("Lighting", headerStyle);
+                                    curWT.cloudsOverride.exposure = EditorGUILayout.Slider("Exposure", curWT.cloudsOverride.exposure,0.0f,2f);
+                                    GUILayout.Space(5);
+                                    curWT.cloudsOverride.scatteringIntensity = EditorGUILayout.Slider("Scattering Intensity", curWT.cloudsOverride.scatteringIntensity,0f,10f);
+                                    curWT.cloudsOverride.multiScatterStrength = EditorGUILayout.Slider("Multi Scattering Strength", curWT.cloudsOverride.multiScatterStrength,0f,1f);
+                                    curWT.cloudsOverride.multiScatterFalloff = EditorGUILayout.Slider("Multi Scattering Falloff", curWT.cloudsOverride.multiScatterFalloff,0f,0.5f);        
+                                    curWT.cloudsOverride.ambientFloor = EditorGUILayout.Slider("Ambient Floor", curWT.cloudsOverride.ambientFloor,0f,1f);
+                                   // curWT.cloudsOverride.directIndirectBalance = EditorGUILayout.Slider("Direct-Indirect Balance", curWT.cloudsOverride.directIndirectBalance,0.0f,1f);
+                    
+                                    curWT.cloudsOverride.silverLiningIntensity = EditorGUILayout.Slider("Silver Lining Intensity", curWT.cloudsOverride.silverLiningIntensity,0f,2f);                             
+                                    curWT.cloudsOverride.silverLiningSpread = EditorGUILayout.Slider("Silver Lining Spread", curWT.cloudsOverride.silverLiningSpread,0f,1f);
+                                    curWT.cloudsOverride.edgeHighlightStrength = EditorGUILayout.Slider("Edge Highlights", curWT.cloudsOverride.edgeHighlightStrength,-1f,1f);
+                       
+                                    curWT.cloudsOverride.ligthAbsorbtion = EditorGUILayout.Slider("Light Absorbtion", curWT.cloudsOverride.ligthAbsorbtion,0f,1.0f);
+                                    curWT.cloudsOverride.ambientLightIntensity = EditorGUILayout.Slider("Ambient Light Intensity", curWT.cloudsOverride.ambientLightIntensity,0f,2f);
+                          
+                                    GUILayout.Space(10);
+                                    EditorGUILayout.LabelField("Density", headerStyle);
+                                    curWT.cloudsOverride.density = EditorGUILayout.Slider("Density", curWT.cloudsOverride.density,0f,2f);
+                                    curWT.cloudsOverride.densitySmoothness = EditorGUILayout.Slider("Density Smoothness", curWT.cloudsOverride.densitySmoothness,0f,2f);
+                                    GUILayout.Space(10);
+                                    EditorGUILayout.LabelField("Noise Shaping", headerStyle);
+                                    curWT.cloudsOverride.baseErosionIntensity = EditorGUILayout.Slider("Base Erosion Intensity", curWT.cloudsOverride.baseErosionIntensity,0f,1f);
+                                    curWT.cloudsOverride.baseNoiseMultiplier = EditorGUILayout.Slider("Base Noise Multiplier", curWT.cloudsOverride.baseNoiseMultiplier,0f,2f);                      
+                                    curWT.cloudsOverride.detailErosionIntensity = EditorGUILayout.Slider("Detail Erosion Intensity", curWT.cloudsOverride.detailErosionIntensity,0f,1f);
+                                    curWT.cloudsOverride.detailNoiseMultiplier = EditorGUILayout.Slider("Detail Noise Multiplier", curWT.cloudsOverride.detailNoiseMultiplier,0f,2f);
+                                    curWT.cloudsOverride.curlIntensity = EditorGUILayout.Slider("Curl Intensity", curWT.cloudsOverride.curlIntensity,0f,1f);
+                                    GUILayout.Space(10); 
+                                
+                                    GUILayout.EndVertical();                  
+                                }
+                                GUILayout.EndVertical(); 
+                                }
+
+                                if(EnviroManager.instance == null || EnviroManager.instance.FlatClouds != null)
+                                {
+                                //Flat Clouds
+                                GUILayout.BeginVertical ("", boxStyleModified);
+                                curWT.showFlatCloudControls = GUILayout.Toggle(curWT.showFlatCloudControls, "Flat Clouds", headerFoldout);
+                                
+                                if(curWT.showFlatCloudControls)
+                                { 
+                                    GUILayout.Space(5);
+                                    EditorGUILayout.LabelField("Cirrus Clouds", headerStyle);
+                                    curWT.flatCloudsOverride.cirrusCloudsCoverage = EditorGUILayout.Slider("Cirrus Clouds Coverage", curWT.flatCloudsOverride.cirrusCloudsCoverage,0f,1f);
+                                    curWT.flatCloudsOverride.cirrusCloudsAlpha = EditorGUILayout.Slider("Cirrus Clouds Alpha", curWT.flatCloudsOverride.cirrusCloudsAlpha,0f,1f);
+                                    curWT.flatCloudsOverride.cirrusCloudsColorPower = EditorGUILayout.Slider("Cirrus Clouds Color", curWT.flatCloudsOverride.cirrusCloudsColorPower,0f,2f);
+                                    GUILayout.Space(10);
+                                    EditorGUILayout.LabelField("Flat Clouds", headerStyle);
+                                    curWT.flatCloudsOverride.flatCloudsCoverage = EditorGUILayout.Slider("Flat Clouds Coverage", curWT.flatCloudsOverride.flatCloudsCoverage,0f,2f);
+                                    curWT.flatCloudsOverride.flatCloudsLightIntensity = EditorGUILayout.Slider("Flat Clouds Light Intensity", curWT.flatCloudsOverride.flatCloudsLightIntensity,0f,2f);
+                                    curWT.flatCloudsOverride.flatCloudsAmbientIntensity = EditorGUILayout.Slider("Flat Clouds Ambient Intensity", curWT.flatCloudsOverride.flatCloudsAmbientIntensity,0f,2f);
+                                    curWT.flatCloudsOverride.flatCloudsDensity =EditorGUILayout.Slider("Flat Clouds Density", curWT.flatCloudsOverride.flatCloudsDensity,0f,2f);        
+                                    curWT.flatCloudsOverride.flatCloudsShadowIntensity = EditorGUILayout.Slider("Flat Clouds Shadow Intensity", curWT.flatCloudsOverride.flatCloudsShadowIntensity,0f,2f);
+                                }
+                                GUILayout.EndVertical();
+                                }
+
+                                if(EnviroManager.instance == null || EnviroManager.instance.Fog != null)
+                                {
+                                //Fog
+                                GUILayout.BeginVertical ("", boxStyleModified);
+                                curWT.showFogControls = GUILayout.Toggle(curWT.showFogControls, "Fog", headerFoldout);
+                                
+                                if(curWT.showFogControls)
+                                { 
+                                    GUILayout.Space(5);
+                                    EditorGUILayout.LabelField("Layer 1", headerStyle);
+                                    curWT.fogOverride.fogDensity = EditorGUILayout.Slider("Fog Density 1", curWT.fogOverride.fogDensity,0f,1f);
+                                    curWT.fogOverride.fogHeightFalloff = EditorGUILayout.Slider("Fog Height Falloff 1", curWT.fogOverride.fogHeightFalloff,0f,0.05f);
+                                    curWT.fogOverride.fogHeight = EditorGUILayout.FloatField("Fog Height 1 ", curWT.fogOverride.fogHeight);
+                                    GUILayout.Space(10);
+                                    EditorGUILayout.LabelField("Layer 2", headerStyle);
+                                    curWT.fogOverride.fogDensity2 = EditorGUILayout.Slider("Fog Density 2", curWT.fogOverride.fogDensity2,0f,1f);
+                                    curWT.fogOverride.fogHeightFalloff2 = EditorGUILayout.Slider("Fog Height Falloff 2", curWT.fogOverride.fogHeightFalloff2,0f,0.05f);
+                                    curWT.fogOverride.fogHeight2 = EditorGUILayout.FloatField("Fog Height 2", curWT.fogOverride.fogHeight2);
+                                    GUILayout.Space(10);
+                                    EditorGUILayout.LabelField("Color", headerStyle);
+                                    curWT.fogOverride.fogColorBlend = EditorGUILayout.Slider("Fog Sky-Color Blending", curWT.fogOverride.fogColorBlend,0f,1.0f);
+                                    curWT.fogOverride.fogColorMod = EditorGUILayout.ColorField("Fog Color Tint", curWT.fogOverride.fogColorMod);
+                                    GUILayout.Space(10);
+                           
+                            #if !ENVIRO_HDRP
+                                    EditorGUILayout.LabelField("Unity Fog", headerStyle);
+                                    
+                                    if(EnviroManager.instance != null && EnviroManager.instance.Fog.Settings.unityFogMode == FogMode.Linear)
+                                    {
+                                        curWT.fogOverride.unityFogStartDistance = EditorGUILayout.FloatField("Unity Fog Start Distance", curWT.fogOverride.unityFogStartDistance);
+                                        curWT.fogOverride.unityFogEndDistance = EditorGUILayout.FloatField("Unity Fog End Distance", curWT.fogOverride.unityFogEndDistance);
+                                    } 
+                                    else
+                                    {
+                                        curWT.fogOverride.unityFogDensity = EditorGUILayout.FloatField("Unity Fog Density", curWT.fogOverride.unityFogDensity);
+                                    }
+                                   
+                                    GUILayout.Space(10);
+                                    EditorGUILayout.LabelField("Volumetrics", headerStyle);
+                                    curWT.fogOverride.scattering = EditorGUILayout.Slider("Scattering Intensity", curWT.fogOverride.scattering,0f,2.0f);
+                                    curWT.fogOverride.extinction = EditorGUILayout.Slider("Extinction Intensity", curWT.fogOverride.extinction,0f,1.0f);
+                                    curWT.fogOverride.anistropy = EditorGUILayout.Slider("Anistropy", curWT.fogOverride.anistropy,0f,1.0f);
+                            #else
+                                    EditorGUILayout.LabelField("HDRP Fog", headerStyle);
+                                    curWT.fogOverride.fogAttenuationDistance = EditorGUILayout.Slider("Attenuation Distance", curWT.fogOverride.fogAttenuationDistance,0f,4000f);
+                                    curWT.fogOverride.baseHeight = EditorGUILayout.FloatField("Base Height", curWT.fogOverride.baseHeight);
+                                    curWT.fogOverride.maxHeight = EditorGUILayout.FloatField("Max Height", curWT.fogOverride.maxHeight);
+                                    GUILayout.Space(10);
+                                    EditorGUILayout.LabelField("HDRP Volumetrics", headerStyle);
+                                    curWT.fogOverride.ambientDimmer = EditorGUILayout.Slider("Ambient Dimmer", curWT.fogOverride.ambientDimmer,0f,1f);
+                                    curWT.fogOverride.directLightMultiplier = EditorGUILayout.Slider("Direct Light Multiplier", curWT.fogOverride.directLightMultiplier,0f,16f);
+                                    curWT.fogOverride.directLightShadowdimmer = EditorGUILayout.Slider("Direct Light Shadow gimmer", curWT.fogOverride.directLightShadowdimmer,0f,1f);
+                            #endif 
+                                }
+                                GUILayout.EndVertical();
+                                }
+
+                                if(EnviroManager.instance == null || EnviroManager.instance.Effects != null)
+                                {
+                                //Effects
+                                GUILayout.BeginVertical ("", boxStyleModified);
+                                curWT.showEffectControls = GUILayout.Toggle(curWT.showEffectControls, "Effects", headerFoldout);
+                                
+                                if(curWT.showEffectControls)
+                                {  
+                                    GUILayout.Space(10);
+                                    if (GUILayout.Button ("Add")) 
+                                    {
+                                        curWT.effectsOverride.effectsOverride.Add (new EnviroEffectsOverrideType());
+                                        EditorUtility.SetDirty(curWT);
+                                    } 
+                
+                                    GUILayout.Space(10);
+                                    
+                                    for (int a = 0; a < curWT.effectsOverride.effectsOverride.Count; a++) 
+                                    {      
+                                        GUILayout.BeginVertical ("", boxStyleModified);
+                                        EditorGUILayout.BeginHorizontal();
+                                        curWT.effectsOverride.effectsOverride[a].showEditor = GUILayout.Toggle(curWT.effectsOverride.effectsOverride[a].showEditor, curWT.effectsOverride.effectsOverride[a].name, headerFoldout);
+                                        GUILayout.FlexibleSpace();
+                                        if(GUILayout.Button("x", EditorStyles.miniButtonRight,GUILayout.Width(18), GUILayout.Height(18)))
+                                        { 
+                                            curWT.effectsOverride.effectsOverride.Remove (curWT.effectsOverride.effectsOverride[a]);
+                                            EditorUtility.SetDirty(curWT);
+                                            return;
+                                        }           
+                                        EditorGUILayout.EndHorizontal();
+
+                                        if(curWT.effectsOverride.effectsOverride[a].showEditor)
+                                        {
+                                            curWT.effectsOverride.effectsOverride[a].name = EditorGUILayout.TextField ("Effect Name", curWT.effectsOverride.effectsOverride[a].name);
+                                            curWT.effectsOverride.effectsOverride[a].emission = EditorGUILayout.Slider ("Emission", curWT.effectsOverride.effectsOverride[a].emission,0f,1f);                                      
+                                        } 
+                                        GUILayout.EndVertical ();
+                                    }
+                                }
+                                GUILayout.EndVertical();
+                                }
+                                if(EnviroManager.instance == null || EnviroManager.instance.Aurora != null)
+                                {
+                                //Aurora
+                                GUILayout.BeginVertical ("", boxStyleModified);
+                                curWT.showAuroraControls = GUILayout.Toggle(curWT.showAuroraControls, "Aurora", headerFoldout);
+                                
+                                if(curWT.showAuroraControls) 
+                                { 
+                                    GUILayout.Space(5);
+                                    curWT.auroraOverride.auroraIntensity = EditorGUILayout.Slider("Aurora Intensity Modifier", curWT.auroraOverride.auroraIntensity,0f,1f);
+                                } 
+                                GUILayout.EndVertical();
+                                }
+                                if(EnviroManager.instance == null || EnviroManager.instance.Environment != null)
+                                {
+                                //Environment
+                                GUILayout.BeginVertical ("", boxStyleModified);
+                                curWT.showEnvironmentControls = GUILayout.Toggle(curWT.showEnvironmentControls, "Environment", headerFoldout);
+                                
+                                if(EnviroManager.instance == null || curWT.showEnvironmentControls) 
+                                { 
+                                    GUILayout.Space(5);
+                                    curWT.environmentOverride.temperatureWeatherMod = EditorGUILayout.Slider("Temperature Modifier", curWT.environmentOverride.temperatureWeatherMod,-20f,20f);
+                                    GUILayout.Space(5);
+                                    curWT.environmentOverride.wetnessTarget = EditorGUILayout.Slider("Wetness Target", curWT.environmentOverride.wetnessTarget,0f,1f);
+                                    curWT.environmentOverride.snowTarget = EditorGUILayout.Slider("Snow Target", curWT.environmentOverride.snowTarget,0f,1f);
+                                    GUILayout.Space(10);
+                                    curWT.environmentOverride.windDirectionX = EditorGUILayout.Slider("Wind Direction X", curWT.environmentOverride.windDirectionX,-1f,1f);
+                                    curWT.environmentOverride.windDirectionY = EditorGUILayout.Slider("Wind Direction Y", curWT.environmentOverride.windDirectionY,-1f,1f);
+                                    GUILayout.Space(5);
+                                    curWT.environmentOverride.windSpeed = EditorGUILayout.Slider("Wind Speed", curWT.environmentOverride.windSpeed,0f,1f);
+                                    curWT.environmentOverride.windTurbulence = EditorGUILayout.Slider("Wind Turbulence", curWT.environmentOverride.windTurbulence,0f,1f);                                } 
+                                    GUILayout.EndVertical();
+                                }
+
+
+                                if(EnviroManager.instance == null || EnviroManager.instance.Lightning != null)
+                                {
+                                //Lightning
+                                GUILayout.BeginVertical ("", boxStyleModified);
+                                curWT.showLightningControls = GUILayout.Toggle(curWT.showLightningControls, "Lightning", headerFoldout);
+                                
+                                if(curWT.showLightningControls) 
+                                {
+                                    GUILayout.Space(5);
+                                    curWT.lightningOverride.lightningStorm = EditorGUILayout.Toggle("Lightning Storm", curWT.lightningOverride.lightningStorm);
+                                    curWT.lightningOverride.randomLightningDelay = EditorGUILayout.Slider("Lightning Delay", curWT.lightningOverride.randomLightningDelay,1f,60f);
+                                }
+                                GUILayout.EndVertical();
+                                }
+
+
+                                if(EnviroManager.instance == null || EnviroManager.instance.Audio != null)
+                                {
+                                //Audio
+                                GUILayout.BeginVertical ("", boxStyleModified);
+                                curWT.showAudioControls = GUILayout.Toggle(curWT.showAudioControls, "Audio", headerFoldout);
+                                
+                                if(curWT.showAudioControls)
+                                {        
+                                    GUILayout.Space(5);
+                                    //Ambient SFX
+                                    GUILayout.BeginVertical ("", boxStyleModified);
+                                    curWT.showAmbientAudioControls = GUILayout.Toggle(curWT.showAmbientAudioControls, "Ambient", headerFoldout);         
+                                    if(curWT.showAmbientAudioControls)
+                                    {    
+                                        GUILayout.Space(10);
+                                        if (GUILayout.Button ("Add")) 
+                                        {
+                                            curWT.audioOverride.ambientOverride.Add (new EnviroAudioOverrideType());
+                                             EditorUtility.SetDirty(curWT);
+                                        }
+                    
+                                        GUILayout.Space(10);
+                                        
+                                        for (int a = 0; a < curWT.audioOverride.ambientOverride.Count; a++) 
+                                        {      
+                                            GUILayout.BeginVertical ("", boxStyleModified);
+                                            EditorGUILayout.BeginHorizontal();
+                                            curWT.audioOverride.ambientOverride[a].showEditor = GUILayout.Toggle(curWT.audioOverride.ambientOverride[a].showEditor, curWT.audioOverride.ambientOverride[a].name, headerFoldout);
+                                            GUILayout.FlexibleSpace();
+                                            if(GUILayout.Button("x", EditorStyles.miniButtonRight,GUILayout.Width(18), GUILayout.Height(18)))
+                                            { 
+                                                curWT.audioOverride.ambientOverride.Remove (curWT.audioOverride.ambientOverride[a]);
+                                                 EditorUtility.SetDirty(curWT);
+                                                return;
+                                            }           
+                                            EditorGUILayout.EndHorizontal();
+
+                                            if(curWT.audioOverride.ambientOverride[a].showEditor)
+                                            {
+                                                curWT.audioOverride.ambientOverride[a].name = EditorGUILayout.TextField ("Audio Name", curWT.audioOverride.ambientOverride[a].name);
+                                                curWT.audioOverride.ambientOverride[a].volume = EditorGUILayout.Slider ("Volume", curWT.audioOverride.ambientOverride[a].volume,0f,1f);                                      
+                                            } 
+                                            GUILayout.EndVertical ();
+                                        }
+                                    }
+                                    GUILayout.EndVertical ();
+
+                                    //Weather SFX
+                                    GUILayout.BeginVertical ("", boxStyleModified);
+                                    curWT.showWeatherAudioControls = GUILayout.Toggle(curWT.showWeatherAudioControls, "Weather", headerFoldout);         
+                                    if(curWT.showWeatherAudioControls)
+                                    {     
+                                        GUILayout.Space(10);
+                                        if (GUILayout.Button ("Add")) 
+                                        {
+                                            curWT.audioOverride.weatherOverride.Add (new EnviroAudioOverrideType());
+                                            EditorUtility.SetDirty(curWT);
+                                        }
+                    
+                                        GUILayout.Space(10);
+                                        
+                                        for (int a = 0; a < curWT.audioOverride.weatherOverride.Count; a++) 
+                                        {      
+                                            GUILayout.BeginVertical ("", boxStyleModified);
+                                            EditorGUILayout.BeginHorizontal();
+                                            curWT.audioOverride.weatherOverride[a].showEditor = GUILayout.Toggle(curWT.audioOverride.weatherOverride[a].showEditor, curWT.audioOverride.weatherOverride[a].name, headerFoldout);
+                                            GUILayout.FlexibleSpace();
+                                            if(GUILayout.Button("x", EditorStyles.miniButtonRight,GUILayout.Width(18), GUILayout.Height(18)))
+                                            { 
+                                                curWT.audioOverride.weatherOverride.Remove (curWT.audioOverride.weatherOverride[a]);
+                                                EditorUtility.SetDirty(curWT);
+                                                return;
+                                            }           
+                                            EditorGUILayout.EndHorizontal();
+
+                                            if(curWT.audioOverride.weatherOverride[a].showEditor)
+                                            {
+                                                curWT.audioOverride.weatherOverride[a].name = EditorGUILayout.TextField ("Audio Name", curWT.audioOverride.weatherOverride[a].name);
+                                                curWT.audioOverride.weatherOverride[a].volume = EditorGUILayout.Slider ("Volume", curWT.audioOverride.weatherOverride[a].volume,0f,1f);                                      
+                                            } 
+                                            GUILayout.EndVertical ();
+                                        }
+                                    }
+                                    GUILayout.EndVertical ();
+                                }
+                                GUILayout.EndVertical();
+                                }
+                                //END
+                            }
+                            GUILayout.EndVertical ();
+                            GUILayout.Space(2.5f);
+                    }
+                }
+                GUILayout.EndVertical ();
+
+
+                /// Transition Foldout
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showTransitionControls = GUILayout.Toggle(myTarget.showTransitionControls, "Transition Controls", headerFoldout);               
+                if(myTarget.showTransitionControls)
+                {
+                    GUILayout.Space(5);
+                    EditorGUILayout.PropertyField(cloudsTransitionSpeed);
+                    EditorGUILayout.PropertyField(fogTransitionSpeed);
+                    EditorGUILayout.PropertyField(skyTransitionSpeed);              
+                    EditorGUILayout.PropertyField(lightingTransitionSpeed);
+                    EditorGUILayout.PropertyField(effectsTransitionSpeed);
+                    EditorGUILayout.PropertyField(auroraTransitionSpeed); 
+                    EditorGUILayout.PropertyField(environmentTransitionSpeed);           
+                    EditorGUILayout.PropertyField(audioTransitionSpeed);
+                
+                }
+                GUILayout.EndVertical ();
+
+                ///Zone Foldout
+                if(EnviroManager.instance != null)
+                {
+                    GUI.backgroundColor = categoryModuleColor;
+                    GUILayout.BeginVertical("",boxStyleModified);
+                    GUI.backgroundColor = Color.white;
+                    myTarget.showZoneControls = GUILayout.Toggle(myTarget.showZoneControls, "Zone Controls", headerFoldout);               
+                    
+                    if(myTarget.showZoneControls)
+                    {
+                        GUILayout.Space(5);
+                        EditorGUILayout.PropertyField(globalAutoWeatherChange);
+                        GUILayout.Space(5);
+                        EnviroManager.instance.defaultZone = (EnviroZone)EditorGUILayout.ObjectField ("Default Zone", EnviroManager.instance.defaultZone, typeof(EnviroZone), true);
+                        EnviroManager.instance.currentZone = (EnviroZone)EditorGUILayout.ObjectField ("Current Zone", EnviroManager.instance.currentZone, typeof(EnviroZone), true);
+                        GUILayout.Space(5);
+                        GUILayout.Label("Zones List" , headerStyle);
+                        GUILayout.Space(5);
+                        for (int i = 0; i < EnviroManager.instance.zones.Count; i++) 
+                        {  
+                            if(EnviroManager.instance.zones[i] != null)
+                            {
+                                GUI.backgroundColor = EnviroManager.instance.zones[i].zoneGizmoColor;
+                                GUILayout.BeginVertical(EnviroManager.instance.zones[i].gameObject.name,boxStyleModified);
+                                GUI.backgroundColor = Color.white;
+                                EditorGUILayout.BeginHorizontal();
+
+                                GUILayout.FlexibleSpace();
+                                if(GUILayout.Button("Show", EditorStyles.miniButtonRight,GUILayout.Width(100), GUILayout.Height(18)))
+                                {
+                                UnityEditor.Selection.activeObject = EnviroManager.instance.zones[i];
+                                } 
+                                EditorGUILayout.EndHorizontal();
+                
+                                EditorGUILayout.BeginHorizontal();
+                                if(EnviroManager.instance.zones[i].currentWeatherType != null)
+                                    GUILayout.Label("Current Weather: " + EnviroManager.instance.zones[i].currentWeatherType.name , wrapStyle);
+                                else
+                                    GUILayout.Label("Current Weather: Not Set" , wrapStyle);
+
+                                if(EnviroManager.instance.zones[i].nextWeatherType != null)
+                                    GUILayout.Label("Next Weather: " + EnviroManager.instance.zones[i].nextWeatherType.name, wrapStyle);
+                                else
+                                    GUILayout.Label("Next Weather: Not Set" , wrapStyle);        
+                                EditorGUILayout.EndHorizontal();
+
+                                GUILayout.EndVertical ();
+                            }
+                        }
+                    }
+                    GUILayout.EndVertical ();
+                }
+               
+                /// Save Load
+                GUI.backgroundColor = categoryModuleColor;
+                GUILayout.BeginVertical("",boxStyleModified);
+                GUI.backgroundColor = Color.white;
+                myTarget.showSaveLoad = GUILayout.Toggle(myTarget.showSaveLoad, "Save/Load", headerFoldout);
+                
+                if(myTarget.showSaveLoad)
+                {
+                    EditorGUILayout.PropertyField(preset);
+                    GUILayout.BeginHorizontal("",wrapStyle);
+
+                    if(myTarget.preset != null)
+                    {
+                        if(GUILayout.Button("Load"))
+                        {
+                            myTarget.LoadModuleValues();
+                        }
+                        if(GUILayout.Button("Save"))
+                        {
+                            myTarget.SaveModuleValues(myTarget.preset);
+                        }
+                    }
+                    if(GUILayout.Button("Save As New"))
+                    {
+                        myTarget.SaveModuleValues();
+                    }
+                    GUILayout.EndHorizontal();
+                }
+                GUILayout.EndVertical();
+                /// Save Load End
+
+                ApplyChanges ();
+            }
+            GUILayout.EndVertical();
+
+            if(myTarget.showModuleInspector)
+             GUILayout.Space(20);
+        }
+    }
+}

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Weather/EnviroWeatherModuleEditor.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: d0a9b609832a6e746bee9539a14fd9ed
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 236601
+  packageName: Enviro 3 - Sky and Weather
+  packageVersion: 3.1.2
+  assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Weather/EnviroWeatherModuleEditor.cs
+  uploadId: 660896

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Weather/EnviroZoneInspector.cs

@@ -0,0 +1,181 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+
+namespace Enviro
+{
+    [CustomEditor(typeof(EnviroZone))]
+    public class EnviroZoneInspector : EnviroBaseInspector
+    {
+        private EnviroZone myTarget;
+
+        private SerializedProperty autoWeatherChanges, weatherChangeIntervall, zoneScale, zoneGizmoColor;
+
+        void OnEnable ()
+        {
+            myTarget = (EnviroZone)target;
+            serializedObj = new SerializedObject(myTarget);
+            autoWeatherChanges = serializedObj.FindProperty("autoWeatherChanges"); 
+            weatherChangeIntervall = serializedObj.FindProperty("weatherChangeIntervall"); 
+            zoneScale = serializedObj.FindProperty("zoneScale"); 
+            zoneGizmoColor = serializedObj.FindProperty("zoneGizmoColor"); 
+        }
+
+        public override void OnInspectorGUI()
+        {
+            SetupGUIStyles();
+
+            GUILayout.BeginVertical("", boxStyle);
+            GUILayout.Label("Enviro Weather Zone",headerStyleMid); 
+
+            //Help Box Button
+            //RenderHelpBoxButton();
+            // if(showHelpBox)
+            // RenderHelpBox("This is a help text test!");
+
+            GUILayout.EndVertical();
+            serializedObj.UpdateIfRequiredOrScript ();
+            EditorGUI.BeginChangeCheck();
+
+
+            GUILayout.BeginVertical("", boxStyle);
+            GUILayout.Label("Zone Setup",headerStyleMid); 
+            GUILayout.BeginVertical("",boxStyleModified);
+            EditorGUILayout.PropertyField(zoneScale);
+            EditorGUILayout.PropertyField(zoneGizmoColor);
+            GUILayout.EndVertical ();
+            GUILayout.EndVertical ();
+  
+
+            GUILayout.BeginVertical("", boxStyle);
+            GUILayout.Label("Weather Setup",headerStyleMid); 
+            GUILayout.Space(5f);
+            if(myTarget.currentWeatherType != null)        
+            GUILayout.Label("Current Weather: " + myTarget.currentWeatherType.name,wrapStyle); 
+            else
+            GUILayout.Label("Current Weather: Not Set",wrapStyle); 
+            GUILayout.Space(5f);
+            if(myTarget.nextWeatherType != null)   
+            {
+            if(EnviroManager.instance != null && EnviroManager.instance.Time != null)
+            {
+                if(EnviroManager.instance.Weather != null && EnviroManager.instance.Weather.globalAutoWeatherChange && myTarget.autoWeatherChanges)
+                GUILayout.Label("Next Change in: " + (myTarget.nextWeatherUpdate - EnviroManager.instance.Time.GetDateInHours()).ToString("#.00") + " hours",wrapStyle); 
+                else
+                GUILayout.Label("Next Change in: Stopped",wrapStyle); 
+            }
+            }
+            else
+            {
+                GUILayout.Label("Next Change in: Not Set");
+            }
+            GUILayout.Space(5f); 
+            if(myTarget.nextWeatherType != null)   
+            GUILayout.Label("Next Weather: " + myTarget.nextWeatherType.name,wrapStyle);
+            else
+            GUILayout.Label("Next Weather: Not Set",wrapStyle);
+            
+            GUILayout.Space(5f);
+            GUILayout.BeginVertical("", boxStyleModified);
+            EditorGUILayout.PropertyField(autoWeatherChanges);
+            EditorGUILayout.PropertyField(weatherChangeIntervall);
+            GUILayout.EndVertical();
+            GUILayout.Space(5f);      
+            GUILayout.BeginVertical("",boxStyleModified);
+            Object selectedObject = null;
+                        
+            if(GUILayout.Button("Add"))
+            {
+                int controlID = EditorGUIUtility.GetControlID (FocusType.Passive);
+                EditorGUIUtility.ShowObjectPicker<EnviroWeatherType>(null,false,"",controlID);
+            }
+
+            string commandName = Event.current.commandName;
+
+            if (commandName == "ObjectSelectorClosed") 
+            {
+                selectedObject = EditorGUIUtility.GetObjectPickerObject ();
+                
+                bool add = true;
+                
+                for (int i = 0; i < myTarget.weatherTypeList.Count; i++)
+                {
+                    if((EnviroWeatherType)selectedObject == myTarget.weatherTypeList[i].weatherType)
+                    add = false;
+                }
+
+                if(selectedObject == null)
+                    add = false;
+
+                if(add)
+                    myTarget.AddWeatherType((EnviroWeatherType)selectedObject);
+            }
+
+            GUILayout.Space(15);
+
+            for (int i = 0; i < myTarget.weatherTypeList.Count; i++) 
+                {      
+                    EnviroZoneWeather curZoneWeather = myTarget.weatherTypeList[i];
+                    GUILayout.BeginVertical ("", boxStyleModified);
+
+                    EditorGUILayout.BeginHorizontal();
+
+                    string name = "Empty";        
+                    if(curZoneWeather.weatherType != null)
+                        name = curZoneWeather.weatherType.name;
+
+                    curZoneWeather.showEditor = GUILayout.Toggle(curZoneWeather.showEditor, name, headerFoldout);
+                    GUILayout.FlexibleSpace();
+
+                    if(curZoneWeather.weatherType != myTarget.currentWeatherType)
+                    {
+                        if(GUILayout.Button("Change Now", EditorStyles.miniButtonRight,GUILayout.Width(80), GUILayout.Height(18)))
+                        {
+                            myTarget.ChangeZoneWeatherInstant(curZoneWeather.weatherType);
+                            //EditorUtility.SetDirty(curWT);
+                        } 
+                    }
+
+                    if(GUILayout.Button("x", EditorStyles.miniButtonRight,GUILayout.Width(18), GUILayout.Height(18)))
+                    {
+                        myTarget.RemoveWeatherZoneType(curZoneWeather);
+                    } 
+                    
+                    EditorGUILayout.EndHorizontal();
+
+                    if(curZoneWeather.showEditor)
+                    {
+                        GUILayout.BeginVertical ("", boxStyleModified);
+
+                        if((EnviroManager.instance != null && EnviroManager.instance.Environment != null) || EnviroManager.instance == null)
+                            curZoneWeather.seasonalProbability = EditorGUILayout.Toggle("Seasonal Probabillity",curZoneWeather.seasonalProbability);
+                           
+                        EditorGUILayout.Space(5f);
+
+                        if(curZoneWeather.seasonalProbability == false || (EnviroManager.instance != null && EnviroManager.instance.Environment == null))
+                        {
+                          curZoneWeather.probability = EditorGUILayout.Slider("Probabillity",curZoneWeather.probability,0f,100f);
+                        } 
+                        else if((EnviroManager.instance != null && EnviroManager.instance.Environment != null) || EnviroManager.instance == null)
+                        {
+                            curZoneWeather.probabilitySpring = EditorGUILayout.Slider("Spring Probabillity",curZoneWeather.probabilitySpring,0f,100f);
+                            curZoneWeather.probabilitySummer = EditorGUILayout.Slider("Summer Probabillity",curZoneWeather.probabilitySummer,0f,100f);
+                            curZoneWeather.probabilityAutumn = EditorGUILayout.Slider("Autumn Probabillity",curZoneWeather.probabilityAutumn,0f,100f);
+                            curZoneWeather.probabilityWinter = EditorGUILayout.Slider("Winter Probabillity",curZoneWeather.probabilityWinter,0f,100f);
+                        }
+
+                        EditorGUILayout.EndVertical ();
+                    }
+
+                    GUILayout.EndVertical ();
+
+                }
+
+            GUILayout.EndVertical ();
+            GUILayout.EndVertical ();
+
+            ApplyChanges();
+        }
+    }
+}

Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Weather/EnviroZoneInspector.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 2266ff05bd770c648becafb7eb2e1d78
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 236601
+  packageName: Enviro 3 - Sky and Weather
+  packageVersion: 3.1.2
+  assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Editor/Modules/Weather/EnviroZoneInspector.cs
+  uploadId: 660896