备份CatanBuilding瘦身独立工程

LocalPackages/StylizedWater2/Editor.meta

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

LocalPackages/StylizedWater2/Editor/AssetInfo.cs

@@ -0,0 +1,431 @@
+//Stylized Water 2
+//Staggart Creations (http://staggart.xyz)
+//Copyright protected under Unity Asset Store EULA
+
+using System;
+using System.Collections.Generic;
+using System.Net;
+using UnityEditor;
+using UnityEditor.PackageManager;
+using UnityEditor.PackageManager.Requests;
+using PackageInfo = UnityEditor.PackageManager.PackageInfo;
+using UnityEngine;
+
+namespace StylizedWater2
+{
+    public class AssetInfo
+    {
+        private const string THIS_FILE_GUID = "d5972a1c9cddd9941aec37a3343647aa";
+        
+        public const string ASSET_NAME = "Stylized Water 2";
+        public const string ASSET_ID = "170386";
+        public const string ASSET_ABRV = "SW2";
+
+        public const string INSTALLED_VERSION = "1.6.0";
+        
+        public const int SHADER_GENERATOR_VERSION_MAJOR = 1;
+        public const int SHADER_GENERATOR_MINOR = 2; 
+        public const int SHADER_GENERATOR_PATCH = 0;
+        
+        public const string MIN_UNITY_VERSION = "2021.3.16f1";
+        public const string MIN_URP_VERSION = "12.1.6";
+
+        private const string VERSION_FETCH_URL = "http://www.staggart.xyz/backend/versions/stylizedwater2.php";
+        public const string DOC_URL = "http://staggart.xyz/unity/stylized-water-2/sws-2-docs/";
+        public const string FORUM_URL = "https://forum.unity.com/threads/999132/";
+        public const string EMAIL_URL = "mailto:contact@staggart.xyz?subject=Stylized Water 2";
+
+        public static bool IS_UPDATED = true;
+        public static bool supportedVersion = true;
+        public static bool compatibleVersion = true;
+        public static bool alphaVersion = false;
+
+#if !URP //Enabled when com.unity.render-pipelines.universal is below MIN_URP_VERSION
+        [InitializeOnLoad]
+        sealed class PackageInstaller : Editor
+        {
+            [InitializeOnLoadMethod]
+            public static void Initialize()
+            {
+                GetLatestCompatibleURPVersion();
+
+                if (EditorUtility.DisplayDialog(ASSET_NAME + " v" + INSTALLED_VERSION, "This package requires the Universal Render Pipeline " + MIN_URP_VERSION + " or newer, would you like to install or update it now?", "OK", "Later"))
+                {
+					Debug.Log("Universal Render Pipeline <b>v" + lastestURPVersion + "</b> will start installing in a moment. Please refer to the URP documentation for set up instructions");
+					
+                    InstallURP();
+                }
+            }
+
+            private static PackageInfo urpPackage;
+
+            private static string lastestURPVersion;
+
+#if SWS_DEV
+            [MenuItem("SWS/Get latest URP version")]
+#endif
+            private static void GetLatestCompatibleURPVersion()
+            {
+                if(urpPackage == null) urpPackage = GetURPPackage();
+                if(urpPackage == null) return;
+                
+                lastestURPVersion = urpPackage.versions.latestCompatible;
+                
+#if SWS_DEV
+                Debug.Log("Latest compatible URP version: " + lastestURPVersion);
+#endif
+            }
+
+            private static void InstallURP()
+            {
+                if(urpPackage == null) urpPackage = GetURPPackage();
+                if(urpPackage == null) return;
+                
+                lastestURPVersion = urpPackage.versions.latestCompatible;
+
+                AddRequest addRequest = Client.Add(URP_PACKAGE_ID + "@" + lastestURPVersion);
+                
+                //Update Core and Shader Graph packages as well, doesn't always happen automatically
+                for (int i = 0; i < urpPackage.dependencies.Length; i++)
+                {
+#if SWS_DEV
+                    Debug.Log("Updating URP dependency <i>" + urpPackage.dependencies[i].name + "</i> to " + urpPackage.dependencies[i].version);
+#endif
+                    addRequest = Client.Add(urpPackage.dependencies[i].name + "@" + urpPackage.dependencies[i].version);
+                }
+                
+                //Wait until finished
+                while(!addRequest.IsCompleted || addRequest.Status == StatusCode.InProgress) { }
+                
+                WaterShaderImporter.ReimportAll();
+            }
+        }
+#endif
+        
+        public const string URP_PACKAGE_ID = "com.unity.render-pipelines.universal";
+
+        public static PackageInfo GetURPPackage()
+        {
+            SearchRequest request = Client.Search(URP_PACKAGE_ID);
+                
+            while (request.Status == StatusCode.InProgress) { /* Waiting... */ }
+
+            if (request.Status == StatusCode.Failure)
+            {
+                Debug.LogError("Failed to retrieve URP package from Package Manager...");
+                return null;
+            }
+
+            return request.Result[0];
+        }
+
+        //Sorry, as much as I hate to intrude on an entire project, this is the only way in Unity to track importing or updating an asset
+        public class ImportOrUpdateAsset : AssetPostprocessor
+        {
+            private static bool OldShadersPresent()
+            {
+                return Shader.Find("Universal Render Pipeline/FX/Stylized Water 2") || Shader.Find("Hidden/StylizedWater2/Deleted");
+            }
+            
+            private void OnPreprocessAsset()
+            {
+                var oldShaders = false;
+                //Importing/updating the Stylized Water 2 asset
+                if (assetPath.EndsWith("StylizedWater2/Editor/AssetInfo.cs") || assetPath.EndsWith("sc.stylizedwater2/Editor/AssetInfo.cs"))
+                {
+                    oldShaders = OldShadersPresent();
+                }
+                //These files change every version, so will trigger when updating or importing the first time
+                if (
+                    //Importing the Underwater Rendering extension
+                    assetPath.EndsWith("UnderwaterRenderer.cs"))
+                    //Any further extensions...
+                {
+                    OnImportExtension("Underwater Rendering");
+                    
+                    oldShaders = OldShadersPresent();
+                }
+
+                if (assetPath.EndsWith("WaterDynamicEffectsRenderFeature.cs"))
+                {
+                    OnImportExtension("Dynamic Effects");
+                }
+                
+                if (oldShaders)
+                {
+                    //Old non-templated shader(s) still present.
+                    if (EditorUtility.DisplayDialog(AssetInfo.ASSET_NAME, "Updating to v1.4.0+. Obsolete shader files were detected." +
+                                                                          "\n\n" +
+                                                                          "The water shader(s) are a now C# generated, thus has moved to a different file." +
+                                                                          "\n\n" +
+                                                                          "Materials in your project using the old shader must switch to it." +
+                                                                          "\n\n" +
+                                                                          "This process is automatic. The obsolete files will also be deleted." +
+                                                                          "\n\n" +
+                                                                          "Rest assured, no settings or functionality will be lost!", "OK", "Cancel"))
+                    {
+                        UpgradeMaterials();
+                    }
+                }
+
+            }
+
+            private void OnImportExtension(string name)
+            {
+                Debug.Log($"[Stylized Water 2] {name} extension installed/deleted or updated. Reimporting water shader(s) to toggle integration.");
+                
+                //Re-import any .watershader files, since these depend on the installation state of extensions
+                WaterShaderImporter.ReimportAll();
+            }
+        }
+
+        #if SWS_DEV
+        [MenuItem("SWS/Upgrading/Upgrade materials to 1.4.0+")]
+        #endif
+        private static void UpgradeMaterials()
+        {
+            Shader oldShader = Shader.Find("Universal Render Pipeline/FX/Stylized Water 2");
+            Shader oldShaderTess = Shader.Find("Universal Render Pipeline/FX/Stylized Water 2 (Tessellation)");
+            
+            Shader newShader = Shader.Find("Stylized Water 2/Standard");
+            Shader newShaderTess = Shader.Find("Stylized Water 2/Standard (Tessellation)");
+
+            int upgradedMaterialCount = 0;
+            
+            //Possible the script imported before the water shader even did
+            //Or the water shader was already deleted, yet this function is triggered by an old underwater-rendering shader.
+            if (newShader != null || oldShader != null)
+            {
+                string[] materials = AssetDatabase.FindAssets("t: Material");
+
+                int totalMaterials = materials.Length;
+                
+                for (int i = 0; i < totalMaterials; i++)
+                {
+                    Material mat = AssetDatabase.LoadAssetAtPath<Material>(AssetDatabase.GUIDToAssetPath(materials[i]));
+
+                    EditorUtility.DisplayProgressBar(ASSET_NAME, $"Checking \"{mat.name}\" ({i}/{totalMaterials})", (float)i / (float)totalMaterials);
+                    
+                    if (mat.shader == oldShader)
+                    {
+                        int queue = mat.renderQueue;
+                        mat.shader = newShader;
+                        mat.renderQueue = queue;
+                        EditorUtility.SetDirty(mat);
+                        upgradedMaterialCount++;
+                    }
+                    
+                    if (mat.shader == oldShaderTess)
+                    {
+                        int queue = mat.renderQueue;
+                        mat.shader = newShaderTess;
+                        mat.renderQueue = queue;
+                        
+                        EditorUtility.SetDirty(mat);
+                        upgradedMaterialCount++;
+                    }
+                }
+            }
+            
+            EditorUtility.ClearProgressBar();
+
+            List<string> deletedFiles = new List<string>();
+            //Delete old files
+            {
+                void DeleteFile(string path)
+                {
+                    if (path != string.Empty)
+                    {
+                        deletedFiles.Add(path);
+                        AssetDatabase.DeleteAsset(path);
+                    }
+                }
+
+                DeleteFile(AssetDatabase.GetAssetPath(oldShader));
+                DeleteFile(AssetDatabase.GetAssetPath(oldShaderTess));
+                
+                //UnderwaterMask.shader
+                DeleteFile(AssetDatabase.GUIDToAssetPath("85caab243c23a1e489cd0bdcaf742560"));
+                
+                //UnderwaterShading.shader
+                DeleteFile(AssetDatabase.GUIDToAssetPath("33652c9d694d8004bb649164aafc9ecc"));
+                
+                //Waterline.shader
+                DeleteFile(AssetDatabase.GUIDToAssetPath("aef8d53c098c94044b72ea6bda9bb6bc"));
+                
+                //UnderwaterPost.shader
+                DeleteFile(AssetDatabase.GUIDToAssetPath("7b53b35c69174ce092d2712e3db77f0e"));
+            }
+
+            if (upgradedMaterialCount > 0 || deletedFiles.Count > 0)
+            {
+                if (EditorUtility.DisplayDialog(AssetInfo.ASSET_NAME, $"Converted {upgradedMaterialCount} materials to use the new water shader." + 
+                                                                      $"\n\nObsolete shader files ({deletedFiles.Count}) deleted:\n\n" +
+                                                                      String.Join(Environment.NewLine, deletedFiles), 
+                    "OK")) { }
+            }
+            
+            AssetDatabase.SaveAssets();
+
+            Debug.Log("<b>[Stylized Water 2]</b> Upgrade of materials and project complete!");
+        }
+        
+        public static bool MeetsMinimumVersion(string versionMinimum)
+        {
+            Version curVersion = new Version(INSTALLED_VERSION);
+            Version minVersion = new Version(versionMinimum);
+
+            return curVersion >= minVersion;
+        }
+
+        public static void OpenAssetStore(string url = null)
+        {
+            if (url == string.Empty) url = "https://assetstore.unity.com/packages/slug/" + ASSET_ID;
+            
+            Application.OpenURL(url + "?aid=1011l7Uk8&pubref=sw2editor");
+        }
+
+        public static void OpenReviewsPage()
+        {
+            Application.OpenURL($"https://assetstore.unity.com/packages/slug/{ASSET_ID}?aid=1011l7Uk8&pubref=sw2editor#reviews");
+        }
+        
+        public static void OpenInPackageManager()
+        {
+            Application.OpenURL("com.unity3d.kharma:content/" + ASSET_ID);
+        }
+        
+        public static void OpenForumPage()
+        {
+            Application.OpenURL(FORUM_URL + "/page-999");
+        }
+        
+        public static string GetRootFolder()
+        {
+            //Get script path
+            string scriptFilePath = AssetDatabase.GUIDToAssetPath(THIS_FILE_GUID);
+
+            //Truncate to get relative path
+            string rootFolder = scriptFilePath.Replace("Editor/AssetInfo.cs", string.Empty);
+
+#if SWS_DEV
+            //Debug.Log("<b>Package root</b> " + rootFolder);
+#endif
+
+            return rootFolder;
+        }
+
+        public static class VersionChecking
+        {
+            public static string GetUnityVersion()
+            {
+                string version = UnityEditorInternal.InternalEditorUtility.GetFullUnityVersion();
+                
+                //Remove GUID in parenthesis 
+                return version.Substring(0, version.LastIndexOf(" ("));
+            }
+            
+            public static void CheckUnityVersion()
+            {
+                #if !UNITY_2020_3_OR_NEWER
+                compatibleVersion = false;
+                #endif
+                
+                #if !UNITY_2021_3_OR_NEWER
+                supportedVersion = false;
+                #endif
+
+                alphaVersion = GetUnityVersion().Contains("f") == false;
+            }
+
+            public static string fetchedVersionString;
+            public static System.Version fetchedVersion;
+            private static bool showPopup;
+
+            public enum VersionStatus
+            {
+                UpToDate,
+                Outdated
+            }
+
+            public enum QueryStatus
+            {
+                Fetching,
+                Completed,
+                Failed
+            }
+            public static QueryStatus queryStatus = QueryStatus.Completed;
+
+#if SWS_DEV
+            [MenuItem("SWS/Check for update")]
+#endif
+            public static void GetLatestVersionPopup()
+            {
+                CheckForUpdate(true);
+            }
+
+            private static int VersionStringToInt(string input)
+            {
+                //Remove all non-alphanumeric characters from version 
+                input = input.Replace(".", string.Empty);
+                input = input.Replace(" BETA", string.Empty);
+                return int.Parse(input, System.Globalization.NumberStyles.Any);
+            }
+
+            public static void CheckForUpdate(bool showPopup = false)
+            {
+                VersionChecking.showPopup = showPopup;
+
+                queryStatus = QueryStatus.Fetching;
+
+                using (WebClient webClient = new WebClient())
+                {
+                    webClient.DownloadStringCompleted += new System.Net.DownloadStringCompletedEventHandler(OnRetrievedServerVersion);
+                    webClient.DownloadStringAsync(new System.Uri(VERSION_FETCH_URL), fetchedVersionString);
+                }
+            }
+
+            private static void OnRetrievedServerVersion(object sender, DownloadStringCompletedEventArgs e)
+            {
+                if (e.Error == null && !e.Cancelled)
+                {
+                    fetchedVersionString = e.Result;
+                    fetchedVersion = new System.Version(fetchedVersionString);
+                    System.Version installedVersion = new System.Version(INSTALLED_VERSION);
+
+                    //Success
+                    IS_UPDATED = (installedVersion >= fetchedVersion) ? true : false;
+
+#if SWS_DEV
+                    Debug.Log("<b>PackageVersionCheck</b> Up-to-date = " + IS_UPDATED + " (Installed:" + INSTALLED_VERSION + ") (Remote:" + fetchedVersionString + ")");
+#endif
+
+                    queryStatus = QueryStatus.Completed;
+
+                    if (VersionChecking.showPopup)
+                    {
+                        if (!IS_UPDATED)
+                        {
+                            if (EditorUtility.DisplayDialog(ASSET_NAME + ", version " + INSTALLED_VERSION, "An updated version is available: " + fetchedVersionString, "Open Package Manager", "Close"))
+                            {
+                                OpenInPackageManager();
+                            }
+                        }
+                        else
+                        {
+                            if (EditorUtility.DisplayDialog(ASSET_NAME + ", version " + INSTALLED_VERSION, "Installed version is up-to-date!", "Close")) { }
+                        }
+                    }
+                }
+                else
+                {
+                    Debug.LogWarning("[" + ASSET_NAME + "] Contacting update server failed: " + e.Error.Message);
+                    queryStatus = QueryStatus.Failed;
+
+                    //When failed, assume installation is up-to-date
+                    IS_UPDATED = true;
+                }
+            }
+        }
+    }
+}

LocalPackages/StylizedWater2/Editor/AssetInfo.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d5972a1c9cddd9941aec37a3343647aa
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Editor/HelpWindow.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9423877ce002b024984ae85461230da7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Editor/Inspectors.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: cb0cf80ddc794103bd55d6c1d2b088a0
+timeCreated: 1701083972

LocalPackages/StylizedWater2/Editor/Inspectors/AlignToWavesInspector.cs

@@ -0,0 +1,262 @@
+//Stylized Water 2
+//Staggart Creations (http://staggart.xyz)
+//Copyright protected under Unity Asset Store EULA
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+#if UNITY_2021_2_OR_NEWER
+using PrefabStageUtility = UnityEditor.SceneManagement.PrefabStageUtility;
+#else
+using PrefabStageUtility = UnityEditor.Experimental.SceneManagement.PrefabStageUtility;
+#endif
+
+namespace StylizedWater2
+{
+    [CanEditMultipleObjects]
+    [CustomEditor(typeof(AlignToWaves))]
+    public class AlignToWavesInspector : Editor
+    {
+        AlignToWaves script;
+
+        SerializedProperty waterObject;
+        SerializedProperty autoFind;
+        SerializedProperty dynamicMaterial;
+        SerializedProperty waterLevelSource;
+        SerializedProperty waterLevel;
+        SerializedProperty childTransform;
+
+        SerializedProperty heightOffset;
+        SerializedProperty rollAmount;
+
+        SerializedProperty samples;
+
+        private bool editSamples;
+        private bool isRiver;
+        private bool wavesEnabled;
+        
+        private string proSkinPrefix => EditorGUIUtility.isProSkin ? "d_" : "";
+        
+        private void OnEnable()
+        {
+            script = (AlignToWaves)target;
+
+            waterObject = serializedObject.FindProperty("waterObject");
+            autoFind = serializedObject.FindProperty("autoFind");
+            dynamicMaterial = serializedObject.FindProperty("dynamicMaterial");
+            waterLevelSource = serializedObject.FindProperty("waterLevelSource");
+            waterLevel = serializedObject.FindProperty("waterLevel");
+            childTransform = serializedObject.FindProperty("childTransform");
+            heightOffset = serializedObject.FindProperty("heightOffset");
+            rollAmount = serializedObject.FindProperty("rollAmount");
+            samples = serializedObject.FindProperty("samples");
+            
+            //Auto fetch if there is only one water body in the scene
+            if (waterObject.objectReferenceValue == null && WaterObject.Instances.Count == 1)
+            {
+                serializedObject.Update();
+                waterObject.objectReferenceValue = WaterObject.Instances[0];
+                EditorUtility.SetDirty(target);
+                serializedObject.ApplyModifiedPropertiesWithoutUndo();
+            }
+            
+            ValidateMaterial();
+        }
+
+        private void OnDisable()
+        {
+            AlignToWaves.Disable = false;
+            Tools.hidden = false;
+        }
+
+        public override void OnInspectorGUI()
+        {
+            UI.DrawHeader();
+            
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                GUILayout.Space(EditorGUIUtility.labelWidth);
+                AlignToWaves.EnableInEditor =
+                    GUILayout.Toggle(AlignToWaves.EnableInEditor, new GUIContent(" Run in edit-mode (global)", EditorGUIUtility.IconContent(
+                        (AlignToWaves.EnableInEditor ? "animationvisibilitytoggleon" : "animationvisibilitytoggleoff")).image), "Button");
+            }
+            
+            EditorGUILayout.Space();
+
+            serializedObject.Update();
+
+            EditorGUI.BeginChangeCheck();
+            
+            EditorGUILayout.PropertyField(waterObject);
+            EditorGUI.indentLevel++;
+            EditorGUILayout.PropertyField(autoFind);
+            EditorGUILayout.PropertyField(dynamicMaterial);
+            EditorGUI.indentLevel--;
+
+            UI.DrawNotification(isRiver, "Material has river mode enabled, buoyancy only works for flat water bodies", MessageType.Error);
+            UI.DrawNotification(!wavesEnabled && !isRiver, "Material used on the water object does not have waves enabled.", MessageType.Error);
+            
+            if (script.waterObject && script.waterObject.material)
+            {
+                UI.DrawNotification((script.waterObject.material.GetFloat("_WorldSpaceUV") == 0f), "Material must use world-projected UV", "Change", ()=> script.waterObject.material.SetFloat("_WorldSpaceUV", 1f), MessageType.Error);
+            }
+
+            if(!autoFind.boolValue && waterObject.objectReferenceValue == null)
+            {
+                UI.DrawNotification("A water object must be assigned!", MessageType.Error);
+            }
+            
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                EditorGUILayout.PrefixLabel("Water level source");
+                waterLevelSource.intValue = GUILayout.Toolbar(waterLevelSource.intValue, new GUIContent[] { new GUIContent("Fixed Value"), new GUIContent("Water Object") });
+            }
+            if (waterLevelSource.intValue == (int)AlignToWaves.WaterLevelSource.FixedValue) EditorGUILayout.PropertyField(waterLevel);
+
+            EditorGUILayout.Space();
+
+            EditorGUILayout.PropertyField(heightOffset);
+            EditorGUILayout.PropertyField(rollAmount);
+
+            EditorGUILayout.Space();
+
+            EditorGUILayout.LabelField("Sample positions", EditorStyles.boldLabel);
+
+            if (targets.Length > 1)
+            {
+                EditorGUILayout.HelpBox("Cannot be modified for a multi-selection", MessageType.Info);
+            }
+            else
+            {
+                if (samples.arraySize > 0)
+                {
+                    editSamples =
+                        GUILayout.Toggle(editSamples,
+                            new GUIContent(" Edit samples", EditorGUIUtility.IconContent("sv_icon_dot0_pix16_gizmo").image),
+                            "Button", GUILayout.MaxWidth(125f), GUILayout.MaxHeight(30f));
+                }
+                else
+                {
+                    EditorGUILayout.HelpBox("No sample positions added. The transform's pivot position is used", MessageType.None);
+                }
+
+                for (int i = 0; i < samples.arraySize; i++)
+                {
+                    SerializedProperty param = samples.GetArrayElementAtIndex(i);
+
+                    using (new EditorGUILayout.HorizontalScope())
+                    {
+                        EditorGUILayout.PropertyField(param, true);
+
+                        if (GUILayout.Button(new GUIContent("",
+                            EditorGUIUtility.IconContent(proSkinPrefix + "TreeEditor.Trash").image, "Delete item"), GUILayout.MaxWidth(30f)))
+                        {
+                            samples.DeleteArrayElementAtIndex(i);
+                            selectedSampleIndex = -1;
+
+                            EditorUtility.SetDirty(target);
+                        }
+                    }
+                }
+
+                using (new EditorGUILayout.HorizontalScope())
+                {
+                    GUILayout.FlexibleSpace();
+                    if (GUILayout.Button(new GUIContent("Add", EditorGUIUtility.IconContent(proSkinPrefix + "Toolbar Plus").image, "Add new sample point")))
+                    {
+                        samples.InsertArrayElementAtIndex(samples.arraySize);
+                        selectedSampleIndex = samples.arraySize - 1;
+
+                        EditorUtility.SetDirty(target);
+                    }
+                }
+            }
+
+            EditorGUILayout.PropertyField(childTransform);
+            if (childTransform.objectReferenceValue == null && samples.arraySize > 0)
+                UI.DrawNotification("Assign a transform to rotate/scale the sample positions with");
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                serializedObject.ApplyModifiedProperties();
+
+                ValidateMaterial();
+            }
+            
+            UI.DrawFooter();
+        }
+
+        private void ValidateMaterial()
+        {
+            if (script.waterObject && script.waterObject.material)
+            {
+                if (script.waterObject.material != script.waterObject.meshRenderer.sharedMaterial) script.waterObject.material = script.waterObject.meshRenderer.sharedMaterial;
+                
+                wavesEnabled = WaveParameters.WavesEnabled(script.waterObject.material);
+                isRiver = script.waterObject.material.IsKeywordEnabled("_RIVER");
+            }
+        }
+
+        private int selectedSampleIndex;
+        Vector3 sampleWorldPos;
+        Vector3 prevSampleWorldPos;
+
+        private void OnSceneGUI()
+        {
+            if (!script) return;
+            
+            AlignToWaves.Disable = PrefabStageUtility.GetCurrentPrefabStage() != null || editSamples;
+            
+            if (editSamples)
+            {
+                //Mute default controls
+                Tools.hidden = true;
+                
+                Handles.color = new Color(0.66f, 0.66f, 0.66f, 1);
+                
+                for (int i = 0; i < script.samples.Count; i++)
+                {
+                    sampleWorldPos = script.ConvertToWorldSpace(script.samples[i]);
+
+                    float size = HandleUtility.GetHandleSize(sampleWorldPos) * 0.25f;
+                    if (Handles.Button(sampleWorldPos, Quaternion.identity, size, size, Handles.SphereHandleCap))
+                    {
+                        selectedSampleIndex = i;
+                    }
+                }
+
+                if (selectedSampleIndex > -1)
+                {
+                    sampleWorldPos = script.ConvertToWorldSpace(script.samples[selectedSampleIndex]);
+                    prevSampleWorldPos = sampleWorldPos;
+                    
+                    sampleWorldPos = Handles.PositionHandle(sampleWorldPos, script.childTransform ? script.childTransform.rotation : script.transform.rotation );
+                    script.samples[selectedSampleIndex] = script.ConvertToLocalSpace(sampleWorldPos);
+
+                    //If moved
+                    if (sampleWorldPos != prevSampleWorldPos)
+                    {
+                        prevSampleWorldPos = sampleWorldPos;
+                        EditorUtility.SetDirty(target);
+                    }
+                }
+            }
+            else
+            {
+                selectedSampleIndex = -1;
+                Tools.hidden = false;
+                
+                if (script.samples == null) return;
+
+                Handles.color = new Color(1,1,1, 0.25f);
+                for (int i = 0; i < script.samples.Count; i++)
+                {
+                    sampleWorldPos = script.ConvertToWorldSpace(script.samples[i]);
+                    Handles.SphereHandleCap(0, sampleWorldPos, SceneView.lastActiveSceneView.camera.transform.rotation, HandleUtility.GetHandleSize(sampleWorldPos) * 0.25f, EventType.Repaint);
+                }
+            }
+        }
+    }
+}

LocalPackages/StylizedWater2/Editor/Inspectors/AlignToWavesInspector.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6551d287f84686b47a644eabc2efd2c8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 148978298399363526, guid: 0000000000000000d000000000000000, type: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Editor/Inspectors/PlanarReflectionRendererInspector.cs

@@ -0,0 +1,350 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.XR;
+
+namespace StylizedWater2
+{
+    [CustomEditor(typeof(PlanarReflectionRenderer))]
+    public class PlanarReflectionRendererInspector : Editor
+    {
+        private PlanarReflectionRenderer renderer;
+        
+        //Rendering
+        private SerializedProperty rotatable;
+        private SerializedProperty cullingMask;
+        private SerializedProperty rendererIndex;
+        private SerializedProperty offset;
+        private SerializedProperty includeSkybox;
+        private SerializedProperty enableFog;
+        
+        //Quality
+        private SerializedProperty renderShadows;
+        private SerializedProperty renderRange;
+        private SerializedProperty renderScale;
+        private SerializedProperty maximumLODLevel;
+        
+        private SerializedProperty waterObjects;
+        private SerializedProperty moveWithTransform;
+
+        private Bounds curBounds;
+        private bool waterLayerError;
+
+        private bool previewReflection
+        {
+            get => EditorPrefs.GetBool("SWS2_PREVIEW_REFLECTION_ENABLED", true);
+            set => EditorPrefs.SetBool("SWS2_PREVIEW_REFLECTION_ENABLED", value);
+        }
+        private RenderTexture previewTexture;
+
+#if URP
+        private void OnEnable()
+        {
+            PipelineUtilities.RefreshRendererList();
+            
+            renderer = (PlanarReflectionRenderer)target;
+
+            rotatable = serializedObject.FindProperty("rotatable");
+            cullingMask = serializedObject.FindProperty("cullingMask");
+            rendererIndex = serializedObject.FindProperty("rendererIndex");
+            offset = serializedObject.FindProperty("offset");
+            includeSkybox = serializedObject.FindProperty("includeSkybox");
+            enableFog = serializedObject.FindProperty("enableFog");
+            renderShadows = serializedObject.FindProperty("renderShadows");
+            renderRange = serializedObject.FindProperty("renderRange");
+            renderScale = serializedObject.FindProperty("renderScale");
+            maximumLODLevel = serializedObject.FindProperty("maximumLODLevel");
+            waterObjects = serializedObject.FindProperty("waterObjects");
+            moveWithTransform = serializedObject.FindProperty("moveWithTransform");
+            
+            if (renderer.waterObjects.Count == 0 && WaterObject.Instances.Count == 1)
+            {
+                renderer.waterObjects.Add(WaterObject.Instances[0]);
+                renderer.RecalculateBounds();
+                renderer.EnableMaterialReflectionSampling();
+                
+                EditorUtility.SetDirty(target);
+                serializedObject.ApplyModifiedPropertiesWithoutUndo();
+            }
+
+            ValidateWaterObjectLayer();
+
+            curBounds = renderer.CalculateBounds();
+
+            RenderPipelineManager.endCameraRendering += OnEndCameraRendering;
+        }
+
+        private Camera currentCamera;
+        private string currentCameraName;
+        private bool waterObjectsVisible;
+        
+        private void OnEndCameraRendering(ScriptableRenderContext context, Camera camera)
+        {
+            if (!previewReflection) return;
+
+            if (PlanarReflectionRenderer.InvalidContext(camera)) return;
+
+            currentCamera = camera;
+            
+            waterObjectsVisible = renderer.WaterObjectsVisible(currentCamera);
+            
+            previewTexture = renderer.TryGetReflectionTexture(currentCamera);
+            currentCameraName = currentCamera.name;
+        }
+        
+        private void OnDisable()
+        {
+            RenderPipelineManager.endCameraRendering -= OnEndCameraRendering;
+        }
+#endif
+
+        public override void OnInspectorGUI()
+        {
+#if !URP
+            UI.DrawNotification("The Universal Render Pipeline package v" + AssetInfo.MIN_URP_VERSION + " or newer is not installed", MessageType.Error);
+#else
+            UI.DrawHeader();
+            
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                GUILayout.Space(EditorGUIUtility.labelWidth);
+                previewReflection =
+                    GUILayout.Toggle(previewReflection, new GUIContent("  Preview reflection", EditorGUIUtility.IconContent(
+                        (previewReflection ? "animationvisibilitytoggleon" : "animationvisibilitytoggleoff")).image), "Button");
+            }
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                GUILayout.Space(EditorGUIUtility.labelWidth);
+                EditorGUILayout.LabelField("Status: " + (waterObjectsVisible && currentCamera ? $"Rendering (camera: {currentCamera.name})" : "Not rendering (water not in view for any camera)"), EditorStyles.miniLabel);
+            }
+            
+            UI.DrawNotification(PipelineUtilities.VREnabled(), "Not supported with VR rendering", MessageType.Error);
+            
+            UI.DrawNotification(PlanarReflectionRenderer.AllowReflections == false, "Reflections have been globally disabled by an external script", MessageType.Warning);
+            
+            serializedObject.Update();
+            EditorGUI.BeginChangeCheck();
+            
+            EditorGUILayout.LabelField("Rendering", EditorStyles.boldLabel);
+
+            EditorGUI.BeginChangeCheck();
+            UI.DrawRendererProperty(rendererIndex);
+            if (EditorGUI.EndChangeCheck())
+            {
+                renderer.SetRendererIndex(rendererIndex.intValue);
+            }
+            
+            //Default renderer
+            if (rendererIndex.intValue == 0)
+            {
+                UI.DrawNotification("\n" +
+                                        "Using the default renderer for reflections is strongly discouraged." +
+                                        "\n\nMost (if not all) render features, such as third-party post processing effects, will also render for the reflection." +
+                                        "\n\nThis can lead to rendering artefacts and negatively impacts overall performance." +
+                                        "\n", MessageType.Warning);
+                
+                //If there are no other renderers to assign, suggest to auto-create one
+                UI.DrawNotification(PipelineUtilities.rendererIndexList.Length <= 2, "It is highly recommend to create a separate empty renderer", "Create and assign", CreateRenderer, MessageType.None);
+                
+                EditorGUILayout.Space();
+            }
+            
+            EditorGUILayout.PropertyField(cullingMask);
+            
+            EditorGUILayout.PropertyField(includeSkybox);
+            EditorGUILayout.PropertyField(enableFog);
+            
+            EditorGUILayout.Space();
+
+            EditorGUILayout.PropertyField(rotatable);
+            EditorGUILayout.PropertyField(offset);
+            
+            EditorGUILayout.Space();
+            
+            EditorGUILayout.LabelField("Quality", EditorStyles.boldLabel);
+            EditorGUI.BeginChangeCheck();
+            EditorGUILayout.PropertyField(renderShadows);
+            if (EditorGUI.EndChangeCheck())
+            {
+                renderer.ToggleShadows(renderShadows.boolValue);
+            }
+            EditorGUILayout.PropertyField(renderRange);
+            EditorGUILayout.PropertyField(renderScale);
+            EditorGUILayout.PropertyField(maximumLODLevel);
+            
+            EditorGUILayout.Space();
+
+            EditorGUILayout.LabelField("Target water objects", EditorStyles.boldLabel);
+            EditorGUILayout.PropertyField(moveWithTransform, new GUIContent("Move bounds with transform", moveWithTransform.tooltip));
+
+            EditorGUI.BeginChangeCheck();
+            EditorGUILayout.PropertyField(waterObjects);
+            if (EditorGUI.EndChangeCheck())
+            {
+                curBounds = renderer.CalculateBounds();
+            }
+            
+            if (EditorGUI.EndChangeCheck())
+            {
+                serializedObject.ApplyModifiedProperties();
+            }
+            
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                GUILayout.FlexibleSpace();
+                if(GUILayout.Button(new GUIContent("Auto-find", "Assigns all active water objects currently in the scene"), EditorStyles.miniButton))
+                {
+                    renderer.waterObjects = new List<WaterObject>(WaterObject.Instances);
+ 
+                    renderer.RecalculateBounds();
+                    curBounds = renderer.bounds;
+                    renderer.EnableMaterialReflectionSampling();
+
+                    ValidateWaterObjectLayer();
+                    
+                    EditorUtility.SetDirty(target);
+                }
+                if(GUILayout.Button("Clear", EditorStyles.miniButton))
+                {
+                    renderer.ToggleMaterialReflectionSampling(false);
+                    renderer.waterObjects.Clear();
+                    renderer.RecalculateBounds();
+                    
+                    EditorUtility.SetDirty(target);
+                }
+            }
+            
+            if (renderer.waterObjects != null)
+            {
+                UI.DrawNotification(renderer.waterObjects.Count == 0, "Assign at least one Water Object", MessageType.Info);
+                
+                if (renderer.waterObjects.Count > 0)
+                {
+                    UI.DrawNotification(curBounds.size != renderer.bounds.size || (moveWithTransform.boolValue == false && curBounds.center != renderer.bounds.center), "Water objects have changed or moved, bounds needs to be recalculated", "Recalculate",() => RecalculateBounds(), MessageType.Error);
+                }
+                
+                UI.DrawNotification(waterLayerError, "One or more Water Objects aren't on the \"Water\" layer.\n\nThis causes recursive reflections", "Fix", () => SetObjectsOnWaterLayer(), MessageType.Error);
+            }
+
+#endif
+            
+            UI.DrawFooter();
+        }
+        
+#if URP
+
+        private void CreateRenderer()
+        {
+            int index = -1;
+            string path = "";
+
+            PipelineUtilities.CreateAndAssignNewRenderer(out index, out path);
+
+            if (index >= 0)
+            {
+                rendererIndex.intValue = index;
+
+                serializedObject.ApplyModifiedProperties();
+                serializedObject.Update();
+                
+                renderer.SetRendererIndex(rendererIndex.intValue);
+
+                if (path != string.Empty)
+                {
+                    Debug.Log("New renderer created at path <i>" + path + "</i>");
+                }
+            }
+        }
+        
+        public override bool HasPreviewGUI()
+        {
+            return previewReflection && previewTexture;
+        }
+        
+        public override bool RequiresConstantRepaint()
+        {
+            return HasPreviewGUI();
+        }
+
+        public override GUIContent GetPreviewTitle()
+        {
+            return currentCamera ? new GUIContent(currentCameraName + " reflection") : new GUIContent("Reflection");
+        }
+
+        public override void OnPreviewSettings()
+        {
+            if (HasPreviewGUI() == false) return;
+
+            GUILayout.Label($"Resolution ({previewTexture.width}x{previewTexture.height})");
+        }
+
+        private bool drawAlpha;
+
+        public override void OnPreviewGUI(Rect r, GUIStyle background)
+        {
+            if (drawAlpha)
+            {
+                EditorGUI.DrawTextureAlpha(r, previewTexture, ScaleMode.ScaleToFit);
+            }
+            else
+            {
+                GUI.DrawTexture(r, previewTexture, ScaleMode.ScaleToFit, false);
+            }
+            
+            Rect btnRect = r;
+            btnRect.x += 10f;
+            btnRect.y += 10f;
+            btnRect.width = 150f;
+            btnRect.height = 20f;
+
+            drawAlpha = GUI.Toggle(btnRect, drawAlpha, new GUIContent(" Alpha channel"));
+        }
+
+        private void ValidateWaterObjectLayer()
+        {
+            if (renderer.waterObjects == null) return;
+
+            waterLayerError = false;
+            int layerID = LayerMask.NameToLayer("Water");
+
+            foreach (WaterObject obj in renderer.waterObjects)
+            {
+                //Is not on "Water" layer?
+                if (obj.gameObject.layer != layerID)
+                {
+                    waterLayerError = true;
+                    return;
+                }
+            }
+        }
+
+        private void SetObjectsOnWaterLayer()
+        {
+            int layerID = LayerMask.NameToLayer("Water");
+
+            foreach (WaterObject obj in renderer.waterObjects)
+            {
+                //Is not on "Water" layer?
+                if (obj.gameObject.layer != layerID)
+                {
+                    obj.gameObject.layer = layerID;
+                    EditorUtility.SetDirty(obj);
+                }
+            }
+            
+            waterLayerError = false;
+        }
+    #endif
+
+        private void RecalculateBounds()
+        {
+#if URP
+            renderer.RecalculateBounds();
+            curBounds = renderer.bounds;
+            EditorUtility.SetDirty(target);
+#endif
+        }
+    }
+}

LocalPackages/StylizedWater2/Editor/Inspectors/PlanarReflectionRendererInspector.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e169bca08efce694eab8006b53ed91c1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Editor/Inspectors/RenderFeatureEditor.cs

@@ -0,0 +1,68 @@
+#if URP
+using System;
+using UnityEditor;
+using UnityEngine;
+
+namespace StylizedWater2
+{
+    [CustomEditor(typeof(StylizedWaterRenderFeature))]
+    public class RenderFeatureEditor : Editor
+    {
+        private SerializedProperty screenSpaceReflectionSettings;
+        
+        private SerializedProperty directionalCaustics;
+        
+        private SerializedProperty displacementPrePassSettings;
+
+        private void OnEnable()
+        {
+            screenSpaceReflectionSettings = serializedObject.FindProperty("screenSpaceReflectionSettings");
+            
+            directionalCaustics = serializedObject.FindProperty("directionalCaustics");
+            
+            displacementPrePassSettings = serializedObject.FindProperty("displacementPrePassSettings");
+        }
+        
+        public override void OnInspectorGUI()
+        {
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                EditorGUILayout.LabelField($"Version {AssetInfo.INSTALLED_VERSION}", EditorStyles.miniLabel);
+
+                if (GUILayout.Button(new GUIContent(" Documentation", EditorGUIUtility.FindTexture("_Help"))))
+                {
+                    Application.OpenURL(AssetInfo.DOC_URL);
+                }
+            }
+            EditorGUILayout.Space();
+            
+            serializedObject.Update();
+            EditorGUI.BeginChangeCheck();
+
+            EditorGUILayout.PropertyField(directionalCaustics);
+            
+            EditorGUILayout.Space();
+            
+            EditorGUILayout.PropertyField(screenSpaceReflectionSettings);
+            if(screenSpaceReflectionSettings.isExpanded) EditorGUILayout.HelpBox("This feature is available for preview, no configurable settings are available yet", MessageType.Info);
+            
+            EditorGUILayout.Space();
+            
+            EditorGUILayout.PropertyField(displacementPrePassSettings);
+            if (displacementPrePassSettings.isExpanded)
+            {
+                EditorGUILayout.HelpBox("This will pre-render all the water geometry's height (including any displacement effects) into a buffer. Allowing other shaders to access this information." +
+                                        "\n\nSee the Displacement.hlsl shader library for the API, or use the \"Sample Water Height\" Sub-graph in Shader Graph." +
+                                        "\n\nThis is for advanced users, there is currently no functionality in Stylized Water 2 that makes use of this.", MessageType.Info);
+            }
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                serializedObject.ApplyModifiedProperties();
+            }
+            
+            UI.DrawFooter();
+        }
+    }
+}
+#endif

LocalPackages/StylizedWater2/Editor/Inspectors/RenderFeatureEditor.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: b1e12468f8ea4290a886e4706e800a98
+timeCreated: 1701084026

LocalPackages/StylizedWater2/Editor/Inspectors/WaterGridInspector.cs

@@ -0,0 +1,116 @@
+//Stylized Water 2
+//Staggart Creations (http://staggart.xyz)
+//Copyright protected under Unity Asset Store EULA
+
+using UnityEditor;
+using UnityEngine;
+
+namespace StylizedWater2
+{
+    [CustomEditor(typeof(WaterGrid))]
+    public class CreateWaterGridInspector : Editor
+    {
+        private WaterGrid script;
+
+        private SerializedProperty material;
+        private SerializedProperty followSceneCamera;
+        private SerializedProperty autoAssignCamera;
+        private SerializedProperty followTarget;
+        
+        private SerializedProperty scale;
+        private SerializedProperty vertexDistance;
+        private SerializedProperty rowsColumns;
+        
+        private int vertexCount;
+
+        private void OnEnable()
+        {
+            script = (WaterGrid) target;
+            script.m_rowsColumns = script.rowsColumns;
+
+            material = serializedObject.FindProperty("material");
+            followSceneCamera = serializedObject.FindProperty("followSceneCamera");
+            autoAssignCamera = serializedObject.FindProperty("autoAssignCamera");
+            followTarget = serializedObject.FindProperty("followTarget");
+            
+            scale = serializedObject.FindProperty("scale");
+            vertexDistance = serializedObject.FindProperty("vertexDistance");
+            rowsColumns = serializedObject.FindProperty("rowsColumns");
+        }
+        
+        public override void OnInspectorGUI()
+        {
+            UI.DrawHeader();
+
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                GUILayout.Space(EditorGUIUtility.labelWidth);
+                WaterGrid.DisplayGrid = GUILayout.Toggle(WaterGrid.DisplayGrid , new GUIContent("  Display Grid", EditorGUIUtility.IconContent((WaterGrid.DisplayGrid ? "animationvisibilitytoggleon" : "animationvisibilitytoggleoff")).image), "Button");
+                WaterGrid.DisplayWireframe = GUILayout.Toggle(WaterGrid.DisplayWireframe, new GUIContent("  Show Wireframe", EditorGUIUtility.IconContent((WaterGrid.DisplayWireframe ? "animationvisibilitytoggleon" : "animationvisibilitytoggleoff")).image), "Button");
+            }
+            
+            serializedObject.Update();
+            EditorGUI.BeginChangeCheck();
+
+            EditorGUILayout.LabelField("Appearance", EditorStyles.boldLabel);
+            EditorGUILayout.PropertyField(material);
+            if(material.objectReferenceValue == null) EditorGUILayout.HelpBox("A material must be assigned", MessageType.Error);
+            
+            EditorGUILayout.Space();
+            
+            EditorGUILayout.LabelField("Movement", EditorStyles.boldLabel);
+
+            EditorGUILayout.PropertyField(followSceneCamera);
+            using (new EditorGUI.DisabledScope(autoAssignCamera.boolValue))
+            {
+                EditorGUILayout.PropertyField(followTarget);
+            }
+            EditorGUI.indentLevel++;
+            EditorGUILayout.PropertyField(autoAssignCamera);
+            EditorGUI.indentLevel--;
+            
+            EditorGUILayout.Space();
+
+            EditorGUILayout.LabelField("Grid geometry", EditorStyles.boldLabel);
+
+            EditorGUILayout.PropertyField(scale, GUILayout.MaxWidth(EditorGUIUtility.labelWidth + 95f));
+
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                EditorGUILayout.PrefixLabel(rowsColumns.displayName);
+                using (new EditorGUI.DisabledScope(rowsColumns.intValue <= 1))
+                {
+                    if (GUILayout.Button("-", EditorStyles.miniButtonLeft, GUILayout.Width(25f)))
+                    {
+                        rowsColumns.intValue--;
+                    }
+                }
+                EditorGUILayout.PropertyField(rowsColumns, GUIContent.none, GUILayout.MaxWidth(40f));
+                if (GUILayout.Button("+", EditorStyles.miniButtonRight, GUILayout.Width(25f)))
+                {
+                    rowsColumns.intValue++;
+                }
+                EditorGUILayout.LabelField($"= {rowsColumns.intValue * rowsColumns.intValue} tiles", EditorStyles.miniLabel);
+            }
+            
+            EditorGUILayout.Space();
+
+            EditorGUILayout.PropertyField(vertexDistance, new GUIContent("Min. vertex distance", vertexDistance.tooltip));
+            vertexCount = Mathf.FloorToInt(((scale.floatValue / rowsColumns.intValue) / vertexDistance.floatValue) * ((scale.floatValue / rowsColumns.intValue) / vertexDistance.floatValue));
+            if(vertexCount > 65535)
+            {
+                EditorGUILayout.HelpBox("Vertex count of individual tiles is too high. Increase the vertex distance, decrease the grid scale, or add more rows/columns", MessageType.Error);
+            }
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                serializedObject.ApplyModifiedProperties();
+                
+                //Executed here since objects can't be destroyed from OnValidate
+                script.Recreate();
+            }
+            
+            UI.DrawFooter();
+        }
+    }
+}

LocalPackages/StylizedWater2/Editor/Inspectors/WaterGridInspector.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 55b547e4881242f4af120838d3e9e6d6
+timeCreated: 1680100927

LocalPackages/StylizedWater2/Editor/Inspectors/WaterObjectInspector.cs

@@ -0,0 +1,138 @@
+using System;
+using UnityEditor;
+using UnityEngine;
+using Object = UnityEngine.Object;
+#if URP
+using UnityEngine.Rendering.Universal;
+#endif
+
+namespace StylizedWater2
+{
+    [CustomEditor(typeof(WaterObject))]
+    [CanEditMultipleObjects]
+    public class WaterObjectInspector : Editor
+    {
+        private WaterObject component;
+
+        private SerializedProperty material;
+        private SerializedProperty meshFilter;
+        private SerializedProperty meshRenderer;
+        
+        private bool depthTextureRequired;
+        private bool opaqueTextureRequired;
+
+        private bool showInstances
+        {
+            get => SessionState.GetBool("WATEROBJECT_SHOW_INSTANCES", false);
+            set => SessionState.SetBool("WATEROBJECT_SHOW_INSTANCES", value);
+        }
+        
+        private Texture icon;
+        
+        private void OnEnable()
+        {
+            component = (WaterObject)target;
+
+            icon = Resources.Load<Texture>("water-object-icon");
+            
+            material = serializedObject.FindProperty("material");
+            meshFilter = serializedObject.FindProperty("meshFilter");
+            meshRenderer = serializedObject.FindProperty("meshRenderer");
+
+            CheckMaterial();
+        }
+
+        private void CheckMaterial()
+        {
+            #if URP
+            if (UniversalRenderPipeline.asset == null || component.material == null) return;
+
+            depthTextureRequired = UniversalRenderPipeline.asset.supportsCameraDepthTexture == false && component.material.GetFloat("_DisableDepthTexture") == 0f;
+            opaqueTextureRequired = UniversalRenderPipeline.asset.supportsCameraOpaqueTexture == false && component.material.GetFloat("_RefractionOn") == 1f;
+            #endif
+        }
+        
+        public override void OnInspectorGUI()
+        {
+            #if URP
+            if (UniversalRenderPipeline.asset)
+            {
+                UI.DrawNotification(
+                    depthTextureRequired,
+                    "Depth texture is disabled, but is required for the water material",
+                    "Enable",
+                    () =>
+                    {
+                        StylizedWaterEditor.EnableDepthTexture();
+                        CheckMaterial();
+                    },
+                    MessageType.Error);
+                
+                UI.DrawNotification(
+                    opaqueTextureRequired,
+                    "Opaque texture is disabled, but is required for the water material",
+                    "Enable",
+                    () =>
+                    {
+                        StylizedWaterEditor.EnableOpaqueTexture();
+                        CheckMaterial();
+                    },
+                    MessageType.Error);
+            }
+            #endif
+            
+            EditorGUILayout.HelpBox("This component provides a means for other scripts to identify and find water bodies", MessageType.None);
+            
+            EditorGUILayout.LabelField("References (Read only)", EditorStyles.boldLabel);
+            
+            EditorGUI.BeginDisabledGroup(true);
+            {
+                EditorGUILayout.PropertyField(material);
+                EditorGUILayout.PropertyField(meshFilter);
+                EditorGUILayout.PropertyField(meshRenderer);
+            }
+            EditorGUI.EndDisabledGroup();
+
+            //In case the material was changed on the attached Mesh Renderer, reflect the change
+            foreach (Object currentTarget in targets)
+            {
+                WaterObject water = (WaterObject)currentTarget;
+                water.FetchWaterMaterial();
+            }
+
+            if (WaterObject.Instances.Count > 1)
+            {
+                EditorGUILayout.Space();
+                
+                showInstances = EditorGUILayout.BeginFoldoutHeaderGroup(showInstances, $"Instances ({WaterObject.Instances.Count})");
+
+                if (showInstances)
+                {
+                    this.Repaint();
+
+                    using (new EditorGUILayout.VerticalScope(EditorStyles.textArea))
+                    {
+                        foreach (WaterObject obj in WaterObject.Instances)
+                        {
+                            var rect = EditorGUILayout.BeginHorizontal(EditorStyles.miniLabel);
+
+                            if (rect.Contains(Event.current.mousePosition))
+                            {
+                                EditorGUIUtility.AddCursorRect(new Rect(Event.current.mousePosition.x, Event.current.mousePosition.y, 27, 27), MouseCursor.Link);
+                                EditorGUI.DrawRect(rect, Color.gray * (EditorGUIUtility.isProSkin ? 0.66f : 0.20f));
+                            }
+
+                            if (GUILayout.Button(new GUIContent(" " + obj.name, icon), EditorStyles.miniLabel, GUILayout.Height(20f)))
+                            {
+                                EditorGUIUtility.PingObject(obj);
+                                Selection.activeGameObject = obj.gameObject;
+                            }
+                            EditorGUILayout.EndHorizontal();
+                        }
+                    }
+                }
+                EditorGUILayout.EndFoldoutHeaderGroup();
+            }
+        }
+    }
+}

LocalPackages/StylizedWater2/Editor/Inspectors/WaterObjectInspector.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 24c4c7f693f04a3893891169c1f864d8
+timeCreated: 1685014300

LocalPackages/StylizedWater2/Editor/Inspectors/WaterShaderImporterEditor.cs

@@ -0,0 +1,341 @@
+//Stylized Water 2
+//Staggart Creations (http://staggart.xyz)
+//Copyright protected under Unity Asset Store EULA
+
+using System.IO;
+using UnityEditor;
+using UnityEditorInternal;
+using UnityEngine;
+
+#if UNITY_2020_2_OR_NEWER
+using UnityEditor.AssetImporters;
+#else
+using UnityEditor.Experimental.AssetImporters;
+#endif
+
+namespace StylizedWater2
+{
+    [CustomEditor(typeof(WaterShaderImporter))]
+    [CanEditMultipleObjects]
+    public class WaterShaderImporterEditor : ScriptedImporterEditor
+    {
+        private WaterShaderImporter importer;
+
+        private SerializedProperty template;
+
+        private SerializedProperty settings;
+
+        private SerializedProperty shaderName;
+        private SerializedProperty hidden;
+        private SerializedProperty type;
+
+        private SerializedProperty autoIntegration;
+        private SerializedProperty fogIntegration;
+
+        private SerializedProperty lightCookies;
+
+        private SerializedProperty customIncludeDirectives;
+
+        private bool underwaterRenderingInstalled;
+        private bool dynamicEffectsInstalled;
+        private ShaderConfigurator.Fog.Integration firstIntegration;
+        private bool curvedWorldInstalled;
+
+        private bool showDependencies;
+
+        public override void OnEnable()
+        {
+            base.OnEnable();
+
+            underwaterRenderingInstalled = StylizedWaterEditor.UnderwaterRenderingInstalled();
+            dynamicEffectsInstalled = StylizedWaterEditor.DynamicEffectsInstalled();
+            firstIntegration = ShaderConfigurator.Fog.GetFirstInstalled();
+            curvedWorldInstalled = StylizedWaterEditor.CurvedWorldInstalled(out var _);
+
+            importer = (WaterShaderImporter)target;
+
+            template = serializedObject.FindProperty("template");
+
+            settings = serializedObject.FindProperty("settings");
+            //settings.isExpanded = true;
+
+            shaderName = settings.FindPropertyRelative("shaderName");
+            hidden = settings.FindPropertyRelative("hidden");
+            type = settings.FindPropertyRelative("type");
+            
+            lightCookies = settings.FindPropertyRelative("lightCookies");
+
+            autoIntegration = settings.FindPropertyRelative("autoIntegration");
+            fogIntegration = settings.FindPropertyRelative("fogIntegration");
+
+            customIncludeDirectives = settings.FindPropertyRelative("customIncludeDirectives");
+        }
+
+        public override bool HasPreviewGUI()
+        {
+            //Hide the useless sphere preview :)
+            return false;
+        }
+
+        public override void OnInspectorGUI()
+        {
+            //base.OnInspectorGUI();
+            Color defaultColor = GUI.contentColor;
+
+            UI.DrawHeader();
+
+            Shader shader = AssetDatabase.LoadAssetAtPath<Shader>(importer.assetPath);
+            if (shader == null)
+            {
+                UI.DrawNotification("Shader failed to compile, try to manually recompile it now.", MessageType.Error);
+            }
+
+            if (GUILayout.Button(new GUIContent("  Recompile", EditorGUIUtility.IconContent("RotateTool").image), GUILayout.MinHeight(30f)))
+            {
+                importer.SaveAndReimport();
+            }
+
+            GUILayout.Space(-2f);
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                using (new EditorGUI.DisabledGroupScope(shader == null))
+                {
+                    if (GUILayout.Button(new GUIContent("  Show Generated Code", EditorGUIUtility.IconContent("align_horizontally_left_active").image), EditorStyles.miniButtonLeft, GUILayout.Height(28f)))
+                    {
+                        GenericMenu menu = new GenericMenu();
+
+                        menu.AddItem(new GUIContent("With tessellation"), false, () => OpenGeneratedCode(true));
+                        menu.AddItem(new GUIContent("Without tessellation"), false, () => OpenGeneratedCode(false));
+
+                        menu.ShowAsContext();
+                    }
+                    if (GUILayout.Button(new GUIContent("Clear cache", "Unity's shader compiler will cache the compiled shader, and internally use that." +
+                                                                       "\n\nThis may result in seemingly false-positive shader errors. Such as in the case of importing the shader, before the URP shader libraries are." +
+                                                                       "\n\nClearing the cache gives the compiler a kick, and makes the shader properly represent the current state of the project/dependencies."), EditorStyles.miniButtonRight, GUILayout.Height(28f)))
+                    {
+                        importer.ClearCache();
+                    }
+                }
+            }
+
+            EditorGUILayout.Space();
+
+            serializedObject.Update();
+            EditorGUI.BeginChangeCheck();
+
+            EditorGUILayout.PropertyField(template);
+
+            if (template.objectReferenceValue == null) EditorGUILayout.HelpBox("• Template is assumed to be in the contents of the file itself", MessageType.None);
+            //EditorGUILayout.LabelField(importer.GetTemplatePath(), EditorStyles.miniLabel);
+
+            EditorGUILayout.Space();
+
+            EditorGUILayout.LabelField("Settings", EditorStyles.boldLabel);
+            EditorGUILayout.PropertyField(shaderName);
+            EditorGUI.indentLevel++;
+            EditorGUILayout.PropertyField(hidden);
+            EditorGUI.indentLevel--;
+
+            EditorGUILayout.PropertyField(type);
+
+            if (type.intValue == (int)WaterShaderImporter.WaterShaderSettings.ShaderType.WaterSurface)
+            {
+                EditorGUILayout.Space();
+
+                EditorGUILayout.LabelField("Integrations", EditorStyles.boldLabel);
+
+                EditorGUILayout.PropertyField(autoIntegration, new GUIContent("Automatic detection", autoIntegration.tooltip));
+                if (autoIntegration.boolValue)
+                {
+                    using (new EditorGUILayout.HorizontalScope())
+                    {
+                        EditorGUI.indentLevel++;
+                        EditorGUILayout.LabelField("Fog post-processing", GUILayout.MaxWidth(EditorGUIUtility.labelWidth));
+                        EditorGUI.indentLevel--;
+
+                        using (new EditorGUILayout.HorizontalScope(EditorStyles.textField))
+                        {
+                            GUI.contentColor = Color.green;
+                            EditorGUILayout.LabelField(firstIntegration.name);
+
+                            GUI.contentColor = defaultColor;
+                        }
+                    }
+
+                    using (new EditorGUILayout.HorizontalScope())
+                    {
+                        EditorGUI.indentLevel++;
+                        EditorGUILayout.LabelField("Curved World 2020", GUILayout.MaxWidth(EditorGUIUtility.labelWidth));
+                        EditorGUI.indentLevel--;
+
+                        using (new EditorGUILayout.HorizontalScope(EditorStyles.textField))
+                        {
+                            if (curvedWorldInstalled)
+                            {
+                                GUI.contentColor = Color.green;
+                                EditorGUILayout.LabelField("Installed");
+                            }
+                            else
+                            {
+                                GUI.contentColor = new Color(1f, 0.65f, 0f);
+                                EditorGUILayout.LabelField("(Not installed)");
+                            }
+
+                            GUI.contentColor = defaultColor;
+                        }
+                    }
+                }
+                else
+                {
+                    EditorGUILayout.PropertyField(fogIntegration);
+                }
+                if (curvedWorldInstalled) EditorGUILayout.HelpBox("Curved World integration must be activated through Window->Amazing Assets->Curved Word (Activator tab)", MessageType.Info);
+                
+                EditorGUILayout.Space();
+
+                EditorGUILayout.LabelField("Functionality support", EditorStyles.boldLabel);
+
+                EditorGUILayout.PropertyField(lightCookies);
+            }
+
+            EditorGUILayout.Space();
+
+            EditorGUILayout.LabelField("Extensions", EditorStyles.boldLabel);
+
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                EditorGUILayout.LabelField("Underwater Rendering", GUILayout.MaxWidth(EditorGUIUtility.labelWidth));
+
+                using (new EditorGUILayout.HorizontalScope(EditorStyles.textField))
+                {
+                    if (underwaterRenderingInstalled)
+                    {
+                        GUI.contentColor = Color.green;
+                        EditorGUILayout.LabelField("Installed");
+                    }
+                    else
+                    {
+                        GUI.contentColor = new Color(1f, 0.65f, 0f);
+                        EditorGUILayout.LabelField("(Not installed)");
+                    }
+
+                    GUI.contentColor = defaultColor;
+                }
+            }
+
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                EditorGUILayout.LabelField("Dynamic Effects", GUILayout.MaxWidth(EditorGUIUtility.labelWidth));
+
+                using (new EditorGUILayout.HorizontalScope(EditorStyles.textField))
+                {
+                    if (dynamicEffectsInstalled)
+                    {
+                        GUI.contentColor = Color.green;
+                        EditorGUILayout.LabelField("Installed");
+                    }
+                    else
+                    {
+                        GUI.contentColor = new Color(1f, 0.65f, 0f);
+                        EditorGUILayout.LabelField("(Not installed)");
+                    }
+
+                    GUI.contentColor = defaultColor;
+                }
+            }
+
+            EditorGUILayout.Space();
+
+            EditorGUILayout.PropertyField(customIncludeDirectives);
+            if (customIncludeDirectives.isExpanded)
+            {
+                EditorGUILayout.HelpBox("These are defined in a HLSLINCLUDE block and apply to all passes" +
+                                        "\nMay be used to insert custom code.", MessageType.Info);
+            }
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                //Force the parameter to a matching value.
+                //This way, if the "auto-integration" option is used, the .meta file will be changed when using the shader in a package, spanning different projects.
+                //When switching a different project, the file will be seen as changed and will be re-imported, in turn applying the project-specific integration.
+                if (autoIntegration.boolValue)
+                {
+                    fogIntegration.intValue = (int)firstIntegration.asset;
+                }
+
+                serializedObject.ApplyModifiedProperties();
+            }
+
+            this.ApplyRevertGUI();
+
+            showDependencies = EditorGUILayout.BeginFoldoutHeaderGroup(showDependencies, $"Dependencies ({importer.dependencies.Count})");
+
+            if (showDependencies)
+            {
+                this.Repaint();
+
+                using (new EditorGUILayout.VerticalScope(EditorStyles.textArea))
+                {
+                    foreach (string dependency in importer.dependencies)
+                    {
+                        var rect = EditorGUILayout.BeginHorizontal(EditorStyles.miniLabel);
+
+                        if (rect.Contains(Event.current.mousePosition))
+                        {
+                            EditorGUIUtility.AddCursorRect(new Rect(Event.current.mousePosition.x, Event.current.mousePosition.y, 27, 27), MouseCursor.Link);
+                            EditorGUI.DrawRect(rect, Color.gray * (EditorGUIUtility.isProSkin ? 0.66f : 0.20f));
+                        }
+
+                        if (GUILayout.Button(dependency == string.Empty ? new GUIContent(" (Missing)", EditorGUIUtility.IconContent("console.warnicon.sml").image) : new GUIContent(" " + dependency, EditorGUIUtility.IconContent("TextAsset Icon").image),
+                                EditorStyles.miniLabel, GUILayout.Height(20f)))
+                        {
+                            if (dependency != string.Empty)
+                            {
+                                TextAsset file = AssetDatabase.LoadAssetAtPath<TextAsset>(dependency);
+
+                                EditorGUIUtility.PingObject(file);
+                            }
+                        }
+                        EditorGUILayout.EndHorizontal();
+                    }
+                }
+
+                EditorGUILayout.HelpBox("Should any of these files be modified/moved/deleted, this shader will also re-import", MessageType.Info);
+            }
+            EditorGUILayout.EndFoldoutHeaderGroup();
+
+            UI.DrawFooter();
+
+            if (shader)
+            {
+                UI.DrawNotification(ShaderUtil.ShaderHasError(shader), "Errors may be false-positives due to caching", "Clear cache", () => importer.ClearCache(true), MessageType.Warning);
+            }
+        }
+
+        void OpenGeneratedCode(bool tessellation)
+        {
+            importer = (WaterShaderImporter)target;
+
+            string filePath = $"{Application.dataPath.Replace("Assets", string.Empty)}Temp/{importer.settings.shaderName}(Generated Code).shader";
+
+            string code = ShaderConfigurator.TemplateParser.CreateShaderCode(importer.GetTemplatePath(), importer, tessellation);
+            File.WriteAllText(filePath, code);
+
+            if (!File.Exists(filePath))
+            {
+                Debug.LogError(string.Format("Path {0} doesn't exists", filePath));
+                return;
+            }
+
+            string externalScriptEditor = ScriptEditorUtility.GetExternalScriptEditor();
+            if (externalScriptEditor != "internal")
+            {
+                InternalEditorUtility.OpenFileAtLineExternal(filePath, 0);
+            }
+            else
+            {
+                Application.OpenURL("file://" + filePath);
+            }
+        }
+    }
+}

LocalPackages/StylizedWater2/Editor/Inspectors/WaterShaderImporterEditor.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 81c37dbe6c244dcca9bde0e9c0f64171
+timeCreated: 1691138447

LocalPackages/StylizedWater2/Editor/MaterialUI.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ab427f26bc4a58a4d982a32fcf593b66
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Editor/Resources.meta

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

LocalPackages/StylizedWater2/Editor/Resources/water-object-icon.png.meta

@@ -0,0 +1,132 @@
+fileFormatVersion: 2
+guid: 83548767ebe1791409159648329da97d
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -100
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Editor/Resources/water-shader-icon.png.meta

@@ -0,0 +1,132 @@
+fileFormatVersion: 2
+guid: 8b93d3698aa42dd4382e180b61a3f224
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -100
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Editor/ShaderConfigurator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 026e0b49a81c6b047b5b159b73908933
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Editor/StylizedWaterEditor.cs

@@ -0,0 +1,261 @@
+//Stylized Water 2
+//Staggart Creations (http://staggart.xyz)
+//Copyright protected under Unity Asset Store EULA
+
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+#if URP
+using UnityEngine.Rendering.Universal;
+#if UNITY_2021_2_OR_NEWER
+using ForwardRendererData = UnityEngine.Rendering.Universal.UniversalRendererData;
+#endif
+#endif
+
+namespace StylizedWater2
+{
+    public class StylizedWaterEditor : Editor
+    {
+        #if URP
+        [MenuItem("GameObject/3D Object/Water/Object", false, 0)]
+        public static void CreateWaterObject()
+        {
+            Material mat = AssetDatabase.LoadAssetAtPath<Material>(AssetDatabase.GUIDToAssetPath("fbb04271505a76f40b984e38071e86f3"));
+            Mesh mesh = AssetDatabase.LoadAssetAtPath<Mesh>(AssetDatabase.GUIDToAssetPath("1e01d80fdc2155d4692276500db33fc9"));
+
+            WaterObject obj = WaterObject.New(mat, mesh);
+            
+            //Position in view
+            if (SceneView.lastActiveSceneView)
+            {
+                obj.transform.position = SceneView.lastActiveSceneView.camera.transform.position + (SceneView.lastActiveSceneView.camera.transform.forward * (Mathf.Max(mesh.bounds.size.x, mesh.bounds.size.z)) * 0.5f);
+            }
+            
+            if (Selection.activeGameObject) obj.transform.parent = Selection.activeGameObject.transform;
+
+            Selection.activeObject = obj;
+            
+            if(Application.isPlaying == false) EditorSceneManager.MarkSceneDirty(EditorSceneManager.GetActiveScene());
+        }
+
+        [MenuItem("GameObject/3D Object/Water/Grid", false, 1)]
+        [MenuItem("Window/Stylized Water 2/Create water grid", false, 2001)]
+        public static void CreateWaterGrid()
+        {
+            GameObject obj = new GameObject("Water Grid", typeof(WaterGrid));
+            Undo.RegisterCreatedObjectUndo(obj, "Created Water Grid");
+
+            obj.layer = LayerMask.NameToLayer("Water");
+            
+            WaterGrid grid = obj.GetComponent<WaterGrid>();
+            grid.Recreate();
+
+            if (Selection.activeGameObject) obj.transform.parent = Selection.activeGameObject.transform;
+            
+            Selection.activeObject = obj;
+
+            //Position in view
+            if (SceneView.lastActiveSceneView)
+            {
+                Vector3 position = SceneView.lastActiveSceneView.camera.transform.position + (SceneView.lastActiveSceneView.camera.transform.forward * grid.scale * 0.5f);
+                position.y = 0f;
+                
+                grid.transform.position = position;
+            }
+            
+            if(Application.isPlaying == false) EditorSceneManager.MarkSceneDirty(EditorSceneManager.GetActiveScene());
+        }
+        
+        [MenuItem("Window/Stylized Water 2/Set up render feature", false, 2000)]
+        public static void SetupRenderFeature()
+        {
+            PipelineUtilities.SetupRenderFeature<StylizedWaterRenderFeature>("Stylized Water 2");
+        }
+        
+        [MenuItem("GameObject/3D Object/Water/Planar Reflections Renderer", false, 2)]
+        [MenuItem("Window/Stylized Water 2/Set up planar reflections", false, 2001)]
+        public static void CreatePlanarReflectionRenderer()
+        {
+            GameObject obj = new GameObject("Planar Reflections Renderer", typeof(PlanarReflectionRenderer));
+            Undo.RegisterCreatedObjectUndo(obj, "Created PlanarReflectionRenderer");
+            PlanarReflectionRenderer r = obj.GetComponent<PlanarReflectionRenderer>();
+            r.ApplyToAllWaterInstances();
+
+            Selection.activeObject = obj;
+            
+            if(Application.isPlaying == false) EditorSceneManager.MarkSceneDirty(EditorSceneManager.GetActiveScene());
+        }
+        #endif
+        
+        [MenuItem("Assets/Create/Water/Mesh")]
+        private static void CreateWaterPlaneAsset()
+        {
+            ProjectWindowUtil.CreateAssetWithContent("New Watermesh.watermesh", "");
+        }
+        
+        [MenuItem("CONTEXT/Transform/Align To Waves")]
+        private static void AddAlignToWaves(MenuCommand cmd)
+        {
+            Transform t = (Transform)cmd.context;
+
+            if (!t.gameObject.GetComponent<AlignToWaves>())
+            {
+                AlignToWaves component = t.gameObject.AddComponent<AlignToWaves>();
+                EditorUtility.SetDirty(t);
+            }
+        }
+        
+        public static bool UnderwaterRenderingInstalled()
+        {
+            //Checking for UnderwaterRenderer.cs meta file
+            string path = AssetDatabase.GUIDToAssetPath("6a52edc7a3652d84784e10be859d5807");
+            return AssetDatabase.LoadMainAssetAtPath(path);
+        }
+        
+        public static bool DynamicEffectsInstalled()
+        {
+            //Checking for the WaterDynamicEffectsRenderFeature.cs meta file
+            string path = AssetDatabase.GUIDToAssetPath("48bd76fbc46e46fe9bc606bd3c30bd9b");
+            return AssetDatabase.LoadMainAssetAtPath(path);
+        }
+
+        public static void OpenGraphicsSettings()
+        {
+            SettingsService.OpenProjectSettings("Project/Graphics");
+        }
+        
+        public static void SelectForwardRenderer()
+        {
+			#if URP
+            if (!UniversalRenderPipeline.asset) return;
+
+            System.Reflection.BindingFlags bindings = System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance;
+            ScriptableRendererData[] m_rendererDataList = (ScriptableRendererData[])typeof(UniversalRenderPipelineAsset).GetField("m_RendererDataList", bindings).GetValue(UniversalRenderPipeline.asset);
+
+            ForwardRendererData main = m_rendererDataList[0] as ForwardRendererData;
+            Selection.activeObject = main;
+			#endif
+        }
+
+        public static void EnableDepthTexture()
+        {
+			#if URP
+            if (!UniversalRenderPipeline.asset) return;
+
+            UniversalRenderPipeline.asset.supportsCameraDepthTexture = true;
+            EditorUtility.SetDirty(UniversalRenderPipeline.asset);
+
+            if (PipelineUtilities.IsDepthTextureOptionDisabledAnywhere())
+            {
+                if (EditorUtility.DisplayDialog(AssetInfo.ASSET_NAME, "The Depth Texture option is still disabled on other pipeline assets (likely for other quality levels).\n\nWould you like to enable it on those as well?", "OK", "Cancel"))
+                {
+                    PipelineUtilities.SetDepthTextureOnAllAssets(true);   
+                }
+            }
+			#endif
+        }
+
+        public static void EnableOpaqueTexture()
+        {
+			#if URP
+            if (!UniversalRenderPipeline.asset) return;
+
+            UniversalRenderPipeline.asset.supportsCameraOpaqueTexture = true;
+            EditorUtility.SetDirty(UniversalRenderPipeline.asset);
+            
+            if (PipelineUtilities.IsOpaqueTextureOptionDisabledAnywhere())
+            {
+                if (EditorUtility.DisplayDialog(AssetInfo.ASSET_NAME, "The Opaque Texture option is still disabled on other pipeline assets (likely for other quality levels).\n\nWould you like to enable it on those as well?", "OK", "Cancel"))
+                {
+                    PipelineUtilities.SetOpaqueTextureOnAllAssets(true);   
+                }
+            }
+			#endif
+        }
+        
+        /// <summary>
+        /// Configures the assigned water material to render as double-sided, which is required for underwater rendering
+        /// </summary>
+        public static void DisableCullingForMaterial(Material material)
+        {
+            if (!material) return;
+            
+            material.SetInt("_Cull", (int)UnityEngine.Rendering.CullMode.Off);
+            
+            EditorUtility.SetDirty(material);
+        }
+        
+        public static bool CurvedWorldInstalled(out string libraryPath)
+        {
+            //Checking for "CurvedWorldTransform.cginc"
+            libraryPath = AssetDatabase.GUIDToAssetPath("208a98c9ab72b9f4bb8735c6a229e807");
+            return libraryPath != string.Empty;
+        }
+
+        #if NWH_DWP2
+        public static bool DWP2Installed => true;
+        #else
+        public static bool DWP2Installed => false;
+        #endif
+
+        public static T Find<T>() where T : Object
+        {
+            #if UNITY_2023_1_OR_NEWER
+            return (T)Object.FindFirstObjectByType(typeof(T));
+            #elif UNITY_2020_1_OR_NEWER
+            return (T)Object.FindObjectOfType(typeof(T), false);
+            #else
+            return (T)Object.FindObjectOfType(typeof(T));
+            #endif
+        }
+
+        public static void SetupForDWP2()
+        {
+            #if NWH_DWP2
+            if (!EditorUtility.DisplayDialog("Dynamic Water Physics 2 -> Stylized Water 2", 
+                "This operation will look for a \"Flat Water Data Provider\" component and replace it with the \"Stylized Water Data Provider\" component", 
+                "OK", "Cancel"))
+            {
+                return;
+            }
+            
+            NWH.DWP2.WaterData.StylizedWaterDataProvider dataProvider = Find<NWH.DWP2.WaterData.StylizedWaterDataProvider>();
+            NWH.DWP2.WaterData.FlatWaterDataProvider oldProvider = Find<NWH.DWP2.WaterData.FlatWaterDataProvider>();
+
+            if (dataProvider)
+            {
+                EditorUtility.DisplayDialog("Dynamic Water Physics 2 -> Stylized Water 2", "A \"Stylized Water Data Provider\" component was already found in the scene", "OK");
+
+                EditorGUIUtility.PingObject(dataProvider.gameObject);
+                
+                return;
+            }
+            
+            if(oldProvider == null)
+            {
+                if (EditorUtility.DisplayDialog("Dynamic Water Physics 2 -> Stylized Water 2", 
+                    "Could not find a \"Flat Water Data Provider\" component in the scene.\n\nIt's recommended to first set up DWP2 according to their manual.", 
+                    "OK"))
+                {
+                    return;
+                }
+            }
+            
+
+            NWH.DWP2.DefaultWater.Water waterScript = Find<NWH.DWP2.DefaultWater.Water>();
+            if(waterScript) DestroyImmediate(waterScript);
+            
+            if (oldProvider)
+            {
+                dataProvider = oldProvider.gameObject.AddComponent<NWH.DWP2.WaterData.StylizedWaterDataProvider>();
+                oldProvider.gameObject.AddComponent<StylizedWater2.WaterObject>();
+                
+                Selection.activeGameObject = oldProvider.gameObject;
+
+                DestroyImmediate(oldProvider);
+            }
+            #endif
+        }
+        
+    }
+}

LocalPackages/StylizedWater2/Editor/StylizedWaterEditor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 23fe47c78f2c84d4db3765a2a5466f68
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Editor/UI.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c3ec5d4ce2810a8428fc54db383a4386
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Editor/WaterMeshImporter.cs

@@ -0,0 +1,221 @@
+//Stylized Water 2
+//Staggart Creations (http://staggart.xyz)
+//Copyright protected under Unity Asset Store EULA
+
+#if UNITY_2020_2_OR_NEWER
+using UnityEditor.AssetImporters;
+#else
+using UnityEditor.Experimental.AssetImporters;
+#endif
+using System;
+using System.IO;
+using UnityEngine;
+using UnityEditor;
+using Object = UnityEngine.Object;
+
+namespace StylizedWater2
+{
+    [ScriptedImporter(3, FILE_EXTENSION)]
+    public class WaterMeshImporter : ScriptedImporter
+    {
+        private const string FILE_EXTENSION = "watermesh";
+        
+        [SerializeField] public WaterMesh waterMesh = new WaterMesh();
+
+        public override void OnImportAsset(AssetImportContext context)
+        {
+            waterMesh.Rebuild();
+
+            context.AddObjectToAsset("mesh", waterMesh.mesh);
+            context.SetMainObject(waterMesh.mesh);
+        }
+        
+        //Handles correct behaviour when double-clicking a .watermesh asset assigned to a field
+        //Otherwise the OS prompts to open it
+        [UnityEditor.Callbacks.OnOpenAsset]
+        public static bool OnOpenAsset(int instanceID, int line)
+        {
+            Object target = EditorUtility.InstanceIDToObject(instanceID);
+
+            if (target is Mesh)
+            {
+                var path = AssetDatabase.GetAssetPath(instanceID);
+                
+                if (Path.GetExtension(path) != "." + FILE_EXTENSION) return false;
+
+                Selection.activeObject = target;
+                return true;
+            }
+            
+            return false;
+        }
+
+    }
+	
+	[CustomEditor(typeof(WaterMeshImporter))]
+    public class WaterMeshImporterEditor: ScriptedImporterEditor
+    {
+        private SerializedProperty waterMesh;
+        
+        private SerializedProperty shape;
+        
+        private SerializedProperty scale;
+        private SerializedProperty UVTiling;
+        
+        private SerializedProperty vertexDistance;
+        
+        private SerializedProperty noise;
+        private SerializedProperty boundsPadding;
+        
+        private WaterMeshImporter importer;
+        
+		private bool autoApplyChanges;
+        private bool previewInSceneView
+        {
+            get => EditorPrefs.GetBool("SWS2_PREVIEW_WATER_MESH_ENABLED", true);
+            set => EditorPrefs.SetBool("SWS2_PREVIEW_WATER_MESH_ENABLED", value);
+        }
+
+        public override void OnEnable()
+        {
+			base.OnEnable();
+			
+            importer = (WaterMeshImporter)target;
+            
+            waterMesh = serializedObject.FindProperty("waterMesh");
+            
+            shape = waterMesh.FindPropertyRelative("shape");
+            scale = waterMesh.FindPropertyRelative("scale");
+            UVTiling = waterMesh.FindPropertyRelative("UVTiling");
+            vertexDistance = waterMesh.FindPropertyRelative("vertexDistance");
+            noise = waterMesh.FindPropertyRelative("noise");
+            boundsPadding = waterMesh.FindPropertyRelative("boundsPadding");
+
+            SceneView.duringSceneGui += OnSceneGUI;
+        }
+
+        public override void OnInspectorGUI()
+        {
+            UI.DrawHeader();
+            
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                GUILayout.Space(EditorGUIUtility.labelWidth);
+                previewInSceneView =
+                    GUILayout.Toggle(previewInSceneView, new GUIContent("  Preview in scene view", EditorGUIUtility.IconContent(
+                        (previewInSceneView ? "animationvisibilitytoggleon" : "animationvisibilitytoggleoff")).image), "Button");
+            }
+            if (previewInSceneView && WaterObject.Instances.Count > 0)
+            {
+                using (new EditorGUILayout.HorizontalScope())
+                {
+                    GUILayout.Space(EditorGUIUtility.labelWidth);
+                    EditorGUILayout.HelpBox($"Drawing on WaterObject instances in the scene ({WaterObject.Instances.Count})", MessageType.None);
+                }
+            }
+            
+            EditorGUILayout.Space();
+
+            serializedObject.Update();
+            EditorGUI.BeginChangeCheck();
+            
+            EditorGUILayout.PropertyField(shape);
+            
+            EditorGUILayout.Space();
+            
+            EditorGUILayout.PropertyField(scale);
+            EditorGUILayout.PropertyField(vertexDistance);
+            
+            int subdivisions = Mathf.FloorToInt(scale.floatValue / vertexDistance.floatValue);
+            int vertexCount = Mathf.FloorToInt(subdivisions * subdivisions);
+
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                GUILayout.Space(EditorGUIUtility.labelWidth);
+                
+                Rect rect = EditorGUILayout.GetControlRect();
+                EditorGUI.ProgressBar(rect, (float)vertexCount/65535f, $"Vertex count: {vertexCount:N1}/{65535f:N1}");
+            }
+            if(vertexCount > 65535)
+            {
+                EditorGUILayout.HelpBox("Vertex count (" + vertexCount + ") is too high. Decrease the scale, or increase the vertex distance.", MessageType.Error);
+            }
+            
+            EditorGUILayout.Space();
+
+            EditorGUILayout.PropertyField(UVTiling);
+            EditorGUILayout.PropertyField(noise);
+            EditorGUILayout.PropertyField(boundsPadding);
+            
+            EditorGUILayout.Space();
+
+            autoApplyChanges = EditorGUILayout.Toggle("Auto-apply changes", autoApplyChanges);
+            
+            if (EditorGUI.EndChangeCheck())
+            {
+                serializedObject.ApplyModifiedProperties();
+                
+                if (autoApplyChanges && HasModified())
+                {
+                    #if UNITY_2022_2_OR_NEWER
+                    this.SaveChanges();
+                    #else
+                    this.ApplyAndImport();
+                    #endif
+                    
+                    importer = (WaterMeshImporter)target;
+                }
+            }
+            
+            this.ApplyRevertGUI();
+            
+            UI.DrawFooter();
+        }
+        
+        private void OnDestroy()
+        {
+            SceneView.duringSceneGui -= OnSceneGUI;
+        }
+
+        private Material mat;
+        private void OnSceneGUI(SceneView obj)
+        {
+            if (!previewInSceneView)
+            {
+                GL.wireframe = false;
+                return;
+            }
+
+            if (!mat)
+            {
+                mat = new Material(Shader.Find("Unlit/Color"));
+                mat.color = new Color(0,0,0, 0.25f);
+                mat.mainTexture = Texture2D.whiteTexture;
+            }
+            mat.SetPass(0);
+            
+            if (importer.waterMesh.mesh)
+            {
+                GL.wireframe = true;
+                if (WaterObject.Instances.Count > 0)
+                {
+                    foreach (WaterObject waterObject in WaterObject.Instances)
+                    {
+                        Graphics.DrawMeshNow(importer.waterMesh.mesh, waterObject.transform.localToWorldMatrix);
+                    }
+                }
+                else
+                {
+                    if (SceneView.lastActiveSceneView)
+                    {
+                        //Position in view
+                        Vector3 position = SceneView.lastActiveSceneView.camera.transform.position + (SceneView.lastActiveSceneView.camera.transform.forward * importer.waterMesh.scale * 0.5f);
+
+                        Graphics.DrawMeshNow(importer.waterMesh.mesh, position, Quaternion.identity);
+                    }
+                }
+                GL.wireframe = false;
+            }
+        }
+    }
+}

LocalPackages/StylizedWater2/Editor/WaterMeshImporter.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5b8903faabaa4d64bbf306b8787d2d67
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Editor/WaterShaderImporter.cs

@@ -0,0 +1,317 @@
+//Stylized Water 2
+//Staggart Creations (http://staggart.xyz)
+//Copyright protected under Unity Asset Store EULA
+
+#if UNITY_2020_2_OR_NEWER
+using UnityEditor.AssetImporters;
+#else
+using UnityEditor.Experimental.AssetImporters;
+#endif
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using UnityEditor;
+using UnityEditorInternal;
+using UnityEngine;
+using Debug = UnityEngine.Debug;
+using Object = UnityEngine.Object;
+
+namespace StylizedWater2
+{
+    [ScriptedImporterAttribute(AssetInfo.SHADER_GENERATOR_VERSION_MAJOR + AssetInfo.SHADER_GENERATOR_MINOR + AssetInfo.SHADER_GENERATOR_PATCH, TARGET_FILE_EXTENSION, 2)]
+    public class WaterShaderImporter : ScriptedImporter
+    {
+        private const string TARGET_FILE_EXTENSION = "watershader";
+        private const string ICON_NAME = "water-shader-icon";
+        
+        [Tooltip("Rather than storing the template in this file, it can be sourced from an external text file" +
+                 "\nUse this if you intent to duplicate this asset, and need only minor modifications to its import settings")]
+        [SerializeField] public LazyLoadReference<Object> template;
+            
+        [Space]
+        
+        public WaterShaderSettings settings;
+
+        /// <summary>
+        /// File paths of any file this shader depends on. This list will be populated with any "#include" paths present in the template
+        /// Registering these as dependencies is required to trigger the shader to recompile when these files are changed
+        /// </summary>
+        //[NonSerialized] //Want to keep these serialized. Will differ per-project, which also causes the file to appear as changed for every project when updating the asset (this triggers a re-import)
+        public List<string> dependencies = new List<string>();
+
+        private bool HasExternalTemplate()
+        {
+            #if UNITY_2020_1_OR_NEWER
+            return template.isSet;
+            #else
+            return template.asset;
+            #endif
+        }
+        
+        public string GetTemplatePath()
+        {
+            return HasExternalTemplate() ? AssetDatabase.GetAssetPath(template.asset) : assetPath;
+        }
+
+        private void OnValidate()
+        {
+            if(settings.shaderName == string.Empty) settings.shaderName = $"{Application.productName} ({DateTime.Now.Ticks})";
+        }
+
+        public override void OnImportAsset(AssetImportContext context)
+        {
+            Shader shader = AssetDatabase.LoadAssetAtPath<Shader>(context.assetPath);
+            //if (shader != null) ShaderUtil.ClearShaderMessages(shader);
+            
+            string templatePath = GetTemplatePath();
+
+            if (templatePath == string.Empty)
+            {
+                Debug.LogError("Failed to import water shader, template file path is null. It possibly hasn't been imported first?", shader);
+                return;
+            }
+            
+            #if SWS_DEV
+            Stopwatch sw = new Stopwatch();
+            sw.Start();
+            #endif
+            
+            string[] lines = File.ReadAllLines(templatePath);
+
+            if (lines.Length == 0)
+            {
+                Debug.LogError("Failed to generated water shader. Template or file content is empty (or wasn't yet imported)...");
+                return;
+            }
+
+            dependencies.Clear();
+            
+            string templateContents = ShaderConfigurator.TemplateParser.CreateShaderCode(context.assetPath, ref lines, this, false);
+            
+            Shader shaderAsset = ShaderUtil.CreateShaderAsset(templateContents, true);
+            ShaderUtil.RegisterShader(shaderAsset);
+            
+            Texture2D thumbnail = Resources.Load<Texture2D>(ICON_NAME);
+            if(!thumbnail) thumbnail = EditorGUIUtility.IconContent("ShaderImporter Icon").image as Texture2D;
+            
+            context.AddObjectToAsset("MainAsset", shaderAsset, thumbnail);
+            context.SetMainObject(shaderAsset);
+            
+            //Do not attempt to create a tessellation variant for the underwater post-effect shaders
+            if (settings.type == WaterShaderSettings.ShaderType.WaterSurface)
+            {
+                //Re-read the original template again
+                lines = File.ReadAllLines(templatePath);
+                templateContents = ShaderConfigurator.TemplateParser.CreateShaderCode(context.assetPath, ref lines, this, true);
+
+                Shader tessellation = ShaderUtil.CreateShaderAsset(templateContents, true);
+                //ShaderUtil.RegisterShader(tessellation);
+                
+                context.AddObjectToAsset("Tessellation", (Object)tessellation, thumbnail);
+            }
+            
+            //Set up dependency, so that changes to the template triggers shaders to regenerate
+            if (HasExternalTemplate() && AssetDatabase.TryGetGUIDAndLocalFileIdentifier(template, out var guid, out long _))
+            {
+                //Note: this strictly only works when adding the file path!
+                //context.DependsOnArtifact(guid);
+                
+                dependencies.Insert(0, AssetDatabase.GUIDToAssetPath(guid));
+            }
+
+            //Dependencies are populated during the template parsing phase.
+            foreach (string dependency in dependencies)
+            {
+                context.DependsOnSourceAsset(dependency);
+            }
+            
+            #if SWS_DEV
+            sw.Stop();
+            //Debug.Log($"Imported \"{Path.GetFileNameWithoutExtension(assetPath)}\" water shader in {sw.Elapsed.Milliseconds}ms. With {dependencies.Count} dependencies.", shader);
+            #endif
+        }
+
+        public void ClearCache(bool recompile = false)
+        {
+            var objs = AssetDatabase.LoadAllAssetsAtPath(assetPath);
+            
+            foreach (var obj in objs)
+            {
+                if (obj is Shader)
+                {
+                    ShaderUtil.ClearShaderMessages((Shader)obj);
+                    ShaderUtil.ClearCachedData((Shader)obj);
+                    
+                    if(recompile) AssetDatabase.ImportAsset(assetPath);
+                    
+                    #if SWS_DEV
+                    Debug.Log($"Cleared cache for {obj.name}");
+                    #endif
+                }
+            }
+        }
+        public void RegisterDependency(string dependencyAssetPath)
+        {
+            if (dependencyAssetPath.StartsWith("Packages/") == false)
+            {
+                string guid = AssetDatabase.AssetPathToGUID(dependencyAssetPath);
+
+                if (guid == string.Empty)
+                {
+                    //Also throws an error for things like '#include_library "SurfaceModifiers/SurfaceModifiers.hlsl"', which are wrapped in an #ifdef. That's a false positive
+                    //Debug.LogException(new Exception($"Tried to import \"{this.assetPath}\" with an missing dependency, supposedly at path: {dependencyAssetPath}."));
+                    return;
+                }
+            }
+
+            //Tessellation variant pass may run, causing the same dependencies to be registered twice, hence check first
+            if(dependencies.Contains(dependencyAssetPath) == false) dependencies.Add(dependencyAssetPath);
+        }
+        
+        //Handles correct behaviour when double-clicking a .watershader asset. Should open in the IDE
+        [UnityEditor.Callbacks.OnOpenAsset]
+        public static bool OnOpenAsset(int instanceID, int line)
+        {
+            Object target = EditorUtility.InstanceIDToObject(instanceID);
+
+            if (target is Shader)
+            {
+                var path = AssetDatabase.GetAssetPath(instanceID);
+                
+                if (Path.GetExtension(path) != "." + TARGET_FILE_EXTENSION) return false;
+
+                string externalScriptEditor = ScriptEditorUtility.GetExternalScriptEditor();
+                if (externalScriptEditor != "internal")
+                {
+                    InternalEditorUtility.OpenFileAtLineExternal(path, 0);
+                }
+                else
+                {
+                    Application.OpenURL("file://" + path);
+                }
+                
+                return true;
+            }
+            
+            return false;
+        }
+
+        [Serializable]
+        public class Directive
+        {
+            public enum Type
+            {
+                [InspectorName("(no prefix)")]
+                custom,
+                [InspectorName("#include")]
+                include,
+                [InspectorName("#pragma")]
+                pragma,
+                [InspectorName("#define")]
+                define
+            }
+            public bool enabled = true;
+            public Type type;
+            public string value;
+
+            public Directive(Type _type, string _value)
+            {
+                this.type = _type;
+                this.value = _value;
+            }
+        }
+        
+        class WaterShaderAssetPostProcessor : AssetPostprocessor
+        {
+            static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
+            {
+                RegisterShaders(importedAssets);
+            }
+
+            //Register imported water shaders, so they work with Shader.Find() and show up in the shader selection menu
+            private static void RegisterShaders(string[] paths)
+            {
+                foreach (var path in paths)
+                {
+                    if (!path.EndsWith(WaterShaderImporter.TARGET_FILE_EXTENSION, StringComparison.InvariantCultureIgnoreCase))
+                        continue;
+
+                    var mainObj = AssetDatabase.LoadMainAssetAtPath(path);
+                    if (mainObj is Shader)
+                    {
+                        if (mainObj.name == string.Empty) return;
+                        
+                        //ShaderUtil.RegisterShader((Shader)mainObj);
+                        
+                        #if SWS_DEV
+                        //Debug.Log($"Registered water shader \"{mainObj.name}\" on import", mainObj);
+                        #endif
+
+                        return;
+                    }
+                }
+            }
+        }
+
+        public static string[] FindAllAssets()
+        {
+            DirectoryInfo directoryInfo = new DirectoryInfo(Application.dataPath);
+            
+            FileInfo[] fileInfos = directoryInfo.GetFiles("*." + TARGET_FILE_EXTENSION, SearchOption.AllDirectories);
+            
+            #if SWS_DEV
+            Debug.Log($"{fileInfos.Length} .{TARGET_FILE_EXTENSION} assets found");
+            #endif
+
+            string[] filePaths = new string[fileInfos.Length];
+
+            for (int i = 0; i < filePaths.Length; i++)
+            {
+                filePaths[i] = fileInfos[i].FullName.Replace(@"\", "/").Replace(Application.dataPath, "Assets");
+            }
+
+            return filePaths;
+        }
+        
+        #if SWS_DEV
+        [MenuItem("SWS/Reimport water shaders")]
+        #endif
+        public static void ReimportAll()
+        {
+            string[] filePaths = FindAllAssets();
+            foreach (var filePath in filePaths)
+            {
+                #if SWS_DEV
+                Debug.Log($"Reimporting: {filePath}");
+                #endif
+                AssetDatabase.ImportAsset(filePath);
+            }
+        }
+
+        [Serializable]
+        public class WaterShaderSettings
+        {
+            [Tooltip("How it will appear in the selection menu")]
+            public string shaderName;
+            [Tooltip("Hide the shader in the selection menu. Yet still make it findable with Shader.Find()")]
+            public bool hidden;
+            public enum ShaderType
+            {
+                WaterSurface,
+                PostProcessing
+            }
+            public ShaderType type;
+            
+            [Tooltip("Before compiling the shader, check whichever asset is present in the project and activate its integration")]
+            public bool autoIntegration = true;
+            public ShaderConfigurator.Fog.Assets fogIntegration = ShaderConfigurator.Fog.Assets.UnityFog;
+
+            [Tooltip("Add support for native light cookies. Disabled by default to allow for cookies to act as caustics projectors that ignore the water surface")]
+            public bool lightCookies = false;
+            
+            public List<Directive> customIncludeDirectives = new List<Directive>();
+        }
+    }
+}

LocalPackages/StylizedWater2/Editor/WaterShaderImporter.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 531a3ff0802e4acbaef16e2b9d97fd66
+timeCreated: 1678979614

LocalPackages/StylizedWater2/Editor/sc.stylizedwater2.editor.asmdef

@@ -0,0 +1,45 @@
+{
+    "name": "sc.stylizedwater2.editor",
+    "rootNamespace": "",
+    "references": [
+        "GUID:93226a8cd37f67d4a996a525146f6f09",
+        "GUID:15fc0a57446b3144c949da3e2b9737a9",
+        "GUID:df380645f10b7bc4b97d4f5eb6303d95",
+        "GUID:3eae0364be2026648bf74846acb8a731",
+        "GUID:e40ba710768534012815d3193fa296cb",
+        "GUID:f9fe0089ec81f4079af78eb2287a6163",
+        "GUID:75ecb28acc33857438e533566abcb3be"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [
+        {
+            "name": "com.unity.xr.management",
+            "expression": "3.2.10",
+            "define": "XR"
+        },
+        {
+            "name": "com.unity.render-pipelines.universal",
+            "expression": "10.3.2",
+            "define": "URP"
+        },
+        {
+            "name": "com.unity.visualeffectgraph",
+            "expression": "10.3.2",
+            "define": "VFX_GRAPH"
+        },
+        {
+            "name": "com.unity.splines",
+            "expression": "2.0.0",
+            "define": "SPLINES"
+        }
+    ],
+    "noEngineReferences": false
+}

LocalPackages/StylizedWater2/Editor/sc.stylizedwater2.editor.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: b0d7a190570d98a42893c25d592fe760
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Materials.meta

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

LocalPackages/StylizedWater2/Materials/Effects.meta

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

LocalPackages/StylizedWater2/Materials/Effects/SplashParticle.mat

@@ -0,0 +1,121 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &-3807344491832048406
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 9
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: SplashParticle
+  m_Shader: {fileID: 4800000, guid: 8516d7a69675844a7a0b7095af7c46af, type: 3}
+  m_ValidKeywords:
+  - _ALPHATEST_ON
+  - _NORMALMAP
+  - _SURFACE_TYPE_TRANSPARENT
+  m_InvalidKeywords:
+  - _FLIPBOOKBLENDING_OFF
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 3000
+  stringTagMap:
+    RenderType: Transparent
+  disabledShaderPasses:
+  - SHADOWCASTER
+  - DepthOnly
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseMap:
+        m_Texture: {fileID: 2800000, guid: d148cb788e2a65248a11186344e26334, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 2800000, guid: c75a2b6518a6b804389f10ae86232a9b, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _AlphaClip: 1
+    - _AlphaToMask: 0
+    - _Blend: 0
+    - _BlendOp: 0
+    - _BumpScale: 1
+    - _CameraFadingEnabled: 0
+    - _CameraFarFadeDistance: 2
+    - _CameraNearFadeDistance: 1
+    - _ColorMode: 0
+    - _Cull: 2
+    - _Cutoff: 0.5
+    - _DistortionBlend: 0
+    - _DistortionEnabled: 0
+    - _DistortionStrength: 1
+    - _DistortionStrengthScaled: 0.1
+    - _DstBlend: 10
+    - _DstBlendAlpha: 10
+    - _EnvironmentReflections: 1
+    - _FlipbookBlending: 0
+    - _FlipbookMode: 0
+    - _GlossMapScale: 0
+    - _Glossiness: 0
+    - _GlossyReflections: 0
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _QueueOffset: 0
+    - _ReceiveShadows: 1
+    - _Smoothness: 0.5
+    - _SmoothnessSource: 0
+    - _SmoothnessTextureChannel: 0
+    - _SoftParticlesEnabled: 0
+    - _SoftParticlesFarFadeDistance: 1
+    - _SoftParticlesNearFadeDistance: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 5
+    - _SrcBlendAlpha: 1
+    - _Surface: 1
+    - _WorkflowMode: 1
+    - _ZWrite: 0
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColorAddSubDiff: {r: 1, g: 0, b: 0, a: 0}
+    - _CameraFadeParams: {r: 0, g: Infinity, b: 0, a: 0}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _SoftParticleFadeParams: {r: 0, g: 0, b: 0, a: 0}
+    - _SpecColor: {r: 0.19999996, g: 0.19999996, b: 0.19999996, a: 1}
+  m_BuildTextureStacks: []

LocalPackages/StylizedWater2/Materials/Effects/SplashParticle.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 36b83f0b942f0634187136771c93c7b8
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Materials/Effects/SplashParticle_Up.mat

@@ -0,0 +1,125 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &-3807344491832048406
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 9
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: SplashParticle_Up
+  m_Shader: {fileID: 4800000, guid: 8516d7a69675844a7a0b7095af7c46af, type: 3}
+  m_ValidKeywords:
+  - _ALPHATEST_ON
+  - _NORMALMAP
+  - _RECEIVE_SHADOWS_OFF
+  - _SURFACE_TYPE_TRANSPARENT
+  m_InvalidKeywords:
+  - _FLIPBOOKBLENDING_OFF
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 3000
+  stringTagMap:
+    RenderType: Transparent
+  disabledShaderPasses:
+  - SHADOWCASTER
+  - DepthOnly
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseMap:
+        m_Texture: {fileID: 2800000, guid: b25bdd89afb6d1e42a291d08a2a51b43, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 2800000, guid: cf59cfe0d17ff9d41ad4a68623e95d16, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: b25bdd89afb6d1e42a291d08a2a51b43, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _AlphaClip: 1
+    - _AlphaToMask: 0
+    - _Blend: 0
+    - _BlendOp: 0
+    - _BumpScale: 1
+    - _CameraFadingEnabled: 0
+    - _CameraFarFadeDistance: 2
+    - _CameraNearFadeDistance: 1
+    - _ColorMode: 0
+    - _Cull: 2
+    - _Cutoff: 0.5
+    - _DistortionBlend: 0.92
+    - _DistortionEnabled: 0
+    - _DistortionStrength: 1
+    - _DistortionStrengthScaled: 0.1
+    - _DstBlend: 10
+    - _DstBlendAlpha: 10
+    - _EnvironmentReflections: 1
+    - _FlipbookBlending: 0
+    - _FlipbookMode: 0
+    - _GlossMapScale: 0
+    - _Glossiness: 0
+    - _GlossinessSource: 0
+    - _GlossyReflections: 0
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _QueueOffset: 0
+    - _ReceiveShadows: 0
+    - _Shininess: 0
+    - _Smoothness: 0.5
+    - _SmoothnessSource: 0
+    - _SmoothnessTextureChannel: 0
+    - _SoftParticlesEnabled: 0
+    - _SoftParticlesFarFadeDistance: 1
+    - _SoftParticlesNearFadeDistance: 0
+    - _SpecSource: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 5
+    - _SrcBlendAlpha: 1
+    - _Surface: 1
+    - _WorkflowMode: 1
+    - _ZWrite: 0
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColorAddSubDiff: {r: 1, g: 0, b: 0, a: 0}
+    - _CameraFadeParams: {r: 0, g: Infinity, b: 0, a: 0}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _SoftParticleFadeParams: {r: 0, g: 0, b: 0, a: 0}
+    - _SpecColor: {r: 0.19999996, g: 0.19999996, b: 0.19999996, a: 1}
+  m_BuildTextureStacks: []

LocalPackages/StylizedWater2/Materials/Effects/SplashParticle_Up.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 850f3ddaf22381d4188a875811f0cf42
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Materials/Effects/Textures.meta

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

LocalPackages/StylizedWater2/Materials/Effects/Textures/CrestSplash_AlbedoAlpha.png.meta

@@ -0,0 +1,147 @@
+fileFormatVersion: 2
+guid: fdf3b141001fcc4409bab4a5885c4bc6
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 1
+    alphaTestReferenceValue: 0.1
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMasterTextureLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 0
+    wrapV: 0
+    wrapW: 0
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  cookieLightType: 1
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Server
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Materials/Effects/Textures/CrestSplash_Normals.png.meta

@@ -0,0 +1,135 @@
+fileFormatVersion: 2
+guid: 613a9115f0d3ba147be1bab79fb09436
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMasterTextureLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 0
+    wrapV: 0
+    wrapW: 0
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 1
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  cookieLightType: 1
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Server
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Materials/Effects/Textures/WaterMist_5x5.png.meta

@@ -0,0 +1,140 @@
+fileFormatVersion: 2
+guid: c49e969dfb39ed24b865b5ea73ea901b
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: -1
+    mipBias: -100
+    wrapU: 0
+    wrapV: 0
+    wrapW: 0
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 1024
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 1024
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Nintendo Switch
+    maxTextureSize: 1024
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Android
+    maxTextureSize: 1024
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Windows Store Apps
+    maxTextureSize: 1024
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Materials/Effects/Textures/WaterMist_5x5_normals.png.meta

@@ -0,0 +1,92 @@
+fileFormatVersion: 2
+guid: 44f9dbe54fbc12d47b885d677aec1c42
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -100
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 1
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Materials/Effects/Textures/WaterRipple.png.meta

@@ -0,0 +1,116 @@
+fileFormatVersion: 2
+guid: 12a8a0e9cb1136a4e8896157fee235c5
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: -1
+    mipBias: -100
+    wrapU: 0
+    wrapV: 0
+    wrapW: 0
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 1024
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 1024
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Nintendo Switch
+    maxTextureSize: 1024
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Materials/Effects/Textures/WaterRipple_normal.png.meta

@@ -0,0 +1,92 @@
+fileFormatVersion: 2
+guid: b235492afd682b14fa330a36bf8539af
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -100
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 1
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Materials/Effects/Textures/WaterSplashCircle_5x5.png.meta

@@ -0,0 +1,128 @@
+fileFormatVersion: 2
+guid: 7a216b9dc9c30094c8447fd44417e6cb
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: -1
+    mipBias: -100
+    wrapU: 0
+    wrapV: 0
+    wrapW: 0
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 1024
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 1024
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Nintendo Switch
+    maxTextureSize: 1024
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Android
+    maxTextureSize: 1024
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Materials/Effects/Textures/WaterSplashCircle_5x5_normals.png.meta

@@ -0,0 +1,92 @@
+fileFormatVersion: 2
+guid: 89ca8e9e9df9e3746a6d9e7339fc5cf9
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -100
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 1
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Materials/Effects/Textures/WaterSplashUp_6x6.png.meta

@@ -0,0 +1,128 @@
+fileFormatVersion: 2
+guid: b25bdd89afb6d1e42a291d08a2a51b43
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: -1
+    mipBias: -100
+    wrapU: 0
+    wrapV: 0
+    wrapW: 0
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Nintendo Switch
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Materials/Effects/Textures/WaterSplashUp_6x6_normals.png.meta

@@ -0,0 +1,128 @@
+fileFormatVersion: 2
+guid: cf59cfe0d17ff9d41ad4a68623e95d16
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -100
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 1
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Nintendo Switch
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Materials/Effects/Textures/WaterSplash_6x6.png.meta

@@ -0,0 +1,140 @@
+fileFormatVersion: 2
+guid: d148cb788e2a65248a11186344e26334
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: -1
+    mipBias: -100
+    wrapU: 0
+    wrapV: 0
+    wrapW: 0
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Nintendo Switch
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Windows Store Apps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Materials/Effects/Textures/WaterSplash_6x6_normals.png.meta

@@ -0,0 +1,140 @@
+fileFormatVersion: 2
+guid: c75a2b6518a6b804389f10ae86232a9b
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -100
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 1
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Nintendo Switch
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Windows Store Apps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Materials/Effects/Textures/WaterfallSplash_5x5.png.meta

@@ -0,0 +1,140 @@
+fileFormatVersion: 2
+guid: 1ec39eae9e109aa4d8c70c77ca06ffa8
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: -1
+    mipBias: -100
+    wrapU: 0
+    wrapV: 0
+    wrapW: 0
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 1024
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 1024
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Nintendo Switch
+    maxTextureSize: 1024
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Windows Store Apps
+    maxTextureSize: 1024
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Android
+    maxTextureSize: 1024
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Materials/Effects/Textures/WaterfallSplash_5x5_normals.png.meta

@@ -0,0 +1,92 @@
+fileFormatVersion: 2
+guid: 26a40374c0f319448be12fc2d9d06595
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -100
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 1
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Materials/Effects/WaterCircle.mat

@@ -0,0 +1,125 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &-3807344491832048406
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 9
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: WaterCircle
+  m_Shader: {fileID: 4800000, guid: 8516d7a69675844a7a0b7095af7c46af, type: 3}
+  m_ValidKeywords:
+  - _ALPHATEST_ON
+  - _NORMALMAP
+  - _RECEIVE_SHADOWS_OFF
+  - _SURFACE_TYPE_TRANSPARENT
+  m_InvalidKeywords:
+  - _FLIPBOOKBLENDING_OFF
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 1
+  m_CustomRenderQueue: 3000
+  stringTagMap:
+    RenderType: Transparent
+  disabledShaderPasses:
+  - SHADOWCASTER
+  - DepthOnly
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseMap:
+        m_Texture: {fileID: 2800000, guid: 7a216b9dc9c30094c8447fd44417e6cb, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 2800000, guid: 89ca8e9e9df9e3746a6d9e7339fc5cf9, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: 7a216b9dc9c30094c8447fd44417e6cb, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _AlphaClip: 1
+    - _AlphaToMask: 0
+    - _Blend: 0
+    - _BlendOp: 0
+    - _BumpScale: 1
+    - _CameraFadingEnabled: 0
+    - _CameraFarFadeDistance: 2
+    - _CameraNearFadeDistance: 1
+    - _ColorMode: 0
+    - _Cull: 0
+    - _Cutoff: 0.5
+    - _DistortionBlend: 0.5
+    - _DistortionEnabled: 0
+    - _DistortionStrength: 1
+    - _DistortionStrengthScaled: 0.1
+    - _DstBlend: 10
+    - _DstBlendAlpha: 10
+    - _EnvironmentReflections: 1
+    - _FlipbookBlending: 0
+    - _FlipbookMode: 0
+    - _GlossMapScale: 0
+    - _Glossiness: 0
+    - _GlossinessSource: 0
+    - _GlossyReflections: 0
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _QueueOffset: 0
+    - _ReceiveShadows: 0
+    - _Shininess: 0
+    - _Smoothness: 0.5
+    - _SmoothnessSource: 0
+    - _SmoothnessTextureChannel: 0
+    - _SoftParticlesEnabled: 0
+    - _SoftParticlesFarFadeDistance: 1
+    - _SoftParticlesNearFadeDistance: 0
+    - _SpecSource: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 5
+    - _SrcBlendAlpha: 1
+    - _Surface: 1
+    - _WorkflowMode: 1
+    - _ZWrite: 0
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColorAddSubDiff: {r: 1, g: 0, b: 0, a: 0}
+    - _CameraFadeParams: {r: 0, g: Infinity, b: 0, a: 0}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _SoftParticleFadeParams: {r: 0, g: 0, b: 0, a: 0}
+    - _SpecColor: {r: 0.19999996, g: 0.19999996, b: 0.19999996, a: 1}
+  m_BuildTextureStacks: []

LocalPackages/StylizedWater2/Materials/Effects/WaterCircle.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e1496308c2bd85a4a857bc219fe9cc7e
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Materials/Effects/WaterMistParticle.mat

@@ -0,0 +1,125 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &-3807344491832048406
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 9
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: WaterMistParticle
+  m_Shader: {fileID: 4800000, guid: 8516d7a69675844a7a0b7095af7c46af, type: 3}
+  m_ValidKeywords:
+  - _FADING_ON
+  - _NORMALMAP
+  - _SOFTPARTICLES_ON
+  - _SURFACE_TYPE_TRANSPARENT
+  m_InvalidKeywords:
+  - _FLIPBOOKBLENDING_OFF
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 3000
+  stringTagMap:
+    RenderType: Transparent
+  disabledShaderPasses:
+  - SHADOWCASTER
+  - DepthOnly
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseMap:
+        m_Texture: {fileID: 2800000, guid: c49e969dfb39ed24b865b5ea73ea901b, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 2800000, guid: 44f9dbe54fbc12d47b885d677aec1c42, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: 7a216b9dc9c30094c8447fd44417e6cb, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _AlphaClip: 0
+    - _AlphaToMask: 0
+    - _Blend: 0
+    - _BlendOp: 0
+    - _BumpScale: 1
+    - _CameraFadingEnabled: 0
+    - _CameraFarFadeDistance: 2
+    - _CameraNearFadeDistance: 1
+    - _ColorMode: 0
+    - _Cull: 2
+    - _Cutoff: 0.476
+    - _DistortionBlend: 1
+    - _DistortionEnabled: 0
+    - _DistortionStrength: 1
+    - _DistortionStrengthScaled: 0.1
+    - _DstBlend: 10
+    - _DstBlendAlpha: 10
+    - _EnvironmentReflections: 1
+    - _FlipbookBlending: 0
+    - _FlipbookMode: 0
+    - _GlossMapScale: 0
+    - _Glossiness: 0
+    - _GlossinessSource: 0
+    - _GlossyReflections: 0
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _QueueOffset: 0
+    - _ReceiveShadows: 1
+    - _Shininess: 0
+    - _Smoothness: 0
+    - _SmoothnessSource: 0
+    - _SmoothnessTextureChannel: 0
+    - _SoftParticlesEnabled: 1
+    - _SoftParticlesFarFadeDistance: 0.8
+    - _SoftParticlesNearFadeDistance: 0
+    - _SpecSource: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 5
+    - _SrcBlendAlpha: 1
+    - _Surface: 1
+    - _WorkflowMode: 1
+    - _ZWrite: 0
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColorAddSubDiff: {r: 1, g: 0, b: 0, a: 0}
+    - _CameraFadeParams: {r: 0, g: Infinity, b: 0, a: 0}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _SoftParticleFadeParams: {r: 0, g: 1.25, b: 0, a: 0}
+    - _SpecColor: {r: 0.199999, g: 0.199999, b: 0.199999, a: 0.737}
+  m_BuildTextureStacks: []

LocalPackages/StylizedWater2/Materials/Effects/WaterMistParticle.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 0a53b1cf91a82c342acb93348cbdf42f
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Materials/Effects/WaterRipple.mat

@@ -0,0 +1,126 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &-3807344491832048406
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 9
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: WaterRipple
+  m_Shader: {fileID: 4800000, guid: 8516d7a69675844a7a0b7095af7c46af, type: 3}
+  m_ValidKeywords:
+  - _ALPHATEST_ON
+  - _COLORADDSUBDIFF_ON
+  - _NORMALMAP
+  - _RECEIVE_SHADOWS_OFF
+  - _SURFACE_TYPE_TRANSPARENT
+  m_InvalidKeywords:
+  - _FLIPBOOKBLENDING_OFF
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 3000
+  stringTagMap:
+    RenderType: Transparent
+  disabledShaderPasses:
+  - SHADOWCASTER
+  - DepthOnly
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseMap:
+        m_Texture: {fileID: 2800000, guid: 12a8a0e9cb1136a4e8896157fee235c5, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 2800000, guid: b235492afd682b14fa330a36bf8539af, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: 96ee4b9247c627147a2a3efb7a7e2d81, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _AlphaClip: 1
+    - _AlphaToMask: 0
+    - _Blend: 0
+    - _BlendOp: 0
+    - _BumpScale: 1
+    - _CameraFadingEnabled: 0
+    - _CameraFarFadeDistance: 2
+    - _CameraNearFadeDistance: 1
+    - _ColorMode: 1
+    - _Cull: 2
+    - _Cutoff: 0.5
+    - _DistortionBlend: 0.5
+    - _DistortionEnabled: 0
+    - _DistortionStrength: 1
+    - _DistortionStrengthScaled: 0.1
+    - _DstBlend: 10
+    - _DstBlendAlpha: 10
+    - _EnvironmentReflections: 1
+    - _FlipbookBlending: 0
+    - _FlipbookMode: 0
+    - _GlossMapScale: 0
+    - _Glossiness: 0
+    - _GlossinessSource: 0
+    - _GlossyReflections: 0
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _QueueOffset: 0
+    - _ReceiveShadows: 0
+    - _Shininess: 0
+    - _Smoothness: 0.5
+    - _SmoothnessSource: 0
+    - _SmoothnessTextureChannel: 0
+    - _SoftParticlesEnabled: 0
+    - _SoftParticlesFarFadeDistance: 1
+    - _SoftParticlesNearFadeDistance: 0
+    - _SpecSource: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 5
+    - _SrcBlendAlpha: 1
+    - _Surface: 1
+    - _WorkflowMode: 1
+    - _ZWrite: 0
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColorAddSubDiff: {r: 1, g: 0, b: 0, a: 0}
+    - _CameraFadeParams: {r: 0, g: Infinity, b: 0, a: 0}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _SoftParticleFadeParams: {r: 0, g: 0, b: 0, a: 0}
+    - _SpecColor: {r: 0.19999996, g: 0.19999996, b: 0.19999996, a: 1}
+  m_BuildTextureStacks: []

LocalPackages/StylizedWater2/Materials/Effects/WaterRipple.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: a247ea74a33eb6546a6b9602f5150c35
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Materials/Effects/WaterfallSplashParticle.mat

@@ -0,0 +1,125 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &-3807344491832048406
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 9
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: WaterfallSplashParticle
+  m_Shader: {fileID: 4800000, guid: 8516d7a69675844a7a0b7095af7c46af, type: 3}
+  m_ValidKeywords:
+  - _FADING_ON
+  - _NORMALMAP
+  - _SOFTPARTICLES_ON
+  - _SURFACE_TYPE_TRANSPARENT
+  m_InvalidKeywords:
+  - _FLIPBOOKBLENDING_OFF
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 3000
+  stringTagMap:
+    RenderType: Transparent
+  disabledShaderPasses:
+  - SHADOWCASTER
+  - DepthOnly
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseMap:
+        m_Texture: {fileID: 2800000, guid: 1ec39eae9e109aa4d8c70c77ca06ffa8, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 2800000, guid: 26a40374c0f319448be12fc2d9d06595, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: 7a216b9dc9c30094c8447fd44417e6cb, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _AlphaClip: 0
+    - _AlphaToMask: 0
+    - _Blend: 0
+    - _BlendOp: 0
+    - _BumpScale: 1
+    - _CameraFadingEnabled: 0
+    - _CameraFarFadeDistance: 2
+    - _CameraNearFadeDistance: 1
+    - _ColorMode: 0
+    - _Cull: 2
+    - _Cutoff: 0.572
+    - _DistortionBlend: 1
+    - _DistortionEnabled: 0
+    - _DistortionStrength: 1
+    - _DistortionStrengthScaled: 0.1
+    - _DstBlend: 10
+    - _DstBlendAlpha: 10
+    - _EnvironmentReflections: 1
+    - _FlipbookBlending: 0
+    - _FlipbookMode: 0
+    - _GlossMapScale: 0
+    - _Glossiness: 0
+    - _GlossinessSource: 0
+    - _GlossyReflections: 0
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _QueueOffset: 0
+    - _ReceiveShadows: 1
+    - _Shininess: 0
+    - _Smoothness: 0
+    - _SmoothnessSource: 0
+    - _SmoothnessTextureChannel: 0
+    - _SoftParticlesEnabled: 1
+    - _SoftParticlesFarFadeDistance: 0.8
+    - _SoftParticlesNearFadeDistance: 0
+    - _SpecSource: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 5
+    - _SrcBlendAlpha: 1
+    - _Surface: 1
+    - _WorkflowMode: 1
+    - _ZWrite: 0
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColorAddSubDiff: {r: 1, g: 0, b: 0, a: 0}
+    - _CameraFadeParams: {r: 0, g: Infinity, b: 0, a: 0}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _SoftParticleFadeParams: {r: 0, g: 1.25, b: 0, a: 0}
+    - _SpecColor: {r: 0.199999, g: 0.199999, b: 0.199999, a: 0.737}
+  m_BuildTextureStacks: []

LocalPackages/StylizedWater2/Materials/Effects/WaterfallSplashParticle.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c6b2ebf8de66bc344847a82469612dd8
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Materials/Effects/WaveCrestSplash.mat

@@ -0,0 +1,122 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &-3807344491832048406
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 9
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: WaveCrestSplash
+  m_Shader: {fileID: 4800000, guid: 8516d7a69675844a7a0b7095af7c46af, type: 3}
+  m_ValidKeywords:
+  - _ALPHATEST_ON
+  - _NORMALMAP
+  - _RECEIVE_SHADOWS_OFF
+  - _SURFACE_TYPE_TRANSPARENT
+  m_InvalidKeywords:
+  - _FLIPBOOKBLENDING_OFF
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 3000
+  stringTagMap:
+    RenderType: Transparent
+  disabledShaderPasses:
+  - SHADOWCASTER
+  - DepthOnly
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseMap:
+        m_Texture: {fileID: 2800000, guid: fdf3b141001fcc4409bab4a5885c4bc6, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 2800000, guid: 613a9115f0d3ba147be1bab79fb09436, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _AlphaClip: 1
+    - _AlphaToMask: 0
+    - _Blend: 0
+    - _BlendOp: 0
+    - _BumpScale: 1
+    - _CameraFadingEnabled: 0
+    - _CameraFarFadeDistance: 2
+    - _CameraNearFadeDistance: 1
+    - _ColorMode: 0
+    - _Cull: 2
+    - _Cutoff: 0.5
+    - _DistortionBlend: 0
+    - _DistortionEnabled: 0
+    - _DistortionStrength: 1
+    - _DistortionStrengthScaled: 0.1
+    - _DstBlend: 10
+    - _DstBlendAlpha: 10
+    - _EnvironmentReflections: 1
+    - _FlipbookBlending: 0
+    - _FlipbookMode: 0
+    - _GlossMapScale: 0
+    - _Glossiness: 0
+    - _GlossyReflections: 0
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _QueueOffset: 0
+    - _ReceiveShadows: 0
+    - _Smoothness: 0.5
+    - _SmoothnessSource: 0
+    - _SmoothnessTextureChannel: 0
+    - _SoftParticlesEnabled: 0
+    - _SoftParticlesFarFadeDistance: 1
+    - _SoftParticlesNearFadeDistance: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 5
+    - _SrcBlendAlpha: 1
+    - _Surface: 1
+    - _WorkflowMode: 1
+    - _ZWrite: 0
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColorAddSubDiff: {r: 1, g: 0, b: 0, a: 0}
+    - _CameraFadeParams: {r: 0, g: Infinity, b: 0, a: 0}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _SoftParticleFadeParams: {r: 0, g: 0, b: 0, a: 0}
+    - _SpecColor: {r: 0.19999996, g: 0.19999996, b: 0.19999996, a: 1}
+  m_BuildTextureStacks: []

LocalPackages/StylizedWater2/Materials/Effects/WaveCrestSplash.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9037e6ba95d968b4985f5ab7f403b0e6
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Materials/StylizedWater2_Clear.mat

@@ -0,0 +1,313 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: StylizedWater2_Clear
+  m_Shader: {fileID: -6465566751694194690, guid: d7b0192b9bf19c949900035fa781fdc4,
+    type: 3}
+  m_ValidKeywords:
+  - _ADVANCED_SHADING
+  - _CAUSTICS
+  - _NORMALMAP
+  - _REFRACTION
+  m_InvalidKeywords:
+  - ADVANCED_LIGHTING
+  - _DEPTHEXP_ON
+  - _DEPTH_TEX
+  - _SIMPLE_LIGHTING
+  - _VERTEXCOLORWAVEFLATTENING_ON
+  - _WORLDSPACEUV_ON
+  - _ZCLIP_ON
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 1
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 2800000, guid: ec6f0adef15b52448a82f3f183525d84, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMapLarge:
+        m_Texture: {fileID: 2800000, guid: ec6f0adef15b52448a82f3f183525d84, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMapSlope:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CausticsTex:
+        m_Texture: {fileID: 2800000, guid: 36b7496f7c0078b49a44468d3e120e62, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DepthTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _FoamTex:
+        m_Texture: {fileID: 2800000, guid: 6a4aa5aa1ed7b9e4e9204a95f56f4d29, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _FoamTexDynamic:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IntersectionNoise:
+        m_Texture: {fileID: 2800000, guid: b8850342fb8b1e846ac3807e35ec1685, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Normals:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _PlanarReflection:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _PlanarReflectionLeft:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Shadermap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _texcoord:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_Lightmaps:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_LightmapsInd:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_ShadowMasks:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - Vector1_1942CF3A: 1
+    - Vector1_BE75C478: 32
+    - Vector1_E23F9E57: 0.5
+    - Vector1_E796673B: 10
+    - _ADVANCED_LIGHTING: 1
+    - _AdvancedLighting: 0
+    - _Advanced_Lighting: 1
+    - _AlphaClip: 0
+    - _AlphaCutoff: 0.5
+    - _AnimationSpeed: 1
+    - _Blend: 0
+    - _BumpScale: 1
+    - _CROSSPAN_INTERSECTIONOn: 0
+    - _CausticsBrightness: 1
+    - _CausticsDistortion: 0.053
+    - _CausticsOn: 1
+    - _CausticsSpeed: 0.15
+    - _CausticsTiling: 0.14
+    - _ColorAbsorption: 0
+    - _CrossPan_IntersectionOn: 1
+    - _Cull: 2
+    - _Cutoff: 0.5
+    - _Depth: 0.84
+    - _DepthExp: 1
+    - _DepthHorizontal: 0.01
+    - _DepthMode: 0
+    - _DepthTexture: 1
+    - _DepthVertical: 5.82
+    - _DisableDepthTexture: 0
+    - _DistanceNormalsOn: 0
+    - _DistanceNormalsTiling: 0.25
+    - _DstBlend: 0
+    - _EdgeFade: 16.4
+    - _EnvironmentReflections: 1
+    - _EnvironmentReflectionsOn: 1
+    - _FlatShadingOn: 0
+    - _FlowSpeed: 1
+    - _FoamBaseAmount: 0.424
+    - _FoamClipping: 0
+    - _FoamDistortion: 0.1
+    - _FoamOn: 0
+    - _FoamOpacity: 0.081
+    - _FoamSize: 0.46
+    - _FoamSpeed: 0.1
+    - _FoamSpeedDynamic: 0.1
+    - _FoamSubSpeed: -0.25
+    - _FoamSubSpeedDynamic: -0.1
+    - _FoamSubTiling: 0.5
+    - _FoamSubTilingDynamic: 2
+    - _FoamTiling: 0.2
+    - _FoamTilingDynamic: 0.1
+    - _FoamWaveAmount: 0
+    - _FoamWaveMask: 0
+    - _FoamWaveMaskExp: 1
+    - _GlossMapScale: 0
+    - _Glossiness: 0
+    - _GlossyReflections: 0
+    - _HorizonDistance: 8
+    - _IntersectionClipping: 0.833
+    - _IntersectionFalloff: 0.408
+    - _IntersectionLength: 1.96
+    - _IntersectionRippleDist: 32
+    - _IntersectionRippleStrength: 0.151
+    - _IntersectionSize: 0.944
+    - _IntersectionSource: 0
+    - _IntersectionSpeed: 0.1
+    - _IntersectionStyle: 0
+    - _IntersectionTiling: 0.21000001
+    - _IntersectionWaveDist: 19.94
+    - _LightingOn: 1
+    - _Metallic: 0
+    - _Metallicness: 0.1
+    - _NORMALMAPOn: 1
+    - _NormalMap: 1
+    - _NormalMapOn: 1
+    - _NormalSpeed: 0.2
+    - _NormalStrength: 0.223
+    - _NormalSubSpeed: -0.5
+    - _NormalSubTiling: 0.5
+    - _NormalTiling: 0.39999992
+    - _OcclusionStrength: 1
+    - _PlanarReflectionsEnabled: 0
+    - _PlanarReflectionsParams: 0
+    - _PointSpotLightReflectionDistortion: 0.5
+    - _PointSpotLightReflectionExp: 64
+    - _PointSpotLightReflectionSize: 0
+    - _PointSpotLightReflectionStrength: 10
+    - _QueueOffset: 0
+    - _ReceiveShadows: 1
+    - _ReflectionBlur: 0.054
+    - _ReflectionDistortion: 0.133
+    - _ReflectionFresnel: 4
+    - _ReflectionFresnelMode: 0
+    - _ReflectionLighting: 0
+    - _ReflectionStrength: 1
+    - _Reflectivity: 1
+    - _RefractionAmount: 0.05
+    - _RefractionChromaticAberration: 1
+    - _RefractionOn: 1
+    - _RefractionStrength: 0.228
+    - _RimRize: 1
+    - _RimTiling: 0.025
+    - _RiverModeOn: 0
+    - _ShadingMode: 1
+    - _ShadowStrength: 1
+    - _ShoreLineLength: 2.4
+    - _ShoreLineWaveDistance: 30
+    - _ShoreLineWaveStr: 1
+    - _SimpleLighting: 1
+    - _SlopeAngleFalloff: 25
+    - _SlopeAngleThreshold: 15
+    - _SlopeFoam: 1
+    - _SlopeSpeed: 4
+    - _SlopeStretch: 0.5
+    - _SlopeStretching: 0.5
+    - _SlopeThreshold: 0.25
+    - _Smoothness: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SparkleIntensity: 0
+    - _SparkleSize: 0.236
+    - _SpecularHighlights: 1
+    - _SpecularReflectionsOn: 1
+    - _Speed: 1
+    - _SrcBlend: 1
+    - _SunReflectionDistortion: 0.9
+    - _SunReflectionPerturbance: 0.707
+    - _SunReflectionSize: 0.914
+    - _SunReflectionStrength: 5
+    - _Surface: 0
+    - _TEXTURE_INTERSECTIONOn: 1
+    - _Texture_IntersectionOn: 0
+    - _Tiling: 0.5
+    - _Translucency: 0
+    - _TranslucencyCurvatureMask: 0
+    - _TranslucencyExp: 4
+    - _TranslucencyOn: 0
+    - _TranslucencyReflectionMask: 0
+    - _TranslucencyStrength: 1
+    - _TranslucencyStrengthDirect: 0.05
+    - _UnderwaterRefractionOffset: 0.2
+    - _UnderwaterSurfaceSmoothness: 0.8
+    - _VertexColorDepth: 0
+    - _VertexColorFoam: 0
+    - _VertexColorWaveFlattening: 1
+    - _WaveCount: 4
+    - _WaveDistance: 0.879
+    - _WaveHeight: 0
+    - _WaveNormalStr: 0.032
+    - _WaveSpeed: 3
+    - _WaveSteepness: 0
+    - _WaveTint: 0
+    - _WavesOn: 0
+    - _WorkflowMode: 1
+    - _WorldSpaceUV: 1
+    - _ZClip: 1
+    - _ZWrite: 0
+    m_Colors:
+    - _BaseColor: {r: 0, g: 0.16451614, b: 0.34, a: 0.9843137}
+    - _Color: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+    - _DepthMapBounds: {r: -402.3, g: -459.43, b: 0.0012693577, a: 0}
+    - _Direction: {r: 1, g: 1, b: 0, a: 0}
+    - _DistanceNormalsFadeDist: {r: 0, g: 300, b: 0, a: 0}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _FoamColor: {r: 1, g: 1, b: 1, a: 1}
+    - _FoamTiling: {r: 0.1, g: 0.1, b: 0, a: 0}
+    - _HorizonColor: {r: 0.68, g: 1, b: 0.99, a: 0.15}
+    - _IntersectionColor: {r: 1, g: 1, b: 1, a: 1}
+    - _NormalTiling: {r: 0.3, g: 0.3, b: 0, a: 0}
+    - _RimColor: {r: 1, g: 1, b: 1, a: 1}
+    - _ShallowColor: {r: 0, g: 1, b: 0.98136926, a: 0}
+    - _SpecColor: {r: 0.2, g: 0.2, b: 0.2, a: 1}
+    - _WaterColor: {r: 0.21176466, g: 0.6745098, b: 1, a: 1}
+    - _WaterShallowColor: {r: 0, g: 0.9394503, b: 1, a: 1}
+    - _WaveDirection: {r: 1, g: 1, b: 1, a: 1}
+    - _WaveFadeDistance: {r: 150, g: 300, b: 0, a: 0}
+  m_BuildTextureStacks: []
+--- !u!114 &6498140463000427223
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 1

LocalPackages/StylizedWater2/Materials/StylizedWater2_Clear.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 43b3db0cf9471a247b8feae47691828e
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Materials/StylizedWater2_Desktop.mat

@@ -0,0 +1,318 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: StylizedWater2_Desktop
+  m_Shader: {fileID: -6465566751694194690, guid: d7b0192b9bf19c949900035fa781fdc4,
+    type: 3}
+  m_ValidKeywords:
+  - _ADVANCED_SHADING
+  - _CAUSTICS
+  - _DISTANCE_NORMALS
+  - _FOAM
+  - _NORMALMAP
+  - _REFRACTION
+  - _SHARP_INERSECTION
+  - _TRANSLUCENCY
+  - _WAVES
+  m_InvalidKeywords:
+  - ADVANCED_LIGHTING
+  - _DEPTHEXP_ON
+  - _DEPTH_TEX
+  - _SIMPLE_LIGHTING
+  - _VERTEXCOLORWAVEFLATTENING_ON
+  - _WORLDSPACEUV_ON
+  - _ZCLIP_ON
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 1
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 2800000, guid: ec6f0adef15b52448a82f3f183525d84, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMapLarge:
+        m_Texture: {fileID: 2800000, guid: 88908a7c7a1f0ed418d1048378c17411, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMapSlope:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CausticsTex:
+        m_Texture: {fileID: 2800000, guid: 36b7496f7c0078b49a44468d3e120e62, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DepthTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _FoamTex:
+        m_Texture: {fileID: 2800000, guid: 6a4aa5aa1ed7b9e4e9204a95f56f4d29, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _FoamTexDynamic:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IntersectionNoise:
+        m_Texture: {fileID: 2800000, guid: b8850342fb8b1e846ac3807e35ec1685, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Normals:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _PlanarReflection:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _PlanarReflectionLeft:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Shadermap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _texcoord:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_Lightmaps:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_LightmapsInd:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_ShadowMasks:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - Vector1_1942CF3A: 1
+    - Vector1_BE75C478: 32
+    - Vector1_E23F9E57: 0.5
+    - Vector1_E796673B: 10
+    - _ADVANCED_LIGHTING: 1
+    - _AdvancedLighting: 1
+    - _Advanced_Lighting: 1
+    - _AlphaClip: 0
+    - _AlphaCutoff: 0.5
+    - _AnimationSpeed: 1
+    - _Blend: 0
+    - _BumpScale: 1
+    - _CROSSPAN_INTERSECTIONOn: 1
+    - _CausticsBrightness: 2
+    - _CausticsDistortion: 0.047
+    - _CausticsOn: 1
+    - _CausticsSpeed: 0.1
+    - _CausticsTiling: 0.1
+    - _ColorAbsorption: 0
+    - _CrossPan_IntersectionOn: 0
+    - _Cull: 0
+    - _Cutoff: 0.5
+    - _Depth: 0.94
+    - _DepthExp: 1
+    - _DepthHorizontal: 1
+    - _DepthMode: 0
+    - _DepthTexture: 1
+    - _DepthVertical: 8
+    - _DisableDepthTexture: 0
+    - _DistanceNormalsOn: 1
+    - _DistanceNormalsTiling: 0.25
+    - _DstBlend: 0
+    - _EdgeFade: 18.7
+    - _EnvironmentReflections: 1
+    - _EnvironmentReflectionsOn: 1
+    - _FlatShadingOn: 0
+    - _FlowSpeed: 1
+    - _FoamBaseAmount: 0.297
+    - _FoamClipping: 0
+    - _FoamDistortion: 0
+    - _FoamOn: 1
+    - _FoamOpacity: 0
+    - _FoamSize: 0.606
+    - _FoamSpeed: 0.06000001
+    - _FoamSpeedDynamic: 0.1
+    - _FoamSubSpeed: -0.25
+    - _FoamSubSpeedDynamic: -0.1
+    - _FoamSubTiling: 0.5
+    - _FoamSubTilingDynamic: 2
+    - _FoamTiling: 0.09999993
+    - _FoamTilingDynamic: 0.1
+    - _FoamWaveAmount: 0
+    - _FoamWaveMask: 0
+    - _FoamWaveMaskExp: 1
+    - _GlossMapScale: 0
+    - _Glossiness: 0
+    - _GlossyReflections: 0
+    - _HorizonDistance: 8
+    - _IntersectionClipping: 0.395
+    - _IntersectionFalloff: 1
+    - _IntersectionLength: 2.27
+    - _IntersectionRippleDist: 16
+    - _IntersectionRippleStrength: 0.125
+    - _IntersectionSize: 0.944
+    - _IntersectionSource: 0
+    - _IntersectionSpeed: 0.06999999
+    - _IntersectionStyle: 1
+    - _IntersectionTiling: 0.13999975
+    - _IntersectionWaveDist: 33.28
+    - _LightingMode: 2
+    - _LightingOn: 1
+    - _Metallic: 0
+    - _Metallicness: 0.1
+    - _NORMALMAPOn: 1
+    - _NormalMap: 1
+    - _NormalMapOn: 1
+    - _NormalSpeed: 0.2
+    - _NormalStrength: 0.202
+    - _NormalSubSpeed: -0.5
+    - _NormalSubTiling: 0.5
+    - _NormalTiling: -0.48000008
+    - _OcclusionStrength: 1
+    - _PlanarReflectionsEnabled: 0
+    - _PlanarReflectionsParams: 0
+    - _PointSpotLightReflectionDistortion: 0.5
+    - _PointSpotLightReflectionExp: 64
+    - _PointSpotLightReflectionSize: 0
+    - _PointSpotLightReflectionStrength: 10
+    - _QueueOffset: 0
+    - _ReceiveShadows: 1
+    - _ReflectionBlur: 0
+    - _ReflectionDistortion: 0.146
+    - _ReflectionFresnel: 6
+    - _ReflectionLighting: 1
+    - _ReflectionStrength: 1
+    - _Reflectivity: 1
+    - _RefractionAmount: 0.05
+    - _RefractionChromaticAberration: 1
+    - _RefractionOn: 1
+    - _RefractionStrength: 0.105
+    - _RimRize: 1
+    - _RimTiling: 0.025
+    - _RiverModeOn: 0
+    - _SHARP_INERSECTIONOn: 1
+    - _ShadingMode: 1
+    - _ShadowStrength: 1
+    - _ShoreLineLength: 0
+    - _ShoreLineWaveDistance: 23
+    - _ShoreLineWaveStr: 1
+    - _SimpleLighting: 1
+    - _SlopeAngleFalloff: 25
+    - _SlopeAngleThreshold: 15
+    - _SlopeFoam: 1
+    - _SlopeSpeed: 4
+    - _SlopeStretching: 0.5
+    - _SlopeThreshold: 0.25
+    - _Smoothness: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SparkleIntensity: 0
+    - _SparkleSize: 0.302
+    - _SpecularHighlights: 1
+    - _SpecularReflectionsOn: 1
+    - _Speed: 1
+    - _SrcBlend: 1
+    - _SunReflectionDistortion: 0.762
+    - _SunReflectionPerturbance: 0.386
+    - _SunReflectionSize: 0.932
+    - _SunReflectionStrength: 10
+    - _Surface: 0
+    - _TEXTURE_INTERSECTIONOn: 0
+    - _Texture_IntersectionOn: 1
+    - _Tiling: 0.5
+    - _Translucency: 1
+    - _TranslucencyCurvatureMask: 0
+    - _TranslucencyExp: 4
+    - _TranslucencyOn: 1
+    - _TranslucencyReflectionMask: 0
+    - _TranslucencyStrength: 1
+    - _TranslucencyStrengthDirect: 0.05
+    - _UnderwaterRefractionOffset: 0.2
+    - _UnderwaterSurfaceSmoothness: 0.8
+    - _VertexColorDepth: 0
+    - _VertexColorFoam: 0
+    - _VertexColorWaveFlattening: 1
+    - _WaveCount: 2
+    - _WaveDistance: 0.775
+    - _WaveHeight: 0.1
+    - _WaveNormalStr: 0.1
+    - _WaveSpeed: 2.3999996
+    - _WaveSteepness: 0
+    - _WaveTint: 0
+    - _WavesOn: 1
+    - _WorkflowMode: 1
+    - _WorldSpaceUV: 1
+    - _ZClip: 1
+    - _ZWrite: 0
+    m_Colors:
+    - _BaseColor: {r: 0, g: 0.16451614, b: 0.34, a: 0.9647059}
+    - _Color: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+    - _DepthMapBounds: {r: -402.3, g: -459.43, b: 0.0012693577, a: 0}
+    - _Direction: {r: 1, g: 1, b: 0, a: 0}
+    - _DistanceNormalsFadeDist: {r: 0, g: 80, b: 0, a: 0}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _FoamColor: {r: 1, g: 1, b: 1, a: 0.92941177}
+    - _FoamTiling: {r: 0.1, g: 0.1, b: 0, a: 0}
+    - _HorizonColor: {r: 0.68, g: 1, b: 0.99, a: 0.15}
+    - _IntersectionColor: {r: 1, g: 1, b: 1, a: 1}
+    - _NormalTiling: {r: 0.5, g: 0.5, b: 0, a: 0}
+    - _RimColor: {r: 1, g: 1, b: 1, a: 1}
+    - _ShallowColor: {r: 0, g: 1, b: 0.98136926, a: 0.3764706}
+    - _SpecColor: {r: 0.2, g: 0.2, b: 0.2, a: 1}
+    - _WaterColor: {r: 0.21176466, g: 0.6745098, b: 1, a: 1}
+    - _WaterShallowColor: {r: 0, g: 0.9394503, b: 1, a: 1}
+    - _WaveDirection: {r: -1, g: -1, b: -1, a: -1}
+    - _WaveFadeDistance: {r: 26.666674, g: 143.33331, b: 0, a: 0}
+  m_BuildTextureStacks: []
+--- !u!114 &6498140463000427223
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 1

LocalPackages/StylizedWater2/Materials/StylizedWater2_Desktop.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: fbb04271505a76f40b984e38071e86f3
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Materials/StylizedWater2_Frozen.mat

@@ -0,0 +1,314 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: StylizedWater2_Frozen
+  m_Shader: {fileID: -6465566751694194690, guid: d7b0192b9bf19c949900035fa781fdc4,
+    type: 3}
+  m_ValidKeywords:
+  - _DISTANCE_NORMALS
+  - _FOAM
+  - _NORMALMAP
+  - _REFRACTION
+  - _TRANSLUCENCY
+  m_InvalidKeywords:
+  - ADVANCED_LIGHTING
+  - _DEPTHEXP_ON
+  - _DEPTH_TEX
+  - _SIMPLE_LIGHTING
+  - _VERTEXCOLORWAVEFLATTENING_ON
+  - _WORLDSPACEUV_ON
+  - _ZCLIP_ON
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 2800000, guid: 88908a7c7a1f0ed418d1048378c17411, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMapLarge:
+        m_Texture: {fileID: 2800000, guid: 88908a7c7a1f0ed418d1048378c17411, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMapSlope:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CausticsTex:
+        m_Texture: {fileID: 2800000, guid: 36b7496f7c0078b49a44468d3e120e62, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DepthTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _FoamTex:
+        m_Texture: {fileID: 2800000, guid: e91f048fea6b6b94eb864b2124843ce9, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _FoamTexDynamic:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IntersectionNoise:
+        m_Texture: {fileID: 2800000, guid: b8850342fb8b1e846ac3807e35ec1685, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Normals:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _PlanarReflection:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _PlanarReflectionLeft:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Shadermap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _texcoord:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_Lightmaps:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_LightmapsInd:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_ShadowMasks:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - Vector1_1942CF3A: 1
+    - Vector1_BE75C478: 32
+    - Vector1_E23F9E57: 0.5
+    - Vector1_E796673B: 10
+    - _ADVANCED_LIGHTING: 1
+    - _AdvancedLighting: 1
+    - _Advanced_Lighting: 1
+    - _AlphaClip: 0
+    - _AlphaCutoff: 0.5
+    - _AnimationSpeed: 1
+    - _Blend: 0
+    - _BumpScale: 1
+    - _CROSSPAN_INTERSECTIONOn: 1
+    - _CausticsBrightness: 2
+    - _CausticsDistortion: 0.047
+    - _CausticsOn: 0
+    - _CausticsSpeed: 0.1
+    - _CausticsTiling: 0.1
+    - _ColorAbsorption: 0.06
+    - _CrossPan_IntersectionOn: 0
+    - _Cull: 0
+    - _Cutoff: 0.5
+    - _Depth: 0.94
+    - _DepthExp: 1
+    - _DepthHorizontal: 8
+    - _DepthMode: 0
+    - _DepthTexture: 1
+    - _DepthVertical: 16
+    - _DisableDepthTexture: 0
+    - _DistanceNormalsOn: 1
+    - _DistanceNormalsTiling: 0.15
+    - _DstBlend: 0
+    - _EdgeFade: 1
+    - _EnvironmentReflections: 1
+    - _EnvironmentReflectionsOn: 1
+    - _FlatShadingOn: 0
+    - _FlowSpeed: 1
+    - _FoamBaseAmount: 0.747
+    - _FoamClipping: 0.373
+    - _FoamDistortion: 3
+    - _FoamOn: 1
+    - _FoamOpacity: 0
+    - _FoamSize: 0.606
+    - _FoamSpeed: 0
+    - _FoamSpeedDynamic: 0.1
+    - _FoamSubSpeed: 0
+    - _FoamSubSpeedDynamic: -0.1
+    - _FoamSubTiling: 0.1
+    - _FoamSubTilingDynamic: 2
+    - _FoamTiling: 0.09999993
+    - _FoamTilingDynamic: 0.1
+    - _FoamWaveAmount: 0
+    - _FoamWaveMask: 0
+    - _FoamWaveMaskExp: 1
+    - _GlossMapScale: 0
+    - _Glossiness: 0
+    - _GlossyReflections: 0
+    - _HorizonDistance: 8
+    - _IntersectionClipping: 0.395
+    - _IntersectionFalloff: 1
+    - _IntersectionLength: 2.27
+    - _IntersectionRippleDist: 16
+    - _IntersectionRippleStrength: 0.125
+    - _IntersectionSize: 0.944
+    - _IntersectionSource: 0
+    - _IntersectionSpeed: 0.06999999
+    - _IntersectionStyle: 0
+    - _IntersectionTiling: 0.13999975
+    - _IntersectionWaveDist: 33.28
+    - _LightingMode: 2
+    - _LightingOn: 1
+    - _Metallic: 0
+    - _Metallicness: 0.1
+    - _NORMALMAPOn: 1
+    - _NormalMap: 1
+    - _NormalMapOn: 1
+    - _NormalSpeed: 0
+    - _NormalStrength: 0.163
+    - _NormalSubSpeed: 0
+    - _NormalSubTiling: 0.1
+    - _NormalTiling: 0.4800001
+    - _OcclusionStrength: 1
+    - _PlanarReflectionsEnabled: 0
+    - _PlanarReflectionsParams: 0
+    - _PointSpotLightReflectionDistortion: 0.868
+    - _PointSpotLightReflectionExp: 64
+    - _PointSpotLightReflectionSize: 0.962
+    - _PointSpotLightReflectionStrength: 1
+    - _QueueOffset: 0
+    - _ReceiveShadows: 1
+    - _ReflectionBlur: 0.139
+    - _ReflectionDistortion: 0.374
+    - _ReflectionFresnel: 6
+    - _ReflectionLighting: 0
+    - _ReflectionStrength: 0.831
+    - _Reflectivity: 1
+    - _RefractionAmount: 0.05
+    - _RefractionChromaticAberration: 1
+    - _RefractionOn: 1
+    - _RefractionStrength: 0.269
+    - _RimRize: 1
+    - _RimTiling: 0.025
+    - _RiverModeOn: 0
+    - _SHARP_INERSECTIONOn: 1
+    - _ShadingMode: 0
+    - _ShadowStrength: 0.819
+    - _ShoreLineLength: 0
+    - _ShoreLineWaveDistance: 23
+    - _ShoreLineWaveStr: 1
+    - _SimpleLighting: 1
+    - _SlopeAngleFalloff: 25
+    - _SlopeAngleThreshold: 15
+    - _SlopeFoam: 1
+    - _SlopeSpeed: 4
+    - _SlopeStretching: 0.5
+    - _SlopeThreshold: 0.25
+    - _Smoothness: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SparkleIntensity: 0
+    - _SparkleSize: 0.302
+    - _SpecularHighlights: 1
+    - _SpecularReflectionsOn: 1
+    - _Speed: 1
+    - _SrcBlend: 1
+    - _SunReflectionDistortion: 0.35
+    - _SunReflectionPerturbance: 0.386
+    - _SunReflectionSize: 1
+    - _SunReflectionStrength: 1
+    - _Surface: 0
+    - _TEXTURE_INTERSECTIONOn: 0
+    - _Texture_IntersectionOn: 1
+    - _Tiling: 0.5
+    - _Translucency: 1
+    - _TranslucencyCurvatureMask: 0
+    - _TranslucencyExp: 8
+    - _TranslucencyOn: 1
+    - _TranslucencyReflectionMask: 0
+    - _TranslucencyStrength: 1
+    - _TranslucencyStrengthDirect: 0.05
+    - _UnderwaterRefractionOffset: 0.2
+    - _UnderwaterSurfaceSmoothness: 0.8
+    - _VertexColorDepth: 0
+    - _VertexColorFoam: 0
+    - _VertexColorWaveFlattening: 1
+    - _WaveCount: 2
+    - _WaveDistance: 0.775
+    - _WaveHeight: 0.1
+    - _WaveNormalStr: 0.1
+    - _WaveSpeed: 2.3999996
+    - _WaveSteepness: 0
+    - _WaveTint: 0
+    - _WavesOn: 0
+    - _WorkflowMode: 1
+    - _WorldSpaceUV: 1
+    - _ZClip: 1
+    - _ZWrite: 0
+    m_Colors:
+    - _BaseColor: {r: 0.09450587, g: 0.29184228, b: 0.34117648, a: 0.9372549}
+    - _Color: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+    - _DepthMapBounds: {r: -402.3, g: -459.43, b: 0.0012693577, a: 0}
+    - _Direction: {r: 1, g: 1, b: 0, a: 0}
+    - _DistanceNormalsFadeDist: {r: 0, g: 49.387802, b: 0, a: 0}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _FoamColor: {r: 1, g: 1, b: 1, a: 0.12156863}
+    - _FoamTiling: {r: 0.1, g: 0.1, b: 0, a: 0}
+    - _HorizonColor: {r: 0.68, g: 1, b: 0.99, a: 0.1764706}
+    - _IntersectionColor: {r: 1, g: 1, b: 1, a: 1}
+    - _NormalTiling: {r: 0.1, g: 0.1, b: 0, a: 0}
+    - _RimColor: {r: 1, g: 1, b: 1, a: 1}
+    - _ShallowColor: {r: 0.07227186, g: 0.2831488, b: 0.34191445, a: 0}
+    - _SpecColor: {r: 0.2, g: 0.2, b: 0.2, a: 1}
+    - _WaterColor: {r: 0.21176466, g: 0.6745098, b: 1, a: 1}
+    - _WaterShallowColor: {r: 0, g: 0.9394503, b: 1, a: 1}
+    - _WaveDirection: {r: -1, g: -1, b: -1, a: -1}
+    - _WaveFadeDistance: {r: 26.666674, g: 143.33331, b: 0, a: 0}
+  m_BuildTextureStacks: []
+--- !u!114 &6498140463000427223
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 1

LocalPackages/StylizedWater2/Materials/StylizedWater2_Frozen.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 595d2aa3b53d78644a010ea17c45d43f
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Materials/StylizedWater2_Lava.mat

@@ -0,0 +1,316 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: StylizedWater2_Lava
+  m_Shader: {fileID: -6465566751694194690, guid: d7b0192b9bf19c949900035fa781fdc4,
+    type: 3}
+  m_ValidKeywords:
+  - _ADVANCED_SHADING
+  - _ENVIRONMENTREFLECTIONS_OFF
+  - _FOAM
+  - _NORMALMAP
+  - _RECEIVE_SHADOWS_OFF
+  - _SMOOTH_INTERSECTION
+  - _SPECULARHIGHLIGHTS_OFF
+  - _UNLIT
+  m_InvalidKeywords:
+  - ADVANCED_LIGHTING
+  - _DEPTHEXP_ON
+  - _DEPTH_TEX
+  - _SIMPLE_LIGHTING
+  - _WORLDSPACEUV_ON
+  - _ZCLIP_ON
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 1
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 2800000, guid: ec6f0adef15b52448a82f3f183525d84, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMapLarge:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMapSlope:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CausticsTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DepthTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _FoamTex:
+        m_Texture: {fileID: 2800000, guid: e91f048fea6b6b94eb864b2124843ce9, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _FoamTexDynamic:
+        m_Texture: {fileID: 2800000, guid: e91f048fea6b6b94eb864b2124843ce9, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IntersectionNoise:
+        m_Texture: {fileID: 2800000, guid: 0ff9da63433ff044ba94d59ff31bbe11, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Normals:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _PlanarReflection:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _PlanarReflectionLeft:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Shadermap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _texcoord:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_Lightmaps:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_LightmapsInd:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_ShadowMasks:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - Vector1_1942CF3A: 1
+    - Vector1_BE75C478: 32
+    - Vector1_E23F9E57: 0.5
+    - Vector1_E796673B: 10
+    - _ADVANCED_LIGHTING: 1
+    - _AdvancedLighting: 1
+    - _Advanced_Lighting: 1
+    - _AlphaClip: 0
+    - _AlphaCutoff: 0.5
+    - _AnimationSpeed: 1
+    - _Blend: 0
+    - _BumpScale: 1
+    - _CROSSPAN_INTERSECTIONOn: 1
+    - _CausticsBrightness: 2
+    - _CausticsDistortion: 0.047
+    - _CausticsOn: 0
+    - _CausticsSpeed: 0.1
+    - _CausticsTiling: 0.5
+    - _ColorAbsorption: 0
+    - _CrossPan_IntersectionOn: 0
+    - _Cull: 2
+    - _Cutoff: 0.5
+    - _Depth: 1
+    - _DepthExp: 1
+    - _DepthHorizontal: 8
+    - _DepthMode: 0
+    - _DepthTexture: 1
+    - _DepthVertical: 16
+    - _DisableDepthTexture: 0
+    - _DistanceNormalsOn: 0
+    - _DistanceNormalsTiling: 0.25
+    - _DstBlend: 0
+    - _EdgeFade: 18.7
+    - _EnvironmentReflections: 1
+    - _EnvironmentReflectionsOn: 0
+    - _FlatShadingOn: 0
+    - _FlowSpeed: 1
+    - _FoamBaseAmount: 1
+    - _FoamClipping: 0.421
+    - _FoamDistortion: 0.25
+    - _FoamOn: 1
+    - _FoamOpacity: 0.326
+    - _FoamSize: 0.01
+    - _FoamSpeed: 0.002
+    - _FoamSpeedDynamic: 0.1
+    - _FoamSubSpeed: -0.25
+    - _FoamSubSpeedDynamic: -0.1
+    - _FoamSubTiling: 0.5
+    - _FoamSubTilingDynamic: 2
+    - _FoamTiling: 0.09999993
+    - _FoamTilingDynamic: 0.1
+    - _FoamWaveAmount: 0
+    - _FoamWaveMask: 0
+    - _FoamWaveMaskExp: 1
+    - _GlossMapScale: 0
+    - _Glossiness: 0
+    - _GlossyReflections: 0
+    - _HorizonDistance: 8
+    - _IntersectionClipping: 0.132
+    - _IntersectionFalloff: 0.222
+    - _IntersectionLength: 1.65
+    - _IntersectionRippleDist: 32
+    - _IntersectionRippleStrength: 0
+    - _IntersectionSize: 0.944
+    - _IntersectionSource: 0
+    - _IntersectionSpeed: 0.030000022
+    - _IntersectionStyle: 2
+    - _IntersectionTiling: 0.100000136
+    - _IntersectionWaveDist: 33.28
+    - _LightingMode: 2
+    - _LightingOn: 0
+    - _Metallic: 0
+    - _Metallicness: 0.1
+    - _NORMALMAPOn: 1
+    - _NormalMap: 1
+    - _NormalMapOn: 1
+    - _NormalSpeed: 0.25
+    - _NormalStrength: 0.048
+    - _NormalSubSpeed: -1
+    - _NormalSubTiling: 0.5
+    - _NormalTiling: -0.48000008
+    - _OcclusionStrength: 1
+    - _PlanarReflectionsEnabled: 0
+    - _PlanarReflectionsParams: 0
+    - _PointSpotLightReflectionDistortion: 0.5
+    - _PointSpotLightReflectionExp: 64
+    - _PointSpotLightReflectionSize: 0
+    - _PointSpotLightReflectionStrength: 10
+    - _QueueOffset: 0
+    - _ReceiveShadows: 0
+    - _ReflectionBlur: 0
+    - _ReflectionDistortion: 0.0467
+    - _ReflectionFresnel: 5
+    - _ReflectionLighting: 1
+    - _ReflectionStrength: 0.268
+    - _Reflectivity: 1
+    - _RefractionAmount: 0.05
+    - _RefractionChromaticAberration: 1
+    - _RefractionOn: 0
+    - _RefractionStrength: 1
+    - _RimRize: 1
+    - _RimTiling: 0.025
+    - _RiverModeOn: 0
+    - _SHARP_INERSECTIONOn: 1
+    - _ShadingMode: 1
+    - _ShadowStrength: 1
+    - _ShoreLineLength: 0
+    - _ShoreLineWaveDistance: 23
+    - _ShoreLineWaveStr: 1
+    - _SimpleLighting: 1
+    - _SlopeAngleFalloff: 25
+    - _SlopeAngleThreshold: 15
+    - _SlopeFoam: 1
+    - _SlopeSpeed: 4
+    - _SlopeStretching: 0.5
+    - _SlopeThreshold: 0.25
+    - _Smoothness: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SparkleIntensity: 0
+    - _SparkleSize: 0.302
+    - _SpecularHighlights: 1
+    - _SpecularReflectionsOn: 0
+    - _Speed: 1
+    - _SrcBlend: 1
+    - _SunReflectionDistortion: 0.228
+    - _SunReflectionPerturbance: 0.386
+    - _SunReflectionSize: 1
+    - _SunReflectionStrength: 0.68
+    - _Surface: 0
+    - _TEXTURE_INTERSECTIONOn: 0
+    - _Texture_IntersectionOn: 1
+    - _Tiling: 0.5
+    - _Translucency: 1
+    - _TranslucencyCurvatureMask: 0
+    - _TranslucencyExp: 4
+    - _TranslucencyOn: 0
+    - _TranslucencyReflectionMask: 0
+    - _TranslucencyStrength: 1
+    - _TranslucencyStrengthDirect: 0.05
+    - _UnderwaterRefractionOffset: 0.2
+    - _UnderwaterSurfaceSmoothness: 0.8
+    - _VertexColorDepth: 0
+    - _VertexColorFoam: 0
+    - _VertexColorWaveFlattening: 0
+    - _WaveCount: 1
+    - _WaveDistance: 0.006
+    - _WaveHeight: 0.015
+    - _WaveNormalStr: 0
+    - _WaveSpeed: 2.3999996
+    - _WaveSteepness: 5
+    - _WaveTint: 0
+    - _WavesOn: 0
+    - _WorkflowMode: 1
+    - _WorldSpaceUV: 1
+    - _ZClip: 1
+    - _ZWrite: 0
+    m_Colors:
+    - _BaseColor: {r: 2.9960785, g: 0.45490196, b: 0, a: 0.9647059}
+    - _Color: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+    - _DepthMapBounds: {r: -402.3, g: -459.43, b: 0.0012693577, a: 0}
+    - _Direction: {r: 1, g: 1, b: 0, a: 0}
+    - _DistanceNormalsFadeDist: {r: 300, g: 0.25, b: 0, a: 0}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _FoamColor: {r: 0, g: 0, b: 0, a: 0.6666667}
+    - _FoamTiling: {r: 0.1, g: 0.1, b: 0, a: 0}
+    - _HorizonColor: {r: 0, g: 0, b: 0, a: 1}
+    - _IntersectionColor: {r: 0, g: 0, b: 0, a: 0.8}
+    - _NormalTiling: {r: 0.080000006, g: 0.080000006, b: 0, a: 0}
+    - _RimColor: {r: 1, g: 1, b: 1, a: 1}
+    - _ShallowColor: {r: 0, g: 0, b: 0, a: 1}
+    - _SpecColor: {r: 0.2, g: 0.2, b: 0.2, a: 1}
+    - _WaterColor: {r: 0.21176466, g: 0.6745098, b: 1, a: 1}
+    - _WaterShallowColor: {r: 0, g: 0.9394503, b: 1, a: 1}
+    - _WaveDirection: {r: -1, g: -1, b: -1, a: -1}
+    - _WaveFadeDistance: {r: 150, g: 300, b: 0, a: 0}
+  m_BuildTextureStacks: []
+--- !u!114 &6498140463000427223
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 1

LocalPackages/StylizedWater2/Materials/StylizedWater2_Lava.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ee48693f3f703a140b228f9f89d0214d
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Materials/StylizedWater2_LavaFlow.mat

@@ -0,0 +1,264 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: StylizedWater2_LavaFlow
+  m_Shader: {fileID: -6465566751694194690, guid: d7b0192b9bf19c949900035fa781fdc4,
+    type: 3}
+  m_ValidKeywords:
+  - _ADVANCED_SHADING
+  - _ENVIRONMENTREFLECTIONS_OFF
+  - _FOAM
+  - _NORMALMAP
+  - _RIVER
+  - _SMOOTH_INTERSECTION
+  - _SPECULARHIGHLIGHTS_OFF
+  - _TRANSLUCENCY
+  - _UNLIT
+  - _WAVES
+  m_InvalidKeywords:
+  - ADVANCED_LIGHTING
+  - _DEPTH_TEX
+  - _VERTEXCOLORWAVEFLATTENING_ON
+  - _WORLDSPACEUV_ON
+  - _ZCLIP_ON
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 3001
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 2800000, guid: ec6f0adef15b52448a82f3f183525d84, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMapLarge:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMapSlope:
+        m_Texture: {fileID: 2800000, guid: b747df9784233eb42a14a0f6604324b5, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CausticsTex:
+        m_Texture: {fileID: 2800000, guid: 36b7496f7c0078b49a44468d3e120e62, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _FoamTex:
+        m_Texture: {fileID: 2800000, guid: e91f048fea6b6b94eb864b2124843ce9, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _FoamTexDynamic:
+        m_Texture: {fileID: 2800000, guid: 6a4aa5aa1ed7b9e4e9204a95f56f4d29, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IntersectionNoise:
+        m_Texture: {fileID: 2800000, guid: 5ea3d632911c4b648893c5f9eb4b46a0, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _PlanarReflection:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _PlanarReflectionLeft:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_Lightmaps:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_LightmapsInd:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_ShadowMasks:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _AlphaClip: 0
+    - _Blend: 0
+    - _BumpScale: 1
+    - _CausticsBrightness: 5
+    - _CausticsDistortion: 0.418
+    - _CausticsOn: 0
+    - _CausticsSpeed: 0.1
+    - _CausticsTiling: 0.1
+    - _ColorAbsorption: 0
+    - _Cull: 2
+    - _Cutoff: 0.5
+    - _Depth: 2.07
+    - _DepthExp: 0
+    - _DepthHorizontal: 8
+    - _DepthVertical: 16
+    - _DisableDepthTexture: 0
+    - _DistanceNormalsOn: 0
+    - _DistanceNormalsTiling: 0.25
+    - _DstBlend: 0
+    - _EdgeFade: 0
+    - _EnvironmentReflections: 1
+    - _EnvironmentReflectionsOn: 0
+    - _FlatShadingOn: 0
+    - _FoamBaseAmount: 1
+    - _FoamClipping: 0
+    - _FoamDistortion: 0.36
+    - _FoamOn: 1
+    - _FoamSize: 0.045
+    - _FoamSpeed: 0.2
+    - _FoamSpeedDynamic: 0.1
+    - _FoamSubSpeed: 0.1
+    - _FoamSubSpeedDynamic: -0.1
+    - _FoamSubTiling: 0.5
+    - _FoamSubTilingDynamic: 2
+    - _FoamTiling: 0.040000014
+    - _FoamTilingDynamic: 0.1
+    - _FoamWaveAmount: 0
+    - _FoamWaveMask: 0
+    - _FoamWaveMaskExp: 1
+    - _GlossMapScale: 0
+    - _Glossiness: 0
+    - _GlossyReflections: 0
+    - _HorizonDistance: 14.9
+    - _IntersectionClipping: 0.486
+    - _IntersectionFalloff: 1
+    - _IntersectionLength: 5
+    - _IntersectionRippleDist: 64
+    - _IntersectionRippleStrength: 0
+    - _IntersectionSource: 0
+    - _IntersectionSpeed: 0.01
+    - _IntersectionStyle: 2
+    - _IntersectionTiling: 0.4
+    - _LightingOn: 0
+    - _Metallic: 0
+    - _NormalMapOn: 1
+    - _NormalSpeed: 0.1
+    - _NormalStrength: 1
+    - _NormalSubSpeed: 0
+    - _NormalSubTiling: 0.70000005
+    - _NormalTiling: 0.030000044
+    - _OcclusionStrength: 1
+    - _PlanarReflectionsEnabled: 0
+    - _PlanarReflectionsParams: 0
+    - _PointSpotLightReflectionDistortion: 0.5
+    - _PointSpotLightReflectionExp: 64
+    - _PointSpotLightReflectionSize: 0
+    - _PointSpotLightReflectionStrength: 10
+    - _QueueOffset: 0
+    - _RAMMode: 1
+    - _ReceiveShadows: 1
+    - _ReflectionBlur: 0.013
+    - _ReflectionDistortion: 0.075
+    - _ReflectionFresnel: 6
+    - _ReflectionLighting: 0
+    - _ReflectionStrength: 1
+    - _RefractionChromaticAberration: 1
+    - _RefractionOn: 0
+    - _RefractionStrength: 0.346
+    - _RiverModeOn: 1
+    - _ShadingMode: 1
+    - _ShadowStrength: 0.418
+    - _SlopeAngleFalloff: 49.2
+    - _SlopeAngleThreshold: 27
+    - _SlopeFoam: 0.58
+    - _SlopeSpeed: 2
+    - _SlopeStretch: 0.491
+    - _SlopeStretching: 0.436
+    - _SlopeThreshold: 0.25
+    - _Smoothness: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SparkleIntensity: 0
+    - _SparkleSize: 0.487
+    - _SpecularHighlights: 1
+    - _SpecularReflectionsOn: 0
+    - _Speed: 0.2
+    - _SrcBlend: 1
+    - _SunReflectionDistortion: 0.974
+    - _SunReflectionSize: 0.937
+    - _SunReflectionStrength: 5
+    - _Surface: 0
+    - _TranslucencyCurvatureMask: 0.446
+    - _TranslucencyExp: 1.85
+    - _TranslucencyOn: 1
+    - _TranslucencyReflectionMask: 0
+    - _TranslucencyStrength: 1
+    - _TranslucencyStrengthDirect: 0.05
+    - _UnderwaterRefractionOffset: 0.2
+    - _UnderwaterSurfaceSmoothness: 0.8
+    - _VertexColorDepth: 0
+    - _VertexColorFoam: 0
+    - _VertexColorWaveFlattening: 1
+    - _WaveCount: 4
+    - _WaveDistance: 0.679
+    - _WaveHeight: 0.56
+    - _WaveNormalStr: 6
+    - _WaveSpeed: 1
+    - _WaveSteepness: 0
+    - _WaveTint: 0.1
+    - _WavesOn: 1
+    - _WorkflowMode: 1
+    - _WorldSpaceUV: 1
+    - _ZClip: 1
+    - _ZWrite: 0
+    m_Colors:
+    - _BaseColor: {r: 4.237095, g: 0.59896106, b: 0, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _Direction: {r: 0, g: -1, b: 0, a: 0}
+    - _DistanceNormalsFadeDist: {r: 300, g: 0.25, b: 0, a: 0}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _FoamColor: {r: 0, g: 0, b: 0, a: 0.50980395}
+    - _FoamTiling: {r: 0.1, g: 0.1, b: 0, a: 0}
+    - _HorizonColor: {r: 0, g: 0, b: 0, a: 1}
+    - _IntersectionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _NormalTiling: {r: 0.3, g: 0.3, b: 0, a: 0}
+    - _ShallowColor: {r: 0, g: 0, b: 0, a: 0}
+    - _SpecColor: {r: 0.19999996, g: 0.19999996, b: 0.19999996, a: 1}
+    - _WaveDirection: {r: 2, g: 1, b: 2, a: 1}
+    - _WaveFadeDistance: {r: 150, g: 300, b: 0, a: 0}
+  m_BuildTextureStacks: []
+--- !u!114 &4759453835961029274
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 2

LocalPackages/StylizedWater2/Materials/StylizedWater2_LavaFlow.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 0aea8ee0b119e02469e0303f06ac266b
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Materials/StylizedWater2_Lowpoly.mat

@@ -0,0 +1,277 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: StylizedWater2_Lowpoly
+  m_Shader: {fileID: -6465566751694194690, guid: d7b0192b9bf19c949900035fa781fdc4,
+    type: 3}
+  m_ValidKeywords:
+  - _ADVANCED_SHADING
+  - _FLAT_SHADING
+  - _RECEIVE_SHADOWS_OFF
+  - _SHARP_INERSECTION
+  - _TRANSLUCENCY
+  - _WAVES
+  m_InvalidKeywords:
+  - _CROSSPAN_INTERSECTION
+  - _DEPTHEXP_ON
+  - _DEPTH_TEX
+  - _ZCLIP_ON
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 1
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 2800000, guid: ec6f0adef15b52448a82f3f183525d84, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMapLarge:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMapSlope:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CausticsTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DepthTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _FoamTex:
+        m_Texture: {fileID: 2800000, guid: 6a4aa5aa1ed7b9e4e9204a95f56f4d29, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _FoamTexDynamic:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IntersectionNoise:
+        m_Texture: {fileID: 2800000, guid: b8850342fb8b1e846ac3807e35ec1685, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _PlanarReflection:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _PlanarReflectionLeft:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_Lightmaps:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_LightmapsInd:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_ShadowMasks:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _AlphaClip: 0
+    - _AnimationSpeed: 1
+    - _Blend: 0
+    - _BumpScale: 1
+    - _CausticsBrightness: 2
+    - _CausticsDistortion: 1
+    - _CausticsOn: 0
+    - _CausticsSpeed: 0.1
+    - _CausticsTiling: 0.5
+    - _ColorAbsorption: 0
+    - _CrossPan_IntersectionOn: 1
+    - _Cull: 2
+    - _Cutoff: 0.5
+    - _Depth: 2.45
+    - _DepthExp: 1
+    - _DepthHorizontal: 2.44
+    - _DepthMode: 0
+    - _DepthTexture: 1
+    - _DepthVertical: 4.2
+    - _DisableDepthTexture: 0
+    - _DistanceNormalsOn: 0
+    - _DistanceNormalsTiling: 0.25
+    - _DstBlend: 0
+    - _EdgeFade: 1.01
+    - _EnvironmentReflections: 1
+    - _EnvironmentReflectionsOn: 1
+    - _FlatShadingOn: 1
+    - _FoamBaseAmount: 1
+    - _FoamClipping: 0
+    - _FoamDistortion: 0.1
+    - _FoamOn: 0
+    - _FoamOpacity: 1
+    - _FoamSize: 0.695
+    - _FoamSpeed: 0.1
+    - _FoamSpeedDynamic: 0.1
+    - _FoamSubSpeed: -0.25
+    - _FoamSubSpeedDynamic: -0.1
+    - _FoamSubTiling: 0.5
+    - _FoamSubTilingDynamic: 2
+    - _FoamTiling: 0.39999992
+    - _FoamTilingDynamic: 0.1
+    - _FoamWaveAmount: 0
+    - _FoamWaveMask: 1
+    - _FoamWaveMaskExp: 1
+    - _GlossMapScale: 0
+    - _Glossiness: 0
+    - _GlossyReflections: 0
+    - _HorizonDistance: 8
+    - _IntersectionClipping: 0.5
+    - _IntersectionFalloff: 1
+    - _IntersectionLength: 1.98
+    - _IntersectionRippleDist: 1
+    - _IntersectionRippleStrength: 0
+    - _IntersectionSource: 0
+    - _IntersectionSpeed: 0.1
+    - _IntersectionStyle: 1
+    - _IntersectionTiling: 0.09999993
+    - _LightingOn: 1
+    - _Metallic: 0
+    - _NormalMapOn: 0
+    - _NormalSpeed: 0.2
+    - _NormalStrength: 0
+    - _NormalSubSpeed: -0.5
+    - _NormalSubTiling: 0.5
+    - _NormalTiling: 1
+    - _OcclusionStrength: 1
+    - _PlanarReflectionsEnabled: 0
+    - _PlanarReflectionsParams: 0
+    - _PointSpotLightReflectionDistortion: 0.5
+    - _PointSpotLightReflectionExp: 64
+    - _PointSpotLightReflectionSize: 0
+    - _PointSpotLightReflectionStrength: 10
+    - _QueueOffset: 0
+    - _ReceiveShadows: 0
+    - _ReflectionBlur: 0.205
+    - _ReflectionDistortion: 0
+    - _ReflectionFresnel: 8
+    - _ReflectionLighting: 0
+    - _ReflectionStrength: 1
+    - _RefractionChromaticAberration: 1
+    - _RefractionOn: 0
+    - _RefractionStrength: 0.118
+    - _RiverModeOn: 0
+    - _SHARP_INERSECTIONOn: 1
+    - _ShadingMode: 1
+    - _ShadowStrength: 1
+    - _ShoreLineLength: 2
+    - _ShoreLineWaveDistance: 64
+    - _ShoreLineWaveStr: 0.008
+    - _SlopeAngleFalloff: 25
+    - _SlopeAngleThreshold: 15
+    - _SlopeFoam: 1
+    - _SlopeSpeed: 4
+    - _SlopeStretching: 0.5
+    - _SlopeThreshold: 0.25
+    - _Smoothness: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SparkleIntensity: 0
+    - _SparkleSize: 0.1
+    - _SpecularHighlights: 1
+    - _SpecularReflectionsOn: 1
+    - _Speed: 1
+    - _SrcBlend: 1
+    - _SunReflectionDistortion: 2
+    - _SunReflectionPerturbance: 1
+    - _SunReflectionSize: 0.95
+    - _SunReflectionStrength: 1
+    - _Surface: 0
+    - _TessMax: 15
+    - _TessMin: 0
+    - _TessValue: 16
+    - _Texture_IntersectionOn: 0
+    - _Translucency: 1
+    - _TranslucencyCurvatureMask: 1
+    - _TranslucencyExp: 1
+    - _TranslucencyOn: 1
+    - _TranslucencyReflectionMask: 0
+    - _TranslucencyStrength: 1
+    - _TranslucencyStrengthDirect: 0.05
+    - _UnderwaterRefractionOffset: 0.2
+    - _UnderwaterSurfaceSmoothness: 0.8
+    - _VertexColorDepth: 0
+    - _VertexColorFoam: 0
+    - _VertexColorWaveFlattening: 0
+    - _WaveCount: 1
+    - _WaveDistance: 0.574
+    - _WaveHeight: 0.15
+    - _WaveNormalStr: 1
+    - _WaveSpeed: 3
+    - _WaveSteepness: 0.1
+    - _WaveTint: 0
+    - _WavesOn: 1
+    - _WorkflowMode: 1
+    - _WorldSpaceUV: 1
+    - _ZClip: 1
+    - _ZWrite: 0
+    m_Colors:
+    - _BaseColor: {r: 0, g: 0.17100494, b: 0.4811321, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _DepthMapBounds: {r: 0, g: 0, b: 0, a: 0}
+    - _Direction: {r: 1, g: 1, b: 0, a: 0}
+    - _DistanceNormalsFadeDist: {r: 300, g: 0.25, b: 0, a: 0}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _FoamColor: {r: 1, g: 1, b: 1, a: 1}
+    - _FoamTiling: {r: 0.1, g: 0.1, b: 0, a: 0}
+    - _HorizonColor: {r: 0.41037738, g: 0.71931076, b: 1, a: 0}
+    - _IntersectionColor: {r: 1, g: 1, b: 1, a: 1}
+    - _NormalTiling: {r: 0.1, g: 0.1, b: 0, a: 0}
+    - _ShallowColor: {r: 0, g: 2, b: 1.9607843, a: 1}
+    - _SpecColor: {r: 0.19999996, g: 0.19999996, b: 0.19999996, a: 1}
+    - _WaveDirection: {r: 1, g: 1, b: 1, a: 1}
+    - _WaveFadeDistance: {r: 150, g: 300, b: 0, a: 0}
+  m_BuildTextureStacks: []
+--- !u!114 &1092640962685890020
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 2

LocalPackages/StylizedWater2/Materials/StylizedWater2_Lowpoly.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: a0b5f77a73da34b4aa3402decf70e1c7
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Materials/StylizedWater2_Mobile.mat

@@ -0,0 +1,316 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: StylizedWater2_Mobile
+  m_Shader: {fileID: -6465566751694194690, guid: d7b0192b9bf19c949900035fa781fdc4,
+    type: 3}
+  m_ValidKeywords:
+  - _ENVIRONMENTREFLECTIONS_OFF
+  - _FOAM
+  - _NORMALMAP
+  - _RECEIVE_SHADOWS_OFF
+  - _SHARP_INERSECTION
+  - _UNLIT
+  m_InvalidKeywords:
+  - ADVANCED_LIGHTING
+  - _CROSSPAN_INTERSECTION
+  - _DEPTHEXP_ON
+  - _DEPTH_TEX
+  - _SIMPLE_LIGHTING
+  - _WORLDSPACEUV_ON
+  - _ZCLIP_ON
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 2800000, guid: ec6f0adef15b52448a82f3f183525d84, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMapLarge:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMapSlope:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CausticsTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DepthTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _FoamTex:
+        m_Texture: {fileID: 2800000, guid: 2e10c404ec8e1ff41bff06b82e5569df, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _FoamTexDynamic:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IntersectionNoise:
+        m_Texture: {fileID: 2800000, guid: b8850342fb8b1e846ac3807e35ec1685, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Normals:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _PlanarReflection:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _PlanarReflectionLeft:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Shadermap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _texcoord:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_Lightmaps:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_LightmapsInd:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_ShadowMasks:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - Vector1_1942CF3A: 1
+    - Vector1_BE75C478: 32
+    - Vector1_E23F9E57: 0.5
+    - Vector1_E796673B: 10
+    - _ADVANCED_LIGHTING: 1
+    - _AdvancedLighting: 1
+    - _Advanced_Lighting: 1
+    - _AlphaClip: 0
+    - _AlphaCutoff: 0.5
+    - _AnimationSpeed: 1
+    - _Blend: 0
+    - _BumpScale: 1
+    - _CROSSPAN_INTERSECTIONOn: 1
+    - _CausticsBrightness: 4.83
+    - _CausticsDistortion: 0.15
+    - _CausticsOn: 0
+    - _CausticsSpeed: 0.1
+    - _CausticsTiling: 0.5
+    - _ColorAbsorption: 0
+    - _CrossPan_IntersectionOn: 0
+    - _Cull: 2
+    - _Cutoff: 0.5
+    - _Depth: 5.01
+    - _DepthExp: 1
+    - _DepthHorizontal: 1
+    - _DepthMode: 0
+    - _DepthTexture: 1
+    - _DepthVertical: 4
+    - _DisableDepthTexture: 0
+    - _DistanceNormalsOn: 0
+    - _DistanceNormalsTiling: 0.25
+    - _DstBlend: 0
+    - _EdgeFade: 7.37
+    - _EnvironmentReflections: 1
+    - _EnvironmentReflectionsOn: 0
+    - _FlatShadingOn: 0
+    - _FlowSpeed: 1
+    - _FoamBaseAmount: 1
+    - _FoamClipping: 0.98
+    - _FoamDistortion: 0.1
+    - _FoamOn: 1
+    - _FoamOpacity: 0.253
+    - _FoamSize: 0.01
+    - _FoamSpeed: 0.030000014
+    - _FoamSpeedDynamic: 0.1
+    - _FoamSubSpeed: -0.25
+    - _FoamSubSpeedDynamic: -0.1
+    - _FoamSubTiling: 0.5
+    - _FoamSubTilingDynamic: 2
+    - _FoamTiling: 0.049999908
+    - _FoamTilingDynamic: 0.1
+    - _FoamWaveAmount: 0
+    - _FoamWaveMask: 0
+    - _FoamWaveMaskExp: 1
+    - _GlossMapScale: 0
+    - _Glossiness: 0
+    - _GlossyReflections: 0
+    - _HorizonDistance: 10.4
+    - _IntersectionClipping: 0.428
+    - _IntersectionFalloff: 1
+    - _IntersectionLength: 1.79
+    - _IntersectionRippleDist: 64
+    - _IntersectionRippleStrength: 0.355
+    - _IntersectionSize: 0.944
+    - _IntersectionSource: 0
+    - _IntersectionSpeed: 0.06000001
+    - _IntersectionStyle: 1
+    - _IntersectionTiling: 0.16999984
+    - _IntersectionWaveDist: 33.28
+    - _LightingMode: 0
+    - _LightingOn: 0
+    - _Metallic: 0
+    - _Metallicness: 0.1
+    - _NORMALMAPOn: 1
+    - _NormalMap: 1
+    - _NormalMapOn: 1
+    - _NormalSpeed: 0.5
+    - _NormalStrength: 1
+    - _NormalSubSpeed: -0.5
+    - _NormalSubTiling: 0.5
+    - _NormalTiling: 0.29999992
+    - _OcclusionStrength: 1
+    - _PlanarReflectionsEnabled: 0
+    - _PlanarReflectionsParams: 0
+    - _PointSpotLightReflectionDistortion: 0.5
+    - _PointSpotLightReflectionExp: 64
+    - _PointSpotLightReflectionSize: 0
+    - _PointSpotLightReflectionStrength: 10
+    - _QueueOffset: 0
+    - _ReceiveShadows: 0
+    - _ReflectionBlur: 0
+    - _ReflectionDistortion: 0.086
+    - _ReflectionFresnel: 5
+    - _ReflectionFresnelMode: 0
+    - _ReflectionLighting: 0
+    - _ReflectionStrength: 0.248
+    - _Reflectivity: 1
+    - _RefractionAmount: 0.05
+    - _RefractionChromaticAberration: 1
+    - _RefractionOn: 0
+    - _RefractionStrength: 0.267
+    - _RimRize: 1
+    - _RimTiling: 0.025
+    - _RiverModeOn: 0
+    - _SHARP_INERSECTIONOn: 1
+    - _ShadingMode: 0
+    - _ShadowStrength: 1
+    - _ShoreLineLength: 0
+    - _ShoreLineWaveDistance: 23
+    - _ShoreLineWaveStr: 1
+    - _SimpleLighting: 1
+    - _SlopeAngleFalloff: 25
+    - _SlopeAngleThreshold: 15
+    - _SlopeFoam: 1
+    - _SlopeSpeed: 4
+    - _SlopeStretching: 0.5
+    - _SlopeThreshold: 0.25
+    - _Smoothness: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SparkleIntensity: 4
+    - _SparkleSize: 0.7
+    - _SpecularHighlights: 1
+    - _SpecularReflectionsOn: 1
+    - _Speed: 1
+    - _SrcBlend: 1
+    - _SunReflectionDistortion: 0.71
+    - _SunReflectionPerturbance: 0.548
+    - _SunReflectionSize: 0.948
+    - _SunReflectionStrength: 10
+    - _Surface: 0
+    - _TEXTURE_INTERSECTIONOn: 0
+    - _Texture_IntersectionOn: 1
+    - _Tiling: 0.5
+    - _Translucency: 0
+    - _TranslucencyCurvatureMask: 0
+    - _TranslucencyExp: 4
+    - _TranslucencyOn: 0
+    - _TranslucencyReflectionMask: 0
+    - _TranslucencyStrength: 1
+    - _TranslucencyStrengthDirect: 0.05
+    - _UnderwaterRefractionOffset: 0.2
+    - _UnderwaterSurfaceSmoothness: 0.8
+    - _VertexColorDepth: 0
+    - _VertexColorFoam: 0
+    - _VertexColorWaveFlattening: 0
+    - _WaveCount: 1
+    - _WaveDistance: 0.763
+    - _WaveHeight: 0
+    - _WaveNormalStr: 0.291
+    - _WaveSpeed: 1
+    - _WaveSteepness: 0
+    - _WaveTint: 0.029
+    - _WavesOn: 0
+    - _WorkflowMode: 1
+    - _WorldSpaceUV: 1
+    - _ZClip: 1
+    - _ZWrite: 0
+    m_Colors:
+    - _BaseColor: {r: 0, g: 0.16451614, b: 0.34, a: 0.9647059}
+    - _Color: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+    - _DepthMapBounds: {r: -402.3, g: -459.43, b: 0.0012693577, a: 0}
+    - _Direction: {r: 1, g: 1, b: 0, a: 0}
+    - _DistanceNormalsFadeDist: {r: 300, g: 0.25, b: 0, a: 0}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _FoamColor: {r: 1, g: 1, b: 1, a: 0.09803922}
+    - _FoamTiling: {r: 0.1, g: 0.1, b: 0, a: 0}
+    - _HorizonColor: {r: 0.2352941, g: 0.9051294, b: 1, a: 1}
+    - _IntersectionColor: {r: 1, g: 1, b: 1, a: 1}
+    - _NormalTiling: {r: 0.3, g: 0.3, b: 0, a: 0}
+    - _RimColor: {r: 1, g: 1, b: 1, a: 1}
+    - _ShallowColor: {r: 0, g: 0.8446603, b: 1, a: 0.39607844}
+    - _SpecColor: {r: 0.2, g: 0.2, b: 0.2, a: 1}
+    - _WaterColor: {r: 0.21176466, g: 0.6745098, b: 1, a: 1}
+    - _WaterShallowColor: {r: 0, g: 0.9394503, b: 1, a: 1}
+    - _WaveDirection: {r: 1, g: 1, b: 1, a: 1}
+    - _WaveFadeDistance: {r: 150, g: 300, b: 0, a: 0}
+  m_BuildTextureStacks: []
+--- !u!114 &6498140463000427223
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 1

LocalPackages/StylizedWater2/Materials/StylizedWater2_Mobile.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9e73dc93ef929ba46ae79f13b165b3dc
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Materials/StylizedWater2_Ocean.mat

@@ -0,0 +1,319 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: StylizedWater2_Ocean
+  m_Shader: {fileID: 482279110045391116, guid: d7b0192b9bf19c949900035fa781fdc4, type: 3}
+  m_ValidKeywords:
+  - _ADVANCED_SHADING
+  - _DISTANCE_NORMALS
+  - _FOAM
+  - _NORMALMAP
+  - _REFRACTION
+  - _SHARP_INERSECTION
+  - _TRANSLUCENCY
+  - _WAVES
+  m_InvalidKeywords:
+  - ADVANCED_LIGHTING
+  - _DEPTHEXP_ON
+  - _DEPTH_TEX
+  - _SIMPLE_LIGHTING
+  - _WORLDSPACEUV_ON
+  - _ZCLIP_ON
+  - _ZWRITE_ON
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 3000
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 2800000, guid: 88908a7c7a1f0ed418d1048378c17411, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMapLarge:
+        m_Texture: {fileID: 2800000, guid: 88908a7c7a1f0ed418d1048378c17411, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMapSlope:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CausticsTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DepthTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _FoamTex:
+        m_Texture: {fileID: 2800000, guid: 6a4aa5aa1ed7b9e4e9204a95f56f4d29, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _FoamTexDynamic:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IntersectionNoise:
+        m_Texture: {fileID: 2800000, guid: 2e10c404ec8e1ff41bff06b82e5569df, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Normals:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _PlanarReflection:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _PlanarReflectionLeft:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Shadermap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _texcoord:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_Lightmaps:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_LightmapsInd:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_ShadowMasks:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - Vector1_1942CF3A: 1
+    - Vector1_BE75C478: 32
+    - Vector1_E23F9E57: 0.5
+    - Vector1_E796673B: 10
+    - _ADVANCED_LIGHTING: 1
+    - _AdvancedLighting: 1
+    - _Advanced_Lighting: 1
+    - _AlphaClip: 0
+    - _AlphaCutoff: 0.5
+    - _AnimationSpeed: 1
+    - _Blend: 0
+    - _BumpScale: 1
+    - _CROSSPAN_INTERSECTIONOn: 1
+    - _CausticsBrightness: 2
+    - _CausticsDistortion: 0.23
+    - _CausticsOn: 0
+    - _CausticsSpeed: 0.1
+    - _CausticsTiling: 0.5
+    - _ColorAbsorption: 0
+    - _CrossPan_IntersectionOn: 0
+    - _Cull: 2
+    - _Cutoff: 0.5
+    - _Depth: 2.42
+    - _DepthExp: 1
+    - _DepthHorizontal: 0.01
+    - _DepthMode: 0
+    - _DepthTexture: 1
+    - _DepthVertical: 8
+    - _DisableDepthTexture: 0
+    - _DistanceNormalsOn: 1
+    - _DistanceNormalsTiling: 0.079999976
+    - _DstBlend: 0
+    - _EdgeFade: 7
+    - _EnvironmentReflections: 1
+    - _EnvironmentReflectionsOn: 1
+    - _FlatShadingOn: 0
+    - _FlowSpeed: 1
+    - _FoamBaseAmount: 0.309
+    - _FoamClipping: 0
+    - _FoamDistortion: 0.13
+    - _FoamOn: 1
+    - _FoamOpacity: 1
+    - _FoamSize: 0.314
+    - _FoamSpeed: -0.5
+    - _FoamSpeedDynamic: 0.1
+    - _FoamSubSpeed: 0
+    - _FoamSubSpeedDynamic: -0.1
+    - _FoamSubTiling: 0.5
+    - _FoamSubTilingDynamic: 2
+    - _FoamTiling: 0.19999993
+    - _FoamTilingDynamic: 0.1
+    - _FoamWaveAmount: 0.539
+    - _FoamWaveMask: 0.638
+    - _FoamWaveMaskExp: 1
+    - _GlossMapScale: 0
+    - _Glossiness: 0
+    - _GlossyReflections: 0
+    - _HorizonDistance: 32
+    - _IntersectionClipping: 0.583
+    - _IntersectionFalloff: 1
+    - _IntersectionLength: 1
+    - _IntersectionRippleDist: 20
+    - _IntersectionRippleStrength: 0.53
+    - _IntersectionSize: 0.944
+    - _IntersectionSource: 0
+    - _IntersectionSpeed: 0.1
+    - _IntersectionStyle: 1
+    - _IntersectionTiling: 1
+    - _IntersectionWaveDist: 33.28
+    - _LightingMode: 2
+    - _LightingOn: 1
+    - _Metallic: 0
+    - _Metallicness: 0.1
+    - _NORMALMAPOn: 1
+    - _NormalMap: 1
+    - _NormalMapOn: 1
+    - _NormalSpeed: 0.5
+    - _NormalStrength: 0.165
+    - _NormalSubSpeed: 0.01
+    - _NormalSubTiling: 1
+    - _NormalTiling: 0.16000009
+    - _OcclusionStrength: 1
+    - _PlanarReflectionsEnabled: 0
+    - _PlanarReflectionsParams: 0
+    - _PointSpotLightReflectionDistortion: 0.5
+    - _PointSpotLightReflectionExp: 64
+    - _PointSpotLightReflectionSize: 0
+    - _PointSpotLightReflectionStrength: 10
+    - _QueueOffset: 0
+    - _ReceiveShadows: 1
+    - _ReflectionBlur: 0
+    - _ReflectionDistortion: 0.274
+    - _ReflectionFresnel: 13.04
+    - _ReflectionLighting: 0
+    - _ReflectionStrength: 1
+    - _Reflectivity: 1
+    - _RefractionAmount: 0.05
+    - _RefractionChromaticAberration: 1
+    - _RefractionOn: 1
+    - _RefractionStrength: 0.228
+    - _RimRize: 1
+    - _RimTiling: 0.025
+    - _RiverModeOn: 0
+    - _SHARP_INERSECTIONOn: 1
+    - _ShadingMode: 1
+    - _ShadowStrength: 1
+    - _ShoreLineLength: 3.1
+    - _ShoreLineWaveDistance: 6
+    - _ShoreLineWaveStr: 0
+    - _SimpleLighting: 1
+    - _SlopeAngleFalloff: 25
+    - _SlopeAngleThreshold: 15
+    - _SlopeFoam: 1
+    - _SlopeSpeed: 4
+    - _SlopeStretching: 0.5
+    - _SlopeThreshold: 0.25
+    - _Smoothness: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SparkleIntensity: 0
+    - _SparkleSize: 0.155
+    - _SpecularHighlights: 1
+    - _SpecularReflectionsOn: 1
+    - _Speed: 1
+    - _SrcBlend: 1
+    - _SunReflectionDistortion: 0.634
+    - _SunReflectionPerturbance: 1
+    - _SunReflectionSize: 0.837
+    - _SunReflectionStrength: 10
+    - _Surface: 0
+    - _TEXTURE_INTERSECTIONOn: 0
+    - _TessMax: 50
+    - _TessMin: 0
+    - _TessValue: 8
+    - _Texture_IntersectionOn: 1
+    - _Tiling: 0.5
+    - _Translucency: 1
+    - _TranslucencyCurvatureMask: 0.869
+    - _TranslucencyExp: 2
+    - _TranslucencyOn: 1
+    - _TranslucencyReflectionMask: 0
+    - _TranslucencyStrength: 2
+    - _TranslucencyStrengthDirect: 0
+    - _UnderwaterRefractionOffset: 0.2
+    - _UnderwaterSurfaceSmoothness: 0.8
+    - _VertexColorDepth: 0
+    - _VertexColorFoam: 0
+    - _VertexColorWaveFlattening: 0
+    - _WaveCount: 5
+    - _WaveDistance: 0.97
+    - _WaveHeight: 1.7
+    - _WaveNormalStr: 2
+    - _WaveSpeed: 1.5
+    - _WaveSteepness: 1.76
+    - _WaveTint: 0.057
+    - _WavesOn: 1
+    - _WorkflowMode: 1
+    - _WorldSpaceUV: 1
+    - _ZClip: 1
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 0, g: 0.08962265, b: 0.1792453, a: 1}
+    - _Color: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+    - _DepthMapBounds: {r: -402.3, g: -459.43, b: 0.0012693577, a: 0}
+    - _Direction: {r: 1, g: 1, b: 0, a: 0}
+    - _DistanceNormalsFadeDist: {r: 10, g: 100, b: 0, a: 0}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _FoamColor: {r: 1, g: 1, b: 1, a: 1}
+    - _FoamTiling: {r: 0.1, g: 0.1, b: 0, a: 0}
+    - _HorizonColor: {r: 0.50953066, g: 5.8970256, b: 6.3541465, a: 0}
+    - _IntersectionColor: {r: 1, g: 1, b: 1, a: 1}
+    - _NormalTiling: {r: 0.22, g: 0.22, b: 0, a: 0}
+    - _RimColor: {r: 1, g: 1, b: 1, a: 1}
+    - _ShallowColor: {r: 0, g: 0.943, b: 0.9245099, a: 1}
+    - _SpecColor: {r: 0.2, g: 0.2, b: 0.2, a: 1}
+    - _WaterColor: {r: 0.21176466, g: 0.6745098, b: 1, a: 1}
+    - _WaterShallowColor: {r: 0, g: 0.9394503, b: 1, a: 1}
+    - _WaveDirection: {r: 1, g: 1, b: 1, a: 1}
+    - _WaveFadeDistance: {r: 76.392815, g: 303.86386, b: 0, a: 0}
+  m_BuildTextureStacks: []
+--- !u!114 &6498140463000427223
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 1

LocalPackages/StylizedWater2/Materials/StylizedWater2_Ocean.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d53e2a245a2e389439504202541600e4
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LocalPackages/StylizedWater2/Materials/StylizedWater2_Realistic.mat

@@ -0,0 +1,321 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: StylizedWater2_Realistic
+  m_Shader: {fileID: 482279110045391116, guid: d7b0192b9bf19c949900035fa781fdc4, type: 3}
+  m_ValidKeywords:
+  - _ADVANCED_SHADING
+  - _CAUSTICS
+  - _DISTANCE_NORMALS
+  - _FOAM
+  - _NORMALMAP
+  - _REFRACTION
+  - _SMOOTH_INTERSECTION
+  - _TRANSLUCENCY
+  - _WAVES
+  m_InvalidKeywords:
+  - ADVANCED_LIGHTING
+  - _DEPTHEXP_ON
+  - _DEPTH_TEX
+  - _SIMPLE_LIGHTING
+  - _WORLDSPACEUV_ON
+  - _ZCLIP_ON
+  - _ZWRITE_ON
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 2800000, guid: b8b8d6f606fb01f4d85ec095b78f8c32, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMapLarge:
+        m_Texture: {fileID: 2800000, guid: 88908a7c7a1f0ed418d1048378c17411, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMapSlope:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CausticsTex:
+        m_Texture: {fileID: 2800000, guid: 36b7496f7c0078b49a44468d3e120e62, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DepthTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _FoamTex:
+        m_Texture: {fileID: 2800000, guid: 6a4aa5aa1ed7b9e4e9204a95f56f4d29, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _FoamTexDynamic:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IntersectionNoise:
+        m_Texture: {fileID: 2800000, guid: 5ea3d632911c4b648893c5f9eb4b46a0, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Normals:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _PlanarReflection:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _PlanarReflectionLeft:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Shadermap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _texcoord:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_Lightmaps:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_LightmapsInd:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_ShadowMasks:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - Vector1_1942CF3A: 1
+    - Vector1_BE75C478: 32
+    - Vector1_E23F9E57: 0.5
+    - Vector1_E796673B: 10
+    - _ADVANCED_LIGHTING: 1
+    - _AdvancedLighting: 1
+    - _Advanced_Lighting: 1
+    - _AlphaClip: 0
+    - _AlphaCutoff: 0.5
+    - _AnimationSpeed: 1
+    - _Blend: 0
+    - _BumpScale: 1
+    - _CROSSPAN_INTERSECTIONOn: 1
+    - _CausticsBrightness: 2
+    - _CausticsDistortion: 0.128
+    - _CausticsOn: 1
+    - _CausticsSpeed: 0.1
+    - _CausticsTiling: 0.15
+    - _ColorAbsorption: 0.11
+    - _CrossPan_IntersectionOn: 0
+    - _Cull: 0
+    - _Cutoff: 0.5
+    - _Depth: 0.94
+    - _DepthExp: 1
+    - _DepthHorizontal: 1.11
+    - _DepthMode: 0
+    - _DepthTexture: 1
+    - _DepthVertical: 6
+    - _DisableDepthTexture: 0
+    - _DistanceNormalsOn: 1
+    - _DistanceNormalsTiling: 0.12
+    - _DstBlend: 0
+    - _EdgeFade: 18.7
+    - _EnvironmentReflections: 1
+    - _EnvironmentReflectionsOn: 1
+    - _FlatShadingOn: 0
+    - _FlowSpeed: 1
+    - _FoamBaseAmount: 0.158
+    - _FoamClipping: 0
+    - _FoamDistortion: 0.1
+    - _FoamOn: 1
+    - _FoamOpacity: 0.104
+    - _FoamSize: 0.01
+    - _FoamSpeed: 0.050000012
+    - _FoamSpeedDynamic: 0.1
+    - _FoamSubSpeed: -0.25
+    - _FoamSubSpeedDynamic: -0.1
+    - _FoamSubTiling: 0.5
+    - _FoamSubTilingDynamic: 2
+    - _FoamTiling: 0.09999993
+    - _FoamTilingDynamic: 0.1
+    - _FoamWaveAmount: 2
+    - _FoamWaveMask: 0
+    - _FoamWaveMaskExp: 1
+    - _GlossMapScale: 0
+    - _Glossiness: 0
+    - _GlossyReflections: 0
+    - _HorizonDistance: 8
+    - _IntersectionClipping: 0.605
+    - _IntersectionFalloff: 1
+    - _IntersectionLength: 2.03
+    - _IntersectionRippleDist: 32
+    - _IntersectionRippleStrength: 0.547
+    - _IntersectionSize: 0.944
+    - _IntersectionSource: 0
+    - _IntersectionSpeed: 0.02
+    - _IntersectionStyle: 2
+    - _IntersectionTiling: 0.03999974
+    - _IntersectionWaveDist: 33.28
+    - _LightingMode: 2
+    - _LightingOn: 1
+    - _Metallic: 0
+    - _Metallicness: 0.1
+    - _NORMALMAPOn: 1
+    - _NormalMap: 1
+    - _NormalMapOn: 1
+    - _NormalSpeed: 1
+    - _NormalStrength: 0.169
+    - _NormalSubSpeed: -0.5
+    - _NormalSubTiling: 0.5
+    - _NormalTiling: 0.5800001
+    - _OcclusionStrength: 1
+    - _PlanarReflectionsEnabled: 0
+    - _PlanarReflectionsParams: 0.99
+    - _PointSpotLightReflectionDistortion: 0.5
+    - _PointSpotLightReflectionExp: 64
+    - _PointSpotLightReflectionSize: 0
+    - _PointSpotLightReflectionStrength: 10
+    - _QueueOffset: 0
+    - _ReceiveShadows: 1
+    - _ReflectionBlur: 0
+    - _ReflectionDistortion: 0.206
+    - _ReflectionFresnel: 8
+    - _ReflectionFresnelMode: 0
+    - _ReflectionLighting: 0
+    - _ReflectionStrength: 1
+    - _Reflectivity: 1
+    - _RefractionAmount: 0.05
+    - _RefractionChromaticAberration: 1
+    - _RefractionOn: 1
+    - _RefractionStrength: 0.284
+    - _RimRize: 1
+    - _RimTiling: 0.025
+    - _RiverModeOn: 0
+    - _SHARP_INERSECTIONOn: 1
+    - _ShadingMode: 1
+    - _ShadowStrength: 1
+    - _ShoreLineLength: 0
+    - _ShoreLineWaveDistance: 23
+    - _ShoreLineWaveStr: 1
+    - _SimpleLighting: 1
+    - _SlopeAngleFalloff: 25
+    - _SlopeAngleThreshold: 15
+    - _SlopeFoam: 1
+    - _SlopeSpeed: 4
+    - _SlopeStretching: 0.5
+    - _SlopeThreshold: 0.25
+    - _Smoothness: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SparkleIntensity: 0
+    - _SparkleSize: 0.527
+    - _SpecularHighlights: 1
+    - _SpecularReflectionsOn: 1
+    - _Speed: 1
+    - _SrcBlend: 1
+    - _SunReflectionDistortion: 0.76
+    - _SunReflectionPerturbance: 0.386
+    - _SunReflectionSize: 0.895
+    - _SunReflectionStrength: 5
+    - _Surface: 0
+    - _TEXTURE_INTERSECTIONOn: 0
+    - _TessMax: 23.86
+    - _TessMin: 0
+    - _TessValue: 41.8
+    - _Texture_IntersectionOn: 1
+    - _Tiling: 0.5
+    - _Translucency: 1
+    - _TranslucencyCurvatureMask: 0.584
+    - _TranslucencyExp: 2
+    - _TranslucencyOn: 1
+    - _TranslucencyReflectionMask: 1
+    - _TranslucencyStrength: 3
+    - _TranslucencyStrengthDirect: 0.05
+    - _UnderwaterRefractionOffset: 0.2
+    - _UnderwaterSurfaceSmoothness: 0.8
+    - _VertexColorDepth: 0
+    - _VertexColorFoam: 0
+    - _VertexColorWaveFlattening: 0
+    - _WaveCount: 5
+    - _WaveDistance: 0.9
+    - _WaveHeight: 0.2
+    - _WaveNormalStr: 3
+    - _WaveSpeed: 1
+    - _WaveSteepness: 2.53
+    - _WaveTint: 0
+    - _WavesOn: 1
+    - _WorkflowMode: 1
+    - _WorldSpaceUV: 1
+    - _ZClip: 1
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 0.033239212, g: 0.06696109, b: 0.101960786, a: 1}
+    - _Color: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+    - _DepthMapBounds: {r: -402.3, g: -459.43, b: 0.0012693577, a: 0}
+    - _Direction: {r: 1, g: 1, b: 0, a: 0}
+    - _DistanceNormalsFadeDist: {r: 0, g: 150, b: 0, a: 0}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _FoamColor: {r: 1, g: 1, b: 1, a: 1}
+    - _FoamTiling: {r: 0.1, g: 0.1, b: 0, a: 0}
+    - _HorizonColor: {r: 0.68, g: 1, b: 0.99, a: 0.15}
+    - _IntersectionColor: {r: 1, g: 1, b: 1, a: 1}
+    - _NormalTiling: {r: 0.5, g: 0.5, b: 0, a: 0}
+    - _RimColor: {r: 1, g: 1, b: 1, a: 1}
+    - _ShallowColor: {r: 0, g: 1, b: 0.38835502, a: 0}
+    - _SpecColor: {r: 0.2, g: 0.2, b: 0.2, a: 1}
+    - _WaterColor: {r: 0.21176466, g: 0.6745098, b: 1, a: 1}
+    - _WaterShallowColor: {r: 0, g: 0.9394503, b: 1, a: 1}
+    - _WaveDirection: {r: -1, g: -1, b: -1, a: -1}
+    - _WaveFadeDistance: {r: 0, g: 82.9268, b: 0, a: 0}
+  m_BuildTextureStacks: []
+--- !u!114 &6498140463000427223
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 1

LocalPackages/StylizedWater2/Materials/StylizedWater2_Realistic.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: cdb5a16f31ee9ca43b20ee76fcbdffbf
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: