merge jonasty

Assets/Fantasy Adventure Environment/Changelog.txt

@@ -0,0 +1,365 @@
+1.5.5
+Minimum supported version is now Unity 2019.3.7f1
+
+Added:
+- (URP) Support for LOD crossfading in Vegetation Studio Pro 1.4.5
+
+Changed:
+- Reorganized folder structure to adhere to the traditional Model/Materials format
+- Scripts are now separated into a Runtime/Editor folder and contain an assembly definition
+- Improved normals for the majority of trees, resulting in better directional shading
+- Normal maps for tree billboards are now actually correct, so will match a tree's shading more closely
+- Roughness and Height maps for terrain layers are now packed into a new RGBA mask map
+- Stiffness for trees is now stored in the UV3 V-component. Branch and trunk shaders have been modified to use this instead of the Alpha vertex color channel. 
+ * This makes it more straightforward to add wind motion support to custom tree models, wind strength may need to be adjusted
+- Tree models are now stored in a single FBX file per asset
+- LOD meshes for rocks/cliffs are now in the same FBX file. LOD crossfading is now enabled for them (looks best in Forward rendering)
+
+Fixed:
+- Some particle materials not always converting properly to URP
+
+Removed:
+- Option to convert from URP to Built-in RP. Instead, his can be achieved by re-importing the package.
+
+1.5.4
+
+Changed:
+- (URP) Converted all Shader Graph custom functions into Sub-graphs to solve Shader Graph's timing sensitive import errors
+
+Fixed:
+- (URP) Tree billboards not being rendered if used with Vegetation Studio Pro
+- (URP) Some materials rendering invisible in URP 11+ (2021.1 beta)
+
+1.5.3
+Minimum supported version is now Unity 2018.4.0. URP now requires v7.4.1 (available since Unity 2019.3.7f1)
+
+Added:
+- Added terrain layers (part of auto upgrade in 2018.3)
+- (URP) LOD crossfading support for vegetation shaders (already enabled by default on all prefabs)
+- (URP) Foliage bending functionality to Foliage shader
+
+Changed:
+- Assuming Linear color space by default, colors have been adjusted to fit
+- (URP) Greatly improved translucency for Foliage shader
+- Particle effects now use the Standard particle shader (this also supports camera fading)
+- Normal map inputs on cliff shaders are now correctly marked as such
+- (URP) Vegetation shaders now use the same material UI as in the built-in RP
+- URP material conversion now forces shaders to re-import after completion, as a workaround for Shader Graph import issues.
+
+Fixed:
+- Foliage bender now pushes grass/foliage away in the correct direction, regardless of the rotation of a mesh.
+
+1.5.2
+
+Added:
+- Options to convert to Built/Universal Render Pipeline under Edit/Render Pipeline menu
+- Color (HDR) field to tree branch shader. Transmission color is now also HDR-enabled.
+
+Fixed:
+- Errors in built-in water shader when reflection probe box projection wasn't enabled
+
+1.5.1
+
+Added:
+- Pigment Map Generator now has a resolution parameter, and option to assign all active terrains
+
+Fixed:
+- (URP) Foliage shader light transmission effect is now influenced by directional light intensity
+- (URP) Particle effect materials now convert completely when installing URP shaders (materials must still be selected once, before changes apply)
+
+1.5.0
+Minimum supported version is now Unity 2017.4.0
+
+Added support for the Universal Render Pipeline in Unity 2019.3+. Shaders can be unpacked and FAE materials converted through the Help menu. 
+
+Notes:
+- Grass is not available for the URP, the Stylized Grass Shader package offers a fully fledged URP grass shader. Grass materials will automatically use the foliage shader instead.
+- LOD Crossfading is unavailable in the URP
+- Custom shader UI's aren't supported by Shader Graph, material inspectors will use default formatting
+
+Added:
+- Revised water shader for the URP with improved intersection effect and shoreline waves.
+
+Changed:
+- Improved color padding on vegetation texture atlas, no longer shows dark edges on some plants on lower mipmaps
+- (URP) Tree branches, light transmission is now masked by shadows
+- Greatly reduced file size of cliff textures with no discernible quality loss (90mb savings)
+- Shader controllers for Vegetation Studio Pro are now included in this package and support URP shaders
+
+1.4.1
+Fixed:
+- Tree branch shader turning black if Directional Light was disabled or when using Mixed lighting with baked lightmaps.
+- Shaders now receive lighting from Spot/Point lights in Forward Rendering when using Vegetation Studio
+- Removed empty LOD2 from GrassPatch prefab, which prevented it from being used with Vegetation Studio Pro
+
+1.4.0
+- Unity 2019.3 compatibility verified
+- All Substance materials have been replaced by textures
+
+Added:
+- Grass patch prefab, designed for mass placement
+
+Changed:
+- Cliff shaders now support Vegetation Studio's Instanced Indirect rendering
+- Demo scenes now have post processing set up by default (Requires Post Processing package to be installed)
+
+Fixed:
+- Improved quality of tree billboard normal maps, fixes black billboards in Unity 2019.2+
+
+1.3.1
+
+Changed:
+- Shading improvements for SpeedTree assets
+
+Fixed:
+- Custom pigment map option not accessible
+
+1.3.0
+
+Added:
+- Ivy kit, consisting out of 6 variants
+- Profile and LUT for the Post Processing Stack v2
+
+Changed:
+- PigmentMapGenerator
+	* Texture operations are now performed on the GPU resulting in much faster rendering
+	* Now has the option to manually input the terrain's size and position
+- Foliage shader now has controls for global wind motion and leaf flutter
+- Wind Controller, direction is now solely determined by the object's forward axis.
+
+Fixed:
+- Black color bleeding on elephant ear plant
+- PigmentMapGenerator rendering half of the terrain when Game View is open and set to "Free Aspect"
+
+Removed:
+- Option to use legacy vertex color layout for tree branch and trunk shaders
+
+1.2.6
+- Checked for compatibility with v2.0.2 of the Substance plugin
+- Minor changes and improvements
+
+1.2.5:
+Added:
+ - Grass terrain substance, rocks layer
+ - Dirt terrain substance, more controls for rocks
+
+Fixed:
+ - PigmentMapGenerator fixes for some scenarios
+
+1.2.4:
+Fixed:
+- Grass and foliage shader, light transmission issue on OpenGL
+- PigmentMapGenerator fixes for some scenarios
+- (2018+) Compatibility with Substance plugin v2.0.1
+
+1.2.3
+Added:
+- WindController can now adjust the overall wind effect based on a WindZone's "Main" value.
+
+Fixed:
+- Water shader not compiling on MacOS when using Metal rendering
+
+Changed:
+- Foliage shader now uses a different wind animation method, resulting in less mesh deformation
+- PigmentMapGenerator, improved workflow when using MegaSplat
+- PigmentMapGenerator, improved support for mesh terrains with a centered pivot point.
+- Minor improvements to tree branch shader
+- Removed LOD group from plants with only one mesh
+
+1.2.2
+Unity 2018.1+: Substances have been converted to regular textures. Go to Help->Fantasy Adventure Environment to install Substance functionality.
+
+1.2.1
+Added:
+- Vegetation shaders now support Instanced Indirect rendering
+- Tree Branch shader now has a toggle to read SpeedTree wind for trees made using the Unity SpeedTree modeler
+
+Changed:
+- Usage of vertex color channels Blue and Alpha have been swapped, to be more in line with third-party baking tools.
+A "Use Legacy Vertex Colors" toggle has been added to the Branch and Trunk shaders to swap them back.
+- Optimized lightmap scale for all asset prefabs
+
+Fixed:
+- Warnings regarding Birch trees when using realtime GI
+
+1.2.0
+Updated minimum supported version to Unity 5.6 to make full use of GPU-instancing
+
+Added:
+- About window
+- PigmentMapGenerator support for multi-terrain setups, please view the documentation for usage instructions
+- Arrow gizmo to WindController
+- Grass shader support for Vegetation Studio's TouchReact system. Flattened grass is also tinted slightly darker.
+- Nav Mesh Obstacle component to all trees
+- WindTrails particle effect
+
+Changed:
+- Recompiled shaders using latest ASE version (1.5.0)
+- WindController no longer utilizes a Substance material
+- WindAmplitude is now a shader value
+- Sunshaft particles now use Soft Particles (Quality Settings) for better performance scaling
+- Sunshafts no longer use the Directional Light's alpha channel for opacity, added an Opacity material parameter instead
+- Grass wind tinting is now influenced by wind strength
+- FoliageBender now adds a slight dark tint to grass
+- Renamed "Resources" folder to "Source", to avoid unneccesary build inclusion
+
+Fixed:
+- Grass light transmission being visible in shadows
+
+Removed:
+- Water/Particles/RockDetail Substance materials (Had no parameters, so were baked to textures)
+
+1.1.2
+Fixed:
+- Build errors on Nintendo Switch
+- Recreated Sunshaft shaders in ASE, fixing PS4 issues
+
+Changed:
+- Removed all third party scripts from demo scene
+
+1.1.1
+Added:
+- Willow_A tree asset (with LODs, billboard and collider)
+- Willow_B tree asset (with LODs, billboard and collider)
+- Ambient Occlusion to tree trunks
+- ShaderGUI for FAE/Tree Trunk shader
+- Current Wind Controller settings information in Shader GUI's when help is toggled
+- Option under GameObject menu to create a new Wind Controller object
+
+Changed:
+Trees:
+- Wind response, Ambient Occlusion and Light Transmission for all trees has been improved and fine-tuned per tree type
+- Corrected normals on Pine_A LOD meshes
+- Corrected UVs of Spruce and Pine tree trunks so the material is less vertically stretched
+- Lowered all trees 0.3 units, so the trunk doesn't appear to float on steep terrain surfaces
+
+Wind:
+- Wind strength is now a shader function and thus can be changed during runtime
+- Wind weight parameter in shaders is renamed to "MaxWindStrength"
+
+Grass:
+- Light transmission now visible in shorter grass as well
+- Improved grass wind color influence (only brightens, rather than darkening and brightening)
+
+1.1.0
+Added:
+- Collider meshes for Palm_B and Palm_C
+- Pigment map generator now has options to flip or rotate the pigment map for mesh terrains
+- Support for a custom pigment map
+
+Changed:
+- Tree trunk gradient is now inverted, making the top darker instead of the bottom (ambient occlusion for trunks to be added)
+- Made wind vectors less uniform (Wind response for trees will soon be improved)
+- Pigment map generator now works with mesh terrains with centered pivots
+- Minor UI improvements
+- Reduced splatmap size in demo scene
+
+Fixed:
+- High trunk weight wind values elongating the trees
+
+1.0.9
+Added
+- Palm_B and Palm_C tree assets (with LODs, billboards)
+- Dead branches to palm trees with separate color controls
+- Custom inspector for WindController script
+- Option to visualize the wind vectors in the Foliage, Grass and Tree Branch shader GUI's
+
+Fixed:
+- Several warnings
+- Substance baker target folder not saving correctly
+
+1.0.8
+Added:
+- Groundcover clovers, dead branches and two elephant ear plants
+- Terrain sand material
+
+Changed:
+- PigmentmapGenerator now also works with mesh terrains
+- Recompiled shaders using Amplify Shader Editor v1.3.4 ("_MaskClipValue" parameter is now called to "_Cutoff", adjusted Shader GUI's accordingly)
+
+1.0.7
+Added:
+- New forest floor Substance material for the terrain, featuring needles, moss, roots, rocks and leafs
+- Ability to bake the Substance textures for the terrain automatically, to allow for easy itteration
+
+Changed:
+- Refactored TerrainRock material, secondary and tertiary layers have been removed, more color properties have been added
+- TerrainSnow material now has a sparkles effect when roughness is set to full
+
+1.0.6
+Added:
+- Custom material inspectors for the Foliage, Grass and Tree Branch shaders. Features buttons to toggle parameter descriptions.
+
+Changed:
+- Removed the height- and pigment map functionality from the Foliage shader. Made a seperate "Grass" shader instead, which does have these features.
+- WindController script, when added, now automatically tries to locate the FAE_WindVectors substance in the project
+- PigmentMapGenerator clears the pigment map texture from the Grass shader when it is disabled. This avoids inadvertently using a pigment map from another scene.
+
+Fixed:
+- Grass animation not working when PigmentMap is deleted
+
+1.0.5
+Added:
+- Grass billboard texture, for use on the terrain (Terrain/Textures folder)
+
+Changed:
+- Made vegetation meshes compatible with Vegetation Studio shaders
+- Checked PigmentmapGenerator compatibilty with MicroSplat, made adjustments accordingly
+- Improved usability of PigmentmapGenerator component
+
+Fixed:
+- Error catching in the PigmentmapGenerator script
+- Corrected normal map behaviour in branch substances
+- Fixed Palm bark artifacts in substance material
+
+Removed:
+- FAE_PigmentMap substance (obsolete)
+- Standard Assets third person controller
+
+1.0.4
+Added:
+- Grass blending with the terrain color is now 100% accurate, and no longer limited to the first 4 terrain textures.
+- Random rotation parameter to GrassAtlas substance
+
+Changed:
+- Polished demo scene some more + performance improvements
+- Cliff shader, increased base-intensity of detail normal map
+- Cliff prefabs, set collider to "Convex" by default, added an optional Box Collider component
+- Seperated the grass substance from the vegetation container
+- Dust motes now use the Sunshaft particle shader, so they react better to lighting conditions
+
+Fixed:
+- CliffAppearance reverting some values to prefab defaults on play
+- Face normals on fern mesh
+
+1.0.3
+Added:
+- Billboard LODs for all trees. Allows you to have much more trees on screen.
+- New Pine bark Substance material
+
+Fixed:
+- Tree branches turning black on DirectX 9
+- Color bleeding on dead pine branches
+- Wrong material on Cliff_E LODs
+
+Changed:
+- Trees now have a capsule collider, so they work as terrain trees. Tree colliders have not been removed, you can use these instead if you wish
+- The Trees Substance container has been split up, each tree type has it's own container now.
+- Spruce_B is now a little more distinct from its counterparts.
+
+1.0.2
+Added:
+- Cliff coverage feature (snow, grass, etc)
+- Custom inspector for CliffAppearance script
+- Demo scene to showcase the cliff coverage functionality
+
+Fixed:
+- Shaders now work correctly on OSX
+
+1.0.1
+Fixed:
+- Tree trunks and branches not moving synchronously when Static Batching is enabled
+- PigmentmapGenerator will now work with any uniform terrain size and position
+
+1.0.0
+Initial release

Assets/Fantasy Adventure Environment/Changelog.txt.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b27dbe64b9567fe4d8f1bb1aaf8768c8
+timeCreated: 1501856553
+licenseType: Store
+TextScriptImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Documentation.url

@@ -0,0 +1,5 @@
+[{000214A0-0000-0000-C000-000000000046}]
+Prop3=19,2
+[InternetShortcut]
+IDList=
+URL=http://staggart.xyz/unity/fantasy-adventure-environment/fae-documentation/

Assets/Fantasy Adventure Environment/Documentation.url.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: be94b4bd91d8c2a45a6952c5606cfcb9
+timeCreated: 1501274475
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Editor.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 55628c1eb68aef5429888e5409ab2804
+folderAsset: yes
+timeCreated: 1508238419
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Editor/CliffAppearanceInspector.cs

@@ -0,0 +1,184 @@
+// Fantasy Adventure Environment
+// Copyright Staggart Creations
+// staggart.xyz
+
+using System;
+using UnityEngine;
+using System.Collections;
+using UnityEditor;
+
+namespace FAE
+{
+    [CustomEditor(typeof(CliffAppearance))]
+    public class CliffAppearanceInspector : Editor
+    {
+        CliffAppearance ca;
+        private bool showHelp = false;
+
+        public SerializedProperty targetMaterials;
+        public SerializedProperty objectColor;
+        public SerializedProperty roughness;
+
+        public SerializedProperty detailNormalMap;
+        public SerializedProperty detailNormalStrength;
+
+        public SerializedProperty globalColorMap;
+        public SerializedProperty globalColor;
+        public SerializedProperty globalTiling;
+
+        public SerializedProperty useCoverageShader;
+        public SerializedProperty coverageColorMap;
+        public SerializedProperty coverageNormalMap;
+        public SerializedProperty coverageAmount;
+        public SerializedProperty coverageTiling;
+        public SerializedProperty coverageMap;
+
+#if UNITY_EDITOR
+        void OnEnable()
+        {
+            ca = (CliffAppearance)target;
+            
+            targetMaterials = serializedObject.FindProperty("targetMaterials");
+
+            objectColor = serializedObject.FindProperty("objectColor");
+            roughness = serializedObject.FindProperty("roughness");
+
+            detailNormalMap = serializedObject.FindProperty("detailNormalMap");
+            detailNormalStrength = serializedObject.FindProperty("detailNormalStrength");
+
+            globalColorMap = serializedObject.FindProperty("globalColorMap");
+            globalColor = serializedObject.FindProperty("globalColor");
+            globalTiling = serializedObject.FindProperty("globalTiling");
+
+            useCoverageShader = serializedObject.FindProperty("useCoverageShader");
+            coverageColorMap = serializedObject.FindProperty("coverageColorMap");
+            coverageNormalMap = serializedObject.FindProperty("coverageNormalMap");
+            coverageAmount = serializedObject.FindProperty("coverageAmount");
+            coverageTiling = serializedObject.FindProperty("coverageTiling");
+            coverageMap = serializedObject.FindProperty("coverageMap");
+
+            Undo.undoRedoPerformed += OnUndoRedo;
+        }
+
+        private void OnDisable()
+        {
+            Undo.undoRedoPerformed -= OnUndoRedo;
+        }
+
+        private void OnUndoRedo()
+        {
+            ca.Apply();
+        }
+
+        public override void OnInspectorGUI()
+        {
+            serializedObject.Update();
+            EditorGUI.BeginChangeCheck();
+
+            if (ca.cliffShader == null) EditorGUILayout.HelpBox("Cliff shader could not be found!", MessageType.Error);
+            if (ca.cliffCoverageShader == null) EditorGUILayout.HelpBox("Cliff Coverage shader could not be found!", MessageType.Error);
+
+            DrawFields();
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                serializedObject.ApplyModifiedProperties();
+                ca.Apply();
+            }
+        }
+
+        private void DrawFields()
+        {
+            DoHeader();
+
+            EditorGUILayout.PropertyField(targetMaterials, true);
+            EditorGUILayout.Space();
+
+            EditorGUILayout.BeginVertical(EditorStyles.helpBox);
+
+            EditorGUILayout.LabelField("Coverage", EditorStyles.boldLabel);
+            EditorGUILayout.Space();
+
+            EditorGUILayout.PropertyField(useCoverageShader, new GUIContent("Enable"));
+
+            if (showHelp) EditorGUILayout.HelpBox("Covers the objects from the Y-axis", MessageType.Info);
+
+            if (ca.useCoverageShader)
+            {
+                EditorGUILayout.HelpBox("Currently this feature requires you to have the PigmentMapGenerator script on your terrain", MessageType.Info);
+
+                EditorGUILayout.PropertyField(coverageMap, new GUIContent("Coverage map"));
+
+                if (showHelp) EditorGUILayout.HelpBox("This grayscale map represents the coverage amount on the terrain \n\nThe bottom left of the texture equals the pivot point of the terrain", MessageType.Info);
+
+                EditorGUILayout.PropertyField(coverageColorMap, new GUIContent("Albedo"));
+                EditorGUILayout.PropertyField(coverageNormalMap, new GUIContent("Normals"));
+
+                EditorGUILayout.PropertyField(coverageAmount, new GUIContent("Amount"));
+                EditorGUILayout.PropertyField(coverageTiling, new GUIContent("Tiling"));
+            }
+
+            EditorGUILayout.Space();
+            EditorGUILayout.EndVertical();
+
+            EditorGUILayout.Space();
+
+            EditorGUILayout.BeginVertical(EditorStyles.helpBox);
+
+            EditorGUILayout.LabelField("Object", EditorStyles.boldLabel);
+            EditorGUILayout.Space();
+
+            EditorGUILayout.PropertyField(objectColor);
+            EditorGUILayout.PropertyField(roughness);
+
+            EditorGUILayout.Space();
+            EditorGUILayout.EndVertical();
+
+            EditorGUILayout.Space();
+
+            EditorGUILayout.BeginVertical(EditorStyles.helpBox);
+
+            EditorGUILayout.LabelField("Detail", EditorStyles.boldLabel);
+            EditorGUILayout.Space();
+
+            if (showHelp) EditorGUILayout.HelpBox("Normal details visible up close", MessageType.Info);
+
+
+            EditorGUILayout.PropertyField(detailNormalMap, new GUIContent("Detail normal map"));
+
+            EditorGUILayout.PropertyField(detailNormalStrength, new GUIContent("Normal strength"));
+
+            EditorGUILayout.Space();
+            EditorGUILayout.EndVertical();
+
+            EditorGUILayout.Space();
+
+            EditorGUILayout.BeginVertical(EditorStyles.helpBox);
+
+            EditorGUILayout.LabelField("Global", EditorStyles.boldLabel);
+            EditorGUILayout.Space();
+
+            if (showHelp) EditorGUILayout.HelpBox("A tri-planar projected color map which tiles across all the objects seamlessly", MessageType.Info);
+
+            EditorGUILayout.PropertyField(globalColorMap, new GUIContent("Global color map"));
+
+            EditorGUILayout.PropertyField(globalColor, new GUIContent("Color"));
+            EditorGUILayout.PropertyField(globalTiling, new GUIContent("Tiling"));
+            
+            EditorGUILayout.Space();
+            EditorGUILayout.EndVertical();
+
+            GUIHelper.DrawFooter();
+        }
+
+        private void DoHeader()
+        {
+            EditorGUILayout.BeginHorizontal();
+            showHelp = GUILayout.Toggle(showHelp, "Toggle help", "Button");
+            GUILayout.Label("FAE Cliff Appearance", GUIHelper.Header);
+            EditorGUILayout.EndHorizontal();
+            if (showHelp) EditorGUILayout.HelpBox("This script allows you to edit multiple materials that use the FAE/Cliff shader. When it's loaded, the settings will be applied to them, so it acts as a sort of preset loader", MessageType.Info);
+        }
+#endif
+    }
+}

Assets/Fantasy Adventure Environment/Editor/CliffAppearanceInspector.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 5d17a1f7b6b847d4f9499d0bfe216b82
+timeCreated: 1503911004
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Editor/FAE_Core.cs

@@ -0,0 +1,346 @@
+// Fantasy Adventure Environment
+// Staggart Creations
+// http://staggart.xyz
+
+using UnityEngine;
+using System.IO;
+
+using UnityEditor;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace FAE
+{
+    public class FAE_Core : Editor
+    {
+        public const string ASSET_NAME = "Fantasy Adventure Environment";
+        public const string ASSET_ABRV = "FAE";
+        public const string ASSET_ID = "70354";
+
+        public const string PACKAGE_VERSION = "20174";
+        public static string INSTALLED_VERSION = "1.5.5";
+        public const string MIN_UNITY_VERSION = "2019.3";
+
+        public static string DOC_URL = "http://staggart.xyz/unity/fantasy-adventure-environment/fae-documentation/";
+        public static string FORUM_URL = "https://forum.unity3d.com/threads/486102";
+
+#if UNITY_2019_3_OR_NEWER
+        private const string UniversalShaderPackageGUID = "7c884420a5dfbaa4db9afe42d366b843";
+#endif
+
+        public static void OpenStorePage()
+        {
+            Application.OpenURL("com.unity3d.kharma:content/" + ASSET_ID);
+        }
+
+        public static string PACKAGE_ROOT_FOLDER
+        {
+            get { return SessionState.GetString(ASSET_ABRV + "_BASE_FOLDER", string.Empty); }
+            set { SessionState.SetString(ASSET_ABRV + "_BASE_FOLDER", value); }
+        }
+
+        public static string GetRootFolder()
+        {
+            //Get script path
+            string[] scriptGUID = AssetDatabase.FindAssets("FAE_Core t:script");
+            string scriptFilePath = AssetDatabase.GUIDToAssetPath(scriptGUID[0]);
+
+            //Truncate to get relative path
+            PACKAGE_ROOT_FOLDER = scriptFilePath.Replace("/Editor/FAE_Core.cs", string.Empty);
+
+#if FAE_DEV
+            Debug.Log("<b>Package root</b> " + PACKAGE_ROOT_FOLDER);
+#endif
+
+            return PACKAGE_ROOT_FOLDER;
+        }
+
+#if UNITY_2019_3_OR_NEWER
+        public enum ShaderInstallation
+        {
+            BuiltIn,
+            UniversalRP
+        }
+
+        public class RunOnImport : AssetPostprocessor
+        {
+            static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
+            {
+                foreach (string str in importedAssets)
+                {
+                    if (str.Contains("FAE_Core.cs"))
+                    {
+                        GetRootFolder();
+
+                        string urpFolder = FAE_Core.PACKAGE_ROOT_FOLDER + "/Shaders/URP/";
+
+                        var info = new DirectoryInfo(urpFolder);
+                        FileInfo[] fileInfo = info.GetFiles();
+
+                        //Only one file in the folder, shaders not yet unpacked
+                        if (fileInfo.Length <= 2 && UnityEngine.Rendering.GraphicsSettings.renderPipelineAsset != null)
+                        {
+                            if (EditorUtility.DisplayDialog("Fantasy Adventure Environment", "The Universal Render Pipeline is in use.\n\nURP compatible shaders can be unpacked and materials upgraded through the \"Help\" window after importing has finished\n\nErrors about _GrabTexture can safely be ignored.", "OK"))
+                            {
+
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        private const string urpName = "Universal Render Pipeline";
+
+        //Look up table to finding pipeline shader variants
+        private static Dictionary<string, string> ShaderRelations = new Dictionary<string, string>
+        {
+            //Peartickles
+            //Since 7.4.1, the legacy particle shaders will work
+            //{ "Legacy Shaders/Particles/Alpha Blended", urpName + "/Particles/Simple Lit" },
+
+			//No longer needed to convert particle materials. Barely works, so particle materials are now packaged for URP
+            //{ "Particles/Alpha Blended", urpName + "/Particles/Simple Lit" },
+            //{ "Mobile/Particles/Alpha Blended", urpName + "/Particles/Simple Lit" },
+            //{ "Particles/Standard Surface", urpName + "/Particles/Simple Lit" },
+            //{ "Particles/Standard Unlit", urpName + "/Particles/Unlit" },
+
+            { "Standard", urpName + "/Lit" },
+            { "Skybox/Cubemap","Skybox/Cubemap" },
+            { "Nature/Terrain/Standard", urpName + "/Terrain/Lit" },
+
+            { "FAE/Fog sheet", urpName + "/FAE/FAE_FogSheet" },
+            { "FAE/Sunshaft", urpName + "/FAE/FAE_Sunshaft" },
+            //{ "FAE/Sunshaft particle", urpName + "/FAE/FAE_SunshaftParticle" },
+
+            { "FAE/Cliff", urpName + "/FAE/FAE_Cliff" },
+            { "FAE/Cliff coverage", urpName + "/FAE/FAE_Cliff_Coverage" },
+
+            { "FAE/Water", urpName + "/FAE/FAE_Water" },
+            { "FAE/Waterfall", urpName + "/FAE/FAE_Waterfall" },
+            { "FAE/Waterfall foam", urpName + "/FAE/FAE_WaterfallFoam" },
+
+            { "FAE/Foliage", urpName+ "/FAE/FAE_Foliage" },
+            { "FAE/Tree Branch", urpName+ "/FAE/FAE_TreeBranch" },
+            { "FAE/Tree Trunk", urpName+ "/FAE/FAE_TreeTrunk" },
+            { "FAE/Tree Billboard", urpName+ "/FAE/FAE_TreeBillboard" }
+        };
+
+        [MenuItem("Edit/Render Pipeline/Fantasy Adventure Environment/Revert to Built-in")]
+        public static void InstallBuiltIn()
+        {
+            InstallShaders(ShaderInstallation.BuiltIn);
+        }
+
+        [MenuItem("Edit/Render Pipeline/Fantasy Adventure Environment/Convert to URP")]
+        public static void InstallURP()
+        {
+
+#if UNITY_2019_3_OR_NEWER && FAE_DEV
+            SwitchRenderPipeline.SetPipeline(ShaderInstallation.UniversalRP);
+#endif
+
+            if (UnityEngine.Rendering.GraphicsSettings.renderPipelineAsset == null)
+            {
+                if (EditorUtility.DisplayDialog("Fantasy Adventure Environment", "No URP asset has been assigned in the Graphics settings. URP should be set up, before converting the package.", "Show me", "Cancel"))
+                {
+                    SettingsService.OpenProjectSettings("Project/Graphics");
+                    return;
+                }
+            }
+
+            InstallShaders(ShaderInstallation.UniversalRP);
+        }
+
+        public static void InstallShaders(ShaderInstallation config)
+        {
+            string guid = UniversalShaderPackageGUID;
+            string packagePath = AssetDatabase.GUIDToAssetPath(guid);
+
+            GetRootFolder();
+
+            //TODO: Package up current shaders
+            if (config == ShaderInstallation.BuiltIn)
+            {
+                //AssetDatabase.ExportPackage(PACKAGE_ROOT_FOLDER + "/Shaders/URP", packagePath, ExportPackageOptions.Default | ExportPackageOptions.Recurse);
+
+                UpgradeMaterials(config);
+            }
+            else
+            {
+                if (packagePath == string.Empty)
+                {
+                    Debug.LogError("URP Shader/material package with the GUID: " + guid + ". Could not be found in the project, was it changed or not imported? It should be located in <i>" + PACKAGE_ROOT_FOLDER + "/Shaders/URP</i>");
+                    return;
+                }
+                AssetDatabase.ImportPackage(packagePath, false);
+                AssetDatabase.importPackageCompleted += new AssetDatabase.ImportPackageCallback(ImportURPCallback);
+            }
+
+#if UNITY_2019_3_OR_NEWER && FAE_DEV
+            SwitchRenderPipeline.SetPipeline(config);
+#endif
+
+        }
+
+        static void ImportURPCallback(string packageName)
+        {
+            AssetDatabase.Refresh();
+
+            UpgradeMaterials(ShaderInstallation.UniversalRP);
+
+            AssetDatabase.importPackageCompleted -= ImportURPCallback;
+        }
+
+        public static void UpgradeMaterials(ShaderInstallation config)
+        {
+            string[] GUIDs = AssetDatabase.FindAssets("t: material", new string[] { PACKAGE_ROOT_FOLDER });
+
+            int count = 0;
+            if (GUIDs.Length > 0)
+            {
+                Material[] mats = new Material[GUIDs.Length];
+
+                for (int i = 0; i < mats.Length; i++)
+                {
+                    EditorUtility.DisplayProgressBar("Material configuration", "Converting FAE materials for " + config, (float)i / mats.Length);
+                    string path = AssetDatabase.GUIDToAssetPath(GUIDs[i]);
+
+                    mats[i] = (Material)AssetDatabase.LoadAssetAtPath(path, typeof(Material));
+
+                    string dest = string.Empty;
+                    string source = mats[i].shader.name;
+                    bool matched = ShaderRelations.TryGetValue(source, out dest);
+
+                    if (config == ShaderInstallation.BuiltIn)
+                    {
+                        //Get key by value (inverse lookup)
+                        dest = ShaderRelations.FirstOrDefault(x => x.Value == source).Key;
+
+                        matched = dest != null;
+                    }
+
+                    if (config == ShaderInstallation.UniversalRP)
+                    {
+                        //Set grass to foliage shader
+                        if (source == "FAE/Grass")
+                        {
+                            dest = urpName + "/FAE/FAE_Foliage";
+                            matched = true;
+                        }
+                    }
+                    if (config == ShaderInstallation.BuiltIn)
+                    {
+                        //Set foliage to grass shader
+                        if (mats[i].name.Contains("Grass"))
+                        {
+                            dest = "FAE/Grass";
+                            matched = true;
+                        }
+                    }
+
+                    if (source == null && dest == null) continue;
+                    if (string.Equals(dest, source)) continue;
+
+                    if (matched)
+                    {
+
+                        if (config == ShaderInstallation.UniversalRP)
+                        {
+                            Texture mainTex = null;
+                            if (mats[i].HasProperty("_MainTex")) mainTex = mats[i].GetTexture("_MainTex");
+                            
+                            if (mats[i].HasProperty("_Color")) mats[i].SetColor("_BaseColor", mats[i].GetColor("_Color"));
+                            if (mats[i].HasProperty("_TintColor")) mats[i].SetColor("_BaseColor", mats[i].GetColor("_TintColor"));
+
+                            //Grass to foliage switch
+                            if (mats[i].HasProperty("_ColorTop")) mats[i].SetColor("_Color", mats[i].GetColor("_ColorTop"));
+
+                            if (mats[i].HasProperty("_MainTex"))
+                            {
+                                mats[i].SetTexture("_BaseMap", mainTex);
+                            }
+
+                            if (mats[i].name.Contains("Grass"))
+                            {
+                                mats[i].SetFloat("_MaxWindStrength", 0.2f);
+                                mats[i].SetFloat("_AmbientOcclusion", 0.15f);
+                            }
+
+                            mats[i].shader = Shader.Find(dest);
+                            
+                            if (mainTex) mats[i].SetTexture("_BaseMap", mainTex);
+                            
+                        }
+
+                        if (mats[i].HasProperty("_TransmissionAmount"))
+                        {
+                            mats[i].SetFloat("_TransmissionAmount", Mathf.Clamp(mats[i].GetFloat("_TransmissionAmount"), 0, 10));
+                        }
+
+                        //Debug.Log("src: " + source + " dst:" + dest);
+                        mats[i].shader = Shader.Find(dest);
+
+                        EditorUtility.SetDirty(mats[i]);
+                        count++;
+                    }
+                    else
+                    {
+#if FAE_DEV
+                        Debug.LogError("No matching " + config + " shader could be found for " + mats[i].shader.name);
+#endif
+                    }
+                }
+                EditorUtility.ClearProgressBar();
+                
+                Debug.Log(count + " materials were configured for the " + config + " render pipeline");
+
+                AssetDatabase.Refresh();
+                AssetDatabase.SaveAssets();
+
+                if (config == ShaderInstallation.UniversalRP)
+                {
+                    delayTime = (float)EditorApplication.timeSinceStartup + renameDelaySec;
+                    EditorApplication.update += PostURPConversion;
+                }
+            }
+        }
+
+        private static float delayTime;
+        private const float renameDelaySec = 1f;
+        
+        private static void PostURPConversion()
+        {
+            //Wait 1s
+            if (EditorApplication.timeSinceStartup >= delayTime)
+            {
+                EditorApplication.update -= PostURPConversion;
+      
+                //If any controllers are present in the open scene, these need to be nudged to apply the correct shaders
+                CliffAppearance[] cliffControllers = GameObject.FindObjectsOfType<CliffAppearance>();
+                for (int i = 0; i < cliffControllers.Length; i++)
+                {
+                    cliffControllers[i].OnEnable();
+                }
+
+                string[] shaderFileGUIDS = AssetDatabase.FindAssets("t: Shader", new[] {PACKAGE_ROOT_FOLDER + "/Shaders/URP"});
+
+                //Force a re-import of the Shader Graphs, depending on the angle of the sun, and the orbit of Jupiter, they fail to reference the FAE.hlsl file if imported last
+                for (int i = 0; i < shaderFileGUIDS.Length; i++)
+                {
+                    AssetDatabase.ImportAsset(AssetDatabase.GUIDToAssetPath(shaderFileGUIDS[i]));
+                }
+                
+                if (EditorUtility.DisplayDialog("Fantasy Adventure Environment", "Ensure the Depth/Opaque Texture options are enabled in your pipeline settings, otherwise the water isn't visible in the game view", "Show me", "OK"))
+                {
+                    Selection.activeObject = UnityEngine.Rendering.GraphicsSettings.renderPipelineAsset;
+                }
+                
+                AssetDatabase.SaveAssets();
+                
+            }
+            
+        }
+#endif
+    }
+}//namespace

Assets/Fantasy Adventure Environment/Editor/FAE_Core.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 0c8c137adabdd2247bf1ed12c029b1dc
+timeCreated: 1521298829
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Editor/FoliageShaderGUI.cs

@@ -0,0 +1,230 @@
+// Fantasy Adventure Environment
+// Copyright Staggart Creations
+// staggart.xyz
+
+using UnityEngine;
+using UnityEditor;
+using System.Collections;
+
+namespace FAE
+{
+    public class FoliageShaderGUI : ShaderGUI
+    {
+
+        MaterialProperty _MaskClipValue;
+
+        //Main maps
+        MaterialProperty _MainTex;
+        MaterialProperty _BumpMap;
+        MaterialProperty _Color;
+
+        //Color
+        MaterialProperty _WindTint;
+        MaterialProperty _AmbientOcclusion;
+        MaterialProperty _TransmissionSize;
+        MaterialProperty _TransmissionAmount;
+
+        //Animation
+        MaterialProperty _MaxWindStrength;
+        MaterialProperty _GlobalWindMotion;
+        MaterialProperty _LeafFlutter;
+        MaterialProperty _WindAmplitudeMultiplier;
+        MaterialProperty _WindSwinging;
+        MaterialProperty _BendingInfluence;
+
+        MaterialEditor m_MaterialEditor;
+        private Material targetMat;
+        
+        //Meta
+        bool showHelp;
+        bool showHelpColor;
+        bool showHelpAnimation;
+
+        bool hasWindController;
+        WindController windController;
+
+        GUIContent mainTexName = new GUIContent("Diffuse", "Diffuse (RGB) and Transparency (A)");
+        GUIContent normalMapName = new GUIContent("Normal Map");
+        private bool visualizeVectors;
+
+        public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props)
+        {
+            if (windController == null) LocateWindController();
+
+            //Receive
+            visualizeVectors = WindController._visualizeVectors;
+
+            this.m_MaterialEditor = materialEditor;
+            targetMat = (Material)materialEditor.target;
+            
+            this.FindProperties(props);
+            //Style similar to Standard shader
+            m_MaterialEditor.SetDefaultGUIWidths();
+            m_MaterialEditor.UseDefaultMargins();
+            EditorGUIUtility.labelWidth = 0f;
+
+#if UNITY_2019_3_OR_NEWER
+            if (UnityEngine.Rendering.GraphicsSettings.currentRenderPipeline != null &&
+                !targetMat.shader.name.Contains("Universal Render Pipeline"))
+            {
+                EditorGUILayout.HelpBox("A render pipeline is in use, but this material is using a shader for the Built-in render pipeline.\n\nShaders and materials can be converted through the Help window", MessageType.Error);
+                EditorGUILayout.Space();
+            }
+#endif
+            
+            EditorGUI.BeginChangeCheck();
+
+            //Draw fields
+            DoHeader();
+
+            DoMapsArea();
+            DoColorArea();
+            DoAnimationArea();
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                //Send
+                WindController.VisualizeVectors(visualizeVectors);
+            }
+
+            GUIHelper.DrawExtraFields(m_MaterialEditor);
+            GUIHelper.DrawFooter();
+        }
+
+        void DoHeader()
+        {
+            EditorGUILayout.BeginHorizontal();
+            showHelp = GUILayout.Toggle(showHelp, "Toggle help", "Button");
+            GUILayout.Label("FAE Foliage Shader", GUIHelper.Header);
+            EditorGUILayout.EndHorizontal();
+            if (showHelp) EditorGUILayout.HelpBox("Please bear in mind, when using custom meshes, that most shader feature require the tips of the mesh to be vertex colored.\n\nBaking Ambient Occlusion into the vertex colors will yield correct results.", MessageType.Warning);
+        }
+
+        void DoMapsArea()
+        {
+            GUILayout.Label("Main maps", EditorStyles.boldLabel);
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.PrefixLabel(_MaskClipValue.displayName);
+            _MaskClipValue.floatValue = EditorGUILayout.Slider(_MaskClipValue.floatValue, 0f, 1f);
+            EditorGUILayout.EndHorizontal();
+            this.m_MaterialEditor.TexturePropertySingleLine(mainTexName, this._MainTex);
+            if(targetMat.HasProperty("_BumpMap"))this.m_MaterialEditor.TexturePropertySingleLine(normalMapName, this._BumpMap);
+
+            EditorGUILayout.Space();
+        }
+
+        void DoColorArea()
+        {
+            EditorGUILayout.BeginHorizontal();
+            showHelpColor = GUILayout.Toggle(showHelpColor, "?", "Button", GUILayout.Width(25f)); GUILayout.Label("Color", EditorStyles.boldLabel);
+            EditorGUILayout.EndHorizontal();
+
+            m_MaterialEditor.ShaderProperty(_Color, _Color.displayName);
+            m_MaterialEditor.ShaderProperty(_AmbientOcclusion, _AmbientOcclusion.displayName);
+            if (showHelpColor) EditorGUILayout.HelpBox("Darkens the areas of the mesh where vertex colors are applied", MessageType.None);
+            m_MaterialEditor.ShaderProperty(_TransmissionAmount, _TransmissionAmount.displayName);
+            if (showHelpColor) EditorGUILayout.HelpBox("Simulates light passing through the material. This will have no effect on short grass.", MessageType.None);
+            m_MaterialEditor.ShaderProperty(_TransmissionSize, _TransmissionSize.displayName);
+
+            EditorGUILayout.Space();
+        }
+
+        void DoAnimationArea()
+        {
+            EditorGUILayout.BeginHorizontal();
+            showHelpAnimation = GUILayout.Toggle(showHelpAnimation, "?", "Button", GUILayout.Width(25f)); GUILayout.Label("Wind animation", EditorStyles.boldLabel);
+            EditorGUILayout.EndHorizontal();
+
+#if UNITY_2019_3_OR_NEWER
+            if (UnityEngine.Rendering.GraphicsSettings.currentRenderPipeline == null)
+            {
+#endif
+            visualizeVectors = EditorGUILayout.Toggle("Visualize wind", visualizeVectors);
+#if UNITY_2019_3_OR_NEWER
+            }
+#endif
+
+#if !VEGETATION_STUDIO_PRO //VS Pro has an FAE wind controller
+            if (!hasWindController)
+            {
+                EditorGUILayout.HelpBox("No \"WindController\" component was found in your scene. Please add this script to an empty GameObject\n\nA prefab can be found in the Prefabs/Effects folder.", MessageType.Warning);
+                EditorGUI.BeginDisabledGroup(true);
+            }
+#else
+            EditorGUI.BeginDisabledGroup(false);
+#endif
+            if (showHelpAnimation) EditorGUILayout.HelpBox("Toggle a visualisation of the wind vectors on all the objects that use FAE shaders featuring wind.\n\nThis allows you to more clearly see the effects of the settings.", MessageType.None);
+
+            m_MaterialEditor.ShaderProperty(_MaxWindStrength, _MaxWindStrength.displayName);
+            if (showHelpAnimation) EditorGUILayout.HelpBox("Determines how much influence the wind has on the object", MessageType.None);
+            m_MaterialEditor.ShaderProperty(_GlobalWindMotion, _GlobalWindMotion.displayName);
+            if (showHelpAnimation) EditorGUILayout.HelpBox("Back and forth motion", MessageType.None);
+            m_MaterialEditor.ShaderProperty(_LeafFlutter, _LeafFlutter.displayName);
+            if (showHelpAnimation) EditorGUILayout.HelpBox("Local wind turbulence", MessageType.None);
+            m_MaterialEditor.ShaderProperty(_WindAmplitudeMultiplier, _WindAmplitudeMultiplier.displayName);
+            if (showHelpAnimation) EditorGUILayout.HelpBox("Multiply the wind amplitude for this material.Essentally this is the size of the wind waves.", MessageType.None);     
+            m_MaterialEditor.ShaderProperty(_WindSwinging, _WindSwinging.displayName);
+            if (showHelpAnimation) EditorGUILayout.HelpBox("Higher values mean the object always sways back against the wind direction", MessageType.None);
+
+            if (targetMat.HasProperty("_WindTint"))
+            {
+                m_MaterialEditor.ShaderProperty(_WindTint, _WindTint.displayName);
+                if (showHelpAnimation)
+                    EditorGUILayout.HelpBox("Vizualises the wind by adding a slight tint, either dark (<0) or light (>0)", MessageType.None);
+            }
+
+            if (showHelpAnimation) EditorGUILayout.HelpBox("Multiply the wind amplitude for this material. Essentally this is the size of the wind waves.", MessageType.None);
+            if (!hasWindController)
+            {
+                EditorGUI.EndDisabledGroup();
+            }
+            m_MaterialEditor.ShaderProperty(_BendingInfluence, _BendingInfluence.displayName);
+            if (showHelpAnimation) EditorGUILayout.HelpBox("Determines how much influence the FoliageBender script has on the object", MessageType.None);
+
+            if (hasWindController && showHelpAnimation)
+            {
+                GUIHelper.DrawWindInfo();
+            }
+
+            EditorGUILayout.Space();
+        }
+
+        void LocateWindController()
+        {
+            //Debug.Log("Searching scene for WindController script");
+            windController = GameObject.FindObjectOfType<WindController>();
+            hasWindController = (windController) ? true : false;
+        }
+
+        public void FindProperties(MaterialProperty[] props)
+        {
+            //Rendering
+#if UNITY_2017_1_OR_NEWER
+            _MaskClipValue = FindProperty("_Cutoff", props);
+#else
+            _MaskClipValue = FindProperty("_Cutoff", props);
+#endif
+
+            //Main maps
+            _MainTex = FindProperty("_MainTex", props);
+            if(targetMat.HasProperty("_BumpMap")) _BumpMap = FindProperty("_BumpMap", props);
+
+            //Color
+            if(targetMat.HasProperty("_WindTint")) _WindTint = FindProperty("_WindTint", props);
+            _Color = FindProperty("_Color", props);
+            _AmbientOcclusion = FindProperty("_AmbientOcclusion", props);
+            _TransmissionSize = FindProperty("_TransmissionSize", props);
+            _TransmissionAmount = FindProperty("_TransmissionAmount", props);
+
+            //Animation
+            _MaxWindStrength = FindProperty("_MaxWindStrength", props);
+            _GlobalWindMotion = FindProperty("_GlobalWindMotion", props);
+            _LeafFlutter = FindProperty("_LeafFlutter", props);
+            _WindAmplitudeMultiplier = FindProperty("_WindAmplitudeMultiplier", props);
+            _WindSwinging = FindProperty("_WindSwinging", props);
+            _BendingInfluence = FindProperty("_BendingInfluence", props);
+
+        }
+
+    }
+}

Assets/Fantasy Adventure Environment/Editor/FoliageShaderGUI.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 30049f26bb0234d408a88ce9718c6d89
+timeCreated: 1507713339
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Editor/GUIHelper.cs

@@ -0,0 +1,75 @@
+using UnityEngine;
+using UnityEditor;
+using System.Collections;
+
+namespace FAE
+{
+    /// <summary>
+    /// Helper class to centralize commonly used fields and styles used in inspectors
+    /// </summary>
+    public class GUIHelper : Editor
+    {
+        /// <summary>Draws the Staggart Creations footer</summary>
+        public static void DrawFooter()
+        {
+            GUILayout.Label("- Staggart Creations -", new GUIStyle(EditorStyles.centeredGreyMiniLabel)
+            {
+                alignment = TextAnchor.MiddleCenter,
+                wordWrap = true,
+                fontSize = 12
+            });
+        }
+
+        /// <summary>Displays a box with the wind values from the current WindController</summary>
+        public static void DrawWindInfo()
+        {
+            EditorGUILayout.Space();
+            EditorGUILayout.LabelField("Global wind settings", EditorStyles.boldLabel);
+            GUIHelper.ProgressBar(WindController._windStrength, 1f, "Strength");
+            GUIHelper.ProgressBar(WindController._windAmplitude, 32f, "Amplitude");
+            EditorGUILayout.Space();
+
+        }
+
+        private static void ProgressBar(float value, float maxValue, string label)
+        {
+            Rect rect = GUILayoutUtility.GetRect(6, 18, "TextField");
+            EditorGUI.ProgressBar(rect, value / maxValue, label + " (" + value + " / " + maxValue + ")");
+        }
+
+        /// <summary>If the supported Unity version is used, a field for setting the Render Queue and GPU Instancing options is drawn</summary>
+        public static void DrawExtraFields(MaterialEditor m_MaterialEditor)
+        {
+            #if UNITY_5_5_OR_NEWER
+                m_MaterialEditor.RenderQueueField();
+            #endif
+
+            #if UNITY_5_6_OR_NEWER
+                m_MaterialEditor.EnableInstancingField();
+            #endif
+        }
+
+        //Styles
+        private static GUIStyle _Header;
+        public static GUIStyle Header
+        {
+            get
+            {
+                if (_Header == null)
+                {
+                    _Header = new GUIStyle(EditorStyles.centeredGreyMiniLabel)
+                    {
+                        alignment = TextAnchor.MiddleCenter,
+                        wordWrap = true,
+                        fontSize = 12
+                    };
+                }
+
+                return _Header;
+            }
+        }
+
+
+
+    }
+}

Assets/Fantasy Adventure Environment/Editor/GUIHelper.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: faa26d0d74c9e7e4196d401cd5c41108
+timeCreated: 1515666192
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Editor/GrassShaderGUI.cs

@@ -0,0 +1,352 @@
+// Fantasy Adventure Environment
+// Copyright Staggart Creations
+// staggart.xyz
+
+using UnityEngine;
+using UnityEditor;
+using System.Collections;
+
+namespace FAE
+{
+    [ExecuteInEditMode]
+    public class GrassShaderGUI : ShaderGUI
+    {
+
+        MaterialProperty _MaskClipValue;
+
+        //Main maps
+        MaterialProperty _MainTex;
+        MaterialProperty _BumpMap;
+
+        //Color
+        MaterialProperty _ColorTop;
+        MaterialProperty _ColorBottom;
+        MaterialProperty _ColorVariation;
+        MaterialProperty _AmbientOcclusion;
+        MaterialProperty _TransmissionSize;
+        MaterialProperty _TransmissionAmount;
+
+        //Animation
+        MaterialProperty _MaxWindStrength;
+        MaterialProperty _WindSwinging;
+        MaterialProperty _WindAmplitudeMultiplier;
+        MaterialProperty _BendingInfluence;
+
+        //VS Touch Bend
+#if TOUCH_REACT
+        MaterialProperty _VS_TOUCHBEND;
+        MaterialProperty _BendingTint;
+#endif
+
+        //Heightmap
+        MaterialProperty _HeightmapInfluence;
+        MaterialProperty _MinHeight;
+        MaterialProperty _MaxHeight;
+
+        //Pigment map
+        MaterialProperty _PigmentMapInfluence;
+        MaterialProperty _PigmentMapHeight;
+
+        MaterialEditor m_MaterialEditor;
+
+        //Meta
+        bool showHelp;
+        bool showHelpColor;
+        bool showHelpAnimation;
+        bool showHelpBending;
+        bool showHelpHeightmap;
+        bool showHelpPigmentmap;
+#if UNITY_5_5_OR_NEWER
+        bool hasPigmentMap = true;
+#endif
+        bool hasWindController;
+        WindController windController;
+
+        GUIContent mainTexName = new GUIContent("Diffuse", "Diffuse (RGB) and Transparency (A)");
+        GUIContent normalMapName = new GUIContent("Normal Map");
+        private bool visualizeVectors;
+
+        public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props)
+        {
+            if (windController == null) LocateWindController();
+            this.FindProperties(props);
+
+            //Receive
+            visualizeVectors = WindController._visualizeVectors;
+
+            this.m_MaterialEditor = materialEditor;
+
+            //Style similar to Standard shader
+            m_MaterialEditor.SetDefaultGUIWidths();
+            m_MaterialEditor.UseDefaultMargins();
+            EditorGUIUtility.labelWidth = 0f;
+
+            //GetGlobalTexture is only available since Unity 5.5
+#if UNITY_5_5_OR_NEWER
+
+            hasPigmentMap = (Shader.GetGlobalTexture("_PigmentMap")) ? true : false;
+#endif
+
+            EditorGUI.BeginChangeCheck();
+
+            //Draw fields
+            DoHeader();
+
+            DoMapsArea();
+            DoColorArea();
+            DoAnimationArea();
+            DoBendingArea();
+            DoHeightmapArea();
+            DoPigmentMapArea();
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                //Send
+                WindController.VisualizeVectors(visualizeVectors);
+            }
+
+            GUIHelper.DrawExtraFields(m_MaterialEditor);
+            GUIHelper.DrawFooter();
+        }
+
+        void DoHeader()
+        {
+            EditorGUILayout.BeginHorizontal();
+            showHelp = GUILayout.Toggle(showHelp, "Toggle help", "Button");
+            GUILayout.Label("FAE Grass Shader", GUIHelper.Header);
+            EditorGUILayout.EndHorizontal();
+            if (showHelp) EditorGUILayout.HelpBox("Please bear in mind, when using custom meshes, that most shader feature require the top of the mesh to be vertex colored.", MessageType.Warning);
+        }
+
+        void DoMapsArea()
+        {
+            GUILayout.Label("Main maps", EditorStyles.boldLabel);
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.PrefixLabel(_MaskClipValue.displayName);
+            _MaskClipValue.floatValue = EditorGUILayout.Slider(_MaskClipValue.floatValue, 0f, 1f);
+            EditorGUILayout.EndHorizontal();
+            this.m_MaterialEditor.TexturePropertySingleLine(mainTexName, this._MainTex);
+            this.m_MaterialEditor.TexturePropertySingleLine(normalMapName, this._BumpMap);
+
+            EditorGUILayout.Space();
+        }
+
+        void DoColorArea()
+        {
+            EditorGUILayout.BeginHorizontal();
+            showHelpColor = GUILayout.Toggle(showHelpColor, "?", "Button", GUILayout.Width(25f)); GUILayout.Label("Color", EditorStyles.boldLabel);
+            EditorGUILayout.EndHorizontal();
+
+            EditorGUI.BeginDisabledGroup(_PigmentMapInfluence.floatValue == 1);
+            m_MaterialEditor.ShaderProperty(_ColorTop, "Top");
+            m_MaterialEditor.ShaderProperty(_ColorBottom, "Bottom");
+            EditorGUI.EndDisabledGroup();
+
+            if (_PigmentMapInfluence.floatValue == 1)
+            {
+            EditorGUILayout.HelpBox("These colors are disabled because the pigment map influence value is set to 1, so they would have no effect", MessageType.None);
+            }
+
+
+            m_MaterialEditor.ShaderProperty(_ColorVariation, _ColorVariation.displayName);
+            if (showHelpColor) EditorGUILayout.HelpBox("Vizualises the wind by adding a slight white tint. When the wind strength is set 0, this effect doesn't appear", MessageType.None);
+            m_MaterialEditor.ShaderProperty(_AmbientOcclusion, _AmbientOcclusion.displayName);
+            if (showHelpColor) EditorGUILayout.HelpBox("Darkens the areas of the mesh where vertex colors are applied", MessageType.None);
+            m_MaterialEditor.ShaderProperty(_TransmissionAmount, _TransmissionAmount.displayName);
+            if (showHelpColor) EditorGUILayout.HelpBox("Simulates light passing through the material. This will have no effect on short grass.", MessageType.None);
+            m_MaterialEditor.ShaderProperty(_TransmissionSize, _TransmissionSize.displayName);
+
+            EditorGUILayout.Space();
+        }
+
+        void DoAnimationArea()
+        {
+            EditorGUILayout.BeginHorizontal();
+            showHelpAnimation = GUILayout.Toggle(showHelpAnimation, "?", "Button", GUILayout.Width(25f)); GUILayout.Label("Wind animation", EditorStyles.boldLabel);
+            EditorGUILayout.EndHorizontal();
+
+            visualizeVectors = EditorGUILayout.Toggle("Visualize wind", visualizeVectors);
+
+#if !VEGETATION_STUDIO_PRO //VS Pro has an FAE wind controller
+            if (!hasWindController)
+            {
+                EditorGUILayout.HelpBox("No \"WindController\" component was found in your scene. Please add this script to an empty GameObject\n\nA prefab can be found in the Prefabs/Effects folder.", MessageType.Warning);
+                EditorGUI.BeginDisabledGroup(true);
+            }
+#else
+                EditorGUI.BeginDisabledGroup(false);
+#endif
+
+            if (showHelpAnimation) EditorGUILayout.HelpBox("Toggle a visualisation of the wind vectors on all the objects that use FAE shaders featuring wind.\n\nThis allows you to more clearly see the effects of the settings.", MessageType.None);
+
+            m_MaterialEditor.ShaderProperty(_MaxWindStrength, _MaxWindStrength.displayName);
+            if (showHelpAnimation) EditorGUILayout.HelpBox("Determines how much influence the wind has on the object", MessageType.None);
+            m_MaterialEditor.ShaderProperty(_WindSwinging, _WindSwinging.displayName);
+            if (showHelpAnimation) EditorGUILayout.HelpBox("Higher values mean the object always sways back against the wind direction", MessageType.None);
+
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.LabelField(_WindAmplitudeMultiplier.displayName);
+            _WindAmplitudeMultiplier.floatValue = EditorGUILayout.FloatField(_WindAmplitudeMultiplier.floatValue, GUILayout.Width(65f));
+            EditorGUILayout.EndHorizontal();
+
+            if (showHelpAnimation) EditorGUILayout.HelpBox("Multiply the wind amplitude for this material. Essentally this is the size of the wind waves.", MessageType.None);
+            if (!hasWindController)
+            {
+                EditorGUI.EndDisabledGroup();
+            }
+
+            if (hasWindController && showHelpAnimation)
+            {
+                GUIHelper.DrawWindInfo();
+            }
+
+            EditorGUILayout.Space();
+
+        }
+
+        void DoBendingArea()
+        {
+            EditorGUILayout.BeginHorizontal();
+            showHelpBending = GUILayout.Toggle(showHelpBending, "?", "Button", GUILayout.Width(25f)); GUILayout.Label("Bending", EditorStyles.boldLabel);
+            EditorGUILayout.EndHorizontal();
+
+#if TOUCH_REACT
+            m_MaterialEditor.ShaderProperty(_VS_TOUCHBEND, new GUIContent("Use Vegetation Studio TouchBend"));
+            if (showHelpBending) EditorGUILayout.HelpBox("Utilize Vegetation Studio's TouchBendSystem", MessageType.None);
+
+            if (_VS_TOUCHBEND.floatValue == 1)
+            {
+                m_MaterialEditor.ShaderProperty(_BendingTint, _BendingTint.displayName);
+                if (showHelpBending) EditorGUILayout.HelpBox("Darken the grass where it is bending", MessageType.None);
+
+            }
+            else
+#endif
+            {
+                m_MaterialEditor.ShaderProperty(_BendingInfluence, _BendingInfluence.displayName);
+                if (showHelpBending) EditorGUILayout.HelpBox("Determines how much influence the FoliageBender script has on the object", MessageType.None);
+
+            }
+
+            EditorGUILayout.Space();
+        }
+
+        void LocateWindController()
+        {
+            //Debug.Log("Searching scene for WindController script");
+            windController = GameObject.FindObjectOfType<WindController>();
+            hasWindController = (windController) ? true : false;
+        }
+
+        void DoHeightmapArea()
+        {
+            EditorGUILayout.BeginHorizontal();
+            showHelpHeightmap = GUILayout.Toggle(showHelpHeightmap, "?", "Button", GUILayout.Width(25f)); GUILayout.Label("Heightmap", EditorStyles.boldLabel);
+            EditorGUILayout.EndHorizontal();
+#if UNITY_5_5_OR_NEWER
+            if(!hasPigmentMap)
+            {
+            EditorGUILayout.HelpBox("No height map was found, please add the PigmentMapGenerator script to your terrain to enable these features", MessageType.Warning);
+                _HeightmapInfluence.floatValue = 0;
+                EditorGUI.BeginDisabledGroup(true);
+            }
+#endif
+            if (showHelpHeightmap) EditorGUILayout.HelpBox("The heightmap is generated through the PigmentMapGenerator script on your terrain", MessageType.None);
+            m_MaterialEditor.ShaderProperty(_HeightmapInfluence, "Influence");
+            if (showHelpHeightmap) EditorGUILayout.HelpBox("Determines the influence the heightmap has on the object", MessageType.None);
+            m_MaterialEditor.ShaderProperty(_MinHeight, _MinHeight.displayName);
+            if (showHelpHeightmap) EditorGUILayout.HelpBox("Minimum grass height", MessageType.None);
+            m_MaterialEditor.ShaderProperty(_MaxHeight, _MaxHeight.displayName);
+            if (showHelpHeightmap) EditorGUILayout.HelpBox("Maximum grass height", MessageType.None);
+
+            EditorGUILayout.Space();
+#if UNITY_5_5_OR_NEWER
+            if (!hasPigmentMap)
+            {
+                EditorGUI.EndDisabledGroup();
+            }
+#endif
+        }
+
+        void DoPigmentMapArea()
+        {
+
+            EditorGUILayout.BeginHorizontal();
+            showHelpPigmentmap = GUILayout.Toggle(showHelpPigmentmap, "?", "Button", GUILayout.Width(25f)); GUILayout.Label("Pigment map", EditorStyles.boldLabel);
+            EditorGUILayout.EndHorizontal();
+
+#if UNITY_5_5_OR_NEWER
+            if(!hasPigmentMap)
+            {
+                EditorGUILayout.HelpBox("No pigment map was found, please add the PigmentMapGenerator script to your terrain to enable these features", MessageType.Warning);
+                _PigmentMapInfluence.floatValue = 0;
+                EditorGUI.BeginDisabledGroup(true);
+            }
+            
+#endif
+            if (showHelpPigmentmap) EditorGUILayout.HelpBox("The pigment map is generated through the PigmentMapGenerator script on your terrain. It colors the grass by the terrain's color.", MessageType.None);
+            m_MaterialEditor.ShaderProperty(_PigmentMapInfluence, "Influence");
+            if (showHelpPigmentmap) EditorGUILayout.HelpBox("Determines how much the object should be colored through the pigment map", MessageType.None);
+            m_MaterialEditor.ShaderProperty(_PigmentMapHeight, "Height");
+            if (showHelpPigmentmap) EditorGUILayout.HelpBox("With this parameter you can choose to only color the base of the grass", MessageType.None);
+
+            EditorGUILayout.Space();
+            if (showHelpPigmentmap) EditorGUILayout.HelpBox("If your grass is completely white, bring the Influence parameter to 0. Or add the PigmentmapGenerator script to your terrain.", MessageType.Info);
+
+#if UNITY_5_4 && !UNITY_5_5_OR_NEWER
+            if (showHelpPigmentmap) EditorGUILayout.HelpBox("In versions older than Unity 5.5, it is possible for your grass to still be colored by the last pigment map generated", MessageType.Info);
+#endif
+
+
+            EditorGUILayout.Space();
+#if UNITY_5_5_OR_NEWER
+            if (!hasPigmentMap)
+            {
+                EditorGUI.EndDisabledGroup();
+            }
+#endif
+        }
+
+        public void FindProperties(MaterialProperty[] props)
+        {
+            //Rendering
+            _MaskClipValue = FindProperty("_Cutoff", props);
+
+            //Main maps
+            _MainTex = FindProperty("_MainTex", props);
+            _BumpMap = FindProperty("_BumpMap", props);
+
+            //Color
+            _ColorTop = FindProperty("_ColorTop", props);
+            _ColorBottom = FindProperty("_ColorBottom", props);
+            _ColorVariation = FindProperty("_ColorVariation", props);
+            _AmbientOcclusion = FindProperty("_AmbientOcclusion", props);
+            _TransmissionSize = FindProperty("_TransmissionSize", props);
+            _TransmissionAmount = FindProperty("_TransmissionAmount", props);
+
+            //Animation
+            _MaxWindStrength = FindProperty("_MaxWindStrength", props);
+            _WindSwinging = FindProperty("_WindSwinging", props);
+            _WindAmplitudeMultiplier = FindProperty("_WindAmplitudeMultiplier", props);
+            _BendingInfluence = FindProperty("_BendingInfluence", props);
+
+#if TOUCH_REACT
+            //TouchBend
+            _VS_TOUCHBEND = FindProperty("_VS_TOUCHBEND", props);
+            _BendingTint = FindProperty("_BendingTint", props);
+#endif
+
+            //Heightmap
+            _HeightmapInfluence = FindProperty("_HeightmapInfluence", props);
+            _MinHeight = FindProperty("_MinHeight", props);
+            _MaxHeight = FindProperty("_MaxHeight", props);
+
+            //Pigment map
+            _PigmentMapInfluence = FindProperty("_PigmentMapInfluence", props);
+            _PigmentMapHeight = FindProperty("_PigmentMapHeight", props);
+
+
+        }
+
+    }
+}

Assets/Fantasy Adventure Environment/Editor/GrassShaderGUI.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 7bc55a191bff1d64db091bcbb1444cf9
+timeCreated: 1507713339
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Editor/HelpWindow.cs

@@ -0,0 +1,342 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace FAE
+{
+    public class HelpWindow : EditorWindow
+    {
+        //Window properties
+        private static int width = 440;
+        private static int height = 300;
+
+        private bool isTabInstallation = true;
+        private bool isTabGettingStarted = false;
+        private bool isTabSupport = false;
+
+        [MenuItem("Help/Fantasy Adventure Environment", false, 0)]
+        public static void ShowWindow()
+        {
+            EditorWindow editorWindow = EditorWindow.GetWindow<HelpWindow>(false, "About", true);
+            editorWindow.titleContent = new GUIContent("Help " + FAE_Core.INSTALLED_VERSION);
+            editorWindow.autoRepaintOnSceneChange = true;
+
+            //Open somewhat in the center of the screen
+            editorWindow.position = new Rect((Screen.width) / 2f, (Screen.height) / 2f, width, height);
+
+            //Fixed size
+            editorWindow.maxSize = new Vector2(width, height);
+            editorWindow.minSize = new Vector2(width, 200);
+
+            Init();
+
+            editorWindow.Show();
+
+        }
+
+        private void SetWindowHeight(float height)
+        {
+            this.maxSize = new Vector2(width, height);
+            this.minSize = new Vector2(width, height);
+        }
+
+        //Store values in the volatile SessionState
+        static void Init()
+        {
+            FAE_Core.GetRootFolder();
+        }
+
+        void OnGUI()
+        {
+            DrawHeader();
+
+            GUILayout.Space(5);
+            DrawTabs();
+            GUILayout.Space(5);
+
+            EditorGUILayout.BeginVertical(EditorStyles.helpBox);
+
+            if (isTabInstallation) DrawInstallation();
+            if (isTabGettingStarted) DrawGettingStarted();
+            if (isTabSupport) DrawSupport();
+
+            //DrawActionButtons();
+
+            EditorGUILayout.EndVertical();
+
+            DrawFooter();
+
+        }
+
+        void DrawHeader()
+        {
+            EditorGUILayout.Space();
+            EditorGUILayout.LabelField("<b><size=24>Fantasy Adventure Environment</size></b>", Header);
+
+            GUILayout.Label("Version: " + FAE_Core.INSTALLED_VERSION, Footer);
+            EditorGUILayout.LabelField("", GUI.skin.horizontalSlider);
+        }
+
+        void DrawTabs()
+        {
+            EditorGUILayout.BeginHorizontal();
+
+            if (GUILayout.Toggle(isTabInstallation, "Installation", Tab))
+            {
+                isTabInstallation = true;
+                isTabGettingStarted = false;
+                isTabSupport = false;
+            }
+
+            if (GUILayout.Toggle(isTabGettingStarted, "Getting started", Tab))
+            {
+                isTabInstallation = false;
+                isTabGettingStarted = true;
+                isTabSupport = false;
+            }
+
+            if (GUILayout.Toggle(isTabSupport, "Support", Tab))
+            {
+                isTabInstallation = false;
+                isTabGettingStarted = false;
+                isTabSupport = true;
+            }
+
+            EditorGUILayout.EndHorizontal();
+        }
+
+        void DrawInstallation()
+        {
+            SetWindowHeight(335);
+
+            EditorGUILayout.LabelField("Render pipeline conversion", EditorStyles.boldLabel);
+
+#if !UNITY_2019_3_OR_NEWER
+
+            EditorGUILayout.HelpBox("Universal Render Pipeline support requires Unity 2019.3.7f1 or newer", MessageType.Info);
+#else
+            if (UnityEngine.Rendering.GraphicsSettings.renderPipelineAsset == null)
+            {
+                EditorGUILayout.HelpBox("No Scriptable Render Pipeline is currently active", MessageType.Warning);
+            }
+
+#if FAE_DEV
+            EditorGUILayout.BeginHorizontal();
+            {
+                if (GUILayout.Button("<b><size=16>Built-in</size></b>\n<i>Amplify Shader Editor shaders</i>", Button))
+                {
+                    FAE_Core.InstallShaders(FAE_Core.ShaderInstallation.BuiltIn);
+                }
+#endif
+                using (new EditorGUI.DisabledGroupScope(UnityEngine.Rendering.GraphicsSettings.renderPipelineAsset == null))
+                {
+                    if (GUILayout.Button("<b><size=16>Universal Render Pipeline</size></b>\n<i>Unpack Shader Graph shaders and URP materials</i>", Button))
+                    {
+                        FAE_Core.InstallShaders(FAE_Core.ShaderInstallation.UniversalRP);
+                    }
+                }
+#if FAE_DEV
+            }
+            EditorGUILayout.EndHorizontal();
+#endif
+
+            EditorGUILayout.Space();
+
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                EditorGUILayout.HelpBox("Note: Grass shader for the URP is available on the Asset Store", MessageType.Info);
+                if (GUILayout.Button("Open Asset Store", GUILayout.Height(40f), GUILayout.Width(120f)))
+                {
+                    Application.OpenURL("com.unity3d.kharma:content/143830");
+                }
+            }
+#endif
+
+        }
+
+        void DrawGettingStarted()
+        {
+            SetWindowHeight(335);
+
+            EditorGUILayout.HelpBox("Please view the documentation for further details about this package and its workings.", MessageType.Info);
+
+            EditorGUILayout.Space();
+
+            if (GUILayout.Button("<b><size=16>Online documentation</size></b>\n<i>Set up, best practices and troubleshooting</i>", Button))
+            {
+                Application.OpenURL(FAE_Core.DOC_URL + "#getting-started-3");
+            }
+
+        }
+
+        void DrawSupport()
+        {
+            SetWindowHeight(350f);
+
+            EditorGUILayout.BeginVertical(); //Support box
+
+            EditorGUILayout.HelpBox("If you have any questions, or ran into issues, please get in touch!", MessageType.Info);
+
+            EditorGUILayout.Space();
+
+            //Buttons box
+            EditorGUILayout.BeginHorizontal();
+            if (GUILayout.Button("<b><size=12>Email</size></b>\n<i>Contact</i>", Button))
+            {
+                Application.OpenURL("mailto:contact@staggart.xyz");
+            }
+            if (GUILayout.Button("<b><size=12>Twitter</size></b>\n<i>Follow developments</i>", Button))
+            {
+                Application.OpenURL("https://twitter.com/search?q=staggart%20creations");
+            }
+            if (GUILayout.Button("<b><size=12>Forum</size></b>\n<i>Join the discussion</i>", Button))
+            {
+                Application.OpenURL(FAE_Core.FORUM_URL);
+            }
+            EditorGUILayout.EndHorizontal();//Buttons box
+
+            EditorGUILayout.EndVertical(); //Support box
+        }
+
+        private void DrawActionButtons()
+        {
+            EditorGUILayout.Space();
+            EditorGUILayout.BeginHorizontal();
+
+
+            if (GUILayout.Button("<size=12>Rate</size>", Button))
+                Application.OpenURL("https://www.assetstore.unity3d.com/en/#!/account/downloads/search=");
+
+            if (GUILayout.Button("<size=12>Review</size>", Button))
+                Application.OpenURL("");
+
+
+            EditorGUILayout.EndHorizontal();
+            EditorGUILayout.Space();
+        }
+
+        private void DrawFooter()
+        {
+            //EditorGUILayout.Space();
+            EditorGUILayout.LabelField("", GUI.skin.horizontalSlider);
+            EditorGUILayout.Space();
+            GUILayout.Label("- Staggart Creations -", Footer);
+        }
+
+        #region Styles
+
+        private static GUIStyle _Footer;
+        public static GUIStyle Footer
+        {
+            get
+            {
+                if (_Footer == null)
+                {
+                    _Footer = new GUIStyle(EditorStyles.centeredGreyMiniLabel)
+                    {
+                        alignment = TextAnchor.MiddleCenter,
+                        wordWrap = true,
+                        fontSize = 12
+                    };
+                }
+
+                return _Footer;
+            }
+        }
+
+        private static GUIStyle _Button;
+        public static GUIStyle Button
+        {
+            get
+            {
+                if (_Button == null)
+                {
+                    _Button = new GUIStyle(GUI.skin.button)
+                    {
+                        alignment = TextAnchor.MiddleLeft,
+                        stretchWidth = true,
+                        richText = true,
+                        wordWrap = true,
+                        padding = new RectOffset()
+                        {
+                            left = 14,
+                            right = 14,
+                            top = 8,
+                            bottom = 8
+                        }
+                    };
+                }
+
+                return _Button;
+            }
+        }
+
+        private static GUIStyle _Header;
+        public static GUIStyle Header
+        {
+            get
+            {
+                if (_Header == null)
+                {
+                    _Header = new GUIStyle(GUI.skin.label)
+                    {
+                        richText = true,
+                        alignment = TextAnchor.MiddleCenter,
+                        wordWrap = true,
+                        fontSize = 18,
+                        fontStyle = FontStyle.Bold
+                    };
+                }
+
+                return _Header;
+            }
+        }
+
+        private static Texture _HelpIcon;
+        public static Texture HelpIcon
+        {
+            get
+            {
+                if (_HelpIcon == null)
+                {
+                    _HelpIcon = EditorGUIUtility.FindTexture("d_UnityEditor.InspectorWindow");
+                }
+                return _HelpIcon;
+            }
+        }
+
+
+        private static GUIStyle _Tab;
+        public static GUIStyle Tab
+        {
+            get
+            {
+                if (_Tab == null)
+                {
+                    _Tab = new GUIStyle(EditorStyles.miniButtonMid)
+                    {
+                        alignment = TextAnchor.MiddleCenter,
+                        stretchWidth = true,
+                        richText = true,
+                        wordWrap = true,
+                        fontSize = 12,
+                        fixedHeight = 30f,
+                        fontStyle = FontStyle.Bold,
+                        padding = new RectOffset()
+                        {
+                            left = 14,
+                            right = 14,
+                            top = 8,
+                            bottom = 8
+                        }
+                    };
+                }
+
+                return _Tab;
+            }
+        }
+
+        #endregion //Stylies
+    }//Window Class
+}

Assets/Fantasy Adventure Environment/Editor/HelpWindow.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 4c9c8d7e3ee887b4fa8186d4f51e313d
+timeCreated: 1575711041
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Editor/PigmentMapGeneratorInspector.cs

@@ -0,0 +1,451 @@
+// Fantasy Adventure Environment
+// Copyright Staggart Creations
+// staggart.xyz
+
+using UnityEngine;
+using System.Collections;
+using UnityEditor;
+using UnityEditor.Callbacks;
+using FAE;
+using System;
+
+namespace FAE
+{
+    [CustomEditor(typeof(PigmentMapGenerator))]
+    public class PigmentMapGeneratorInspector : Editor
+    {
+        PigmentMapGenerator pmg;
+
+        new SerializedObject serializedObject;
+
+        SerializedProperty isMultiTerrain;
+        SerializedProperty isMegaSplat;
+
+        SerializedProperty terrainObjects;
+
+        SerializedProperty manualInput;
+        SerializedProperty resIdx;
+        SerializedProperty useCustomPigmentMap;
+        SerializedProperty inputPigmentMap;
+        SerializedProperty layerMask;
+
+        public static string[] reslist = new string[] { "64x64", "128x128", "256x256", "512x512", "1024x1024", "2048x2048", "4096x4096" };
+
+        // Use this for initialization
+        void OnEnable()
+        {
+            pmg = (PigmentMapGenerator)target;
+
+            GetProperties();
+        }
+
+        private void GetProperties()
+        {
+            serializedObject = new SerializedObject(pmg);
+
+            isMultiTerrain = serializedObject.FindProperty("isMultiTerrain");
+            isMegaSplat = serializedObject.FindProperty("isMegaSplat");
+            terrainObjects = serializedObject.FindProperty("terrainObjects");
+
+            manualInput = serializedObject.FindProperty("manualInput");
+            resIdx = serializedObject.FindProperty("resIdx");
+            useCustomPigmentMap = serializedObject.FindProperty("useCustomPigmentMap");
+            inputPigmentMap = serializedObject.FindProperty("customPigmentMap");
+            layerMask = serializedObject.FindProperty("layerMask");
+
+        }
+
+        //Meta
+        private string terrainInfo;
+        private bool showHelp;
+
+        public override void OnInspectorGUI()
+        {
+            DoHeader();
+
+#if UNITY_2019_3_OR_NEWER
+            if (UnityEngine.Rendering.GraphicsSettings.renderPipelineAsset)
+            {
+                EditorGUILayout.HelpBox("Not available in the Universal Render Pipeline.\n\nThe Stylized Grass Shader package is URP compatible", MessageType.Warning);
+
+                GUILayout.Space(-32);
+                using (new EditorGUILayout.HorizontalScope())
+                {
+                    GUILayout.FlexibleSpace();
+                    if (GUILayout.Button("Open Asset Store", GUILayout.Width(120)))
+                    {
+                        Application.OpenURL("com.unity3d.kharma:content/143830");
+                    }
+                    GUILayout.Space(8);
+                }
+                GUILayout.Space(11);
+            }
+#endif
+
+            EditorGUI.BeginChangeCheck();
+
+            serializedObject.Update();
+
+            DrawTerrainInfo();
+
+            EditorGUILayout.PropertyField(useCustomPigmentMap, new GUIContent("Custom pigment map"));
+            if (showHelp) EditorGUILayout.HelpBox("This option allows you to assign a custom pigment map, rather than rendering one.", MessageType.Info);
+
+            EditorGUILayout.Space();
+
+            //Custom pigment map
+            if (useCustomPigmentMap.boolValue)
+            {
+                EditorGUILayout.PropertyField(inputPigmentMap, new GUIContent("Input"));
+
+                if (showHelp) EditorGUILayout.HelpBox("Grass heightmap should be stored in the alpha channel.", MessageType.Info);
+
+                if (pmg.customPigmentMap)
+                {
+                    //Check if input heightmap is readable
+                    try
+                    {
+                        pmg.customPigmentMap.GetPixel(0, 0);
+                    }
+                    catch (UnityException e)
+                    {
+                        if (e.Message.StartsWith("Texture '" + pmg.customPigmentMap.name + "' is not readable"))
+                        {
+
+                            EditorGUILayout.HelpBox("Please enable the Read/Write option on texture \"" + pmg.customPigmentMap.name + "\"\n\nIt accessed be read otherwise.", MessageType.Error);
+                        }
+                    }
+                }
+
+                EditorGUILayout.Space();
+
+            }
+
+            //If terrain list is empty, expand it
+            if (isMultiTerrain.boolValue && terrainObjects.arraySize == 0 && !manualInput.boolValue)
+            {
+                terrainObjects.isExpanded = true;
+            }
+
+            DoTerrainList();
+
+            EditorGUILayout.Space();
+
+            if (!useCustomPigmentMap.boolValue)
+            {
+                //Safety check, required for preventing errors when updating from 1.1.2 to 1.2.0
+                //if (pmg.terrains == null || pmg.terrains.Length == 0) return;
+
+                //If single terrain without any textures
+                if (!isMegaSplat.boolValue)
+                {
+#if UNITY_2018_3_OR_NEWER
+                    if (!isMultiTerrain.boolValue && pmg.workflow == TerrainUVUtil.Workflow.Terrain && pmg.terrains[0].terrainData.terrainLayers.Length == 0)
+#else
+                    if (!isMultiTerrain.boolValue && pmg.workflow == TerrainUVUtil.Workflow.Terrain && pmg.terrains[0].terrainData.splatPrototypes.Length == 0)
+#endif
+                    {
+                        EditorGUILayout.HelpBox("Assign at least one texture to your terrain", MessageType.Error);
+                        return;
+                    }
+                }
+
+                DoHeightMap();
+
+                DoTexTransforms();
+
+                DoRenderer();
+            }
+
+            EditorGUILayout.Space();
+
+            //Button
+            //If multi terrain, with no objects assigned, don't show Generate button
+            if (isMultiTerrain.boolValue && terrainObjects.arraySize == 0 && !manualInput.boolValue)
+            {
+                EditorGUILayout.HelpBox("Assign at least one terrain object", MessageType.Error);
+            }
+
+            EditorGUI.BeginDisabledGroup(isMultiTerrain.boolValue && terrainObjects.arraySize == 0 && !manualInput.boolValue);
+            string buttonLabel = (useCustomPigmentMap.boolValue) ? "Assign" : "Generate";
+            if (GUILayout.Button(buttonLabel, GUILayout.Height(40f)))
+            {
+                pmg.Generate();
+            }
+            EditorGUI.EndDisabledGroup();
+            EditorGUILayout.Space();
+
+            DoPreview();
+
+            //GUIHelper.DrawFooter();
+
+            serializedObject.ApplyModifiedProperties();
+
+            if (GUI.changed || EditorGUI.EndChangeCheck())
+            {
+                EditorUtility.SetDirty((PigmentMapGenerator)target);
+                EditorUtility.SetDirty(this);
+
+            }
+        }
+
+        private void DoHeader()
+        {
+
+            EditorGUILayout.BeginHorizontal();
+            showHelp = GUILayout.Toggle(showHelp, "Toggle help", "Button");
+            GUILayout.Label("FAE Pigmentmap Generator", GUIHelper.Header);
+            EditorGUILayout.EndHorizontal();
+            if (showHelp) EditorGUILayout.HelpBox("This renders a color map from your terrain, which is used by the \"FAE/Grass\" shader to blend the grass color with the terrain.", MessageType.Info);
+            if (showHelp) EditorGUILayout.HelpBox("If you'd like some objects to be included, like cliffs, parent them under your terrain object.", MessageType.Info);
+            if (showHelp) EditorGUILayout.HelpBox("For a multi-terrain setup, add this script to the parent object of your terrain tiles/chunks.", MessageType.Info);
+
+            EditorGUILayout.Space();
+        }
+
+        private void DrawTerrainInfo()
+        {
+            EditorGUILayout.PropertyField(manualInput, new GUIContent("Manual input"));
+            if (showHelp) EditorGUILayout.HelpBox("Allows you to manually set the terrain's size, center and corner values. Particularly useful if your terrain(s) sits in a different scene.", MessageType.Info);
+
+            if (manualInput.boolValue)
+            {
+                pmg.targetCenterPosition = EditorGUILayout.Vector3Field("Center", pmg.targetCenterPosition);
+                pmg.targetSize = EditorGUILayout.Vector3Field("Size", pmg.targetSize);
+                pmg.targetOriginPosition = EditorGUILayout.Vector3Field("Corner/Origin", pmg.targetOriginPosition);
+
+                EditorGUILayout.Space();
+
+                using (new EditorGUILayout.HorizontalScope())
+                {
+                    GUILayout.FlexibleSpace();
+                    if (GUILayout.Button("Apply", EditorStyles.miniButton))
+                    {
+                        Shader.SetGlobalVector("_TerrainUV", new Vector4(pmg.targetSize.x, pmg.targetSize.z, Mathf.Abs(pmg.targetOriginPosition.x), Mathf.Abs(pmg.targetOriginPosition.z)));
+                    }
+                }
+
+                return;
+            }
+
+            terrainInfo = string.Format("Size:           ({0},{1},{2}) \nCenter:       ({3},{4}) \nCorner:       ({5},{6})",
+                Mathf.Round(pmg.targetSize.x),
+                Mathf.Round(pmg.targetSize.y),
+                Mathf.Round(pmg.targetSize.z),
+                Mathf.Round(pmg.targetCenterPosition.x),
+                Mathf.Round(pmg.targetCenterPosition.z),
+                Mathf.Round(pmg.targetOriginPosition.x),
+                Mathf.Round(pmg.targetOriginPosition.z)
+             );
+
+            EditorGUILayout.HelpBox(terrainInfo, MessageType.Info);
+
+            GUILayout.Space(-32);
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                GUILayout.FlexibleSpace();
+                pmg.showArea = GUILayout.Toggle(pmg.showArea, new GUIContent(" Show area", EditorGUIUtility.IconContent("Prefab Icon").image), "Button", GUILayout.MaxHeight(17f));
+                GUILayout.Space(8);
+            }
+            GUILayout.Space(11);
+
+        }
+
+        private void DoTerrainList()
+        {
+            if (isMultiTerrain.boolValue && !manualInput.boolValue)
+            {
+                EditorGUILayout.PropertyField(terrainObjects, new GUIContent("Terrain objects"), true);
+
+                if (terrainObjects.isExpanded)
+                {
+                    EditorGUILayout.HelpBox("The first object in the array must be the corner chunk, where the terrain continues on the postive X and Z axis", MessageType.Warning);
+
+                    using (new EditorGUILayout.HorizontalScope())
+                    {
+                        if (GUILayout.Button("Assign all child objects"))
+                        {
+                            pmg.GetChildTerrainObjects(pmg.transform);
+                        }
+                        if (GUILayout.Button("Add active terrains"))
+                        {
+                            AssignActiveTerrains();
+                        }
+                    }
+                }
+            }
+            else
+            {
+                //Single terrain, don't show array    
+            }
+        }
+
+        private void DoHeightMap()
+        {
+
+            EditorGUILayout.BeginVertical(EditorStyles.helpBox);
+
+            //If is single terrain
+            if (!isMultiTerrain.boolValue && pmg.workflow == TerrainUVUtil.Workflow.Terrain && !isMegaSplat.boolValue && !manualInput.boolValue)
+            {
+
+                EditorGUILayout.LabelField("Grass heightmap", EditorStyles.boldLabel);
+                EditorGUILayout.Space();
+
+                pmg.heightmapChannel = (PigmentMapGenerator.HeightmapChannel)EditorGUILayout.EnumPopup("Height source material", pmg.heightmapChannel);
+                if (showHelp) EditorGUILayout.HelpBox("This is the texture whose painted weight will determine the grass height \n\nThe effect can be controlled through the \"Heightmap influence\" parameter on the FAE/Grass shader", MessageType.None);
+
+                /*
+                if (pmg.heightmapChannel > 0)
+                {
+                    using (new EditorGUILayout.HorizontalScope())
+                    {
+                        GUILayout.FlexibleSpace();
+                        EditorGUILayout.LabelField(pmg.terrains[0].terrainData.splatPrototypes[(int)pmg.heightmapChannel - 1].texture.name);
+                    }
+                }
+                */
+            }
+            //If mesh or multi terrain
+            else
+            {
+                //Field to assign heightmap texture
+                EditorGUILayout.LabelField("Input grass heightmap (optional)", EditorStyles.boldLabel);
+                EditorGUILayout.Space();
+
+                pmg.inputHeightmap = EditorGUILayout.ObjectField("Heightmap", pmg.inputHeightmap, typeof(Texture2D), false) as Texture2D;
+
+                if (showHelp) EditorGUILayout.HelpBox("This information is used in the \"FAE/Grass\" shader to make the grass shorter where desired", MessageType.Info);
+
+                if (pmg.inputHeightmap)
+                {
+                    //Check if input heightmap is readable
+                    try
+                    {
+                        pmg.inputHeightmap.GetPixel(0, 0);
+                    }
+                    catch (UnityException e)
+                    {
+                        if (e.Message.StartsWith("Texture '" + pmg.inputHeightmap.name + "' is not readable"))
+                        {
+
+                            EditorGUILayout.HelpBox("Please enable Read/Write on texture \"" + pmg.inputHeightmap.name + "\"", MessageType.Error);
+                        }
+                    }
+                }
+
+            }
+
+            EditorGUILayout.Space();
+
+            EditorGUILayout.EndVertical();
+        }
+
+        private void DoTexTransforms()
+        {
+            if (pmg.workflow == TerrainUVUtil.Workflow.Terrain) return;
+
+            EditorGUILayout.BeginVertical(EditorStyles.helpBox);
+
+            EditorGUILayout.LabelField("Texture transformation", EditorStyles.boldLabel);
+            EditorGUILayout.Space();
+            if (showHelp) EditorGUILayout.HelpBox("The UV's of your mesh terrain may differ, so these options allow you to compensate for this.", MessageType.Info);
+
+            pmg.flipHortizontally = EditorGUILayout.Toggle("Flip horizontally", pmg.flipHortizontally);
+            pmg.flipVertically = EditorGUILayout.Toggle("Flip vertically", pmg.flipVertically);
+            pmg.textureRotation = (PigmentMapGenerator.TextureRotation)EditorGUILayout.EnumPopup("Rotation", pmg.textureRotation);
+
+            EditorGUILayout.Space();
+            EditorGUILayout.EndVertical();
+        }
+
+        private void DoRenderer()
+        {
+            EditorGUILayout.BeginVertical(EditorStyles.helpBox);
+
+            EditorGUILayout.LabelField("Renderer", EditorStyles.boldLabel);
+            EditorGUILayout.Space();
+
+            if (manualInput.boolValue)
+            {
+                EditorGUILayout.PropertyField(layerMask, new GUIContent("Layer mask"));
+                EditorGUILayout.HelpBox("Manual input mode requires terrains to be on a dedicated layer", MessageType.None);
+            }
+
+            resIdx.intValue = EditorGUILayout.Popup("Resolution", resIdx.intValue, reslist, new GUILayoutOption[0]);
+
+            pmg.useAlternativeRenderer = EditorGUILayout.ToggleLeft("Using third-party terrain shader", pmg.useAlternativeRenderer);
+            if (showHelp) EditorGUILayout.HelpBox("Some third-party terrain shaders require you to use this, otherwise the result may be black.", MessageType.Info);
+
+            if (pmg.useAlternativeRenderer) pmg.renderLightBrightness = EditorGUILayout.Slider("Brightness adjustment", pmg.renderLightBrightness, 0f, 1f);
+            if (pmg.useAlternativeRenderer && showHelp) EditorGUILayout.HelpBox("To compensate for any shader variations on the terrain, you can use this to increase the brightness of the pigment map, in case it turns out too dark/bright.", MessageType.Info);
+
+            EditorGUILayout.Space();
+            EditorGUILayout.EndVertical();
+        }
+
+        private void DoPreview()
+        {
+            if (!useCustomPigmentMap.boolValue)
+            {
+                //Pigment map preview
+                if (!pmg.pigmentMap) return;
+
+                EditorGUILayout.BeginHorizontal();
+                EditorGUILayout.LabelField(string.Format("Output pigment map ({0}x{0})", pmg.pigmentMap.height), EditorStyles.boldLabel);
+                EditorGUILayout.EndHorizontal();
+
+                Rect cRect = EditorGUILayout.GetControlRect();
+                using (new EditorGUILayout.HorizontalScope())
+                {
+                    EditorGUI.DrawPreviewTexture(new Rect(cRect.x, cRect.y, 150f, 150f), pmg.pigmentMap, null, ScaleMode.ScaleAndCrop);
+                }
+                GUILayout.Space(140f);
+
+                //Single terrain
+                if (!isMultiTerrain.boolValue)
+                {
+                    if (pmg.workflow == TerrainUVUtil.Workflow.Terrain)
+                    {
+                        if (pmg.hasTerrainData)
+                        {
+                            EditorGUILayout.LabelField("The output texture file is stored next to the TerrainData asset", EditorStyles.helpBox);
+                        }
+                        else
+                        {
+                            EditorGUILayout.LabelField("The output texture file is stored next to the scene file", EditorStyles.helpBox);
+                        }
+                    }
+                    else if (pmg.workflow == TerrainUVUtil.Workflow.Mesh)
+                    {
+                        EditorGUILayout.LabelField("The output texture file is stored next to the material file", EditorStyles.helpBox);
+                    }
+                }
+                //Multi terrain
+                else
+                {
+                    if (pmg.workflow == TerrainUVUtil.Workflow.Terrain)
+                    {
+                        EditorGUILayout.LabelField("The output texture file is stored next to the scene file", EditorStyles.helpBox);
+                    }
+                    else if (pmg.workflow == TerrainUVUtil.Workflow.Mesh)
+                    {
+                        EditorGUILayout.LabelField("The output texture file is stored next to the material file", EditorStyles.helpBox);
+                    }
+                }
+            }
+        }
+
+        private void AssignActiveTerrains()
+        {
+            Terrain[] terrains = Terrain.activeTerrains;
+            pmg.terrainObjects = new GameObject[terrains.Length];
+
+            for (int i = 0; i < terrains.Length; i++)
+            {
+                pmg.terrainObjects[i] = terrains[i].gameObject;
+            }
+        }
+
+    }
+}

Assets/Fantasy Adventure Environment/Editor/PigmentMapGeneratorInspector.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 89d2a64dd502a9341a89a3dc4fa986ae
+timeCreated: 1508238424
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Editor/TreeBranchShaderGUI.cs

@@ -0,0 +1,229 @@
+// Fantasy Adventure Environment
+// Copyright Staggart Creations
+// staggart.xyz
+
+using UnityEngine;
+using UnityEditor;
+using System.Collections;
+
+namespace FAE
+{
+    public class TreeBranchShaderGUI : ShaderGUI
+    {
+
+        MaterialProperty _MaskClipValue;
+
+        MaterialProperty _UseSpeedTreeWind;
+
+        //Main maps
+        MaterialProperty _MainTex;
+        MaterialProperty _BumpMap;
+
+        //Color
+        MaterialProperty _Color;
+        MaterialProperty _HueVariation;
+        MaterialProperty _AmbientOcclusion;
+        MaterialProperty _TransmissionColor;
+        MaterialProperty _GradientBrightness;
+        MaterialProperty _Smoothness;
+        MaterialProperty _FlatLighting;
+
+        //Animation
+        MaterialProperty _MaxWindStrength;
+        MaterialProperty _WindAmplitudeMultiplier;
+
+        MaterialEditor m_MaterialEditor;
+
+        //Meta
+        bool showHelp;
+        bool showHelpColor;
+        bool showHelpAnimation;
+
+        bool hasWindController;
+        WindController windController;
+
+        GUIContent mainTexName = new GUIContent("Diffuse", "Diffuse (RGB) and Transparency (A)");
+        GUIContent normalMapName = new GUIContent("Normal Map");
+        private Material targetMat;
+        
+        private bool visualizeVectors;
+
+        public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props)
+        {
+            if (windController == null) LocateWindController();
+
+            //Receive
+            visualizeVectors = WindController._visualizeVectors;
+
+            this.m_MaterialEditor = materialEditor;
+            targetMat = (Material)materialEditor.target;
+            
+            this.FindProperties(props);
+            
+            //Style similar to Standard shader
+            m_MaterialEditor.SetDefaultGUIWidths();
+            m_MaterialEditor.UseDefaultMargins();
+            EditorGUIUtility.labelWidth = 0f;
+
+#if UNITY_2019_3_OR_NEWER
+            if (UnityEngine.Rendering.GraphicsSettings.currentRenderPipeline != null &&
+                !targetMat.shader.name.Contains("Universal Render Pipeline"))
+            {
+                EditorGUILayout.HelpBox("A render pipeline is in use, but this material is using a shader for the Built-in render pipeline.\n\nShaders and materials can be converted through the Help window", MessageType.Error);
+                EditorGUILayout.Space();
+            }
+#endif
+            
+            EditorGUI.BeginChangeCheck();
+
+            //Draw fields
+            DoHeader();
+
+            DoMapsArea();
+            DoColorArea();
+            DoAnimationArea();
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                //Send
+                WindController.VisualizeVectors(visualizeVectors);
+            }
+
+            GUILayout.Label("Advanced Options", EditorStyles.boldLabel);
+
+            GUIHelper.DrawExtraFields(m_MaterialEditor);
+
+            GUIHelper.DrawFooter();
+
+        }
+
+        void DoHeader()
+        {
+            EditorGUILayout.BeginHorizontal();
+            showHelp = GUILayout.Toggle(showHelp, "Toggle help", "Button");
+            GUILayout.Label("FAE Tree Branch Shader", GUIHelper.Header);
+            EditorGUILayout.EndHorizontal();
+            if (showHelp) EditorGUILayout.HelpBox("Please bear in mind, when using custom meshes, that most shader features require the Ambient Occlusion to be baked into the RGB vertex colors.", MessageType.Warning);
+        }
+
+        void DoMapsArea()
+        {
+            GUILayout.Label("Main maps", EditorStyles.boldLabel);
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.PrefixLabel(_MaskClipValue.displayName);
+            _MaskClipValue.floatValue = EditorGUILayout.Slider(_MaskClipValue.floatValue, 0f, 1f);
+            EditorGUILayout.EndHorizontal();
+
+            this.m_MaterialEditor.TexturePropertySingleLine(mainTexName, this._MainTex, this._Color);
+            if(targetMat.HasProperty("_BumpMap")) this.m_MaterialEditor.TexturePropertySingleLine(normalMapName, this._BumpMap);
+
+            EditorGUILayout.Space();
+        }
+
+        void DoColorArea()
+        {
+            EditorGUILayout.BeginHorizontal();
+            showHelpColor = GUILayout.Toggle(showHelpColor, "?", "Button", GUILayout.Width(25f)); GUILayout.Label("Color", EditorStyles.boldLabel);
+            EditorGUILayout.EndHorizontal();
+
+            m_MaterialEditor.ShaderProperty(_HueVariation, _HueVariation.displayName);
+            if (showHelpColor) EditorGUILayout.HelpBox("Uses the object's world-space position to add a color variation. This effect is controlled through the alpha channel.\n\n Note: Does not work with meshes that are batched or combined", MessageType.None);
+            m_MaterialEditor.ShaderProperty(_AmbientOcclusion, _AmbientOcclusion.displayName);
+            if (showHelpColor) EditorGUILayout.HelpBox("Darkens the areas of the mesh where red vertex colors are applied", MessageType.None);
+            m_MaterialEditor.ShaderProperty(_TransmissionColor, new GUIContent("Translucency"));
+            if (showHelpColor) EditorGUILayout.HelpBox("Simulates light passing through the material. The alpha channel controls the intensity. This effect is controlled through the blue channel.", MessageType.None);
+            m_MaterialEditor.ShaderProperty(_GradientBrightness, _GradientBrightness.displayName);
+            if (showHelpColor) EditorGUILayout.HelpBox("Adds a gradient to the branch mesh from bottom to top. This information is stored in the alpha vertex color channel.\n\nWithout this information, the parameter will have no effect.", MessageType.None);
+            m_MaterialEditor.ShaderProperty(_Smoothness, _Smoothness.displayName);
+            if (showHelpColor) EditorGUILayout.HelpBox("Determines the shininess of the material", MessageType.None);
+            m_MaterialEditor.ShaderProperty(_FlatLighting, _FlatLighting.displayName);
+            if (showHelpColor) EditorGUILayout.HelpBox("A value of 1 makes the mesh normals point upwards. For some trees this is necessary to achieve the best visual result.", MessageType.None);
+
+            EditorGUILayout.Space();
+        }
+
+        void DoAnimationArea()
+        {
+            EditorGUILayout.BeginHorizontal();
+            showHelpAnimation = GUILayout.Toggle(showHelpAnimation, "?", "Button", GUILayout.Width(25f)); GUILayout.Label("Wind animation", EditorStyles.boldLabel);
+            EditorGUILayout.EndHorizontal();
+
+#if !VEGETATION_STUDIO_PRO //VS Pro has an FAE wind controller
+            if (!hasWindController)
+            {
+                EditorGUILayout.HelpBox("No \"WindController\" component was found in your scene. Please add this script to an empty GameObject\n\nGo to GameObject->3D Object to create one", MessageType.Warning);
+                EditorGUI.BeginDisabledGroup(true);
+
+            }
+#else
+                EditorGUI.BeginDisabledGroup(false);
+#endif
+
+#if UNITY_2019_3_OR_NEWER
+            if (UnityEngine.Rendering.GraphicsSettings.currentRenderPipeline == null)
+            {
+#endif
+            visualizeVectors = EditorGUILayout.Toggle("Visualize wind", visualizeVectors);
+#if UNITY_2019_3_OR_NEWER
+            }
+#endif
+
+            if (showHelpAnimation) EditorGUILayout.HelpBox("Toggle a visualisation of the wind vectors on all the objects that use FAE shaders featuring wind.\n\nThis allows you to more clearly see the effects of the settings.", MessageType.None);
+
+            m_MaterialEditor.ShaderProperty(_UseSpeedTreeWind, new GUIContent("Sample SpeedTree wind"));
+            if (showHelpAnimation) EditorGUILayout.HelpBox("If this is a tree created using the Unity SpeedTree Modeler, this toggle will make the shader read the wind information as stored by SpeedTree.", MessageType.None);
+
+            m_MaterialEditor.ShaderProperty(_MaxWindStrength, new GUIContent("Max wind strength"));
+            if (showHelpAnimation) EditorGUILayout.HelpBox("Determines how much influence the wind has on the branches", MessageType.None);
+
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.LabelField(new GUIContent("Wind Amplitude Multiplier"));
+            _WindAmplitudeMultiplier.floatValue = EditorGUILayout.FloatField(_WindAmplitudeMultiplier.floatValue, GUILayout.Width(65f));
+            EditorGUILayout.EndHorizontal();
+            //m_MaterialEditor.ShaderProperty(_WindAmplitudeMultiplier, _WindAmplitudeMultiplier.displayName);
+            if (showHelpAnimation) EditorGUILayout.HelpBox("Multiply the wind amplitude for this material. Essentally this is the size of the wind waves.", MessageType.None);
+
+            if (hasWindController && showHelpAnimation)
+            {
+                GUIHelper.DrawWindInfo();
+            }
+
+            EditorGUI.EndDisabledGroup();
+            EditorGUILayout.Space();
+        }
+
+        void LocateWindController()
+        {
+            //Debug.Log("Searching scene for WindController script");
+            windController = GameObject.FindObjectOfType<WindController>();
+            hasWindController = (windController) ? true : false;
+        }
+
+        public void FindProperties(MaterialProperty[] props)
+        {
+            //Rendering
+            _MaskClipValue = FindProperty("_Cutoff", props);
+
+            _UseSpeedTreeWind = FindProperty("_UseSpeedTreeWind", props);
+
+            //Main maps
+            _Color = FindProperty("_Color", props);
+            _MainTex = FindProperty("_MainTex", props);
+            if(targetMat.HasProperty("_BumpMap")) _BumpMap = FindProperty("_BumpMap", props);
+
+            //Color
+            _HueVariation = FindProperty("_HueVariation", props);
+            _AmbientOcclusion = FindProperty("_AmbientOcclusion", props);
+            _TransmissionColor = FindProperty("_TransmissionColor", props);
+            _GradientBrightness = FindProperty("_GradientBrightness", props);
+            _Smoothness = FindProperty("_Smoothness", props);
+            _FlatLighting = FindProperty("_FlatLighting", props);
+
+            //Animation
+            _MaxWindStrength = FindProperty("_MaxWindStrength", props);
+            _WindAmplitudeMultiplier = FindProperty("_WindAmplitudeMultiplier", props);
+
+        }
+
+    }
+}

Assets/Fantasy Adventure Environment/Editor/TreeBranchShaderGUI.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 3880253f9cdf3574fa25cffb6830501e
+timeCreated: 1507713339
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Editor/TreeTrunkShaderGUI.cs

@@ -0,0 +1,132 @@
+// Fantasy Adventure Environment
+// Copyright Staggart Creations
+// staggart.xyz
+
+using UnityEngine;
+using UnityEditor;
+using System.Collections;
+
+namespace FAE
+{
+    public class TreeTrunkShaderGUI : ShaderGUI
+    {
+
+        //Main maps
+        MaterialProperty _MainTex;
+        MaterialProperty _BumpMap;
+
+        MaterialProperty _UseSpeedTreeWind;
+
+        //Color
+        MaterialProperty _AmbientOcclusion;
+        MaterialProperty _GradientBrightness;
+        MaterialProperty _Smoothness;
+
+        MaterialEditor m_MaterialEditor;
+#if UNITY_2019_3_OR_NEWER
+        private Material targetMat;
+#endif
+
+        //Meta
+        bool showHelp;
+
+        GUIContent mainTexName = new GUIContent("Diffuse", "Diffuse (RGB) and Transparency (A)");
+        GUIContent normalMapName = new GUIContent("Normal Map");
+
+        public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props)
+        {
+            this.m_MaterialEditor = materialEditor;
+#if UNITY_2019_3_OR_NEWER
+            targetMat = materialEditor.target as Material;
+#endif
+            
+            this.FindProperties(props);
+            
+            //Style similar to Standard shader
+            m_MaterialEditor.SetDefaultGUIWidths();
+            m_MaterialEditor.UseDefaultMargins();
+            EditorGUIUtility.labelWidth = 0f;
+
+#if UNITY_2019_3_OR_NEWER
+            if (UnityEngine.Rendering.GraphicsSettings.currentRenderPipeline != null &&
+                !targetMat.shader.name.Contains("Universal Render Pipeline"))
+            {
+                EditorGUILayout.HelpBox("Universal Render Pipeline is in use, but this material is using a shader for the Built-in render pipeline.\n\nShaders and materials can be converted through the Help window", MessageType.Error);
+                EditorGUILayout.Space();
+            }
+#endif
+            
+            EditorGUI.BeginChangeCheck();
+
+            //Draw fields
+            DoHeader();
+
+            DoMapsArea();
+            DoColorArea();
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                //Apply changes
+            }
+
+            GUILayout.Label("Advanced Options", EditorStyles.boldLabel);
+
+            GUIHelper.DrawExtraFields(m_MaterialEditor);
+
+            m_MaterialEditor.ShaderProperty(_UseSpeedTreeWind, new GUIContent("Sample SpeedTree wind"));
+            if (showHelp) EditorGUILayout.HelpBox("If this is a tree created using the SpeedTree Unity Modeler, this toggle will make the shader read the wind information as stored by SpeedTree.", MessageType.None);
+
+            if(showHelp) GUIHelper.DrawWindInfo();
+
+            GUIHelper.DrawFooter();
+
+        }
+
+        void DoHeader()
+        {
+            EditorGUILayout.BeginHorizontal();
+            showHelp = GUILayout.Toggle(showHelp, "Toggle help", "Button");
+            GUILayout.Label("FAE Tree Trunk Shader", GUIHelper.Header);
+            EditorGUILayout.EndHorizontal();
+            if (showHelp) EditorGUILayout.HelpBox("Tree trunk shader, featuring global wind motion", MessageType.Info);
+        }
+
+        void DoMapsArea()
+        {
+            GUILayout.Label("Main maps", EditorStyles.boldLabel);
+            this.m_MaterialEditor.TexturePropertySingleLine(mainTexName, this._MainTex);
+            this.m_MaterialEditor.TexturePropertySingleLine(normalMapName, this._BumpMap);
+
+            EditorGUILayout.Space();
+        }
+
+        void DoColorArea()
+        {
+            m_MaterialEditor.ShaderProperty(_AmbientOcclusion, _AmbientOcclusion.displayName);
+            if (showHelp) EditorGUILayout.HelpBox("Darkens the areas of the mesh where red vertex colors are applied", MessageType.None);
+            m_MaterialEditor.ShaderProperty(_GradientBrightness, _GradientBrightness.displayName);
+            if (showHelp) EditorGUILayout.HelpBox("Adds a gradient to the branch mesh from bottom to top. This information is stored in the alpha vertex color channel.\n\nWithout this information, the parameter will have no effect.", MessageType.None);
+            m_MaterialEditor.ShaderProperty(_Smoothness, _Smoothness.displayName);
+            if (showHelp) EditorGUILayout.HelpBox("Multiplies the value of the texture's alpha channel to decrease the roughness amount", MessageType.None);
+
+            EditorGUILayout.Space();
+        }
+
+
+        public void FindProperties(MaterialProperty[] props)
+        {
+            _UseSpeedTreeWind = FindProperty("_UseSpeedTreeWind", props);
+
+            //Main maps
+            _MainTex = FindProperty("_MainTex", props);
+            _BumpMap = FindProperty("_BumpMap", props);
+
+            //Color
+            _AmbientOcclusion = FindProperty("_AmbientOcclusion", props);
+            _GradientBrightness = FindProperty("_GradientBrightness", props);
+            _Smoothness = FindProperty("_Smoothness", props);
+
+        }
+
+    }
+}

Assets/Fantasy Adventure Environment/Editor/TreeTrunkShaderGUI.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: bb6351a34e16d4a49a9f87e59cd6f148
+timeCreated: 1513768856
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Editor/WindControllerInspector.cs

@@ -0,0 +1,173 @@
+using UnityEngine;
+using System.Collections;
+using UnityEditor;
+
+namespace FAE
+{
+    [CustomEditor(typeof(WindController))]
+    public class WindControllerInspector : Editor
+    {
+        WindController wc;
+
+        private bool showHelp = false;
+        private bool visualizeVectors;
+
+        new SerializedObject serializedObject;
+
+        SerializedProperty listenToWindZone;
+        SerializedProperty windZone;
+
+        SerializedProperty windVectors;
+
+        SerializedProperty windSpeed;
+        SerializedProperty windStrength;
+        SerializedProperty windAmplitude;
+
+        SerializedProperty trunkWindSpeed;
+        SerializedProperty trunkWindWeight;
+        SerializedProperty trunkWindSwinging;
+        
+        void OnEnable()
+        {
+            wc = (WindController)target;
+            serializedObject = new SerializedObject(target);
+            listenToWindZone = serializedObject.FindProperty("listenToWindZone");
+            windZone = serializedObject.FindProperty("windZone");
+            windVectors = serializedObject.FindProperty("windVectors");
+
+            windSpeed = serializedObject.FindProperty("windSpeed");
+            windStrength = serializedObject.FindProperty("windStrength");
+            windAmplitude = serializedObject.FindProperty("windAmplitude");
+
+            trunkWindSpeed = serializedObject.FindProperty("trunkWindSpeed");
+            trunkWindWeight = serializedObject.FindProperty("trunkWindWeight");
+            trunkWindSwinging = serializedObject.FindProperty("trunkWindSwinging");
+        }
+
+        public override void OnInspectorGUI()
+        {
+            serializedObject.Update();
+
+            EditorGUI.BeginChangeCheck();
+
+            //Sync inspector var to static class var
+            visualizeVectors = WindController._visualizeVectors;
+
+            Undo.RecordObject(this, "Component");
+            Undo.RecordObject(wc, "WindController");
+
+            DrawFields();
+
+            serializedObject.ApplyModifiedProperties();
+
+            if (GUI.changed || EditorGUI.EndChangeCheck())
+            {
+                EditorUtility.SetDirty((WindController)target);
+                wc.Apply();
+
+                //Set the static var
+                WindController.VisualizeVectors(visualizeVectors);
+            }
+
+        }
+        
+        private void DrawFields()
+        {
+            DoHeader();
+
+            EditorGUILayout.Space();
+
+            EditorGUILayout.PropertyField(windVectors);
+            if (!windVectors.objectReferenceValue)
+            {
+                EditorGUILayout.HelpBox("Assign a wind vector map for wind to function", MessageType.Error);
+                return;
+            }
+            
+            EditorGUILayout.PropertyField(listenToWindZone, new GUIContent("Listen to Wind Zone"));
+            if (showHelp) EditorGUILayout.HelpBox("When a Wind Zone is assigned, the wind strength and tree trunk weight values are divided by it's \"Main\" parameter value.\n\nThis allows you to use weather systems such as Enviro", MessageType.Info);
+            if (listenToWindZone.boolValue)
+            {
+                EditorGUILayout.PropertyField(windZone, new GUIContent("Wind Zone"));
+            }
+
+            EditorGUILayout.Space();
+
+            EditorGUILayout.BeginVertical(EditorStyles.helpBox);
+
+            EditorGUILayout.LabelField("Wind settings", EditorStyles.toolbarButton);
+            EditorGUILayout.Space();
+
+            EditorGUILayout.PropertyField(windSpeed, new GUIContent("Speed"));
+            if (showHelp) EditorGUILayout.HelpBox("The overall speed of the wind.", MessageType.Info);
+            EditorGUILayout.PropertyField(windStrength, new GUIContent("Strength"));
+            if (showHelp) EditorGUILayout.HelpBox("The overall strength of the wind.", MessageType.Info);
+            EditorGUILayout.PropertyField(windAmplitude, new GUIContent("Amplitude"));
+            if (showHelp) EditorGUILayout.HelpBox("The overall amplitude of the wind, essentially the size of wind waves.\n\nThe shader have a \"WindAmplitudeMultiplier\" parameter which multiplies this value in the material.", MessageType.Info);
+
+            EditorGUILayout.Space();
+            EditorGUILayout.EndVertical();
+            
+            EditorGUILayout.Space();
+
+            EditorGUILayout.BeginVertical(EditorStyles.helpBox);
+
+            EditorGUILayout.LabelField("Tree trunks", EditorStyles.toolbarButton);
+            EditorGUILayout.Space();
+
+            EditorGUILayout.PropertyField(trunkWindSpeed, new GUIContent("Speed"));
+            if (showHelp) EditorGUILayout.HelpBox("The speed by which the tree moves.", MessageType.Info);
+            EditorGUILayout.PropertyField(trunkWindWeight, new GUIContent("Weight"));
+            if (showHelp) EditorGUILayout.HelpBox("The amount of influence the wind has on a tree.", MessageType.Info);
+            EditorGUILayout.PropertyField(trunkWindSwinging, new GUIContent("Swinging"));
+            if (showHelp) EditorGUILayout.HelpBox("A value higher than 0 means the trees will also move against the wind direction.", MessageType.Info);
+
+            EditorGUILayout.Space();
+            EditorGUILayout.EndVertical();
+
+            visualizeVectors = EditorGUILayout.Toggle("Visualize wind", visualizeVectors);
+            if (showHelp) EditorGUILayout.HelpBox("Toggle a visualisation of the wind vectors on all the objects that use FAE shaders featuring wind.\n\nThis allows you to more clearly see the effects of the settings.", MessageType.Info);
+
+            GUIHelper.DrawFooter();
+        }
+
+        private void DoHeader()
+        {
+            EditorGUILayout.BeginHorizontal();
+            showHelp = GUILayout.Toggle(showHelp, "Toggle help", "Button");
+            GUILayout.Label("FAE Wind Controller", GUIHelper.Header);
+            EditorGUILayout.EndHorizontal();
+            if (showHelp) EditorGUILayout.HelpBox("This script drives the wind parameters of the Foliage, Grass, Tree Branch and Tree Trunk shaders.", MessageType.Info);
+        }
+
+        [MenuItem("GameObject/3D Object/FAE Wind Controller")]
+        private static void NewMenuOption()
+        {
+            WindController currentWindController = GameObject.FindObjectOfType<WindController>();
+            if (currentWindController != null)
+            {
+                if (EditorUtility.DisplayDialog("FAE Wind Controller", "A WindController object already exists in your scene", "Create anyway", "Cancel"))
+                {
+                    CreateNewWindController();
+                }
+            }
+            else
+            {
+                CreateNewWindController();
+            }
+        }
+
+        private static void CreateNewWindController()
+        {
+            GameObject newWindController = new GameObject()
+            {
+                name = "Wind Controller"
+            };
+            newWindController.AddComponent<WindController>();
+
+            Selection.activeGameObject = newWindController;
+            
+            Undo.RegisterCreatedObjectUndo(newWindController, "Created Wind Controller");
+        }
+    }
+}

Assets/Fantasy Adventure Environment/Editor/WindControllerInspector.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: bba522f8ef960fb4dac08d178efef495
+timeCreated: 1510830180
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Editor/sc.fae.editor.asmdef

@@ -0,0 +1,31 @@
+{
+    "name": "sc.fae.editor",
+    "references": [
+        "GUID:8c4644ab61e3e7d4d8f26823347fc459",
+        "GUID:15fc0a57446b3144c949da3e2b9737a9"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [
+        "Android",
+        "iOS",
+        "LinuxStandalone64",
+        "Lumin",
+        "macOSStandalone",
+        "PS4",
+        "Stadia",
+        "Switch",
+        "tvOS",
+        "WSA",
+        "WebGL",
+        "WindowsStandalone32",
+        "WindowsStandalone64",
+        "XboxOne"
+    ],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

Assets/Fantasy Adventure Environment/Editor/sc.fae.editor.asmdef.meta

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

Assets/Fantasy Adventure Environment/Materials.meta

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

Assets/Fantasy Adventure Environment/Materials/Effects.meta

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

Assets/Fantasy Adventure Environment/Materials/Effects/FAE_AdditiveParticle.mat

@@ -0,0 +1,156 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &-1525330443554570735
+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: 5
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: FAE_AdditiveParticle
+  m_Shader: {fileID: 4800000, guid: 8516d7a69675844a7a0b7095af7c46af, type: 3}
+  m_ShaderKeywords: _EMISSION _FADING_ON _SOFTPARTICLES_ON _SURFACE_TYPE_TRANSPARENT
+  m_LightmapFlags: 0
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 3000
+  stringTagMap:
+    RenderType: Transparent
+  disabledShaderPasses:
+  - ALWAYS
+  - SHADOWCASTER
+  - DepthOnly
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _Alpha:
+        m_Texture: {fileID: 10300, guid: 0000000000000000f000000000000000, type: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseMap:
+        m_Texture: {fileID: 10300, guid: 0000000000000000f000000000000000, type: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Diffuse:
+        m_Texture: {fileID: -803380585, guid: d7dd9c87a38759643b443947f2b96d7d, 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: 10300, guid: 0000000000000000f000000000000000, type: 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}
+    - _ParallaxMap:
+        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}
+    - _node_2965:
+        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}
+    m_Ints: []
+    m_Floats:
+    - _AlphaClip: 0
+    - _Blend: 2
+    - _BlendOp: 0
+    - _BumpScale: 1
+    - _CameraFadingEnabled: 1
+    - _CameraFarFadeDistance: 2
+    - _CameraNearFadeDistance: 1
+    - _ColorMode: 0
+    - _Cull: 2
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DistortionBlend: 0.5
+    - _DistortionEnabled: 0
+    - _DistortionStrength: 1
+    - _DistortionStrengthScaled: 0
+    - _DstBlend: 1
+    - _EmissionEnabled: 0
+    - _Fadedistance: 0.5
+    - _FlipbookBlending: 0
+    - _FlipbookMode: 0
+    - _Gloss: 0.5
+    - _Glossiness: 0.5
+    - _Intersectionfade: 20
+    - _InvFade: 1
+    - _LightingEnabled: 1
+    - _Metallic: 0
+    - _Mode: 4
+    - _Noisesize: 0.006
+    - _OcclusionStrength: 1
+    - _Opacity: 0.138
+    - _Parallax: 0.02
+    - _QueueOffset: 0
+    - _ReceiveShadows: 1
+    - _Smoothness: 0.5
+    - _SmoothnessSource: 0
+    - _SoftParticlesEnabled: 1
+    - _SoftParticlesFarFadeDistance: 1
+    - _SoftParticlesNearFadeDistance: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 5
+    - _Surface: 1
+    - _UVSec: 0
+    - _ZWrite: 0
+    - __dirty: 0
+    - _node_1319: 10
+    - _node_3718: 24.9
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColorAddSubDiff: {r: 0, g: 0, b: 0, a: 0}
+    - _CameraFadeParams: {r: 1, g: 1, 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, b: 0, a: 0}
+    - _SpecColor: {r: 1, g: 1, b: 1, a: 1}
+    - _TintColor: {r: 0.5, g: 0.5, b: 0.5, a: 0.5}
+  m_BuildTextureStacks: []

Assets/Fantasy Adventure Environment/Materials/Effects/FAE_AdditiveParticle.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 6f7eb092bd8c5744984d49b87e9aeafc
+timeCreated: 1470398566
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Materials/Effects/FAE_FogPlane.mat

@@ -0,0 +1,128 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &-5021892467123282645
+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: 5
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: FAE_FogPlane
+  m_Shader: {fileID: -6465566751694194690, guid: 3977c45b16955f8459c5245a22851508,
+    type: 3}
+  m_ShaderKeywords: _EMISSION
+  m_LightmapFlags: 0
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _Alpha:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Dust:
+        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}
+    - _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}
+    - _ParallaxMap:
+        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:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _Depth: 8
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _DustSpeed: 0
+    - _DustStrength: 1
+    - _Emission: 1
+    - _Factor: 0.1
+    - _FadeDistance: 0.01
+    - _Float0: 0.805
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _Pow: 1
+    - _QueueControl: 0
+    - _QueueOffset: 0
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    - __dirty: 0
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 0}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+  m_BuildTextureStacks: []

Assets/Fantasy Adventure Environment/Materials/Effects/FAE_FogPlane.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: bc8486fd976709b49afe3c08749c84b2
+timeCreated: 1494782066
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Materials/Effects/FAE_FogPlaneDark.mat

@@ -0,0 +1,114 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: FAE_FogPlaneDark
+  m_Shader: {fileID: -6465566751694194690, guid: 3977c45b16955f8459c5245a22851508,
+    type: 3}
+  m_ShaderKeywords: _EMISSION
+  m_LightmapFlags: 0
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _Alpha:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Dust:
+        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}
+    - _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}
+    - _ParallaxMap:
+        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}
+    m_Ints: []
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _Depth: 8
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _DustSpeed: 0
+    - _DustStrength: 1
+    - _Emission: 1
+    - _Factor: 1
+    - _FadeDistance: 0.01
+    - _Float0: 0.805
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _Pow: 1
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    - __dirty: 0
+    m_Colors:
+    - _Color: {r: 0.18382353, g: 0.18382353, b: 0.18382353, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+  m_BuildTextureStacks: []
+--- !u!114 &5042114733478812165
+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: 5

Assets/Fantasy Adventure Environment/Materials/Effects/FAE_FogPlaneDark.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c71fd5bf700b6654381c77c2ba630425
+timeCreated: 1494782066
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Materials/Effects/FAE_FogsheetsParticle.mat

@@ -0,0 +1,135 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &-8479172598304795613
+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: 5
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: FAE_FogsheetsParticle
+  m_Shader: {fileID: 4800000, guid: 8516d7a69675844a7a0b7095af7c46af, type: 3}
+  m_ShaderKeywords: _FADING_ON _SOFTPARTICLES_ON _SURFACE_TYPE_TRANSPARENT
+  m_LightmapFlags: 6
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 3000
+  stringTagMap:
+    RenderType: Transparent
+  disabledShaderPasses:
+  - ALWAYS
+  - SHADOWCASTER
+  - DepthOnly
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseMap:
+        m_Texture: {fileID: 2800000, guid: 844dae9f5057cb141bb303905ef379fa, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        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}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: 844dae9f5057cb141bb303905ef379fa, 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}
+    - _ParallaxMap:
+        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
+    - _Blend: 2
+    - _BlendOp: 0
+    - _BumpScale: 1
+    - _CameraFadingEnabled: 1
+    - _CameraFarFadeDistance: 34.31
+    - _CameraNearFadeDistance: 7.95
+    - _ColorMode: 0
+    - _Cull: 2
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DistortionBlend: 0.5
+    - _DistortionEnabled: 0
+    - _DistortionStrength: 1
+    - _DistortionStrengthScaled: 0
+    - _DstBlend: 1
+    - _EmissionEnabled: 0
+    - _FlipbookBlending: 0
+    - _FlipbookMode: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _InvFade: 0.06
+    - _LightingEnabled: 1
+    - _Metallic: 0
+    - _Mode: 4
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _QueueOffset: 0
+    - _ReceiveShadows: 1
+    - _Smoothness: 0.5
+    - _SmoothnessSource: 0
+    - _SmoothnessTextureChannel: 0
+    - _SoftParticlesEnabled: 1
+    - _SoftParticlesFarFadeDistance: 6.24
+    - _SoftParticlesNearFadeDistance: 0.65
+    - _SpecularHighlights: 1
+    - _SrcBlend: 5
+    - _Surface: 1
+    - _UVSec: 0
+    - _ZWrite: 0
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColorAddSubDiff: {r: 0, g: 0, b: 0, a: 0}
+    - _CameraFadeParams: {r: 7.95, g: 0.037936267, 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.65, g: 0.17889088, b: 0, a: 0}
+    - _SpecColor: {r: 1, g: 1, b: 1, a: 1}
+    - _TintColor: {r: 1, g: 1, b: 1, a: 1}
+  m_BuildTextureStacks: []

Assets/Fantasy Adventure Environment/Materials/Effects/FAE_FogsheetsParticle.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9607c63bc2492fd489245838e7b101fb
+timeCreated: 1497612061
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Materials/Effects/FAE_LeafParticle.mat

@@ -0,0 +1,135 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: FAE_LeafParticle
+  m_Shader: {fileID: 4800000, guid: 8516d7a69675844a7a0b7095af7c46af, type: 3}
+  m_ShaderKeywords: _ALPHATEST_ON _EMISSION
+  m_LightmapFlags: 0
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 2450
+  stringTagMap:
+    RenderType: TransparentCutout
+  disabledShaderPasses:
+  - ALWAYS
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseMap:
+        m_Texture: {fileID: 2800000, guid: cc92f22ef59deb346855e78f7f0e23d9, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        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}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: cc92f22ef59deb346855e78f7f0e23d9, 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}
+    - _ParallaxMap:
+        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:
+    - PixelSnap: 0
+    - _AlphaClip: 1
+    - _Blend: 0
+    - _BlendOp: 0
+    - _BumpScale: 1
+    - _CameraFadingEnabled: 0
+    - _CameraFarFadeDistance: 2
+    - _CameraNearFadeDistance: 1
+    - _ColorMode: 0
+    - _Cull: 2
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DistortionBlend: 0.5
+    - _DistortionEnabled: 0
+    - _DistortionStrength: 1
+    - _DistortionStrengthScaled: 0
+    - _DstBlend: 0
+    - _EmissionEnabled: 0
+    - _FlipbookBlending: 0
+    - _FlipbookMode: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _InvFade: 3
+    - _LightingEnabled: 1
+    - _Metallic: 0
+    - _Mode: 1
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _QueueOffset: 0
+    - _ReceiveShadows: 1
+    - _Smoothness: 0.5
+    - _SmoothnessSource: 0
+    - _SmoothnessTextureChannel: 0
+    - _SoftParticlesEnabled: 0
+    - _SoftParticlesFarFadeDistance: 1
+    - _SoftParticlesNearFadeDistance: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _Surface: 0
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColorAddSubDiff: {r: 0, g: 0, b: 0, a: 0}
+    - _CameraFadeParams: {r: 0, g: Infinity, b: 0, a: 0}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmisColor: {r: 0.49803922, g: 0.49803922, b: 0.49803922, a: 0}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _SoftParticleFadeParams: {r: 0, g: 0, b: 0, a: 0}
+    - _SpecColor: {r: 1, g: 1, b: 1, a: 1}
+    - _TintColor: {r: 1, g: 1, b: 1, a: 1}
+  m_BuildTextureStacks: []
+--- !u!114 &142840704646882375
+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: 5

Assets/Fantasy Adventure Environment/Materials/Effects/FAE_LeafParticle.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: eb90cfcfbc575f6489371b97e180f526
+timeCreated: 1496319857
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Materials/Effects/FAE_Lensflare.flare

@@ -0,0 +1,47 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!121 &12100000
+Flare:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: FAE_Lensflare
+  m_FlareTexture: {fileID: 2800000, guid: 300a963095cf5804bad4cf0beeb32a6f, type: 3}
+  m_TextureLayout: 3
+  m_Elements:
+  - m_ImageIndex: 0
+    m_Position: 0
+    m_Size: 90
+    m_Color: {r: 1, g: 1, b: 1, a: 1}
+    m_UseLightColor: 1
+    m_Rotate: 0
+    m_Zoom: 0
+    m_Fade: 1
+  - m_ImageIndex: 1
+    m_Position: 0
+    m_Size: 50
+    m_Color: {r: 1, g: 1, b: 1, a: 1}
+    m_UseLightColor: 1
+    m_Rotate: 0
+    m_Zoom: 1
+    m_Fade: 1
+  - m_ImageIndex: 2
+    m_Position: 1.02
+    m_Size: 10.82
+    m_Color: {r: 1, g: 1, b: 1, a: 1}
+    m_UseLightColor: 1
+    m_Rotate: 0
+    m_Zoom: 0
+    m_Fade: 1
+  - m_ImageIndex: 3
+    m_Position: 2.5
+    m_Size: 7.3
+    m_Color: {r: 1, g: 1, b: 1, a: 1}
+    m_UseLightColor: 1
+    m_Rotate: 0
+    m_Zoom: 0
+    m_Fade: 1
+  m_UseFog: 1
+--- !u!1002 &12100001
+EditorExtensionImpl:
+  serializedVersion: 6

Assets/Fantasy Adventure Environment/Materials/Effects/FAE_Lensflare.flare.meta

@@ -0,0 +1,5 @@
+fileFormatVersion: 2
+guid: 9365737486dc4424f93336e7c4c9144a
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 

Assets/Fantasy Adventure Environment/Materials/Effects/FAE_Sunshaft.mat

@@ -0,0 +1,91 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: FAE_Sunshaft
+  m_Shader: {fileID: -6465566751694194690, guid: 07f05a6185f494a439b754d9581d8170,
+    type: 3}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 5
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _Alpha:
+        m_Texture: {fileID: -804463737, guid: 9afc9fffc8d5eb04fbf46f8da66a5439, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: bef6984f846f11442b4bd5000f44af64, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Texture:
+        m_Texture: {fileID: -804463737, guid: 9afc9fffc8d5eb04fbf46f8da66a5439, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Texture0:
+        m_Texture: {fileID: -804463737, guid: 9afc9fffc8d5eb04fbf46f8da66a5439, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TextureSample1:
+        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:
+    - _Cutoff: 0.5
+    - _Emission: 2.37
+    - _Fadedistance: 6.1
+    - _IntersectionFade: 9.92
+    - _Intersectionfade: 9.6
+    - _InvFade: 1
+    - _MaskClipValue: 0.5
+    - _Opacity: 0.5
+    - _PanningSpeed: 0.23
+    - _QueueControl: 0
+    - _QueueOffset: 0
+    - _ToggleSwitch0: 0
+    - _UseLightColor: 1
+    - __dirty: 0
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 0}
+    - _TintColor: {r: 0.5, g: 0.5, b: 0.5, a: 0.5}
+  m_BuildTextureStacks: []
+--- !u!114 &4154821097252647534
+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: 5

Assets/Fantasy Adventure Environment/Materials/Effects/FAE_Sunshaft.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d5b77898dc615b742a3cfa8741f9ce3b
+timeCreated: 1496404183
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Materials/Effects/FAE_SunshaftParticle.mat

@@ -0,0 +1,100 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: FAE_SunshaftParticle
+  m_Shader: {fileID: 4800000, guid: 9fe67a59c15773a4a8bdbf006a7e43c5, type: 3}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 5
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _Alpha:
+        m_Texture: {fileID: -804463737, guid: 9afc9fffc8d5eb04fbf46f8da66a5439, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Diffuse:
+        m_Texture: {fileID: -803380585, guid: d7dd9c87a38759643b443947f2b96d7d, 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: bef6984f846f11442b4bd5000f44af64, 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}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _node_2965:
+        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}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _Fadedistance: 12.3
+    - _Gloss: 0.5
+    - _Glossiness: 0.5
+    - _Intersectionfade: 20
+    - _InvFade: 0.34
+    - _Metallic: 0
+    - _Mode: 0
+    - _Noisesize: 0.006
+    - _OcclusionStrength: 1
+    - _Opacity: 0.115
+    - _Parallax: 0.02
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    - __dirty: 0
+    - _node_1319: 10
+    - _node_3718: 24.9
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _SpecColor: {r: 1, g: 1, b: 1, a: 1}
+    - _TintColor: {r: 1, g: 1, b: 1, a: 0.459}

Assets/Fantasy Adventure Environment/Materials/Effects/FAE_SunshaftParticle.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4c34341261dd5284d98c48e163e04a91
+timeCreated: 1470398566
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Materials/Effects/FAE_Water.mat

@@ -0,0 +1,157 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &-591258107748843939
+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: 5
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: FAE_Water
+  m_Shader: {fileID: -6465566751694194690, guid: e02af2867afa32a46ae65b908b67dbed,
+    type: 3}
+  m_ShaderKeywords: _WORLDSPACETILING_ON
+  m_LightmapFlags: 2
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        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}
+    - _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: 2800000, guid: 1aebbb812b32bde4b8eb211cdcaa87d6, type: 3}
+        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}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Reflection:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _RefractionmapEdgeB:
+        m_Texture: {fileID: 223006684, guid: 557c5daa3682e654fb1b3bcb0f2981ce, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Shadermap:
+        m_Texture: {fileID: 2800000, guid: 39618f4b1a43f7b4e9dad30dd15e9fab, type: 3}
+        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: 4
+    - Vector1_67814CC1: 0.1
+    - Vector1_7DFD32F9: 0.13
+    - Vector1_BE75C478: -12.79
+    - Vector1_E23F9E57: 0.876
+    - Vector1_E796673B: 6.97
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _Depth: 5.6
+    - _Depthdarkness: 0.58
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _EdgeFade: 1
+    - _FlowSpeed: 1.02
+    - _Fresnelexponent: 4
+    - _Glossiness: 0.806
+    - _HighlightPanning: 0
+    - _Metallic: 0
+    - _Metallicness: 0.265
+    - _Mode: 0
+    - _NormalStrength: 1
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _QueueControl: 0
+    - _QueueOffset: 0
+    - _RefractionAmount: 0.0586
+    - _RimDistance: 0
+    - _RimRize: 2
+    - _RimSize: 4
+    - _RimTiling: 4.9
+    - _Rimfalloff: 0.25
+    - _Rimtiling: 0.79
+    - _SrcBlend: 1
+    - _SurfaceHighlight: 0.101
+    - _SurfaceHightlighttiling: 0.25
+    - _Surfacehightlightsize: 0
+    - _TesselationEdgeLengt: 0.15
+    - _Tiling: 0.27
+    - _Transparency: 0.534
+    - _UVSec: 0
+    - _UseIntersectionHighlight: 1
+    - _Wavesspeed: 0.37
+    - _Wavesstrength: 0
+    - _Wavetint: 0.051
+    - _Worldspacetiling: 1
+    - _ZWrite: 1
+    - __dirty: 1
+    m_Colors:
+    - Color_D0289068: {r: 0, g: 0.9394503, b: 1, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _FresnelColor: {r: 1, g: 1, b: 1, a: 0.5019608}
+    - _RimColor: {r: 1, g: 1, b: 1, a: 1}
+    - _WaterColor: {r: 0.21323532, g: 0.67444223, b: 1, a: 1}
+    - _WaterShallowColor: {r: 0, g: 0.9394503, b: 1, a: 1}
+  m_BuildTextureStacks: []

Assets/Fantasy Adventure Environment/Materials/Effects/FAE_Water.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 510ef6177dc68c24b853414d9ec6612d
+timeCreated: 1490281498
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Materials/Effects/FAE_WindStreakTrail.mat

@@ -0,0 +1,128 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: FAE_WindStreakTrail
+  m_Shader: {fileID: 4800000, guid: 0406db5a14f94604a8c57ccfbc9f3b46, type: 3}
+  m_ShaderKeywords: _COLORADDSUBDIFF_ON _EMISSION _SURFACE_TYPE_TRANSPARENT
+  m_LightmapFlags: 0
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 3000
+  stringTagMap:
+    RenderType: Transparent
+  disabledShaderPasses:
+  - ALWAYS
+  - SHADOWCASTER
+  - DepthOnly
+  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: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        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}
+    - _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}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _AlphaClip: 0
+    - _Blend: 2
+    - _BlendOp: 0
+    - _BumpScale: 1
+    - _CameraFadingEnabled: 0
+    - _CameraFarFadeDistance: 2
+    - _CameraNearFadeDistance: 1
+    - _ColorMode: 1
+    - _Cull: 2
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DistortionBlend: 0.5
+    - _DistortionEnabled: 0
+    - _DistortionStrength: 1
+    - _DistortionStrengthScaled: 0
+    - _DstBlend: 1
+    - _EmissionEnabled: 0
+    - _FlipbookBlending: 0
+    - _FlipbookMode: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _InvFade: 0.01
+    - _LightingEnabled: 0
+    - _Metallic: 0
+    - _Mode: 4
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _QueueOffset: 0
+    - _SmoothnessTextureChannel: 0
+    - _SoftParticlesEnabled: 0
+    - _SoftParticlesFarFadeDistance: 1
+    - _SoftParticlesNearFadeDistance: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 5
+    - _Surface: 1
+    - _UVSec: 0
+    - _ZWrite: 0
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 0.15294118}
+    - _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: 0.15294118}
+    - _ColorAddSubDiff: {r: 1, g: 0, b: 0, a: 0}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _SoftParticleFadeParams: {r: 0, g: 0, b: 0, a: 0}
+    - _TintColor: {r: 1, g: 1, b: 1, a: 0.078431375}
+  m_BuildTextureStacks: []
+--- !u!114 &5707635822681850722
+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: 5

Assets/Fantasy Adventure Environment/Materials/Effects/FAE_WindStreakTrail.mat.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 76d5aaedf8aab6646b89b30a06c9a90d
+timeCreated: 1522780908
+licenseType: Store
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Materials/Effects/Textures.meta

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

Assets/Fantasy Adventure Environment/Materials/Effects/Textures/FAE_FloorFog_Particle.png.meta

@@ -0,0 +1,92 @@
+fileFormatVersion: 2
+guid: 844dae9f5057cb141bb303905ef379fa
+timeCreated: 1521302365
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 256
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 256
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: iPhone
+    maxTextureSize: 256
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Android
+    maxTextureSize: 256
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Materials/Effects/Textures/FAE_LensflareAtlas.png.meta

@@ -0,0 +1,92 @@
+fileFormatVersion: 2
+guid: 300a963095cf5804bad4cf0beeb32a6f
+timeCreated: 1525030036
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: 1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 0
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: iPhone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Android
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Materials/Effects/Textures/FAE_Sunshaft_Shadermap.png.meta

@@ -0,0 +1,68 @@
+fileFormatVersion: 2
+guid: bef6984f846f11442b4bd5000f44af64
+timeCreated: 1521302442
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Materials/Effects/Textures/FAE_Water_Normals.png.meta

@@ -0,0 +1,92 @@
+fileFormatVersion: 2
+guid: 1a1e99c7f4bb0a4479e4e5c835fd6c98
+timeCreated: 1521301982
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 1
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: iPhone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Android
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Materials/Effects/Textures/FAE_Water_Normals_URP.png.meta

@@ -0,0 +1,103 @@
+fileFormatVersion: 2
+guid: 1aebbb812b32bde4b8eb211cdcaa87d6
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 10
+  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
+  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
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Materials/Effects/Textures/FAE_Water_Shadermap.png.meta

@@ -0,0 +1,68 @@
+fileFormatVersion: 2
+guid: f3a337f61eb58134f97ca1b4183a2ebf
+timeCreated: 1521301932
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Materials/Effects/Textures/FAE_Water_Shadermap_URP.png.meta

@@ -0,0 +1,103 @@
+fileFormatVersion: 2
+guid: 39618f4b1a43f7b4e9dad30dd15e9fab
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 10
+  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: -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: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 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
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Materials/Effects/Textures/FAE_Waterfall_Color.png.meta

@@ -0,0 +1,68 @@
+fileFormatVersion: 2
+guid: cf6fb875805026b4f8c4df0ded4b341e
+timeCreated: 1521302143
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Materials/Effects/Textures/FAE_Waterfall_Shadermap.png.meta

@@ -0,0 +1,98 @@
+fileFormatVersion: 2
+guid: cd3599394ee15cf47a144615252f4943
+timeCreated: 1521302143
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  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
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 0
+    mipBias: -1
+    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}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: iPhone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Android
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Materials/Effects/Textures/FAE_Windvectors.png.meta

@@ -0,0 +1,92 @@
+fileFormatVersion: 2
+guid: 6c795dd1d1d319e479e68164001557e8
+timeCreated: 1521296216
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 1
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 512
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 512
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: iPhone
+    maxTextureSize: 512
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Android
+    maxTextureSize: 512
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Materials/Objects.meta

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

Assets/Fantasy Adventure Environment/Materials/Objects/FAE_Branches.mat

@@ -0,0 +1,127 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: FAE_Branches
+  m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
+  m_ShaderKeywords: _EMISSION _NORMALMAP _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+  m_LightmapFlags: 1
+  m_EnableInstancingVariants: 1
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap:
+    RenderType: Opaque
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseMap:
+        m_Texture: {fileID: 2800000, guid: 015e4feafc467fc40a4f0d5550d3578e, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 2800000, guid: 461375bbf118d9640a211d513456a4e1, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        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}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: 015e4feafc467fc40a4f0d5550d3578e, 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}
+    - _ParallaxMap:
+        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
+    - _ClearCoatMask: 0
+    - _ClearCoatSmoothness: 0
+    - _Cull: 2
+    - _Cutoff: 0.5
+    - _DetailAlbedoMapScale: 1
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _EnvironmentReflections: 1
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _QueueOffset: 0
+    - _ReceiveShadows: 1
+    - _Smoothness: 0.5
+    - _SmoothnessTextureChannel: 1
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _Surface: 0
+    - _UVSec: 0
+    - _WorkflowMode: 1
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _SpecColor: {r: 0.19999996, g: 0.19999996, b: 0.19999996, a: 1}
+  m_BuildTextureStacks: []
+--- !u!114 &9045132327437526114
+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: 5

Assets/Fantasy Adventure Environment/Materials/Objects/FAE_Branches.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 67db05b848ced8c4e88dea90aaaefd0f
+timeCreated: 1508853551
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Materials/Rocks.meta

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

Assets/Fantasy Adventure Environment/Materials/Rocks/Cliff_A_Mat.mat

@@ -0,0 +1,204 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Cliff_A_Mat
+  m_Shader: {fileID: -6465566751694194690, guid: 7f57b0c643f528f4297b72348cab9faf,
+    type: 3}
+  m_ShaderKeywords: _DETAIL_MULX2 _EMISSION _NORMALMAP _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+  m_LightmapFlags: 5
+  m_EnableInstancingVariants: 1
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 2800000, guid: 184d6a203cd3af44397cedb44de6cfed, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CoverageAlbedo:
+        m_Texture: {fileID: 2800000, guid: 6dc430d5c113ab14c91065b0117acafb, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CoverageMap:
+        m_Texture: {fileID: 2800000, guid: f372ecf27e5c4954c8bf0015e21ca538, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CoverageNormals:
+        m_Texture: {fileID: 2800000, guid: 51954d6e0de971a43ac1ba884c6836f5, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 10, y: 10}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 1726649286, guid: 0ea7c6367f83bcc498b851eb479925fa, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Detailnormal:
+        m_Texture: {fileID: 2800000, guid: 06bdf21e154425948b0978955fd687b4, 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}
+    - _Globalalbedo:
+        m_Texture: {fileID: 2800000, guid: 90c15e788b01a3646a1f0b65505c9972, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Globalcolor:
+        m_Texture: {fileID: 2800000, guid: 016e95565131cbe4bbe66d399a1c4efa, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: c469316b0e200614daa4511fd0e1d512, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 2800000, guid: 9ee4c82c0409e14459b838d4bdf9ce44, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ObjectHeightAO:
+        m_Texture: {fileID: 2800000, guid: fbc47f2c09271b549a9391df18145172, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Objectalbedo:
+        m_Texture: {fileID: 2800000, guid: 4cc5117dfac9f974cbdb39ceb28e5059, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Objectnormals:
+        m_Texture: {fileID: 2800000, guid: 5d23501e26536f746ac3ce3d9a0bdb5f, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Objectroughness:
+        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}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _PigmentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _RockAlbedo:
+        m_Texture: {fileID: 2800000, guid: 4cc5117dfac9f974cbdb39ceb28e5059, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _RockNormal:
+        m_Texture: {fileID: 2800000, guid: 5d23501e26536f746ac3ce3d9a0bdb5f, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _RockSpecular:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SnowAlbedo:
+        m_Texture: {fileID: -1782295886, guid: 7154642c7e2a90e42ac41a57d23f7317, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SnowNormal:
+        m_Texture: {fileID: 2800000, guid: 84ec7eb4fd0bebc4fb72c2887112b5a2, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SnowNormals:
+        m_Texture: {fileID: 417745122, guid: 7154642c7e2a90e42ac41a57d23f7317, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SnowSpecular:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TextureSample3:
+        m_Texture: {fileID: 2800000, guid: 19b818e26c2922a488c06b1fbdae5df3, type: 3}
+        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:
+    - _BumpScale: 1
+    - _CoverageAmount: 1
+    - _CoverageTiling: 8
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 0
+    - _Detailstrength: 0.28
+    - _DstBlend: 0
+    - _Float0: 4.78
+    - _Globaltiling: 0.163
+    - _GlossMapScale: 0.727
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _MaskClipValue: 0.5
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _QueueControl: 0
+    - _QueueOffset: 0
+    - _Roughness: 0.276
+    - _SmoothnessTextureChannel: 1
+    - _SnowAmount: 2
+    - _SnowCover: 1
+    - _SnowTiling: 7
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _TessMax: 25
+    - _TessMin: 10
+    - _TessValue: 4
+    - _UVSec: 0
+    - _Worldtiling: 0.06
+    - _ZWrite: 1
+    - __dirty: 0
+    m_Colors:
+    - _Color: {r: 0.4852941, g: 0.4852941, b: 0.4852941, a: 0}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _GlobalColor: {r: 1, g: 1, b: 1, a: 1}
+    - _ObjectColor: {r: 0.86764705, g: 0.86764705, b: 0.86764705, a: 1}
+  m_BuildTextureStacks: []
+--- !u!114 &7853589313422011170
+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: 5

Assets/Fantasy Adventure Environment/Materials/Rocks/Cliff_A_Mat.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 883bbd715dd7e2e428aa32e0c388722a
+timeCreated: 1494252210
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Materials/Rocks/Cliff_B_Mat.mat

@@ -0,0 +1,218 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &-9119524640666183101
+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: 5
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Cliff_B_Mat
+  m_Shader: {fileID: -6465566751694194690, guid: 7f57b0c643f528f4297b72348cab9faf,
+    type: 3}
+  m_ShaderKeywords: _DETAIL_MULX2 _EMISSION _NORMALMAP _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+  m_LightmapFlags: 5
+  m_EnableInstancingVariants: 1
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 2800000, guid: 184d6a203cd3af44397cedb44de6cfed, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CoverageAlbedo:
+        m_Texture: {fileID: 2800000, guid: 6dc430d5c113ab14c91065b0117acafb, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CoverageMap:
+        m_Texture: {fileID: 2800000, guid: f372ecf27e5c4954c8bf0015e21ca538, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CoverageNormals:
+        m_Texture: {fileID: 2800000, guid: 51954d6e0de971a43ac1ba884c6836f5, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 10, y: 10}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Detailnormal:
+        m_Texture: {fileID: 2800000, guid: 06bdf21e154425948b0978955fd687b4, type: 3}
+        m_Scale: {x: 10, y: 10}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Globalalbedo:
+        m_Texture: {fileID: 2800000, guid: 90c15e788b01a3646a1f0b65505c9972, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Globalcolor:
+        m_Texture: {fileID: 2800000, guid: 016e95565131cbe4bbe66d399a1c4efa, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _GrassDiffuse:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _GrassdiffuseAheight:
+        m_Texture: {fileID: -1782295886, guid: 7154642c7e2a90e42ac41a57d23f7317, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Grassnormal:
+        m_Texture: {fileID: 417745122, guid: 7154642c7e2a90e42ac41a57d23f7317, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: c469316b0e200614daa4511fd0e1d512, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 2800000, guid: 9ee4c82c0409e14459b838d4bdf9ce44, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ObjectHeightAO:
+        m_Texture: {fileID: 2800000, guid: fbc47f2c09271b549a9391df18145172, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Objectalbedo:
+        m_Texture: {fileID: 2800000, guid: c469316b0e200614daa4511fd0e1d512, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Objectnormals:
+        m_Texture: {fileID: 2800000, guid: 184d6a203cd3af44397cedb44de6cfed, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Objectroughness:
+        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}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _PigmentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Rockdiffuse:
+        m_Texture: {fileID: 2800000, guid: d84a0fef99ecb614e884feee98ccff2f, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Rocknormal:
+        m_Texture: {fileID: 2800000, guid: c30b9cbff6831f14781f04ee653e852e, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SnowAlbedo:
+        m_Texture: {fileID: -1782295886, guid: 7154642c7e2a90e42ac41a57d23f7317, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SnowNormals:
+        m_Texture: {fileID: 417745122, guid: 7154642c7e2a90e42ac41a57d23f7317, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TextureSample3:
+        m_Texture: {fileID: 2800000, guid: 19b818e26c2922a488c06b1fbdae5df3, type: 3}
+        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:
+    - _BumpScale: 1
+    - _Contrast: 1
+    - _CoverageAmount: 1
+    - _CoverageTiling: 8
+    - _Cutoff: 0.5
+    - _Debug: 0
+    - _DetailNormalMapScale: 0
+    - _Detailstrength: 0.28
+    - _Distance: 3
+    - _DstBlend: 0
+    - _Float0: 4.78
+    - _Float4: 2
+    - _Globaltiling: 0.163
+    - _GlossMapScale: 0.727
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Grassedgecontrast: 0.481
+    - _Grassheight: 1.045
+    - _Grasstiling: 0.31
+    - _Grasstransitioncontrast: 0.77
+    - _Height: 1
+    - _MaskClipValue: 0.5
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _QueueControl: 0
+    - _QueueOffset: 0
+    - _RockTilingNear: 0.1
+    - _RocktilingFar: 0.03
+    - _Roughness: 0.276
+    - _SmoothnessTextureChannel: 1
+    - _SnowCover: 1
+    - _SnowTiling: 7
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _TessMax: 25
+    - _TessMin: 10
+    - _TessValue: 4
+    - _TransitionExponent: 3
+    - _UVSec: 0
+    - _Worldtiling: 0.06
+    - _ZWrite: 1
+    - __dirty: 0
+    m_Colors:
+    - _Color: {r: 0.4852941, g: 0.4852941, b: 0.4852941, a: 0}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _GlobalColor: {r: 1, g: 1, b: 1, a: 1}
+    - _GrassColor: {r: 0.5909737, g: 1, b: 0.1985294, a: 1}
+    - _Grasscolor: {r: 1, g: 1, b: 1, a: 1}
+    - _ObjectColor: {r: 0.86764705, g: 0.86764705, b: 0.86764705, a: 1}
+    - _RockColor: {r: 0.5019608, g: 0.5019608, b: 0.5019608, a: 1}
+  m_BuildTextureStacks: []

Assets/Fantasy Adventure Environment/Materials/Rocks/Cliff_B_Mat.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3fb461ac7c57a6a45a721f002c1fe26d
+timeCreated: 1494252210
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Materials/Rocks/Cliff_C_Mat.mat

@@ -0,0 +1,109 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Cliff_C_Mat
+  m_Shader: {fileID: -6465566751694194690, guid: 7f57b0c643f528f4297b72348cab9faf,
+    type: 3}
+  m_ShaderKeywords: _EMISSION
+  m_LightmapFlags: 5
+  m_EnableInstancingVariants: 1
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _CoverageAlbedo:
+        m_Texture: {fileID: 2800000, guid: 6dc430d5c113ab14c91065b0117acafb, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CoverageMap:
+        m_Texture: {fileID: 2800000, guid: f372ecf27e5c4954c8bf0015e21ca538, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CoverageNormals:
+        m_Texture: {fileID: 2800000, guid: 51954d6e0de971a43ac1ba884c6836f5, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Detailnormal:
+        m_Texture: {fileID: 2800000, guid: 06bdf21e154425948b0978955fd687b4, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Globalalbedo:
+        m_Texture: {fileID: 2800000, guid: 90c15e788b01a3646a1f0b65505c9972, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Objectalbedo:
+        m_Texture: {fileID: 2800000, guid: a0e9a23a3c69a2d4da534663b350e533, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Objectnormals:
+        m_Texture: {fileID: 2800000, guid: 8761a6c7bff18b74ba9aefd6d30a7a22, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _PigmentMap:
+        m_Texture: {fileID: 1574344641, guid: 1d897bcb600b6fe4985220cd34d54f67, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SnowAlbedo:
+        m_Texture: {fileID: -1782295886, guid: 7154642c7e2a90e42ac41a57d23f7317, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SnowNormals:
+        m_Texture: {fileID: 417745122, guid: 7154642c7e2a90e42ac41a57d23f7317, type: 3}
+        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:
+    - _CoverageAmount: 1
+    - _CoverageTiling: 8
+    - _Detailstrength: 0.28
+    - _Float4: 0.13
+    - _Globaltiling: 0.163
+    - _MaskClipValue: 0.5
+    - _QueueControl: 0
+    - _QueueOffset: 0
+    - _Roughness: 0.276
+    - _SnowCover: 1
+    - _SnowTiling: 7
+    - __dirty: 0
+    m_Colors:
+    - _GlobalColor: {r: 1, g: 1, b: 1, a: 1}
+    - _ObjectColor: {r: 0.86764705, g: 0.86764705, b: 0.86764705, a: 1}
+  m_BuildTextureStacks: []
+--- !u!114 &2731119889213136563
+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: 5

Assets/Fantasy Adventure Environment/Materials/Rocks/Cliff_C_Mat.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f6653cb4a7fc86c439e596edb503062b
+timeCreated: 1496574837
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Materials/Rocks/Cliff_D_Mat.mat

@@ -0,0 +1,109 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Cliff_D_Mat
+  m_Shader: {fileID: -6465566751694194690, guid: 7f57b0c643f528f4297b72348cab9faf,
+    type: 3}
+  m_ShaderKeywords: _EMISSION
+  m_LightmapFlags: 5
+  m_EnableInstancingVariants: 1
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _CoverageAlbedo:
+        m_Texture: {fileID: 2800000, guid: 6dc430d5c113ab14c91065b0117acafb, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CoverageMap:
+        m_Texture: {fileID: 2800000, guid: f372ecf27e5c4954c8bf0015e21ca538, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CoverageNormals:
+        m_Texture: {fileID: 2800000, guid: 51954d6e0de971a43ac1ba884c6836f5, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Detailnormal:
+        m_Texture: {fileID: 2800000, guid: 06bdf21e154425948b0978955fd687b4, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Globalalbedo:
+        m_Texture: {fileID: 2800000, guid: 90c15e788b01a3646a1f0b65505c9972, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Objectalbedo:
+        m_Texture: {fileID: 2800000, guid: 48e1d6f40e814994fae4203c926e5b8a, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Objectnormals:
+        m_Texture: {fileID: 2800000, guid: c9c829510e77ea549a19e8369714dce9, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _PigmentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SnowAlbedo:
+        m_Texture: {fileID: -1782295886, guid: 7154642c7e2a90e42ac41a57d23f7317, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SnowNormals:
+        m_Texture: {fileID: 417745122, guid: 7154642c7e2a90e42ac41a57d23f7317, type: 3}
+        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:
+    - _CoverageAmount: 1
+    - _CoverageTiling: 8
+    - _Detailstrength: 0.28
+    - _Float4: 0.13
+    - _Globaltiling: 0.163
+    - _MaskClipValue: 0.5
+    - _QueueControl: 0
+    - _QueueOffset: 0
+    - _Roughness: 0.276
+    - _SnowCover: 1
+    - _SnowTiling: 7
+    - __dirty: 0
+    m_Colors:
+    - _GlobalColor: {r: 1, g: 1, b: 1, a: 1}
+    - _ObjectColor: {r: 0.86764705, g: 0.86764705, b: 0.86764705, a: 1}
+  m_BuildTextureStacks: []
+--- !u!114 &6431559579656581559
+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: 5

Assets/Fantasy Adventure Environment/Materials/Rocks/Cliff_D_Mat.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 8860e9ce8f7069c47a0cd17fe89a34aa
+timeCreated: 1496574837
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Materials/Rocks/Cliff_E_Mat.mat

@@ -0,0 +1,163 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &-1022586412749370917
+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: 5
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Cliff_E_Mat
+  m_Shader: {fileID: -6465566751694194690, guid: 7f57b0c643f528f4297b72348cab9faf,
+    type: 3}
+  m_ShaderKeywords: _EMISSION _NORMALMAP
+  m_LightmapFlags: 5
+  m_EnableInstancingVariants: 1
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 2800000, guid: 300878dfaad9f8748af1edfc6f13c2c6, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CoverageAlbedo:
+        m_Texture: {fileID: 2800000, guid: 6dc430d5c113ab14c91065b0117acafb, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CoverageMap:
+        m_Texture: {fileID: 2800000, guid: f372ecf27e5c4954c8bf0015e21ca538, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CoverageNormals:
+        m_Texture: {fileID: 2800000, guid: 51954d6e0de971a43ac1ba884c6836f5, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Detailnormal:
+        m_Texture: {fileID: 2800000, guid: 06bdf21e154425948b0978955fd687b4, 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}
+    - _Globalalbedo:
+        m_Texture: {fileID: 2800000, guid: 90c15e788b01a3646a1f0b65505c9972, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: 463963cd6790673438853b0028fb8933, 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}
+    - _Objectalbedo:
+        m_Texture: {fileID: 2800000, guid: 463963cd6790673438853b0028fb8933, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Objectnormals:
+        m_Texture: {fileID: 2800000, guid: 300878dfaad9f8748af1edfc6f13c2c6, type: 3}
+        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}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _PigmentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SnowAlbedo:
+        m_Texture: {fileID: -1782295886, guid: 7154642c7e2a90e42ac41a57d23f7317, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SnowNormals:
+        m_Texture: {fileID: 417745122, guid: 7154642c7e2a90e42ac41a57d23f7317, type: 3}
+        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:
+    - _BumpScale: 1
+    - _CoverageAmount: 1
+    - _CoverageTiling: 8
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _Detailstrength: 0.28
+    - _DstBlend: 0
+    - _Float4: 0.13
+    - _Globaltiling: 0.163
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _MaskClipValue: 0.5
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _QueueControl: 0
+    - _QueueOffset: 0
+    - _Roughness: 0.276
+    - _SmoothnessTextureChannel: 0
+    - _SnowCover: 1
+    - _SnowTiling: 7
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    - __dirty: 0
+    m_Colors:
+    - _Color: {r: 0.8, g: 0.8, b: 0.8, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _GlobalColor: {r: 1, g: 1, b: 1, a: 1}
+    - _ObjectColor: {r: 0.86764705, g: 0.86764705, b: 0.86764705, a: 1}
+  m_BuildTextureStacks: []

Assets/Fantasy Adventure Environment/Materials/Rocks/Cliff_E_Mat.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d370d2b28db6b1242acde8161dfb3d35
+timeCreated: 1497001361
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Materials/Rocks/Cliff_F_Mat.mat

@@ -0,0 +1,163 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Cliff_F_Mat
+  m_Shader: {fileID: -6465566751694194690, guid: 7f57b0c643f528f4297b72348cab9faf,
+    type: 3}
+  m_ShaderKeywords: _EMISSION
+  m_LightmapFlags: 5
+  m_EnableInstancingVariants: 1
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CoverageAlbedo:
+        m_Texture: {fileID: 2800000, guid: 6dc430d5c113ab14c91065b0117acafb, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CoverageMap:
+        m_Texture: {fileID: 2800000, guid: f372ecf27e5c4954c8bf0015e21ca538, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CoverageNormals:
+        m_Texture: {fileID: 2800000, guid: 51954d6e0de971a43ac1ba884c6836f5, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Detailnormal:
+        m_Texture: {fileID: 2800000, guid: 06bdf21e154425948b0978955fd687b4, 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}
+    - _Globalalbedo:
+        m_Texture: {fileID: 2800000, guid: 90c15e788b01a3646a1f0b65505c9972, 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}
+    - _Objectalbedo:
+        m_Texture: {fileID: 2800000, guid: d7ed88b50cd38d24dbe8a21e35d1fd47, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Objectnormals:
+        m_Texture: {fileID: 2800000, guid: a6d38eece76fa96438dc27380c87f472, type: 3}
+        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}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _PigmentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SnowAlbedo:
+        m_Texture: {fileID: -1782295886, guid: 7154642c7e2a90e42ac41a57d23f7317, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SnowNormals:
+        m_Texture: {fileID: 417745122, guid: 7154642c7e2a90e42ac41a57d23f7317, type: 3}
+        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:
+    - _BumpScale: 1
+    - _CoverageAmount: 1
+    - _CoverageTiling: 8
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _Detailstrength: 0.28
+    - _DstBlend: 0
+    - _Float4: 0.13
+    - _Globaltiling: 0.163
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _MaskClipValue: 0.5
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _QueueControl: 0
+    - _QueueOffset: 0
+    - _Roughness: 0.276
+    - _SmoothnessTextureChannel: 0
+    - _SnowCover: 1
+    - _SnowTiling: 7
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    - __dirty: 0
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _GlobalColor: {r: 1, g: 1, b: 1, a: 1}
+    - _ObjectColor: {r: 0.86764705, g: 0.86764705, b: 0.86764705, a: 1}
+  m_BuildTextureStacks: []
+--- !u!114 &2935542345623018778
+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: 5

Assets/Fantasy Adventure Environment/Materials/Rocks/Cliff_F_Mat.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 98764edd700fce5438f40f258bc48927
+timeCreated: 1497355877
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Materials/Rocks/RockCluster_Mat.mat

@@ -0,0 +1,163 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: RockCluster_Mat
+  m_Shader: {fileID: -6465566751694194690, guid: 7f57b0c643f528f4297b72348cab9faf,
+    type: 3}
+  m_ShaderKeywords: _EMISSION _NORMALMAP _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+  m_LightmapFlags: 5
+  m_EnableInstancingVariants: 1
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 2800000, guid: 45e11de0c10675446a101ebe24f6a766, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CoverageAlbedo:
+        m_Texture: {fileID: 2800000, guid: 6dc430d5c113ab14c91065b0117acafb, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CoverageMap:
+        m_Texture: {fileID: 2800000, guid: f372ecf27e5c4954c8bf0015e21ca538, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CoverageNormals:
+        m_Texture: {fileID: 2800000, guid: 51954d6e0de971a43ac1ba884c6836f5, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Detailnormal:
+        m_Texture: {fileID: 2800000, guid: 06bdf21e154425948b0978955fd687b4, 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}
+    - _Globalalbedo:
+        m_Texture: {fileID: 2800000, guid: 90c15e788b01a3646a1f0b65505c9972, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: 29b5e630e0276064393a9090eb94bc90, 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}
+    - _Objectalbedo:
+        m_Texture: {fileID: 2800000, guid: 29b5e630e0276064393a9090eb94bc90, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Objectnormals:
+        m_Texture: {fileID: 2800000, guid: 45e11de0c10675446a101ebe24f6a766, type: 3}
+        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}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _PigmentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SnowAlbedo:
+        m_Texture: {fileID: -1782295886, guid: 7154642c7e2a90e42ac41a57d23f7317, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SnowNormals:
+        m_Texture: {fileID: 417745122, guid: 7154642c7e2a90e42ac41a57d23f7317, type: 3}
+        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:
+    - _BumpScale: 0
+    - _CoverageAmount: 1
+    - _CoverageTiling: 8
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _Detailstrength: 0.28
+    - _DstBlend: 0
+    - _Float4: 0.13
+    - _Globaltiling: 0.163
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _MaskClipValue: 0.5
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _QueueControl: 0
+    - _QueueOffset: 0
+    - _Roughness: 0.276
+    - _SmoothnessTextureChannel: 1
+    - _SnowCover: 1
+    - _SnowTiling: 7
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    - __dirty: 0
+    m_Colors:
+    - _Color: {r: 0.8, g: 0.8, b: 0.8, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _GlobalColor: {r: 1, g: 1, b: 1, a: 1}
+    - _ObjectColor: {r: 0.86764705, g: 0.86764705, b: 0.86764705, a: 1}
+  m_BuildTextureStacks: []
+--- !u!114 &6790188634392776089
+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: 5

Assets/Fantasy Adventure Environment/Materials/Rocks/RockCluster_Mat.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ec75d09494f567544851d79620d0203b
+timeCreated: 1496068417
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Materials/Rocks/Textures.meta

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

Assets/Fantasy Adventure Environment/Materials/Rocks/Textures/Cliff_A_AlbedoRoughness.png.meta

@@ -0,0 +1,121 @@
+fileFormatVersion: 2
+guid: 4cc5117dfac9f974cbdb39ceb28e5059
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 9
+  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: -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: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 1024
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Standalone
+    maxTextureSize: 1024
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: iPhone
+    maxTextureSize: 1024
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Android
+    maxTextureSize: 1024
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Materials/Rocks/Textures/Cliff_A_Normal.png.meta

@@ -0,0 +1,59 @@
+fileFormatVersion: 2
+guid: 5d23501e26536f746ac3ce3d9a0bdb5f
+timeCreated: 1497354455
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 2
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    linearTexture: 1
+    correctGamma: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 1
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 0
+  cubemapConvolution: 0
+  cubemapConvolutionSteps: 7
+  cubemapConvolutionExponent: 1.5
+  seamlessCubemap: 0
+  textureFormat: -1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 1
+  lightmap: 0
+  rGBM: 0
+  compressionQuality: 50
+  allowsAlphaSplitting: 0
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 1
+  buildTargetSettings: []
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Materials/Rocks/Textures/Cliff_B_AlbedoRoughness.png.meta

@@ -0,0 +1,121 @@
+fileFormatVersion: 2
+guid: c469316b0e200614daa4511fd0e1d512
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 9
+  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: -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: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 1024
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Standalone
+    maxTextureSize: 1024
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: iPhone
+    maxTextureSize: 1024
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Android
+    maxTextureSize: 1024
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Materials/Rocks/Textures/Cliff_B_Normal.png.meta

@@ -0,0 +1,59 @@
+fileFormatVersion: 2
+guid: 184d6a203cd3af44397cedb44de6cfed
+timeCreated: 1494252221
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 2
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    linearTexture: 1
+    correctGamma: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 1
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 0
+  cubemapConvolution: 0
+  cubemapConvolutionSteps: 7
+  cubemapConvolutionExponent: 1.5
+  seamlessCubemap: 0
+  textureFormat: -1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 1
+  lightmap: 0
+  rGBM: 0
+  compressionQuality: 50
+  allowsAlphaSplitting: 0
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 1
+  buildTargetSettings: []
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Fantasy Adventure Environment/Materials/Rocks/Textures/Cliff_C_AlbedoRoughness.png.meta

@@ -0,0 +1,121 @@
+fileFormatVersion: 2
+guid: a0e9a23a3c69a2d4da534663b350e533
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 9
+  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: -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: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 1024
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Standalone
+    maxTextureSize: 1024
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: iPhone
+    maxTextureSize: 1024
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Android
+    maxTextureSize: 1024
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: