com.warwlock.mtree 1.0.2

package/Editor/MTree.Editor.asmdef

@@ -0,0 +1,18 @@
+{
+    "name": "MTree.Editor",
+    "rootNamespace": "",
+    "references": [
+        "GUID:a17eaea2482276b43ac7a9cb9c9ec810"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

package/Editor/MTree.Editor.asmdef.meta

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

package/Editor/MenuItem.cs

@@ -0,0 +1,31 @@
+using UnityEngine;
+using UnityEditor;
+
+public class MenuItems
+{
+    [MenuItem("GameObject/3D Object/Create new Mtree...")]
+    private static void CreateNewMtree()
+    {
+        GameObject tree = new GameObject("New Mtree");
+        MtreeComponent mtree = tree.AddComponent<MtreeComponent>();
+        mtree.GenerateTree();
+        Selection.activeGameObject = tree;
+        if (SceneView.lastActiveSceneView != null)
+        {
+            tree.gameObject.transform.position = SceneView.lastActiveSceneView.pivot;
+        }
+
+    }
+    [MenuItem("Window/Mtree/Add Mtree Global Wind Controller To Scene...")]
+    private static void CreateGlobalMtreeWindController()
+    {
+        GameObject WindController = new GameObject("Mtree Wind Controller");
+        WindController.AddComponent<WindZone>();
+        WindController.AddComponent<MtreeWind>();
+        if (SceneView.lastActiveSceneView != null)
+        {
+            WindController.transform.position = Vector3.zero;
+        }
+
+    }
+}

package/Editor/MenuItem.cs.meta

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

package/Editor/MtreeBezierInspector.cs

@@ -0,0 +1,161 @@
+using UnityEditor;
+using UnityEngine;
+
+[CustomEditor(typeof(MtreeBezier))]
+public class MtreeBezierInspector : Editor {
+
+	private const int stepsPerCurve = 10;
+	private const float directionScale = 0.5f;
+	private const float handleSize = 0.04f;
+	private const float pickSize = 0.06f;
+	private static Color[] modeColors = {
+		Color.white,
+		Color.blue,
+		Color.cyan
+	};
+
+	private MtreeBezier spline;
+	private Transform handleTransform;
+	private Quaternion handleRotation;
+	private int selectedIndex = -1;
+
+	private string DoBezier,DoLeaf;
+	public override void OnInspectorGUI () {
+
+		var gs = new GUIStyle();
+		gs.fontStyle = FontStyle.Bold;
+
+		spline = target as MtreeBezier;
+		GUILayout.Space(10);
+		EditorGUI.BeginChangeCheck();
+		EditorGUILayout.LabelField("MTree Addon",gs);
+
+		if(spline.MTreeDoBezier){
+			DoBezier = "Deactivate Bezier Mode";
+		}else{
+			DoBezier = "Activate Bezier Mode";
+		}
+		if(GUILayout.Button(DoBezier)){
+			Undo.RecordObject(spline,DoBezier);
+			spline.MTreeDoBezier = !spline.MTreeDoBezier;
+			EditorUtility.SetDirty(spline);
+		}
+		if (GUILayout.Button("Add Curve")) {
+			Undo.RecordObject(spline, "Add Curve");
+			spline.AddCurve();
+			EditorUtility.SetDirty(spline);
+		}
+		if(EditorGUI.EndChangeCheck()){
+			spline.GetComponent<MtreeComponent>().GenerateTree();
+		}
+		GUILayout.Space(10);
+		EditorGUI.BeginChangeCheck();
+		EditorGUILayout.LabelField("Branch / Leaf Directions",gs);
+		if(spline.MTreeLeafDirection){
+			DoLeaf = "Deactivate Leaf Direction Mode";
+		}else{
+			DoLeaf = "Activate Leaf Direction Mode";
+		}
+		if(GUILayout.Button(DoLeaf)){
+			Undo.RecordObject(spline,DoLeaf);
+			spline.MTreeLeafDirection = !spline.MTreeLeafDirection;
+			EditorUtility.SetDirty(spline);
+		}
+		spline.s_branchdirection = EditorGUILayout.Vector3Field("Branch Growth Direction",spline.s_branchdirection);
+		
+		if(EditorGUI.EndChangeCheck()){
+			
+			spline.s_branchdirection.x = Mathf.Clamp(spline.s_branchdirection.x,-1,1);
+			spline.s_branchdirection.y = Mathf.Clamp(spline.s_branchdirection.y,-1,1);
+			spline.s_branchdirection.z = Mathf.Clamp(spline.s_branchdirection.z,-1,1);
+			Undo.RecordObject(spline,"Branch Growth Direction");
+			spline.GetComponent<MtreeComponent>().GenerateTree();
+			EditorUtility.SetDirty(spline);
+		}
+		GUILayout.Space(10);
+		
+		if (selectedIndex >= 0 && selectedIndex < spline.ControlPointCount) {
+			EditorGUILayout.LabelField("Bezier Position / Mode",gs);
+			DrawSelectedPointInspector();
+		}
+
+		
+
+		
+	}
+
+	private void DrawSelectedPointInspector() {
+		GUILayout.Label("Selected Point");
+		EditorGUI.BeginChangeCheck();
+		Vector3 point = EditorGUILayout.Vector3Field("Position", spline.GetControlPoint(selectedIndex));
+		if (EditorGUI.EndChangeCheck()) {
+			Undo.RecordObject(spline, "Move Point");
+			EditorUtility.SetDirty(spline);
+			spline.SetControlPoint(selectedIndex, point);
+		}
+		EditorGUI.BeginChangeCheck();
+		BezierControlPointMode mode = (BezierControlPointMode)EditorGUILayout.EnumPopup("Mode", spline.GetControlPointMode(selectedIndex));
+		if (EditorGUI.EndChangeCheck()) {
+			Undo.RecordObject(spline, "Change Point Mode");
+			spline.SetControlPointMode(selectedIndex, mode);
+			EditorUtility.SetDirty(spline);
+		}
+		
+	}
+
+	private void OnSceneGUI () {
+		spline = target as MtreeBezier;
+		handleTransform = spline.transform;
+		handleRotation = Tools.pivotRotation == PivotRotation.Local ?
+		handleTransform.rotation : Quaternion.identity;
+		
+		Vector3 p0 = ShowPoint(0);
+		if(spline.points.Length>3){
+			for (int i = 1; i < spline.ControlPointCount; i += 3) {
+				Vector3 p1 = ShowPoint(i);
+				Vector3 p2 = ShowPoint(i + 1);
+				Vector3 p3 = ShowPoint(i + 2);
+				
+				Handles.color = Color.gray;
+				Handles.DrawLine(p0, p1);
+				Handles.DrawLine(p2, p3);
+				
+				Handles.DrawBezier(p0, p3, p1, p2, Color.white, null, 2f);
+				p0 = p3;
+			}
+		}
+	}
+
+
+	private Vector3 ShowPoint (int index) {
+		Vector3 point = handleTransform.TransformPoint(spline.GetControlPoint(index));
+		float size = HandleUtility.GetHandleSize(point);
+		if (index == 0) {
+			size *= 5;
+		}
+		if(index > 0 ){
+			size *= 3;
+		}
+		if(index % 3 == 1 || index % 3 == 2){
+			Handles.color = modeColors[(int)spline.GetControlPointMode(index)] * Color.blue;
+			}
+		if(index % 3 == 0){
+			Handles.color = modeColors[(int)spline.GetControlPointMode(index)] * Color.green;
+			}
+		if (Handles.Button(point, handleRotation, size * handleSize, size * pickSize, Handles.SphereHandleCap)) {
+			selectedIndex = index;
+			Repaint();
+		}
+		if (selectedIndex == index) {
+			EditorGUI.BeginChangeCheck();
+
+			point = Handles.DoPositionHandle(point, handleRotation);
+			if (EditorGUI.EndChangeCheck()) {
+				Undo.RecordObject(spline, "Move Point");
+				EditorUtility.SetDirty(spline);
+				spline.SetControlPoint(index, handleTransform.InverseTransformPoint(point));
+			}
+		}
+		return point;
+	}
+}

package/Editor/MtreeBezierInspector.cs.meta

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

package/Editor/MtreeEditor.cs

@@ -0,0 +1,434 @@
+using UnityEngine;
+using UnityEditor;
+using Mtree;
+using System;
+using System.IO;
+
+namespace Mtree
+{
+
+    [CanEditMultipleObjects]
+    [CustomEditor(typeof(MtreeComponent))]
+    public class MtreeEditor : Editor
+    {
+        MtreeComponent tree;
+        private static string[] lodOptions = { "0", "1", "2", "3" };
+        private static string[] tabNames = { "Functions", "Quality", "Save as prefab" };
+        private int rectHeightMultiplier;
+
+        public float BB_GRP_Brightness = 1;
+        public float BB_GRP_TopCardPositon = 0.5f;
+        public int BB_GRP_hasTopCard = 1;
+        public int BB_GRP_isSingleSided = 1;
+
+        private void OnEnable()
+        {
+            tree = (MtreeComponent)target;
+#if UNITY_2018_3_OR_NEWER
+            if (PrefabUtility.GetPrefabInstanceHandle(target) != null) // Prefabs with MtreeComponents should not be made as it tempers with the TreeFunctionAsset objects. Thus prefabs are deleted
+            {
+                DeletePefab();
+                return;
+            }
+#else
+            if (PrefabUtility.GetPrefabObject(target) != null) // Prefabs with MtreeComponents should not be made as it tempers with the TreeFunctionAsset objects. Thus prefabs are deleted
+            {
+                DeletePefab();
+                return;
+            }
+#endif
+            if (tree.tree == null && tree.MtreeVersion == Mtree.MtreeVariables.MtreeVersion)
+            {
+                UpdateTree();
+            }
+            rectHeightMultiplier = TreeFunctionAsset.height + TreeFunctionAsset.margin;
+            Undo.undoRedoPerformed += tree.UndoCallBack;
+        }
+
+        private void DeletePefab()
+        {
+#if UNITY_2018_3_OR_NEWER
+            string prefabPath = AssetDatabase.GetAssetPath(PrefabUtility.GetPrefabInstanceHandle(target));
+            AssetDatabase.DeleteAsset(prefabPath);
+#else
+            string prefabPath = AssetDatabase.GetAssetPath(PrefabUtility.GetPrefabObject(target));
+            AssetDatabase.DeleteAsset(prefabPath);
+#endif
+        }
+
+        public override void OnInspectorGUI()
+        {
+            if (IsMultiSelection()) // Editor to display when multiple trees are selected
+            {
+                DisplayMultiObjectsEditting();
+                return; // Not drawing the rest when multpile trees are selected
+            }
+
+            DisplayLodSelection();
+
+            SerializedProperty tabIndexProperty = serializedObject.FindProperty("tabIndex");
+            tabIndexProperty.intValue = GUILayout.Toolbar(tabIndexProperty.intValue, tabNames);
+            serializedObject.ApplyModifiedProperties();
+
+            switch (tabIndexProperty.intValue)
+            {
+                case 0:
+                    DisplayTemplates();
+                    DisplayFunctionsTab();
+                    break;
+                case 1:
+                    DisplayQualityTab();
+                    break;
+                case 2:
+                    DisplaySaveTab();
+                    break;
+            }
+
+
+            EditorGUILayout.LabelField("polycount: " + tree.polycount.ToString(), EditorStyles.boldLabel);
+
+        }
+
+        private void DisplayTemplates()
+        {
+            EditorGUIUtility.labelWidth = 60;
+            EditorGUILayout.BeginVertical(EditorStyles.helpBox);
+
+
+            EditorGUILayout.BeginHorizontal();
+            
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("template"),new GUIContent("Template"), true);
+            serializedObject.ApplyModifiedProperties();
+            string SaveButton = "Save Template"; if (tree.template != null) SaveButton = "Override"; else SaveButton = "Save";
+
+            EditorGUI.BeginDisabledGroup(tree.template == null);
+            if (GUILayout.Button("Load Template"))
+            {
+                serializedObject.FindProperty("selectedFunctionIndex").intValue = 0;
+                serializedObject.FindProperty("template").objectReferenceValue = tree.template;
+                serializedObject.ApplyModifiedProperties();
+                
+                tree.FromTemplate();
+                UpdateTree();
+                
+            }
+            EditorGUI.EndDisabledGroup();
+            if(GUILayout.Button(SaveButton + " Template"))
+            {
+                if(SaveButton == "Override")
+                {
+                    string templatePath = AssetDatabase.GetAssetPath(tree.template);
+                    AssetDatabase.DeleteAsset(templatePath);
+                    tree.template = TreeTemplate.CreateFromFunctions(tree.treeFunctionsAssets, templatePath);
+
+                    serializedObject.FindProperty("template").objectReferenceValue = tree.template;
+                    serializedObject.ApplyModifiedProperties();
+                }
+                if (SaveButton == "Save")
+                {
+                    string templatePath = EditorUtility.SaveFilePanelInProject("Save Template", tree.name + ".asset", "asset", "");
+                    if (templatePath.Length > 0)
+                    {
+                        tree.template = TreeTemplate.CreateFromFunctions(tree.treeFunctionsAssets, templatePath);
+                        serializedObject.FindProperty("template").objectReferenceValue = tree.template;
+                        serializedObject.ApplyModifiedPropertiesWithoutUndo();
+                    }
+                }
+            }
+            EditorGUILayout.EndHorizontal();
+
+            EditorGUILayout.EndVertical();
+
+        }
+
+        private void DisplayLodSelection()
+        {
+            EditorGUI.BeginChangeCheck();
+            SerializedProperty lodIndexProp = serializedObject.FindProperty("LodIndex");
+            lodIndexProp.intValue = EditorGUILayout.Popup("LOD", lodIndexProp.intValue, lodOptions);
+            if (EditorGUI.EndChangeCheck())
+            {
+                serializedObject.ApplyModifiedProperties();
+                UpdateTree();
+            }
+        }
+
+        private void DisplayQualityTab()
+        {
+            EditorGUI.BeginChangeCheck();
+            tree.LODs[tree.LodIndex].DrawProperties();
+            if (EditorGUI.EndChangeCheck())
+                UpdateTree();
+        }
+        #if UNITY_2018_3_OR_NEWER
+        
+        private void SetupLegacyMode()
+        {
+            if (Utils.GetCurrentPipeline() == "hdrp")
+            {
+                
+                tree.isHDRP = true;
+	            tree.hdrpAsset = UnityEngine.Rendering.GraphicsSettings.defaultRenderPipeline;
+                UnityEngine.Rendering.GraphicsSettings.defaultRenderPipeline = null;
+                
+            }
+        }
+        private void SetupHDRPMode(){
+            if(tree.isHDRP){
+                UnityEngine.Rendering.GraphicsSettings.defaultRenderPipeline = tree.hdrpAsset;
+                tree.isHDRP = false;
+            }
+        }
+        private void SetupLegacyMaterials(GameObject t){
+            if(tree.isHDRP)
+            {
+                foreach(Material m in t.GetComponent<MeshRenderer>().sharedMaterials){
+                    if(m.shader.name == "Mtree/SRP/Leafs HDRP")
+                        m.shader = Shader.Find("Mtree/Leafs");
+                    if(m.shader.name == "Mtree/SRP/Bark HDRP")
+                        m.shader = Shader.Find("Mtree/Bark");
+                }
+	           
+            }
+        }
+        private void SetupHDRPMaterials(GameObject t){
+            if(tree.isHDRP){
+
+                foreach(Material m in t.GetComponent<MeshRenderer>().sharedMaterials){
+                    if(m.shader.name == "Mtree/Leafs")
+                        m.shader = Shader.Find("Mtree/SRP/Leafs HDRP");
+                    if(m.shader.name == "Mtree/Bark")
+                        m.shader = Shader.Find("Mtree/SRP/Bark HDRP");
+                }
+            }
+        }
+        #endif
+
+
+        private void DisplaySaveTab()
+        {
+            EditorGUILayout.BeginVertical(EditorStyles.helpBox);
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("saveTreeFolder"), new GUIContent("Save folder"));
+            if (GUILayout.Button("Find folder"))
+            {
+                string path = EditorUtility.OpenFolderPanel("save tree location", "Assets", "Assets");
+                path = "Assets" + path.Substring(Application.dataPath.Length);
+                serializedObject.FindProperty("saveTreeFolder").stringValue = path;
+                AssetDatabase.Refresh();
+            }
+            
+
+            EditorGUILayout.EndHorizontal();
+            tree.gameObject.name = EditorGUILayout.TextField("name", tree.gameObject.name);
+            EditorGUILayout.Space();
+            EditorGUILayout.BeginVertical("Box");
+            EditorGUILayout.LabelField("Billboard Settings");
+            serializedObject.FindProperty("BB_Brightness").floatValue = EditorGUILayout.Slider("Brightness",serializedObject.FindProperty("BB_Brightness").floatValue, 0, 3);
+            serializedObject.FindProperty("BB_isSingleSided").intValue = GUILayout.Toolbar(serializedObject.FindProperty("BB_isSingleSided").intValue, new string[] { "Double Sided", "Single Sided" });
+            serializedObject.FindProperty("BB_hasTopCard").intValue = GUILayout.Toolbar(serializedObject.FindProperty("BB_hasTopCard").intValue, new string[] {"No Top Card","Has Top Card"});            
+            if (tree.BB_hasTopCard == 1)
+                serializedObject.FindProperty("BB_TopCardPositon").floatValue = EditorGUILayout.Slider("Top Card Positon", serializedObject.FindProperty("BB_TopCardPositon").floatValue, 0, 1);
+            serializedObject.ApplyModifiedProperties();
+            EditorGUILayout.EndVertical();
+            if (GUILayout.Button("Save as Prefab")){
+#if UNITY_2018_3_OR_NEWER
+                SetupLegacyMode();
+                SetupLegacyMaterials(tree.gameObject);
+                tree.SaveAsPrefab(false,tree.isHDRP);
+                SetupHDRPMaterials(tree.gameObject);
+                SetupHDRPMode();
+#else
+                tree.SaveAsPrefab(false,false);
+#endif          
+                }
+            EditorGUILayout.EndVertical();
+        }
+
+        private void DisplayMultiObjectsEditting()
+        {
+            //EditorGUILayout.BeginVertical(EditorStyles.helpBox);
+            //EditorGUILayout.BeginHorizontal();
+            //string saveTreeFolder = EditorGUILayout.TextField("Save Folder", tree.saveTreeFolder);
+            //if (GUILayout.Button("Find folder"))
+            //{
+            //    string path = EditorUtility.OpenFolderPanel("save tree location", "Assets", "Assets");
+            //    if (path.Length > 0)
+            //    {
+            //        path = "Assets" + path.Substring(Application.dataPath.Length);
+            //        saveTreeFolder = path;
+            //        foreach (MtreeComponent t in Array.ConvertAll(targets, item => (MtreeComponent)item))
+            //        {
+            //            SerializedObject obj = new SerializedObject(t);
+            //            obj.FindProperty("saveTreeFolder").stringValue = saveTreeFolder;
+            //            obj.ApplyModifiedProperties();
+            //        }
+            //        AssetDatabase.Refresh();
+            //    }
+            //}
+            //EditorGUILayout.EndHorizontal();
+
+            //EditorGUILayout.BeginVertical("Box");
+            //EditorGUILayout.LabelField("Billboard Settings");
+            //BB_GRP_Brightness = EditorGUILayout.Slider("Brightness", BB_GRP_Brightness,0,3);
+            //BB_GRP_isSingleSided = GUILayout.Toolbar(BB_GRP_isSingleSided, new string[] { "Double Sided", "Single Sided" });
+            //BB_GRP_isSingleSided = GUILayout.Toolbar(BB_GRP_hasTopCard, new string[] { "No Top Card", "Has Top Card" });
+            //if (BB_GRP_hasTopCard == 1)
+            //    BB_GRP_TopCardPositon = EditorGUILayout.Slider("Top Card Positon", BB_GRP_TopCardPositon, 0, 1);
+            //EditorGUILayout.EndVertical();
+            //if (GUILayout.Button("Save all as Prefabs"))
+            //{
+            //    saveTreeFolder = tree.saveTreeFolder;
+            //    foreach (MtreeComponent t in Array.ConvertAll(targets, item => (MtreeComponent)item))
+            //    {
+            //        t.BB_Brightness = BB_GRP_Brightness;
+            //        t.BB_isSingleSided = BB_GRP_isSingleSided;
+            //        t.BB_hasTopCard = BB_GRP_hasTopCard;
+            //        t.BB_TopCardPositon = BB_GRP_TopCardPositon;
+            //        t.SaveAsPrefab(groupedSave: true);
+            //    }
+            //    UnityEngine.Object obj = AssetDatabase.LoadAssetAtPath(saveTreeFolder, typeof(UnityEngine.Object));
+            //    // Select the object in the project folder
+            //    Selection.activeObject = obj;
+            //    // Also flash the folder yellow to highlight it
+            //    EditorGUIUtility.PingObject(obj);
+            //}
+            //EditorGUILayout.EndVertical();
+        }
+
+        private void DisplayFunctionsTab()
+        {
+            EditorGUIUtility.labelWidth = 135;
+            int functionCount = tree.treeFunctionsAssets.Count; // Used in multiple for loops
+    
+            EditorGUI.BeginDisabledGroup(tree.treeFunctionsAssets[tree.selectedFunctionIndex].name == "Leaves");
+            if (GUILayout.Button("Add function"))
+            {
+                GenericMenu addFunctionMenu = new GenericMenu();
+                if (tree.selectedFunctionIndex == 0)
+                    addFunctionMenu.AddItem(new GUIContent("Add Roots"), false, tree.AddTreeFunction<RootsFunction>);
+                addFunctionMenu.AddItem(new GUIContent("Add Branches"), false, tree.AddTreeFunction<BranchFunction>);
+                addFunctionMenu.AddItem(new GUIContent("Add Leafs"), false, tree.AddTreeFunction<LeafFunction>);
+                addFunctionMenu.AddItem(new GUIContent("Split"), false, tree.AddTreeFunction<SplitFunction>);
+                addFunctionMenu.AddItem(new GUIContent("Grow"), false, tree.AddTreeFunction<GrowFunction>);
+                addFunctionMenu.ShowAsContext();
+            }
+            EditorGUI.EndDisabledGroup();
+
+            int rectHeight = functionCount * rectHeightMultiplier; // get the height of the drawing window inside inspector
+            Rect rect = GUILayoutUtility.GetRect(10, 1000, rectHeight, rectHeight); // Create drawing window
+            Event e = Event.current; // Get current event
+
+            int heighIndex = 0;
+            tree.treeFunctionsAssets[0].UpdateRectRec(ref heighIndex, 0);
+
+            if (e.type == EventType.MouseDown && e.button == 0) // If mouse button is pressed, get button pressed and act accordingly
+            {
+                for (int i = 0; i < functionCount; i++)
+                {
+                    TreeFunctionAsset tf = tree.treeFunctionsAssets[i];
+
+
+                    if (tf.rect.Contains(e.mousePosition - rect.position))
+                    {
+                        if (tf.deleteRect.Contains(e.mousePosition - rect.position))
+                        {
+                            tree.RemoveFunction(tf);
+                            UpdateTree();
+                        }
+                        else
+                        {
+                            serializedObject.FindProperty("selectedFunctionIndex").intValue = i;
+                            serializedObject.ApplyModifiedProperties();
+                        }
+                        GUIUtility.ExitGUI();
+                        break;
+                    }
+                }
+            }
+            if(e.type == EventType.MouseDown && e.button == 1){
+                for(int i = 0; i<functionCount;i++){
+                    TreeFunctionAsset tf = tree.treeFunctionsAssets[i];
+                    if(tf.rect.Contains(e.mousePosition - rect.position)){
+                            var menu = new GenericMenu();
+                            if(!tf.name.Contains("Trunk"))
+                                menu.AddItem(new GUIContent("Copy Tree Function"),false,SaveTF);
+                            else
+                                menu.AddDisabledItem(new GUIContent("Copy Tree Function"));
+
+                                
+                            if(tree.savedFunction != null && tree.treeFunctionsAssets[tree.selectedFunctionIndex].name != "Leaves")
+                                menu.AddItem(new GUIContent("Paste Tree Function"),false,InsertTF);
+                            else
+                                menu.AddDisabledItem(new GUIContent("Paste Tree Function"));
+
+                            menu.ShowAsContext();
+                            e.Use();
+                        
+                    }
+                }
+            }
+            GUI.BeginClip(rect);
+
+            for (int i = 0; i < tree.treeFunctionsAssets.Count; i++)
+                tree.treeFunctionsAssets[i].DrawFunction(i == tree.selectedFunctionIndex, i>0);
+
+            GUI.EndClip();
+
+            EditorGUI.BeginChangeCheck();
+            EditorGUILayout.BeginVertical(EditorStyles.helpBox);
+
+            if (GUILayout.Button("Randomize tree"))
+            {
+                tree.RandomizeTree();
+            }
+
+            TreeFunctionAsset selectedFunction = tree.treeFunctionsAssets[tree.selectedFunctionIndex];
+            selectedFunction.DrawProperties();
+
+            EditorGUILayout.EndVertical();
+            EditorGUILayout.BeginVertical(EditorStyles.helpBox);
+            var gs = new GUIStyle();
+            gs.richText = true;
+            EditorGUILayout.LabelField("Wind");
+            EditorGUILayout.Slider(serializedObject.FindProperty("VColBarkModifier"),0.1f,5,new GUIContent("Bark Multiplier"));
+            EditorGUILayout.Slider(serializedObject.FindProperty("VColLeafModifier"),0.1f,5,new GUIContent("Leaf Multiplier"));
+            serializedObject.ApplyModifiedProperties();
+            EditorGUILayout.EndVertical();
+            if (EditorGUI.EndChangeCheck())
+                UpdateTree();
+			EditorGUILayout.Space ();
+			BezierMode ();
+        }
+        
+        void SaveTF(){
+            tree.savedFunction = tree.treeFunctionsAssets[tree.selectedFunctionIndex];
+        }
+        void InsertTF(){
+            var tf = Instantiate(tree.savedFunction);
+            tf.parent = tree.treeFunctionsAssets[tree.selectedFunctionIndex];
+            tf.Init(tree.treeFunctionsAssets[tree.selectedFunctionIndex],true);
+            tree.treeFunctionsAssets.Add(tf);
+            UpdateTree();
+        }
+
+        private void UpdateTree()
+        {
+            tree.GenerateTree();
+        }
+
+        private bool IsMultiSelection()
+        {
+            return targets.Length > 1;
+        }
+		private void BezierMode(){
+			EditorGUI.BeginChangeCheck ();
+			serializedObject.FindProperty("hasBezier").intValue = GUILayout.Toolbar(serializedObject.FindProperty("hasBezier").intValue,new string[]{"Use Mtree","Use Bezier"});
+			serializedObject.ApplyModifiedProperties();
+			if(EditorGUI.EndChangeCheck())
+				tree.BezierManager();
+		}
+    }
+
+
+}

package/Editor/MtreeEditor.cs.meta

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