com.warwlock.mtree 1.0.2

package/Runtime/TreeFunctions/TrunkFunction.cs

@@ -0,0 +1,88 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+namespace Mtree
+{
+    public class TrunkFunction : TreeFunctionAsset
+    {
+        public float radiusMultiplier = .3f;
+        public AnimationCurve radius;
+        public float length = 15;
+        public int number = 1;
+        public float randomness = .1f;
+        public float originAttraction = .1f;
+        public float resolution = 1.5f;
+        public AnimationCurve rootShape;
+        public float rootRadius = .25f;
+        public float rootInnerRadius = .2f;
+        public float rootHeight = 1f;
+        public float rootResolution = 3f;
+        public int flareNumber = 5;
+        public float spinAmount = .1f;
+        public float displacementStrength = 1f;
+        public float displacementSize = 2.5f;
+        public float heightOffset = .5f;
+
+        public override void Init(TreeFunctionAsset parent, bool preserveSettings = false)
+        {
+            base.Init(parent);
+            name = "Trunk";
+            if (!preserveSettings)
+            {
+                Keyframe[] keys = new Keyframe[2] { new Keyframe(0f, 1f, 0f, 0f), new Keyframe(1f, 0f, -1f, -1f) };
+                radius = new AnimationCurve(keys);
+                Keyframe[] rootKeys = new Keyframe[2] { new Keyframe(0f, 1f, -2f, -2f), new Keyframe(1f, 0f, 0f, 0f) };
+                rootShape = new AnimationCurve(rootKeys);
+            }
+
+        }
+
+        public override void DrawProperties()
+        {
+        #if UNITY_EDITOR
+
+            SerializedObject obj = new SerializedObject(this);
+
+            EditorGUILayout.PropertyField(obj.FindProperty("seed"), new GUIContent("Seed"));
+            Utils.BoundedFloatProperty(obj.FindProperty("length"), "Length", 0.01f);
+            Utils.BoundedFloatProperty(obj.FindProperty("radiusMultiplier"), "Radius", 0.01f);
+            Utils.BoundedFloatProperty(obj.FindProperty("resolution"), new GUIContent("Resolution", "Number of segments per unit of length"), 0.01f);
+            EditorGUILayout.Slider(obj.FindProperty("originAttraction"), 0, 1, new GUIContent("Axis attraction", "How much the tree is drawn to its original axis"));
+            EditorGUILayout.PropertyField(obj.FindProperty("radius"), new GUIContent("Shape"));
+            EditorGUILayout.Slider(obj.FindProperty("randomness"), 0, .5f, new GUIContent("Randomness", "How irregular the trunk looks"));
+            EditorGUILayout.PropertyField(obj.FindProperty("displacementStrength"), new GUIContent("Displacement strength", "Strength of the the noise affecting the geometry of the trunk"));
+            EditorGUILayout.PropertyField(obj.FindProperty("displacementSize"), new GUIContent("Displacement size", "Size of the noise affecting the geometry of the trunk"));
+            EditorGUILayout.PropertyField(obj.FindProperty("spinAmount"), new GUIContent("Spin amount", "How much the trunk is twisted"));
+            EditorGUILayout.PropertyField(obj.FindProperty("heightOffset"), new GUIContent("Height Offset", "How much the trunk goes inside the ground. Helps when a tree is placed on an uneven ground"));
+
+            EditorGUILayout.BeginVertical(EditorStyles.helpBox);
+            EditorGUILayout.LabelField("Flares");
+
+            EditorGUILayout.PropertyField(obj.FindProperty("rootShape"), new GUIContent("Shape"));
+            Utils.BoundedFloatProperty(obj.FindProperty("rootHeight"), "Start Height", 0.01f);
+            EditorGUILayout.Slider(obj.FindProperty("rootRadius"), 0, 2, new GUIContent("Outer Radius"));
+            EditorGUILayout.Slider(obj.FindProperty("rootInnerRadius"), 0, 1, new GUIContent("Inner Radius"));
+            Utils.BoundedFloatProperty(obj.FindProperty("rootResolution"), new GUIContent("Additional Resolution"), 1);
+            EditorGUILayout.IntSlider(obj.FindProperty("flareNumber"), 0, 10, new GUIContent("Number"));
+
+            EditorGUILayout.EndVertical();
+            obj.ApplyModifiedProperties();
+
+        #endif
+        }
+
+        public override void Execute(MTree tree)
+        {
+            base.Execute(tree);
+
+            Random.InitState(seed);
+
+            tree.AddTrunk(Vector3.down * heightOffset, Vector3.up, length, radius, radiusMultiplier, resolution, randomness
+            , id, rootShape, rootRadius, rootHeight, rootResolution, originAttraction);
+        }
+    }
+}

package/Runtime/TreeFunctions/TrunkFunction.cs.meta

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

package/Runtime/TreeFunctions.meta

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

package/Runtime/TreePoint.cs

@@ -0,0 +1,27 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Mtree
+{
+    public struct TreePoint
+    {
+        public Vector3 position, direction;
+        public float radius;
+        public NodeType type;
+        public Vector3 parentDirection;
+        public float parentRadius;
+        public float distanceFromOrigin;
+
+        public TreePoint(Vector3 pos, Vector3 dir, float rad, NodeType type, Vector3 parentDirection, float distanceFromOrigin, float parentRadius)
+        {
+            position = pos;
+            direction = dir;
+            radius = rad;
+            this.type = type;
+            this.parentDirection = parentDirection;
+            this.distanceFromOrigin = distanceFromOrigin;
+            this.parentRadius = parentRadius;
+        }
+    }
+}

package/Runtime/TreePoint.cs.meta

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

package/Runtime/TreeTemplate.cs

@@ -0,0 +1,50 @@
+
+using System.Collections;
+using System.Collections.Generic;
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+using UnityEngine;
+
+namespace Mtree
+{
+    public class TreeTemplate : ScriptableObject
+    {
+#if UNITY_EDITOR
+        public List<TreeFunctionAsset> treeFunctions;
+
+        public static TreeTemplate CreateFromFunctions(List<TreeFunctionAsset> functionsToCopy, string path)
+        {
+            List<TreeFunctionAsset> treeFunctions = new List<TreeFunctionAsset>();
+
+            for (int i = 0; i < functionsToCopy.Count; i++)
+            {
+                TreeFunctionAsset function = Instantiate(functionsToCopy[i]);
+                treeFunctions.Add(function);
+            }
+
+            for (int i = 0; i < functionsToCopy.Count; i++)
+            {
+                int parentIndex = functionsToCopy.IndexOf(functionsToCopy[i].parent);
+                TreeFunctionAsset parent = parentIndex == -1 ? null : treeFunctions[parentIndex];
+                treeFunctions[i].Init(parent, true);
+            }
+
+            TreeTemplate template = ScriptableObject.CreateInstance<TreeTemplate>();
+            template.treeFunctions = treeFunctions;
+
+            AssetDatabase.CreateAsset(template, path);
+
+            template = AssetDatabase.LoadAssetAtPath<TreeTemplate>(path);
+
+            for (int i = 0; i < treeFunctions.Count; i++)
+                AssetDatabase.AddObjectToAsset(treeFunctions[i], template);
+
+            AssetDatabase.SaveAssets();
+            AssetDatabase.Refresh();
+
+            return template;
+        }
+#endif
+    }
+ }

package/Runtime/TreeTemplate.cs.meta

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

package/Runtime/Utils.cs

@@ -0,0 +1,268 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+
+
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+namespace Mtree
+{
+    public class Utils
+    {
+        public static string GetCurrentPipeline()
+        {
+            var ActivePipeline = "legacy";
+            if (GraphicsSettings.defaultRenderPipeline != null)
+            {
+                if (GraphicsSettings.defaultRenderPipeline.GetType().ToString().Contains("LightweightRenderPipelineAsset"))
+                    ActivePipeline = "lwrp";
+                if (GraphicsSettings.defaultRenderPipeline.GetType().ToString().Contains("UniversalRenderPipelineAsset"))
+                    ActivePipeline = "urp";
+                if (GraphicsSettings.defaultRenderPipeline.GetType().ToString().Contains("HDRenderPipelineAsset"))
+                    ActivePipeline = "hdrp";
+            }
+            else
+            {
+                ActivePipeline = "legacy";
+            }
+            return ActivePipeline;
+        }
+
+        public static Shader GetBarkShader()
+        {
+            Shader shader = null;
+
+            switch(GetCurrentPipeline())
+            {
+                case "legacy":
+                    shader = Shader.Find("Mtree/Bark");
+                break;
+
+                case "lwrp":
+                    shader = Shader.Find("Mtree/SRP/Bark LWRP");
+                break;
+
+                case "hdrp":
+                    shader = Shader.Find("Mtree/SRP/Bark HDRP");
+                break;
+
+                case "urp":
+                    shader = Shader.Find("Mtree/SRP/Bark URP");
+                break;
+            }
+            return shader;
+        }
+
+        public static Shader GetLeafShader()
+        {
+            Shader shader = null;
+            
+            switch(GetCurrentPipeline()){
+                case "legacy":
+                    shader = Shader.Find("Mtree/Leafs");
+                break;
+
+                case "lwrp":
+                    shader = Shader.Find("Mtree/SRP/Leafs LWRP");
+                break;
+
+                case "hdrp":
+                    shader = Shader.Find("Mtree/SRP/Leafs HDRP");
+                break;
+
+                case "urp":
+                    shader = Shader.Find("Mtree/SRP/Leafs URP");
+                break;
+            }
+            return shader;
+        }
+
+        public static Shader GetBillboardShader()
+        {
+            Shader shader = null;
+            
+            switch(GetCurrentPipeline()){
+                case "legacy":
+                    shader = Shader.Find("Mtree/Billboard");
+                break;
+
+                case "lwrp":
+                    shader = Shader.Find("Mtree/SRP/Billboard LWRP");
+                break;
+
+                case "hdrp":
+                    shader = Shader.Find("Mtree/SRP/Billboard HDRP");
+                break;
+
+                case "urp":
+                    shader = Shader.Find("Universal Render Pipeline/Lit");
+                break;
+            }
+            return shader;
+        }
+        public static Shader GetVertexColorShader()
+        {
+            Shader shader = null;
+            
+            switch(GetCurrentPipeline()){
+                case "legacy":
+                    shader = Shader.Find("Hidden/Mtree/VertexColorShader");
+                break;
+
+                case "lwrp":
+                    shader = Shader.Find("Hidden/Mtree/SRP/VertexColorShader LWRP");
+                break;
+
+                case "hdrp":
+                    shader = Shader.Find("Hidden/Mtree/SRP/VertexColorShader HDRP");
+                break;
+
+                case "urp":
+                    shader = Shader.Find("Hidden/Mtree/SRP/VertexColorShader URP");
+                break;
+            }
+            return shader;
+        }
+
+        public static T[] SampleArray<T>(T[] array, int number)
+        {
+            number = Mathf.Max(0, Mathf.Min(array.Length, number));
+            T[] result = new T[number];
+            for (int i = 0; i < number; i++)
+            {
+                int index = Random.Range(i, array.Length - 1);
+                result[i] = array[index];
+                array[index] = array[i];
+            }
+
+            return result;
+        }
+
+        public static void DilateTexture(Texture2D texture, int iterations )//, bool removeBackground = false)
+        {
+            Color[] cols = texture.GetPixels();
+
+            // [Removed dueto HDRP]
+            // if (removeBackground)
+            //     RemoveBackground(ref cols);
+
+            Color[] copyCols = new Color[cols.Length];
+            System.Array.Copy(cols, copyCols, cols.Length);
+            HashSet<int> borderIndices = new HashSet<int>();
+            HashSet<int> indexBuffer = new HashSet<int>();
+            int w = texture.width;
+            int h = texture.height;
+            for (int i = 0; i < cols.Length; i++)
+            {
+                if (cols[i].a < 0.5f)
+                {
+                    for (int x = -1; x < 2; x++)
+                    {
+                        for (int y = -1; y < 2; y++)
+                        {
+                            int index = i + y * w + x;
+                            if (index >= 0 && index < cols.Length && cols[index].a > 0.5f) // if a non transparent pixel is near the transparent one, add the transparent pixel index to border indices
+                            {
+                                borderIndices.Add(i);
+                                goto End;
+                            }
+                        }
+                    }
+                    End:;
+                }
+            }
+
+            for (int iteration = 0; iteration < iterations; iteration++)
+            {
+                foreach (int i in borderIndices)
+                {
+                    Color meanCol = Color.black;
+                    int opaqueNeighbours = 0;
+                    for (int x = -1; x < 2; x++)
+                    {
+                        for (int y = -1; y < 2; y++)
+                        {
+                            int index = i + y * w + x;
+                            if (index >= 0 && index < cols.Length && index != i)
+                            {
+                                if (cols[index].a > 0.5f)
+                                {
+                                    cols[index].a = 1;
+                                    meanCol += cols[index];
+                                    opaqueNeighbours++;
+                                }
+                                else
+                                {
+                                    indexBuffer.Add(index);
+                                }
+                            }
+                        }
+                    }
+                    cols[i] = meanCol / opaqueNeighbours;
+                }
+
+                indexBuffer.ExceptWith(borderIndices);
+
+                borderIndices = indexBuffer;
+                indexBuffer = new HashSet<int>();
+            }
+            for (int i = 0; i < cols.Length; i++)
+                cols[i].a = copyCols[i].a;
+            texture.SetPixels(cols);
+        }
+        
+        // [Removed dueto HDRP]
+
+        // private static void RemoveBackground(ref Color[] colors)
+        // {
+        //     Debug.Log("Removing");
+        //     Color backgroundColor = new Color(0.173f, 0.294f, 0.471f);
+        //     for (int i = 0; i < colors.Length; i++)
+        //     {
+        //         Color c = colors[i];
+        //         if (Mathf.Abs(c.r - backgroundColor.r) + Mathf.Abs(c.g - backgroundColor.g) + Mathf.Abs(c.b - backgroundColor.b) < .05)
+        //             colors[i] = new Color(0, 0, 0, 0);
+        //     }
+        // }
+
+        public static void AddTriangle(Queue<int> triangles ,int i1, int i2, int i3)
+        {
+            triangles.Enqueue(i1); triangles.Enqueue(i2); triangles.Enqueue(i3);
+        }
+
+#if UNITY_EDITOR
+
+        public static void BoundedFloatProperty(SerializedProperty prop, string label = "", float minValue = Mathf.NegativeInfinity, float maxValue = Mathf.Infinity)
+        {
+            GUIContent labelGui = label == "" ? null : new GUIContent(label);
+            BoundedFloatProperty(prop, labelGui, minValue, maxValue);
+        }
+
+        public static void BoundedFloatProperty(SerializedProperty prop, GUIContent label = null, float minValue = Mathf.NegativeInfinity, float maxValue = Mathf.Infinity)
+        {
+            Rect position = EditorGUILayout.GetControlRect(label != null);
+
+            EditorGUI.BeginProperty(position, label, prop);
+            EditorGUI.PropertyField(position, prop, label);
+            prop.floatValue = Mathf.Clamp(prop.floatValue, minValue, maxValue);
+            EditorGUI.EndProperty();
+
+        }
+
+        public static void BoundedIntProperty(SerializedProperty prop, GUIContent label = null, int minValue = int.MinValue, int maxValue = int.MaxValue)
+        {
+            Rect position = EditorGUILayout.GetControlRect(label != null);
+
+            EditorGUI.BeginProperty(position, label, prop);
+            EditorGUI.PropertyField(position, prop, label);
+            prop.intValue = Mathf.Clamp(prop.intValue, minValue, maxValue);
+            EditorGUI.EndProperty();
+        }
+#endif
+}    
+
+}

package/Runtime/Utils.cs.meta

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

package/Runtime/VSProIntegration.cs

@@ -0,0 +1,132 @@
+using System.Collections;
+using System.Collections.Generic;
+
+#if VEGETATION_STUDIO_PRO
+using AwesomeTechnologies.VegetationSystem;
+using UnityEngine;
+ 
+namespace AwesomeTechnologies.Shaders
+{
+    public class MtreeShaderController : IShaderController
+    {
+        public bool MatchShader(string shaderName)
+        {
+            return (shaderName == "Mtree/Bark" || shaderName == "Mtree/Leafs");
+        }
+ 
+        public bool MatchBillboardShader(Material[] materials)
+        {
+            return false;
+        }
+ 
+        public ShaderControllerSettings Settings { get; set; }
+        bool CustomLightSource;
+ 
+        public void CreateDefaultSettings(Material[] materials)
+        {
+            Settings = new ShaderControllerSettings
+            {
+                Heading = "Mtree settings",
+                Description = "",
+                LODFadePercentage = true,
+                LODFadeCrossfade = true,
+                SampleWind = true,
+            };
+  
+            Settings.AddLabelProperty("Foliage settings");
+            Settings.AddColorProperty("BarkTintColor", "Bark Color", "", GetColor(materials, "_Color","Bark"));
+            Settings.AddColorProperty("FoliageTintColor", "Leaf Color", "", GetColor(materials,"_Color","Leafs"));
+            Settings.AddFloatProperty("MtreeCutoff","Alpha Cutoff","",GetFloatValue(materials,"_Cutoff","Leafs"),0,1);
+            
+
+            Settings.AddLabelProperty("Translucency Settings");
+            Settings.AddFloatProperty("TranslucentStrength","Srength", "", GetFloatValue(materials, "_Translucency", "Leafs"), 0, 50);
+            Settings.AddFloatProperty("TransNormalDistortion", "Normal Distortion", "", GetFloatValue(materials, "_TransNormalDistortion", "Leafs"), 0, 1);
+            Settings.AddFloatProperty("TransScattering", "Scattering Falloff", "", GetFloatValue(materials, "_TransScattering", "Leafs"), 1, 50);
+            Settings.AddColorProperty("TranslucentColor","Translucent Color","Only Works if Translucent Light Mode set to Custom!",GetColor(materials, "_TranslucencyTint", "Leafs"));
+
+            Settings.AddLabelProperty("Other Settings");
+            Settings.AddFloatProperty("AmbientOcclusion", "AO Strength", "", GetGlobalFloatValue(materials, "_OcclusionStrength"), 0, 1);
+            Settings.AddFloatProperty("MtreeGlobalWindInfluence", "Global Wind Influence","",GetGlobalFloatValue(materials,"_GlobalWindInfluence"),0,1);
+            Settings.AddFloatProperty("MtreeGlobalWindTurbulence", "Global Wind Turbulence Influence","",GetFloatValue(materials,"_GlobalTurbulenceInfluence","Leafs"),0,1);
+
+        }
+       
+        public void UpdateMaterial(Material material, EnvironmentSettings environmentSettings)
+        {
+            if (Settings == null) return;
+                float GlobalWindInfluence = Settings.GetFloatPropertyValue("MtreeGlobalWindInfluence");
+                material.SetFloat("_GlobalWindInfluence", GlobalWindInfluence);
+                float aoStrength = Settings.GetFloatPropertyValue("AmbientOcclusion");
+                material.SetFloat("_OcclusionStrength", aoStrength);
+
+            if (material.shader.name == "Mtree/Bark")
+            {
+                Color barkTintColor = Settings.GetColorPropertyValue("BarkTintColor");
+                material.SetColor("_Color", barkTintColor);
+            }
+            if (material.shader.name == "Mtree/Leafs")
+            {
+                Color foliageTintColor = Settings.GetColorPropertyValue("FoliageTintColor");
+                material.SetColor("_Color", foliageTintColor);
+
+                float foliageCutoff = Settings.GetFloatPropertyValue("MtreeCutoff");
+                material.SetFloat("_Cutoff", foliageCutoff);
+
+                float translucentStrength = Settings.GetFloatPropertyValue("TranslucentStrength");
+                material.SetFloat("_Translucency", translucentStrength);
+
+                float TransNormalDistortion = Settings.GetFloatPropertyValue("TransnormalDistortion");
+                material.SetFloat("_TransNormalDistortion", TransNormalDistortion);
+
+                float TransScattering = Settings.GetFloatPropertyValue("TransScattering");
+                material.SetFloat("_TransScattering", TransScattering);
+
+                Color translucentColor = Settings.GetColorPropertyValue("TranslucentColor");
+                material.SetColor("_TranslucencyTint",translucentColor);
+
+                float GlobalWindTurbulence = Settings.GetFloatPropertyValue("MtreeGlobalWindTurbulence");
+                material.SetFloat("_GlobalTurbulenceInfluence",GlobalWindTurbulence);
+            }
+                
+                
+               
+
+
+         
+        }
+
+        Color GetColor(Material[] materials, string property,string shadertype)
+        {
+            foreach (Material mat in materials)
+            {
+                if (mat.shader.name == "Mtree/"+shadertype)
+                    return mat.GetColor(property);
+            }
+            return Color.black;
+        }
+        float GetFloatValue(Material[] materials,string property, string shadertype)
+        {
+            foreach(Material mat in materials)
+                if (mat.shader.name == "Mtree/" + shadertype)
+                    return mat.GetFloat(property);
+            return 0.1f;
+        }
+        float GetGlobalFloatValue(Material[] materials, string property)
+        {
+            foreach (Material mat in materials)
+                if (mat.shader.name == "Mtree/Bark" || mat.shader.name == "Mtree/Leafs")
+                    return mat.GetFloat(property);
+            return 0.1f;
+        }
+
+
+
+
+
+        public void UpdateWind(Material material, WindSettings windSettings)
+        {
+        }
+    }
+}
+#endif

package/Runtime/VSProIntegration.cs.meta

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

package/Runtime.meta

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